कहन योग एल्गोरिथ्म

संख्यात्मक विश्लेषण में, कहन योग एल्गोरिथ्म, जिसे क्षतिपूर्ति योग के रूप में भी जाना जाता है, स्पष्ट दृष्टिकोण की तुलना में, परिमित-स्पष्ट फ़्लोटिंग-पॉइंट संख्याओं के अनुक्रम को जोड़कर प्राप्त कुल में संख्यात्मक त्रुटि को अधिक कम कर देता है। यह एक अलग चल रहे क्षतिपूर्ति (छोटी त्रुटियों को जमा करने के लिए एक चर) को रखकर किया जाता है, जो वास्तव में क्षतिपूर्ति वेरिएबल की परिशुद्धता द्वारा योग की परिशुद्धता को बढ़ाता है।

विशेष रूप से, क्रम में केवल $n$ संख्याओं को जोड़ने पर सबसे व्यर्थ स्थिति वाली त्रुटि होती है जो $n$ के आनुपातिक रूप से बढ़ती है, और एक मूल माध्य वर्ग त्रुटि होती है जो यादृच्छिक इनपुट के लिए ${\sqrt {n}}$ के रूप में बढ़ती है (राउंडऑफ़ त्रुटियां एक यादृच्छिक चाल बनाती हैं)। क्षतिपूर्ति योग के साथ, पर्याप्त उच्च परिशुद्धता के साथ क्षतिपूर्ति चर का उपयोग करते हुए सबसे व्यर्थ स्थिति वाली त्रुटि सीमा प्रभावी रूप से n से स्वतंत्र होती है, इसलिए बड़ी संख्या में मानों को एक त्रुटि के साथ सारांशित किया जा सकता है जो केवल परिणाम की फ़्लोटिंग-पॉइंट परिशुद्धता पर निर्भर करता है

कलन विधि का श्रेय विलियम कहाँ को दिया जाता है; ऐसा लगता है कि इवो बाबुस्का स्वतंत्र रूप से एक समान एल्गोरिथ्म के साथ आए हैं (इसलिए कहन-बाबुस्का सारांश)। समान, पहले की तकनीकें, उदाहरण के लिए, ब्रेसेनहैम की लाइन एल्गोरिदम हैं, जो पूर्णांक संचालन में संचित त्रुटि का ट्रैक रखती हैं (चूँकि पहली बार उसी समय के आसपास प्रलेखित किया गया था)) और डेल्टा-सिग्मा मॉड्यूलेशन है।

एल्गोरिदम

छद्मकोड में, एल्गोरिदम होगा:

function KahanSum(input)
    var sum = 0.0                    // Prepare the accumulator.
    var c = 0.0                      // A running compensation for lost low-order bits.

    for i = 1 to input.length do     // The array input has elements indexed input[1] to input[input.length].
        var y = input[i] - c         // c is zero the first time around.
        var t = sum + y              // Alas, sum is big, y small, so low-order digits of y are lost.
        c = (t - sum) - y            // (t - sum) cancels the high-order part of y; subtracting y recovers negative (low part of y)
        sum = t                      // Algebraically, c should always be zero. Beware overly-aggressive optimizing compilers!
    next i                           // Next time around, the lost low part will be added to y in a fresh attempt.

    return sum

इस एल्गोरिथम को फास्ट2सम एल्गोरिथम का उपयोग करने के लिए फिर से लिखा जा सकता है:

function KahanSum2(input)
    var sum = 0.0                    // Prepare the accumulator.
    var c = 0.0                      // A running compensation for lost low-order bits.

    for i = 1 to input.length do     // The array input has elements indexed input[1] to input[input.length].
        var y = input[i] + c         // c is zero the first time around.
        (sum,c) = Fast2Sum(sum,y)    // sum + c is an approximation to the exact sum.
    next i                           // Next time around, the lost low part will be added to y in a fresh attempt.

    return sum

