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

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

विशेष रूप से, क्रम में केवल $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$ या बड़ा न हो। दोहरी परिशुद्धता में, यह लगभग $10^{16}$ के $n$ से मेल खाता है, जो अधिकांश योगों से बहुत बड़ा है। तो, एक निश्चित नियम संख्या के लिए, क्षतिपूर्ति योग की त्रुटियां प्रभावी रूप से $O(\varepsilon )$ होती हैं, जो $n$ से स्वतंत्र होती हैं।

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

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

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

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

    for i = 1 to input.length do
        var t = sum + input[i]
        if |sum| >= |input[i]| then
            c += (sum - t) + input[i] // If sum is bigger, low-order digits of input[i] are lost.
        else
            c += (input[i] - t) + sum // Else low-order digits of sum are lost.
        endif
        sum = t
    next i

    return sum + c                    // Correction only applied once in the very end.

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

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

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

function KahanBabushkaKleinSum(input)
    var sum = 0.0
    var cs  = 0.0
    var ccs = 0.0
    var c   = 0.0
    var cc  = 0.0

    for i = 1 to input.length do
        var t = sum + input[i]
        if |sum| >= |input[i]| then
            c = (sum - t) + input[i]
        else
            c = (input[i] - t) + sum
        endif
        sum = t
        t = cs + c
        if |cs| >= |c| then
            cc = (cs - t) + c
        else
            cc = (c - t) + cs
        endif
        cs = t
        ccs = ccs + cc
    end loop 

    return sum + cs + ccs

विकल्प

चूँकि काहन का एल्गोरिदम n संख्याओं के योग के लिए $O(1)$ त्रुटि वृद्धि को प्राप्त करता है, केवल कुछ व्यर्थ $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 को संख्यात्मक अनुप्रयोगों के लिए उत्तम अनुकूल बनाने के लिए पुन: ऑर्डर करने पर रोक लगा दी गई थी (और फोरट्रान के समान, जो पुन: ऑर्डर करने पर भी रोक लगाता है), चूँकि वास्तव में कंपाइलर विकल्प पुनः-ऑर्डरिंग को पुनः सक्षम कर सकते हैं, जैसा कि ऊपर बताया गया है।

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

function KahanSum(input)
    var sum = 0.0
    var c = 0.0

    for i = 1 to input.length do
        var y = input[i] - c
        volatile var t = sum + y
        volatile var z = t - sum
        c = z - y
        sum = t
    next i

    return sum

लाइब्रेरी द्वारा समर्थन

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

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

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

C शार्प (प्रोग्रामिंग लैंग्वेज) या C# लैंग्वेज में, एचपीसीशार्प नुगेट पैकेज न्यूमैयर वैरिएंट और जोड़ीवार योग को प्रयुक्त करता है: दोनों स्केलर के रूप में, एसआईएमडी प्रोसेसर निर्देशों का उपयोग करके डेटा-समानांतर और समानांतर मल्टी-कोर होते है।

यह भी देखें

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

बाहरी संबंध

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