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

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

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

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

एल्गोरिदम

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

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

    i = 1 से इनपुट.लेंथ के लिए // सरणी इनपुट में तत्वों को इनपुट[1] से इनपुट[इनपुट.लेंथ] तक अनुक्रमित किया गया है।
        var y = इनपुट[i] - c // c पहली बार शून्य है।
        var t = sum + y // अफ़सोस, sum बड़ा है, y छोटा, इसलिए y के निम्न-क्रम अंक खो गए हैं।
        c = (t - sum) - y // (t - sum) y के उच्च-क्रम वाले भाग को रद्द करता है; y घटाने पर ऋणात्मक (y का निचला भाग) वापस आ जाता है
        योग = टी // बीजगणितीय रूप से, सी हमेशा शून्य होना चाहिए। अत्यधिक आक्रामक अनुकूलन कंपाइलरों से सावधान रहें!
    अगला i // अगली बार, खोया हुआ निचला हिस्सा एक नए प्रयास में y में जोड़ा जाएगा।

    वापसी राशि

इस एल्गोरिथम को 2Sum एल्गोरिथम का उपयोग करने के लिए फिर से लिखा जा सकता है: फ़ंक्शन KahanSum2(इनपुट)

    var योग = 0.0 // संचायक तैयार करें।
    var c = 0.0 // खोए हुए कम-ऑर्डर बिट्स के लिए एक चालू मुआवजा।

    i = 1 से इनपुट.लेंथ के लिए // सरणी इनपुट में तत्वों को इनपुट[1] से इनपुट[इनपुट.लेंथ] तक अनुक्रमित किया गया है।
        var y = इनपुट[i] + c // c पहली बार शून्य है।
        (sum,c) = Fast2Sum(sum,y) // sum + c सटीक योग का एक अनुमान है।
    अगला i // अगली बार, खोया हुआ निचला हिस्सा एक नए प्रयास में y में जोड़ा जाएगा।

    वापसी राशि

कार्य उदाहरण

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

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

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

  y = 3.14159 - 0.00000 y = इनपुट[i] - c
  टी = 10000.0 + 3.14159
    = 10003.14159 लेकिन केवल छह अंक ही बरकरार रखे गए हैं।
    =10003.1 कई अंक खो गए हैं!
  सी = (10003.1 - 10000.0) - 3.14159 इस 'आवश्यक' का मूल्यांकन लिखित रूप में किया जाना चाहिए!
    = 3.10000 - 3.14159 y का आत्मसात किया हुआ भाग पुनः प्राप्त हुआ, बनाम मूल पूर्ण y।
    = -0.0415900 अनुगामी शून्य दिखाए गए हैं क्योंकि यह छह अंकों का अंकगणित है।
योग = 10003.1 इस प्रकार, इनपुट (i) से कुछ अंक योग के बराबर थे।

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

  y = 2.71828 - (-0.0415900) पिछले चरण की कमी शामिल हो जाती है।
    = 2.75987 इसका आकार y के समान है: अधिकांश अंक मिलते हैं।
  t = 10003.1 + 2.75987 लेकिन कुछ ही लोग योग के अंकों को पूरा करते हैं।
    = 10005.85987 और परिणाम पूर्णांकित है
    = 10005.9 छह अंक तक.
  सी = (10005.9 - 10003.1) - 2.75987 यह जो कुछ भी अंदर गया उसे निकाल देता है।
    = 2.80000 - 2.75987 इस मामले में, बहुत अधिक।
    = 0.040130 लेकिन कोई बात नहीं, अगली बार अतिरिक्त घटा दिया जाएगा।
योग = 10005.9 सटीक परिणाम 10005.85987 है, इसे 6 अंकों में सही ढंग से पूर्णांकित किया गया है।

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