कार्य उदाहरण

यह उदाहरण दशमलव में दिया जायेगा. कंप्यूटर समान्यत: बाइनरी अंकगणित का उपयोग करते हैं, किंतु चित्रित सिद्धांत वही है। मान लीजिए कि हम छह अंकों वाले दशमलव फ़्लोटिंग-पॉइंट अंकगणित का उपयोग कर रहे हैं, sum मान 10000.0 प्राप्त कर लिया है, और अगले दो मान input[i] 3.14159 और 2.71828 हैं। स्पष्ट परिणाम 10005.85987 है, जो 10005.9 के समान है। एक सादे योग के साथ, प्रत्येक आने वाले मूल्य को संरेखित किया जाएगा sum, और कई निम्न-क्रम अंक खो जाएंगे (काट-छांट या पूर्णांकन द्वारा)। पूर्णांकन के बाद पहला परिणाम 10003.1 होगा। दूसरा परिणाम राउंडिंग से पहले 10005.81828 और राउंडिंग के बाद 10005.8 होगा। यह सही नहीं है।

यह उदाहरण दशमलव में दिया जायेगा. कंप्यूटर समान्यत: बाइनरी अंकगणित का उपयोग करते हैं, किंतु चित्रित सिद्धांत वही है। मान लीजिए कि हम छह अंकों वाले दशमलव फ़्लोटिंग-पॉइंट अंकगणित का उपयोग कर रहे हैं, योग मान 10000.0 तक पहुंच गया है, और input[i]के अगले दो मान 3.14159 और 2.71828 हैं। स्पष्ट परिणाम 10005.85987 है, जो 10005.9 के समान है। एक सादे sum के साथ, प्रत्येक आने वाले मूल्य को sumके साथ संरेखित किया जाएगा, और कई निम्न-क्रम अंक खो जाएंगे (खंडन या पूर्णांकन द्वारा)। पूर्णांकन के बाद पहला परिणाम 10003.1 होगा। दूसरा परिणाम राउंडिंग से पहले 10005.81828 और राउंडिंग के बाद 10005.8 होगा। यह सही नहीं है।

चूँकि , क्षतिपूर्ति योग के साथ, हमें 10005.9 का सही पूर्णांकित परिणाम मिलता है।

ये मान लीजिए c प्रारंभिक मान शून्य है.

 y = 3.14159 - 0.00000             y = input[i] - c
  t = 10000.0 + 3.14159
    = 10003.14159                   But only six digits are retained.
    = 10003.1                       Many digits have been lost!
  c = (10003.1 - 10000.0) - 3.14159 This must be evaluated as written! 
    = 3.10000 - 3.14159             The assimilated part of y recovered, vs. the original full y.
    = -0.0415900                    Trailing zeros shown because this is six-digit arithmetic.
sum = 10003.1                       Thus, few digits from input(i) met those of sum.

योग इतना बड़ा है कि केवल इनपुट संख्याओं के उच्च-क्रम अंक ही जमा हो रहे हैं। किंतु अगले चरण पर, c त्रुटि देता है.

  y = 2.71828 - (-0.0415900)        The shortfall from the previous stage gets included.
    = 2.75987                       It is of a size similar to y: most digits meet.
  t = 10003.1 + 2.75987             But few meet the digits of sum.
    = 10005.85987                   And the result is rounded
    = 10005.9                       To six digits.
  c = (10005.9 - 10003.1) - 2.75987 This extracts whatever went in.
    = 2.80000 - 2.75987             In this case, too much.
    = 0.040130                      But no matter, the excess would be subtracted off next time.
sum = 10005.9                       Exact result is 10005.85987, this is correctly rounded to 6 digits.

