View source for राउंड-ऑफ़ एरर

{{short description|Computational error due to rounding numbers}}
{{For|the acrobatic movement, roundoff|Roundoff}}
{{Use dmy dates|date=August 2019|cs1-dates=y}}

[[ कम्प्यूटिंग ]] में, एक राउंडऑफ़ त्रुटि,<ref>{{citation |title=Introduction to Numerical Analysis Using MATLAB |author-first=Rizwan |author-last=Butt |publisher=Jones & Bartlett Learning |date=2009 |isbn=978-0-76377376-2 |pages=11–18 |url=https://books.google.com/books?id=QWub-UVGxqkC&pg=PA11}}</ref> इसे पूर्णांकन त्रुटि भी कहा जाता है,<ref>{{citation |title=Numerical Computation 1: Methods, Software, and Analysis |author-first=Christoph W. |author-last=Ueberhuber |publisher=Springer |date=1997 |isbn=978-3-54062058-7 |url=https://books.google.com/books?id=JH9I7EJh3JUC&pg=PA139 |pages=139–146}}</ref> सटीक [[अंकगणित]] का उपयोग करके किसी दिए गए [[कलन विधि]] द्वारा उत्पादित परिणाम और परिमित-परिशुद्धता, [[ गोलाई ]] अंकगणित का उपयोग करके समान एल्गोरिदम द्वारा उत्पादित परिणाम के बीच का अंतर है।<ref name="Forrester_2018">{{cite book |title= गणित/Comp241 संख्यात्मक विधियाँ (व्याख्यान नोट्स)|author-first=Dick |author-last=Forrester |publisher=[[Dickinson College]] |date=2018}}</ref> पूर्णांकन त्रुटियाँ [[वास्तविक संख्या]]ओं के निरूपण और उनके साथ किए गए अंकगणितीय संक्रियाओं में अशुद्धि के कारण होती हैं। यह [[परिमाणीकरण त्रुटि]] का एक रूप है। रेफरी>{{citation |title=Information Technology in Theory |author-first1=Pelin |author-last1=Aksoy |author-first2=Laura |author-last2=DeNardis |publisher=Cengage Learning |date=2007 |isbn=978-1-42390140-2 |page=134 |url=https://books.google.com/books?id=KGS5IcixljwC&pg=PA134}}</ref> सन्निकटन [[समीकरण]]ों या एल्गोरिदम का उपयोग करते समय, विशेष रूप से वास्तविक संख्याओं (जिनमें सिद्धांत रूप में अनंत रूप से कई अंक होते हैं) का प्रतिनिधित्व करने के लिए सीमित कई अंकों का उपयोग करते समय, [[संख्यात्मक विश्लेषण]] का एक लक्ष्य गणना त्रुटियों का [[त्रुटि विश्लेषण (गणित)]] करना है। रेफरी>{{citation |title=A First Course in Numerical Analysis |edition=2nd |series=Dover Books on Mathematics |author-first1=Anthony |author-last1=Ralston |author-first2=Philip |author-last2=Rabinowitz |publisher=Courier Dover Publications |date=2012 |isbn=978-0-48614029-2 |url=https://books.google.com/books?id=TVq8AQAAQBAJ&pg=PA2 |pages=2–4}}</ref> संगणना त्रुटियाँ, जिन्हें [[संख्यात्मक त्रुटि]]याँ भी कहा जाता है, में ट्रंकेशन त्रुटियाँ और राउंडऑफ़ त्रुटियाँ दोनों शामिल हैं।

जब किसी राउंडऑफ त्रुटि वाले इनपुट के साथ गणना का क्रम बनाया जाता है, तो त्रुटियां जमा हो सकती हैं, जो कभी-कभी गणना पर हावी हो जाती हैं। खराब स्थिति वाली समस्याओं में, महत्वपूर्ण त्रुटि जमा हो सकती है। रेफरी>{{citation |title=MATLAB Programming with Applications for Engineers |author-first=Stephen |author-last=Chapman |publisher=Cengage Learning |date=2012 |isbn=978-1-28540279-6 |url=https://books.google.com/books?id=of8KAAAAQBAJ&pg=PA454 |page=454}}</ref>

संक्षेप में, संख्यात्मक गणना में शामिल राउंडऑफ़ त्रुटियों के दो प्रमुख पहलू हैं:<ref name="Chapra_2012">{{cite book |author-last=Chapra |author-first=Steven |title=इंजीनियरों और वैज्ञानिकों के लिए MATLAB के साथ संख्यात्मक पद्धतियाँ लागू की गईं|publisher=[[McGraw Hill Education|McGraw-Hill]] |date=2012 |isbn=9780073401102 |edition=3rd}}</ref>
# संख्याओं के परिमाण और सटीकता दोनों को दर्शाने की कंप्यूटर की क्षमता स्वाभाविक रूप से सीमित है।
# कुछ संख्यात्मक जोड़-तोड़ राउंडऑफ़ त्रुटियों के प्रति अत्यधिक संवेदनशील होते हैं। यह गणितीय विचारों के साथ-साथ कंप्यूटर द्वारा अंकगणितीय संचालन करने के तरीके दोनों के परिणामस्वरूप हो सकता है।

== प्रतिनिधित्व त्रुटि ==

अंकों की एक सीमित स्ट्रिंग का उपयोग करके किसी संख्या का प्रतिनिधित्व करने का प्रयास करने से उत्पन्न त्रुटि राउंडऑफ़ त्रुटि का एक रूप है जिसे प्रतिनिधित्व त्रुटि कहा जाता है।<ref name="Laplante_2000">{{cite book |title=कंप्यूटर विज्ञान, इंजीनियरिंग और प्रौद्योगिकी का शब्दकोश|first=Philip A. |last=Laplante |publisher=[[CRC Press]] |date=2000 |isbn=978-0-84932691-2 |page=420 |url=https://books.google.com/books?id=U1M3clUwCfEC&pg=PA420}}</ref> यहां दशमलव निरूपण में निरूपण त्रुटि के कुछ उदाहरण दिए गए हैं:

{| class="wikitable" style="margin:1em auto"
! Notation
! Representation
! Approximation
! Error
|-
|1/7 || 0.{{overline|142 857}} || 0.142 857 || 0.000 000 {{overline|142 857}}
|-
|[[Natural logarithm|ln 2]] || 0.693 147 180 559 945 309 41...   || 0.693 147 || 0.000 000 180 559 945 309 41...
|-
|[[Logarithm|log<sub>10</sub> 2]] || 0.301 029 995 663 981 195 21...   || 0.3010 || 0.000 029 995 663 981 195 21...
|-
|[[cube root|{{radic|2|3}}]] || 1.259 921 049 894 873 164 76...   || 1.25992 || 0.000 001 049 894 873 164 76...
|-
|[[square root|{{radic|2}}]] || 1.414 213 562 373 095 048 80...   || 1.41421 || 0.000 003 562 373 095 048 80...
|-
|[[E (mathematical constant)|''e'']] || 2.718 281 828 459 045 235 36...   || 2.718 281 828 459 045   || 0.000 000 000 000 000 235 36...
|-
|[[Pi|''π'']] || 3.141 592 653 589 793 238 46...   || 3.141 592 653 589 793 || 0.000 000 000 000 000 238 46...
|}
किसी प्रतिनिधित्व में अनुमत अंकों की संख्या बढ़ाने से संभावित राउंडऑफ़ त्रुटियों की भयावहता कम हो जाती है, लेकिन कई अंकों तक सीमित कोई भी प्रतिनिधित्व अभी भी [[गणनीय]] वास्तविक संख्याओं के लिए कुछ हद तक राउंडऑफ़ त्रुटि का कारण बनेगा। गणना के मध्यवर्ती चरणों के लिए उपयोग किए जाने वाले अतिरिक्त अंकों को गार्ड अंक के रूप में जाना जाता है।<ref name="Higham_2002">{{cite book |title=संख्यात्मक एल्गोरिदम की सटीकता और स्थिरता|edition=2 |author-first=Nicholas John |author-link=Nicholas Higham |author-last=Higham |publisher=[[Society for Industrial and Applied Mathematics]] (SIAM) |date=2002 |isbn=978-0-89871521-7 |pages=43–44 |url=https://books.google.com/books?id=epilvM5MMxwC&pg=PA43}}</ref>

कई बार पूर्णांकन करने से त्रुटि जमा हो सकती है।<ref name="Volkov_1990">{{cite book |title=संख्यात्मक तरीके|author-first=E. A. |author-last=Volkov |publisher=[[Taylor & Francis]] |date=1990 |isbn=978-1-56032011-1 |page=24 |url=https://books.google.com/books?id=ubfrNN8GGOIC&pg=PA24}}</ref> उदाहरण के लिए, यदि 9.945309 को दो दशमलव स्थानों (9.95) तक पूर्णांकित किया जाता है, फिर एक दशमलव स्थान (10.0) तक पूर्णांकित किया जाता है, तो कुल त्रुटि 0.054691 होती है। एक चरण में 9.945309 को एक दशमलव स्थान (9.9) तक पूर्णांकित करने पर कम त्रुटि (0.045309) आती है। यह तब हो सकता है, उदाहरण के लिए, जब सॉफ़्टवेयर विस्तारित परिशुद्धता#x86 विस्तारित परिशुद्धता प्रारूप|x86 80-बिट फ़्लोटिंग-पॉइंट में अंकगणित करता है और फिर परिणाम को [[डबल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप]]|आईईईई 754 बाइनरी64 फ़्लोटिंग-पॉइंट में राउंड करता है।

== फ़्लोटिंग-पॉइंट संख्या प्रणाली ==

[[निश्चित-बिंदु अंकगणित]]|निश्चित-बिंदु संख्या प्रणाली की तुलना में, फ्लोटिंग-प्वाइंट अंकगणित|फ्लोटिंग-बिंदु संख्या प्रणाली वास्तविक संख्याओं का प्रतिनिधित्व करने में अधिक कुशल है, इसलिए आधुनिक कंप्यूटरों में इसका व्यापक रूप से उपयोग किया जाता है। जबकि वास्तविक संख्या <math>\mathbb{R}</math> अनंत और निरंतर हैं, एक फ्लोटिंग-पॉइंट संख्या प्रणाली <math>F</math> परिमित और पृथक है. इस प्रकार, प्रतिनिधित्व त्रुटि, जो राउंडऑफ़ त्रुटि की ओर ले जाती है, फ़्लोटिंग-पॉइंट नंबर सिस्टम के तहत होती है।

=== फ्लोटिंग-पॉइंट संख्या प्रणाली का संकेतन ===
एक फ़्लोटिंग-पॉइंट संख्या प्रणाली <math>F</math> द्वारा चित्रित है <math>4</math> पूर्णांक:
*<math> \beta </math>: आधार या मूलांक
*<math>p</math>: शुद्धता
*<math> [L, U] </math>: घातांक सीमा, कहाँ <math>L</math> निचली सीमा है और <math>U</math> ऊपरी सीमा है

कोई <math>x \in F</math> निम्नलिखित रूप है:
 <math display="block"> x = \pm (\underbrace{d_{0}.d_{1}d_{2}\ldots d_{p-1}}_\text{mantissa})_{\beta}  \times \beta ^{\overbrace{E}^\text{exponent}} = \pm d_{0}\times \beta ^{E}+d_{1}\times \beta ^{E-1}+\ldots+ d_{p-1}\times \beta ^{E-(p-1)}</math>
कहाँ <math>d_{i}</math> ऐसा एक पूर्णांक है <math>0 \leq d_{i} \leq \beta-1</math> के लिए <math>i = 0, 1, \ldots, p-1</math>, और <math>E</math> ऐसा एक पूर्णांक है <math>L \leq E \leq U</math>.

=== सामान्यीकृत फ़्लोटिंग-नंबर सिस्टम ===

* यदि अग्रणी अंक हो तो फ़्लोटिंग-पॉइंट संख्या प्रणाली सामान्यीकृत हो जाती है <math>d_{0}</math> जब तक संख्या शून्य न हो, हमेशा शून्येतर होती है।<ref name="Forrester_2018"/>चूंकि मंटिसा है <math>d_{0}.d_{1}d_{2}\ldots d_{p-1}</math>, एक सामान्यीकृत प्रणाली में एक गैर-शून्य संख्या का मंटिसा संतुष्ट होता है <math>1 \leq \text{mantissa} < \beta</math>. इस प्रकार, नॉनज़ेरो [[इंस्टीट्यूट ऑफ़ इलेक्ट्रिकल एंड इलेक्ट्रॉनिक्स इंजीनियर्स]] का सामान्यीकृत रूप फ्लोटिंग-पॉइंट नंबर है <math>\pm 1.bb \ldots b \times 2^{E}</math> कहाँ <math>b \in {0, 1}</math>. बाइनरी में, अग्रणी अंक हमेशा होता है <math>1</math> इसलिए इसे लिखा नहीं जाता है और इसे अंतर्निहित बिट कहा जाता है। यह अतिरिक्त सटीकता देता है ताकि प्रतिनिधित्व त्रुटि के कारण होने वाली राउंडऑफ़ त्रुटि कम हो जाए।
* चूंकि फ्लोटिंग-पॉइंट नंबर सिस्टम <math>F</math> परिमित और असतत है, यह सभी वास्तविक संख्याओं का प्रतिनिधित्व नहीं कर सकता है जिसका अर्थ है कि अनंत वास्तविक संख्याओं को केवल पूर्णांकन के माध्यम से कुछ सीमित संख्याओं द्वारा अनुमानित किया जा सकता है। किसी दी गई वास्तविक संख्या का फ़्लोटिंग-पॉइंट सन्निकटन <math>x</math> द्वारा <math>fl(x)</math> निरूपित किया जा सकता है.
** सामान्यीकृत फ़्लोटिंग-पॉइंट संख्याओं की कुल संख्या है <math display="block">2(\beta -1)\beta^{p-1} (U-L+1)+1,</math> कहाँ
*** <math>2</math> सकारात्मक या नकारात्मक होने पर संकेत की पसंद को गिना जाता है
*** <math>(\beta -1)</math> अग्रणी अंक की पसंद को गिना जाता है
*** <math>\beta^{p-1}</math> शेष मंटिसा को गिनता है
*** <math>U-L+1</math> घातांकों की पसंद को गिना जाता है
*** <math>1</math> संख्या होने पर मामले को गिना जाता है <math>0</math>.

=== आईईईई मानक ===

इंस्टीट्यूट ऑफ इलेक्ट्रिकल एंड इलेक्ट्रॉनिक्स इंजीनियर्स मानक में आधार बाइनरी है, यानी। <math>\beta = 2</math>, और सामान्यीकरण का उपयोग किया जाता है। आईईईई मानक एक फ्लोटिंग पॉइंट शब्द के अलग-अलग क्षेत्रों में संकेत, प्रतिपादक और मंटिसा को संग्रहीत करता है, जिनमें से प्रत्येक की एक निश्चित चौड़ाई (बिट्स की संख्या) होती है। फ़्लोटिंग-पॉइंट संख्याओं के लिए परिशुद्धता के दो सबसे अधिक उपयोग किए जाने वाले स्तर एकल परिशुद्धता और दोहरी परिशुद्धता हैं।
 {| class="wikitable" style="margin:1em auto"
! Precision
! Sign (bits)
! Exponent (bits)
! Mantissa (bits)
|-
|Single || 1 || 8 || 23 
|-
|Double || 1 || 11 || 52
|}


== [[मशीन ईपीएसलॉन]] ==

फ्लोटिंग-पॉइंट नंबर सिस्टम में राउंडऑफ़ त्रुटि के स्तर को मापने के लिए मशीन एप्सिलॉन का उपयोग किया जा सकता है। यहां दो अलग-अलग परिभाषाएं दी गई हैं.<ref name="Forrester_2018"/>

* मशीन एप्सिलॉन, निरूपित <math>\epsilon_\text{mach}</math>, एक गैर-शून्य वास्तविक संख्या का प्रतिनिधित्व करने में अधिकतम संभव [[सन्निकटन त्रुटि]] है <math>x</math> फ़्लोटिंग-पॉइंट संख्या प्रणाली में। <math display="block">\epsilon_\text{mach} = \max_{x} \frac{|x-fl(x)|}{|x|}</math>
* मशीन एप्सिलॉन, निरूपित <math>\epsilon_\text{mach}</math>, सबसे छोटी संख्या है <math>\epsilon</math> ऐसा है कि <math>fl(1+\epsilon) > 1</math>. इस प्रकार, <math>fl(1+\delta)=fl(1)=1</math> जब कभी भी <math>|\delta| < \epsilon_\text{mach}</math>.

== विभिन्न राउंडिंग नियमों के तहत राउंडऑफ़ त्रुटि ==

गोल करने के दो सामान्य नियम हैं, राउंड-बाय-चॉप और राउंड-टू-नियरेस्ट। IEEE मानक राउंड-टू-नियरेस्ट का उपयोग करता है।

* गोल-दर-काट: आधार-<math>\beta</math> का विस्तार <math>x</math> के बाद छोटा कर दिया गया है <math>(p-1)</math>-वाँ अंक.
** यह पूर्णांकन नियम पक्षपाती है क्योंकि यह परिणाम को हमेशा शून्य की ओर ले जाता है।
* राउंड-टू-नियरेस्ट: <math>fl(x)</math> को निकटतम फ़्लोटिंग-पॉइंट नंबर पर सेट किया गया है <math>x</math>. जब कोई टाई होती है, तो फ़्लोटिंग-पॉइंट संख्या जिसका अंतिम संग्रहीत अंक सम है (साथ ही, अंतिम अंक, बाइनरी रूप में, 0 के बराबर है) का उपयोग किया जाता है।
** आईईईई मानक के लिए जहां आधार <math>\beta</math> है <math>2</math>, इसका मतलब है कि जब कोई टाई होता है तो इसे गोल किया जाता है ताकि अंतिम अंक बराबर हो <math>0</math>.
** यह पूर्णांकन नियम अधिक सटीक है लेकिन कम्प्यूटेशनल रूप से अधिक महंगा है।
** गोल करना ताकि अंतिम संग्रहीत अंक एक समान हो जब कोई टाई हो, यह सुनिश्चित करता है कि इसे व्यवस्थित रूप से ऊपर या नीचे गोल नहीं किया गया है। इसका उद्देश्य केवल पक्षपाती पूर्णांकन के कारण लंबी गणनाओं में अवांछित धीमी बहाव की संभावना से बचना है।
* निम्नलिखित उदाहरण दो राउंडिंग नियमों के तहत राउंडऑफ़ त्रुटि के स्तर को दर्शाता है।<ref name="Forrester_2018"/>राउंडिंग नियम, राउंड-टू-नियरेस्ट, सामान्य तौर पर राउंडऑफ़ त्रुटि को कम करता है।
 {| class="wikitable" style="margin:1em auto"
! x
! Round-by-chop
! Roundoff Error
! Round-to-nearest
! Roundoff Error
|-
|1.649 || 1.6 || 0.049 || 1.6 || 0.049
|-
|1.650 || 1.6 || 0.050 || 1.6 || 0.050
|-
|1.651 || 1.6 || 0.051 || 1.7 || -0.049 
|-
|1.699 || 1.6 || 0.099 || 1.7 || -0.001
|-
|1.749 || 1.7 || 0.049 || 1.7 || 0.049
|-
|1.750 || 1.7 || 0.050 || 1.8 || -0.050
|}


=== आईईईई मानक में राउंडऑफ़ त्रुटि की गणना ===

मान लीजिए कि राउंड-टू-नियरेस्ट और आईईईई डबल प्रिसिजन का उपयोग किया जाता है।

* उदाहरण: दशमलव संख्या <math>(9.4)_{10}=(1001.{\overline{0110}})_{2}</math> में पुनर्व्यवस्थित किया जा सकता है <math display="block">+1.\underbrace{0010110011001100110011001100110011001100110011001100}_\text{52 bits}110 \ldots \times 2^{3}</math> चूँकि बाइनरी बिंदु के दाईं ओर 53-वां बिट 1 है और उसके बाद अन्य गैर-शून्य बिट्स आते हैं, राउंड-टू-नियरेस्ट नियम के लिए राउंड अप की आवश्यकता होती है, यानी 52-वें बिट में 1 बिट जोड़ें। इस प्रकार, आईईईई मानक 9.4 में सामान्यीकृत फ्लोटिंग-पॉइंट प्रतिनिधित्व है
 <math display="block">fl(9.4)=1.0010110011001100110011001100110011001100110011001101 \times 2^{3}.</math>
* अब प्रतिनिधित्व करते समय राउंडऑफ़ त्रुटि की गणना की जा सकती है <math>9.4</math> साथ <math>fl(9.4)</math>.
यह निरूपण अनंत पूँछ को त्यागकर प्राप्त किया गया है <math display="block">0.{\overline{1100}} \times 2^{-52}\times 2^{3} = 0.{\overline{0110}} \times 2^{-51} \times 2^{3}=0.4 \times 2^{-48}</math> दाहिनी पूँछ से और फिर जोड़ा गया <math>1 \times 2^{-52} \times 2^{3}=2^{-49}</math> गोलाकार चरण में.
:तब <math>fl(9.4) = 9.4-0.4 \times 2^{-48} + 2^{-49} = 9.4+(0.2)_{10} \times 2^{-49}</math>.
:इस प्रकार, राउंडऑफ़ त्रुटि है <math>(0.2 \times 2^{-49})_{10}</math>.

===मशीन ईपीएसलॉन का उपयोग करके राउंडऑफ़ त्रुटि को मापना ===

मशीन ईपीएसलॉन <math>\epsilon_\text{mach}</math> उपरोक्त दो राउंडिंग नियमों का उपयोग करते समय राउंडऑफ़ त्रुटि के स्तर को मापने के लिए इसका उपयोग किया जा सकता है। नीचे सूत्र और संबंधित प्रमाण दिए गए हैं।<ref name="Forrester_2018"/>मशीन एप्सिलॉन की पहली परिभाषा का उपयोग यहां किया गया है।

==== प्रमेय ====
# गोल-गोल काटें: <math>\epsilon_\text{mach} = \beta^{1-p}</math>
# राउंड-टू-नियरेस्ट: <math>\epsilon_\text{mach} = \frac{1}{2}\beta^{1-p}</math>


==== प्रमाण ====
होने देना <math>x=d_{0}.d_{1}d_{2} \ldots d_{p-1}d_{p} \ldots \times \beta^{n} \in \mathbb{R}</math> कहाँ <math>n \in [L, U]</math>, और जाने <math>fl(x)</math> का फ़्लोटिंग-पॉइंट प्रतिनिधित्व हो <math>x</math>.
चूंकि राउंड-बाय-चॉप का उपयोग किया जा रहा है, इसलिए यह है
<math display="block"> \begin{align}
\frac{|x-fl(x)|}{|x|} &= \frac{|d_{0}.d_{1}d_{2}\ldots d_{p-1}d_{p}d_{p+1}\ldots \times \beta^{n} - d_{0}.d_{1}d_{2}\ldots d_{p-1} \times \beta^{n}|}{|d_{0}.d_{1}d_{2}\ldots \times \beta^{n}|}\\
&= \frac{|d_{p}.d_{p+1} \ldots \times \beta^{n-p}|}{|d_{0}.d_{1}d_{2}\ldots \times \beta^{n}|}\\
&= \frac{|d_{p}.d_{p+1}d_{p+2}\ldots|}{|d_{0}.d_{1}d_{2}\ldots|} \times \beta^{-p}
\end{align}</math>
इस मात्रा का अधिकतम निर्धारण करने के लिए, अंश का अधिकतम और हर का न्यूनतम ज्ञात करने की आवश्यकता है। तब से <math>d_{0}\neq 0</math> (सामान्यीकृत प्रणाली), हर का न्यूनतम मान है <math>1</math>. अंश ऊपर से घिरा हुआ है <math>(\beta-1).(\beta-1){\overline{(\beta-1)}}=\beta </math>. इस प्रकार, <math>\frac{|x-fl(x)|}{|x|} \leq \frac{\beta}{1} \times \beta^{-p} = \beta^{1-p}</math>. इसलिए, <math>\epsilon=\beta^{1-p}</math> गोल-गोल काटने के लिए।
राउंड-टू-नियरेस्ट का प्रमाण समान है।
* ध्यान दें कि राउंड-टू-नियरेस्ट नियम का उपयोग करते समय मशीन एप्सिलॉन की पहली परिभाषा दूसरी परिभाषा के बिल्कुल बराबर नहीं है, लेकिन यह राउंड-बाय-चॉप के बराबर है।

== फ़्लोटिंग-पॉइंट अंकगणित के कारण राउंडऑफ़ त्रुटि ==

भले ही कुछ संख्याओं को फ़्लोटिंग-पॉइंट संख्याओं द्वारा सटीक रूप से दर्शाया जा सकता है और ऐसी संख्याओं को मशीन नंबर कहा जाता है, फ़्लोटिंग-पॉइंट अंकगणित करने से अंतिम परिणाम में राउंडऑफ़ त्रुटि हो सकती है।

=== जोड़ ===

मशीन जोड़ में जोड़ी जाने वाली दो संख्याओं के दशमलव बिंदुओं को पंक्तिबद्ध करना, उन्हें जोड़ना और फिर परिणाम को फ़्लोटिंग-पॉइंट संख्या के रूप में संग्रहीत करना शामिल है। जोड़ स्वयं उच्च परिशुद्धता में किया जा सकता है लेकिन परिणाम को निर्दिष्ट परिशुद्धता पर वापस गोल किया जाना चाहिए, जिससे राउंडऑफ़ त्रुटि हो सकती है।<ref name="Forrester_2018"/>

* उदाहरण के लिए, जोड़ना <math>1</math> को <math>2^{-53}</math> आईईईई में दोहरी परिशुद्धता इस प्रकार है,{{Break}}<math>\begin{align}
1.00\ldots 0 \times 2^{0} + 1.00\ldots 0 \times 2^{-53} &= 1.\underbrace{00\ldots 0}_\text{52 bits} \times 2^{0} + 0.\underbrace{00\ldots 0}_\text{52 bits}1 \times 2^{0}\\
&= 1.\underbrace{00\ldots 0}_\text{52 bits}1\times 2^{0}.
\end{align}</math>{{Break}}इसे इस रूप में सहेजा गया है <math>1.\underbrace{00\ldots 0}_\text{52 bits}\times 2^{0}</math> चूंकि आईईईई मानक में राउंड-टू-नियरेस्ट का उपयोग किया जाता है। इसलिए, <math>1+2^{-53}</math> के बराबर है <math>1</math> आईईईई में दोहरी परिशुद्धता और राउंडऑफ़ त्रुटि है <math>2^{-53}</math>.

यह उदाहरण दर्शाता है कि बड़ी संख्या और छोटी संख्या को जोड़ने पर राउंडऑफ़ त्रुटि उत्पन्न हो सकती है। घातांकों का मिलान करने के लिए मंटिसा में दशमलव बिंदुओं को स्थानांतरित करने से कुछ कम महत्वपूर्ण अंकों का नुकसान होता है। परिशुद्धता की हानि को अवशोषण के रूप में वर्णित किया जा सकता है।<ref>{{cite book |last1=Biran |first1=Adrian B. |last2=Breiner |first2=Moshe |title=प्रत्येक इंजीनियर को MATLAB और सिमुलिंक के बारे में क्या पता होना चाहिए|date=2010 |publisher=[[CRC Press]] |publication-place=[[Boca Raton]], [[Florida]] |isbn=978-1-4398-1023-1 |pages=193–194 |chapter=5}}</ref>
ध्यान दें कि दो फ़्लोटिंग-पॉइंट संख्याओं को जोड़ने से राउंडऑफ़ त्रुटि होगी जब उनका योग दोनों में से बड़े से अधिक परिमाण का क्रम होगा।

* उदाहरण के लिए, आधार के साथ एक सामान्यीकृत फ़्लोटिंग-पॉइंट संख्या प्रणाली पर विचार करें <math>10</math> और परिशुद्धता <math>2</math>. तब <math>fl(62)=6.2 \times 10^{1}</math> और <math>fl(41) = 4.1 \times 10^{1}</math>. ध्यान दें कि <math>62+41=103</math> लेकिन <math>fl(103)=1.0 \times 10^{2}</math>. की एक राउंडऑफ़ त्रुटि है <math>103-fl(103)=3</math>.

इस प्रकार की त्रुटि एकल ऑपरेशन में अवशोषण त्रुटि के साथ हो सकती है।

=== गुणन ===
सामान्य तौर पर, 2-अंकीय मंटिसा के उत्पाद में 2पी अंक तक होते हैं, इसलिए परिणाम मंटिसा में फिट नहीं हो सकता है।<ref name="Forrester_2018"/>इस प्रकार परिणाम में राउंडऑफ़ त्रुटि शामिल होगी।

* उदाहरण के लिए, आधार के साथ एक सामान्यीकृत फ़्लोटिंग-पॉइंट संख्या प्रणाली पर विचार करें <math>\beta=10</math> और मंटिसा अंक अधिकतम हैं <math>2</math>. तब <math>fl(77) = 7.7 \times 10^{1}</math> और <math>fl(88) = 8.8 \times 10^{1}</math>. ध्यान दें कि <math>77 \times 88=6776</math> लेकिन <math>fl(6776) = 6.7 \times 10^{3}</math> चूंकि वहां अधिक से अधिक <math>2</math> मंटिसा अंक. राउंडऑफ़ त्रुटि होगी <math>6776 - fl(6776)  = 6776 - 6.7 \times 10^{3}=76</math>.

=== प्रभाग ===

सामान्य तौर पर, 2पी-अंकीय मंटिसा के भागफल में पी-अंक से अधिक हो सकता है। इस प्रकार परिणाम में राउंडऑफ़ त्रुटि शामिल होगी।

* उदाहरण के लिए, यदि उपरोक्त सामान्यीकृत फ़्लोटिंग-पॉइंट संख्या प्रणाली अभी भी उपयोग की जा रही है, तो <math>1/3=0.333 \ldots</math> लेकिन <math>fl(1/3)=fl(0.333 \ldots)=3.3 \times 10^{-1}</math>. तो, पूंछ <math>0.333 \ldots - 3.3 \times 10^{-1}=0.00333 \ldots </math> काट दिया जाता है.

=== घटाव ===

अवशोषण घटाव पर भी लागू होता है।

* उदाहरण के लिए, घटाना <math>2^{-60}</math> से <math>1</math> आईईईई में दोहरी परिशुद्धता इस प्रकार है, <math display="block">\begin{align}
1.00\ldots 0 \times 2^{0} - 1.00\ldots 0 \times 2^{-60} &= \underbrace{1.00\ldots 0}_\text{60 bits} \times 2^{0} - \underbrace{0.00\ldots 01}_\text{60 bits} \times 2^{0}\\
&= \underbrace{0.11\ldots 1}_\text{60 bits}\times 2^{0}.
\end{align}</math> इसे इस रूप में सहेजा गया है <math>\underbrace{1.00\ldots 0}_\text{53 bits}\times 2^{0}</math> चूंकि आईईईई मानक में राउंड-टू-नियरेस्ट का उपयोग किया जाता है। इसलिए, <math>1-2^{-60}</math> के बराबर है <math>1</math> आईईईई में दोहरी परिशुद्धता और राउंडऑफ़ त्रुटि है <math>-2^{-60}</math>.

दो लगभग बराबर संख्याओं को घटाने को घटाव रद्दीकरण कहा जाता है।<ref name="Forrester_2018"/> 
जब अग्रणी अंकों को रद्द कर दिया जाता है, तो परिणाम सटीक रूप से प्रस्तुत करने के लिए बहुत छोटा हो सकता है और इसे बस के रूप में दर्शाया जाएगा <math>0</math>.

* उदाहरण के लिए, चलो <math>|\epsilon| < \epsilon_\text{mach}</math> और मशीन एप्सिलॉन की दूसरी परिभाषा का उपयोग यहां किया गया है। इसका समाधान क्या है <math>(1+\epsilon) - (1-\epsilon)</math>?{{Break}} ह ज्ञात है कि <math>1+\epsilon</math> और <math>1-\epsilon</math> लगभग समान संख्याएँ हैं, और <math>(1+\epsilon) - (1-\epsilon)=1+\epsilon-1+\epsilon=2\epsilon</math>. हालाँकि, फ़्लोटिंग-पॉइंट संख्या प्रणाली में, <math>fl((1+\epsilon) - (1-\epsilon))=fl(1+\epsilon)-fl(1-\epsilon)=1-1=0</math>. यद्यपि <math>2\epsilon</math> आसानी से इतना बड़ा है कि दोनों उदाहरणों का प्रतिनिधित्व किया जा सके <math>\epsilon</math> देकर गोल कर दिया गया है <math>0</math>.

कुछ हद तक बड़े के साथ भी <math>\epsilon</math>, सामान्य मामलों में परिणाम अभी भी काफी अविश्वसनीय है। मान की सटीकता में बहुत अधिक विश्वास नहीं है क्योंकि किसी भी फ़्लोटिंग-पॉइंट संख्या में सबसे अधिक अनिश्चितता सबसे दाईं ओर के अंक हैं।

* उदाहरण के लिए, <math>1.99999 \times 10 ^{2}- 1.99998 \times 10^{2} = 0.00001\times10^{2} =1 \times 10^{-5}\times 10^{2}=1\times10^{-3}</math>. परिणाम <math>1\times10^{-3}</math> स्पष्ट रूप से प्रस्तुत करने योग्य है, लेकिन इसमें बहुत अधिक विश्वास नहीं है।

यह भयावह रद्दीकरण की घटना से निकटता से संबंधित है, जिसमें दो संख्याओं को सन्निकटन के रूप में जाना जाता है।

== राउंडऑफ़ त्रुटि का संचय ==

जब सटीक प्रतिनिधित्व के कारण राउंडऑफ त्रुटि के साथ प्रारंभिक इनपुट पर गणना का अनुक्रम लागू किया जाता है तो त्रुटियां बढ़ या जमा हो सकती हैं।

=== अस्थिर एल्गोरिदम ===

एक एल्गोरिदम या संख्यात्मक प्रक्रिया को स्थिर कहा जाता है यदि इनपुट में छोटे परिवर्तन केवल आउटपुट में छोटे परिवर्तन उत्पन्न करते हैं, और यदि आउटपुट में बड़े परिवर्तन उत्पन्न होते हैं तो अस्थिर कहा जाता है।<ref name="Collins_2005">{{cite web |author-last=Collins |author-first=Charles |title=स्थिति एवं स्थिरता|url=https://www.math.utk.edu/~ccollins/M577/Handouts/cond_stab.pdf |website=Department of Mathematics in University of Tennessee |date=2005 |access-date=2018-10-28}}</ref> उदाहरण के लिए, की गणना <math>f(x) = \sqrt{1 + x} - 1</math> स्पष्ट विधि का उपयोग निकट अस्थिर है <math>x = 0</math> दो समान मात्राओं को घटाने में हुई बड़ी त्रुटि के कारण, जबकि समतुल्य अभिव्यक्ति <math>\textstyle{f(x) = \frac{x}{\sqrt{1+x} + 1}}</math> स्थिर है.<ref name="Collins_2005"/>


=== ख़राब समस्याएँ ===

यहां तक कि अगर एक स्थिर एल्गोरिदम का उपयोग किया जाता है, तब भी किसी समस्या का समाधान राउंडऑफ़ त्रुटि के संचय के कारण गलत हो सकता है जब समस्या स्वयं खराब स्थिति में हो।

किसी समस्या की [[शर्त संख्या]] समाधान में सापेक्ष परिवर्तन और इनपुट में सापेक्ष परिवर्तन का अनुपात है।<ref name="Forrester_2018"/>यदि इनपुट में छोटे सापेक्ष परिवर्तन के परिणामस्वरूप समाधान में छोटे सापेक्ष परिवर्तन होते हैं तो एक समस्या अच्छी तरह से अनुकूल होती है। अन्यथा, समस्या ख़राब है.<ref name="Forrester_2018"/>दूसरे शब्दों में, यदि समस्या की स्थिति संख्या 1 से बहुत बड़ी है तो कोई समस्या अनुपयुक्त होती है।

शर्त संख्या को राउंडऑफ़ त्रुटियों के माप के रूप में पेश किया गया है जो खराब स्थिति वाली समस्याओं को हल करते समय उत्पन्न हो सकती हैं।<ref name="Chapra_2012"/>


== यह भी देखें ==
* [[परिशुद्धता (अंकगणित)]]
* काट-छाँट
* गोलाई
* [[महत्व की हानि]]
* [[तैरनेवाला स्थल]]
* [[कहन योग एल्गोरिथ्म]]
* मशीन एप्सिलॉन
* विल्किंसन का बहुपद

==संदर्भ==
{{Reflist}}


== अग्रिम पठन ==
* {{cite book |title=Humble Pi: When Math Goes Wrong in the Real World |year=2021 |author= Matt Parker |publisher=Riverhead Books |isbn=978-0593084694}}


== बाहरी संबंध ==
* [http://mathworld.wolfram.com/RoundoffError.html Roundoff Error] at MathWorld.
* {{cite journal |author-first=David |author-last=Goldberg |author-link=David Goldberg (PARC) |title=What Every Computer Scientist Should Know About Floating-Point Arithmetic |journal=[[ACM Computing Surveys]] |date=March 1991 |volume=23 |issue=1 |pages=5–48 |doi=10.1145/103162.103163 |s2cid=222008826 |url=http://perso.ens-lyon.fr/jean-michel.muller/goldberg.pdf |access-date=2016-01-20}} ([http://www.validlab.com/goldberg/paper.pdf], [http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html])
* [http://www.devtopics.com/20-famous-software-disasters/ 20 Famous Software Disasters]

{{Authority control}}

{{DEFAULTSORT:RoundOff Error}}[[Category: संख्यात्मक विश्लेषण]] 

[[sv:Avrundningsfel]]



[[Category: Machine Translated Page]]
[[Category:Created On 21/07/2023]]