तो योग दो संचायकों के साथ किया जाता है: sum योग रखता है, और cउन भागो को जमा करता है जो योग में समाहित नहीं होते हैं, जिससे अगली बार (sum ) के निम्न-क्रम वाले भाग को हल किया जा सकता है । इस प्रकार सारांश cमें "गार्ड अंक" के साथ आगे बढ़ता है, जो किसी भी न होने से उत्तम है, किंतु इनपुट की दोगुनी स्पष्टता के साथ गणना करने जितना अच्छा नहीं है। चूँकि , केवल गणनाओं की स्पष्टता बढ़ाना सामान्य रूप से व्यावहारिक नहीं है; यदि input पहले से ही दोगुनी परिशुद्धता में है, तो कुछ सिस्टम चौगुनी परिशुद्धता की आपूर्ति करते हैं, और यदि वे करते हैं, तो इनपुट क्वाडरूपल परिशुद्धता में हो सकता है।

स्पष्टता

इसकी स्पष्टता विशेषताओं की सराहना करने के लिए क्षतिपूर्ति योग में त्रुटियों का सावधानीपूर्वक विश्लेषण आवश्यक है। चूँकि यह सरल योग से अधिक स्पष्ट है, फिर भी यह अनिर्धारित योगों के लिए बड़ी सापेक्ष त्रुटियाँ दे सकता है।

मान लीजिए कि कोई योग कर रहा है $n$ मान $x_{i}$, के लिए $i=1,\,\ldots ,\,n$. स्पष्ट योग है

$S_{n}=\sum _{i=1}^{n}x_{i}$ (अनंत परिशुद्धता के साथ गणना की गई)।

मुआवजे के योग के साथ, व्यक्ति इसके बदले प्राप्त करता है $S_{n}+E_{n}$, त्रुटि कहां है $E_{n}$ से घिरा हुआ है: $|E_{n}|\leq {\big [}2\varepsilon +O(n\varepsilon ^{2}){\big ]}\sum _{i=1}^{n}|x_{i}|,$ कहाँ $\varepsilon$ नियोजित किए जा रहे अंकगणित की मशीन परिशुद्धता है (उदा. $\varepsilon \approx 10^{-16}$ आईईईई मानक दोहरी सुनिश्चितता फ़्लोटिंग पॉइंट के लिए)। समान्यत:, ब्याज की मात्रा सापेक्ष त्रुटि होती है $|E_{n}|/|S_{n}|$, जो इसलिए ऊपर से घिरा हुआ है

${\frac {|E_{n}|}{|S_{n}|}}\leq {\big [}2\varepsilon +O(n\varepsilon ^{2}){\big ]}{\frac {\sum \limits _{i=1}^{n}|x_{i}|}{\left|\sum \limits _{i=1}^{n}x_{i}\right|}}.$

सापेक्ष त्रुटि सीमा के लिए अभिव्यक्ति में, अंश $\Sigma |x_{i}|/|\Sigma x_{i}|$ योग समस्या की शर्त संख्या है. अनिवार्य रूप से, शर्त संख्या त्रुटियों के लिए योग समस्या की आंतरिक संवेदनशीलता का प्रतिनिधित्व करती है, भले ही इसकी गणना कैसे की जाती है। निश्चित परिशुद्धता में एक निश्चित एल्गोरिदम द्वारा प्रत्येक (पिछली स्थिर) योग विधि से जुड़ी सापेक्ष त्रुटि (यानी वे नहीं जो मनमानी-स्पष्ट अंकगणित का उपयोग करते हैं, न ही एल्गोरिदम जिनकी स्मृति और समय की आवश्यकताएं डेटा के आधार पर बदलती हैं), इस स्थिति संख्या के लिए आनुपातिक है। एक व्यर्थ स्थिति वाली योग समस्या वह होती है जिसमें यह अनुपात बड़ा होता है, और इस मामले में क्षतिपूर्ति योग में भी बड़ी सापेक्ष त्रुटि हो सकती है। उदाहरण के लिए, यदि सारांश $x_{i}$ शून्य माध्य के साथ असंबंधित यादृच्छिक संख्याएं हैं, योग एक यादृच्छिक चलना है, और स्थिति संख्या आनुपातिक रूप से बढ़ेगी ${\sqrt {n}}$. दूसरी ओर, गैर-शून्य के साथ यादृच्छिक इनपुट के लिए स्थिति संख्या अनंतस्पर्शी को एक परिमित स्थिरांक के रूप में दर्शाती है $n\to \infty$. यदि सभी इनपुट गैर-नकारात्मक हैं, तो शर्त संख्या 1 है।

एक शर्त संख्या को देखते हुए, क्षतिपूर्ति योग की सापेक्ष त्रुटि प्रभावी रूप से स्वतंत्र है $n$. सिद्धांत रूप में, वहाँ है $O(n\varepsilon ^{2})$ जो कि रैखिक रूप से बढ़ता है $n$, किंतु व्यवहार में यह शब्द प्रभावी रूप से शून्य है: चूंकि अंतिम परिणाम एक परिशुद्धता के साथ पूर्णांकित होता है $\varepsilon$, द $n\varepsilon ^{2}$ टर्म राउंड शून्य तक, जब तक $n$ मोटे तौर पर है $1/\varepsilon$ या बड़ा. दोहरी परिशुद्धता में, यह एक से मेल खाता है $n$ मोटे तौर पर $10^{16}$, अधिकांश योगों से बहुत बड़ा। इसलिए, एक निश्चित स्थिति संख्या के लिए, क्षतिपूर्ति योग की त्रुटियां प्रभावी रूप से होती हैं $O(\varepsilon )$, स्वतंत्र $n$.

इसकी तुलना में, सरल योग के लिए बाध्य सापेक्ष त्रुटि (केवल अनुक्रम में संख्याओं को जोड़ना, प्रत्येक चरण पर पूर्णांक बनाना) इस प्रकार बढ़ती है $O(\varepsilon n)$ शर्त संख्या से गुणा किया गया। चूँकि , यह सबसे व्यर्थ स्थिति वाली त्रुटि व्यवहार में शायद ही कभी देखी जाती है, क्योंकि यह केवल तभी होती है जब पूर्णांकन त्रुटियाँ सभी एक ही दिशा में होती हैं। व्यवहार में, इसकी बहुत अधिक संभावना है कि पूर्णांकन त्रुटियों में शून्य माध्य के साथ एक यादृच्छिक चिह्न होता है, जिससे वे एक यादृच्छिक चाल बनाते हैं; इस मामले में, सरल योग में मूल माध्य वर्ग सापेक्ष त्रुटि होती है जो बढ़ती है $O\left(\varepsilon {\sqrt {n}}\right)$ शर्त संख्या से गुणा किया गया। चूँकि , यह अभी भी मुआवजे के योग से बहुत व्यर्थ है। चूँकि , यदि योग को दोगुनी स्पष्टता से निष्पादित किया जा सकता है, तो $\varepsilon$ द्वारा प्रतिस्थापित किया जाता है $\varepsilon ^{2}$, और अनुभवहीन सारांश की तुलना में सबसे व्यर्थ स्थिति वाली त्रुटि है $O(n\varepsilon ^{2})$ मूल परिशुद्धता पर मुआवजे के योग में शब्द।

उसी प्रतीक के द्वारा, $\Sigma |x_{i}|$ जो दिखाई देता है $E_{n}$ उपरोक्त सबसे व्यर्थ स्थिति है जो केवल तब होती है जब सभी गोलाकार त्रुटियों का चिह्न समान होता है (और अधिकतम संभावित परिमाण के होते हैं)। व्यवहार में, यह अधिक संभावना है कि त्रुटियों में यादृच्छिक संकेत होते हैं, इस मामले में शर्तें $\Sigma |x_{i}|$ यादृच्छिक चाल द्वारा प्रतिस्थापित किया जाता है, इस मामले में, शून्य माध्य वाले यादृच्छिक इनपुट के लिए भी, त्रुटि होती है $E_{n}$ के रूप में ही बढ़ता है $O\left(\varepsilon {\sqrt {n}}\right)$ (अनदेखा करना $n\varepsilon ^{2}$ अवधि), समान दर योग $S_{n}$ बढ़ता है, रद्द करता है ${\sqrt {n}}$ जब सापेक्ष त्रुटि की गणना की जाती है तो कारक। इसलिए, असम्बद्ध रूप से गैर-वातानुकूलित योगों के लिए भी, मुआवजे के योग के लिए सापेक्ष त्रुटि अक्सर सबसे व्यर्थ स्थिति के विश्लेषण से बहुत छोटी हो सकती है।

आगे संवर्द्धन

न्यूमैयर कहन एल्गोरिदम का एक उन्नत संस्करण पेश किया, जिसे वह एक उत्तम कहन-बाबुस्का एल्गोरिदम कहते हैं, जो उस मामले को भी कवर करता है जब जोड़ा जाने वाला अगला शब्द चल रहे योग की तुलना में पूर्ण मूल्य में बड़ा होता है, जो बड़े और छोटे की भूमिका को प्रभावी ढंग से बदलता है। छद्मकोड में, एल्गोरिथ्म है:

फ़ंक्शन KahanBabushkaNeumaierSum(इनपुट)
 वर योग = 0.0
 var c = 0.0 // खोए हुए कम-ऑर्डर बिट्स के लिए एक चालू मुआवजा।

 i = 1 के लिए इनपुट.लेंथ करें
 var t = योग + इनपुट[i]
 यदि |योग| >= |इनपुट[i]| तब
 c += (sum - t) + इनपुट[i] // यदि योग बड़ा है, तो इनपुट[i] के निम्न-क्रम अंक खो जाते हैं।
 अन्य
 c += (इनपुट[i] - t) + योग // अन्यथा योग के निम्न-क्रम अंक खो जाते हैं।
 अगर अंत
 योग = टी
 अगला मैं

 वापसी योग + सी // सुधार अंत में केवल एक बार लागू होता है।

यह संवर्द्धन कहन के एल्गोरिदम में फास्ट2सम के साथ दोबारा लिखे गए फास्ट2सम के प्रतिस्थापन के समान है।

संख्याओं के कई अनुक्रमों के लिए, दोनों एल्गोरिदम सहमत हैं, किंतु पीटर्स के कारण एक सरल उदाहरणदिखाता है कि वे कैसे भिन्न हो सकते हैं। संक्षेप के लिए $[1.0,+10^{100},1.0,-10^{100}]$ दोहरी परिशुद्धता में, काहन का एल्गोरिदम 0.0 उत्पन्न करता है, जबकि न्यूमैयर का एल्गोरिदम सही मान 2.0 उत्पन्न करता है।

उत्तम स्पष्टता के उच्च-क्रम संशोधन भी संभव हैं। उदाहरण के लिए, क्लेन द्वारा सुझाया गया एक संस्करण, जिसे उन्होंने दूसरे क्रम का पुनरावृत्त कहन-बाबुस्का एल्गोरिदम कहा। छद्मकोड में, एल्गोरिथ्म है:

फ़ंक्शन KahanBabushkaKleinSum(इनपुट)
 वर योग = 0.0
 वर सीएस = 0.0
 वर सीसीएस = 0.0
 वर सी = 0.0
 वर सीसी = 0.0

 i = 1 के लिए इनपुट.लेंथ करें
 var t = योग + इनपुट[i]
 यदि |योग| >= |इनपुट[i]| तब
 सी = (योग - टी) + इनपुट[i]
 अन्य
 सी = (इनपुट[i] - टी) + योग
 अगर अंत
 योग = टी
 टी = सीएस + सी
 यदि |सीएस| >= |सी| तब
 सीसी = (सीएस - टी) + सी
 अन्य
 सीसी = (सी - टी) + सीएस
 अगर अंत
 सीएस = टी
 सीसीएस = सीसीएस + सीसी
 अंत पाश

 वापसी योग + सीएस + सीसीएस

विकल्प

चूँकि कहन का एल्गोरिदम हासिल करता है $O(1)$ n संख्याओं के योग के लिए त्रुटि वृद्धि, केवल थोड़ी व्यर्थ $O(\log n)$ विकास को जोड़ीवार योग द्वारा प्राप्त किया जा सकता है: एक संख्याओं के सेट को पुनरावर्ती रूप से दो भागो में विभाजित करता है, प्रत्येक आधे भाग का योग करता है, और फिर दो योगों को जोड़ता है। इसका लाभ यह है कि इसमें सरल योग के समान अंकगणितीय परिचालन की आवश्यकता होती है (कहान के एल्गोरिदम के विपरीत, जिसके लिए चार गुना अंकगणित की आवश्यकता होती है और चार गुना सरल योग की विलंबता होती है) और समानांतर में गणना की जा सकती है। पुनरावृत्ति का आधार मामला सैद्धांतिक रूप से केवल एक (या शून्य) संख्याओं का योग हो सकता है, किंतु पुनरावृत्ति के ओवरहेड को परिशोधित करने के लिए, समान्यत: एक बड़े आधार मामले का उपयोग किया जाएगा। जोड़ीदार योग के समतुल्य का उपयोग कई तेज़ फास्ट फूरियर ट्रांसफॉर्मएफएफटी) एल्गोरिदम में किया जाता है और यह उन एफएफटी में राउंडऑफ त्रुटियों के लघुगणकीय विकास के लिए जिम्मेदार है। व्यवहार में, यादृच्छिक संकेतों की राउंडऑफ त्रुटियों के साथ, जोड़ीवार योग की मूल माध्य वर्ग त्रुटियां वास्तव में बढ़ती हैं $O\left({\sqrt {\log n}}\right)$.

एक अन्य विकल्प मनमाना-स्पष्ट अंकगणित का उपयोग करना है, जिसे सैद्धांतिक रूप से बहुत अधिक कम्प्यूटेशनल प्रयास की लागत के साथ पूर्णांकित करने की आवश्यकता नहीं है। मनमाना परिशुद्धता का उपयोग करके बिल्कुल गोल रकम निष्पादित करने का एक तरीका कई फ़्लोटिंग-पॉइंट घटकों का उपयोग करके अनुकूली रूप से विस्तार करना है। यह उन सामान्य मामलों में कम्प्यूटेशनल लागत को कम कर देगा जहां उच्च परिशुद्धता की आवश्यकता नहीं है।

संकलक अनुकूलन द्वारा संभावित अमान्यकरण

सिद्धांत रूप में, एक पर्याप्त रूप से आक्रामक कंपाइलर अनुकूलन कहन सारांश की प्रभावशीलता को नष्ट कर सकता है: उदाहरण के लिए, यदि कंपाइलर ने वास्तविक अंकगणित के साहचर्य नियमों के अनुसार अभिव्यक्तियों को सरल बनाया है, तो यह अनुक्रम में दूसरे चरण को सरल बना सकता है

t = sum + y;

c = (t - sum) - y;

को

c = ((sum + y) - sum) - y;

और फिर को

c = 0;

इस प्रकार त्रुटि क्षतिपूर्ति समाप्त हो जाती है। व्यवहार में, कई कंपाइलर सरलीकरण में एसोसिएटिविटी नियमों (जो केवल फ़्लोटिंग-पॉइंट अंकगणित में अनुमानित होते हैं) का उपयोग नहीं करते हैं, जब तक कि असुरक्षित अनुकूलन को सक्षम करने वाले कंपाइलर विकल्पों द्वारा स्पष्ट रूप से ऐसा करने का निर्देश नहीं दिया जाता है, चूँकि Intel C++ कंपाइलर एक उदाहरण है जो डिफ़ॉल्ट रूप से साहचर्य-आधारित परिवर्तनों की अनुमति देता है। C प्रोग्रामिंग भाषा के मूल K&R C संस्करण ने कंपाइलर को वास्तविक-अंकगणितीय साहचर्यता नियमों के अनुसार फ़्लोटिंग-पॉइंट अभिव्यक्तियों को फिर से व्यवस्थित करने की अनुमति दी, किंतु बाद के ANSI C मानक ने C को संख्यात्मक अनुप्रयोगों के लिए उत्तम अनुकूल बनाने के लिए पुन: ऑर्डर करने पर रोक लगा दी (और फोरट्रान के समान, जो पुन: ऑर्डर करने पर भी रोक लगाता है), चूँकि व्यवहार में कंपाइलर विकल्प पुनः-ऑर्डरिंग को पुनः सक्षम कर सकते हैं, जैसा कि ऊपर बताया गया है।

ऐसे अनुकूलन को स्थानीय रूप से बाधित करने का एक पोर्टेबल तरीका मूल फॉर्मूलेशन में से एक पंक्ति को दो कथनों में तोड़ना है, और दो मध्यवर्ती उत्पादों को अस्थिर वेरिएबल बनाना है:

फ़ंक्शन KahanSum(इनपुट)
 वर योग = 0.0
 वर सी = 0.0

 i = 1 के लिए इनपुट.लेंथ करें
 var y = इनपुट[i] - c
 अस्थिर var t = योग + y
 अस्थिर var z = t - योग
 सी = जेड - वाई
 योग = टी
 अगला मैं

 वापसी राशि

पुस्तकालयों द्वारा समर्थन

सामान्य तौर पर, कंप्यूटर भाषाओं में अंतर्निहित योग फ़ंक्शन आम तौर पर कोई गारंटी नहीं देते हैं कि एक विशेष योग एल्गोरिथ्म को नियोजित किया जाएगा, काहन योग तो बिल्कुल भी नहीं। रैखिक बीजगणित सबरूटीन्स के लिए बीएलएएस मानक स्पष्ट रूप से प्रदर्शन कारणों से संचालन के किसी विशेष कम्प्यूटेशनल क्रम को अनिवार्य करने से बचाता है, और बीएलएएस कार्यान्वयन आम तौर पर कहन सारांश का उपयोग नहीं करते हैं।

पायथन (प्रोग्रामिंग भाषा) कंप्यूटर भाषा की मानक लाइब्रेरी, जोनाथन शेवचुक एल्गोरिथ्म का उपयोग करते हुए, बिल्कुल गोल योग के लिए एक fsum फ़ंक्शन निर्दिष्ट करती है।कई आंशिक रकमों को ट्रैक करने के लिए।

जूलिया (प्रोग्रामिंग भाषा) भाषा में, का डिफ़ॉल्ट कार्यान्वयन sum फ़ंक्शन अच्छे प्रदर्शन के साथ उच्च स्पष्टता के लिए जोड़ीवार योग करता है, किंतु एक बाहरी लाइब्रेरी न्यूमैयर के नामित संस्करण का कार्यान्वयन प्रदान करती है sum_kbn ऐसे मामलों के लिए जब उच्च स्पष्टता की आवश्यकता होती है। सी शार्प (प्रोग्रामिंग भाषा)|सी# भाषा में, HPCsharp nuget पैकेज न्यूमैयर वैरिएंट और जोड़ीवार योग को लागू करता है: दोनों स्केलर के रूप में, SIMD प्रोसेसर निर्देशों का उपयोग करके डेटा-समानांतर और समानांतर मल्टी-कोर।

यह भी देखें

• विचरण की गणना के लिए एल्गोरिदम, जिसमें स्थिर योग शामिल है

बाहरी संबंध

• Floating-point Summation, Dr. Dobb's Journal September, 1996