View source for आर्बिट्ररी-स्पष्ट अंकगणित

{{Short description|Calculations where numbers' precision is only limited by computer memory}}
{{Floating-point}}
[[कंप्यूटर विज्ञान]] में, '''आर्बिट्ररी-स्पष्ट अंकगणित''', जिसे बिग्नम अंकगणित, बहु-स्पष्ट अंकगणित, या कभी-कभी अनंत-स्पष्टता अंकगणित भी कहा जाता है, यह इंगित करता है कि गणना उन संख्याओं पर की जाती है जिनके [[संख्यात्मक अंक]] की स्पष्टता (अंकगणित) केवल उपलब्ध [[मेमोरी (कंप्यूटर)]] द्वारा सीमित होती है। ) होस्ट सिस्टम का यह अधिकांश [[अंकगणितीय तर्क इकाई]] (एएलयू) हार्डवेयर में पाए जाने वाले तेज़ [[निश्चित-परिशुद्धता अंकगणित|निश्चित-स्पष्टता अंकगणित]] के विपरीत है, जो सामान्यतः 8 और 64 [[अंश]] के बीच स्पष्टता प्रदान करता है।

कई आधुनिक [[प्रोग्रामिंग भाषा|प्रोग्रामिंग]] लैंग्वेज में बिग्नम के लिए अंतर्निहित समर्थन है,<ref>{{Cite web|last=dotnet-bot|title=BigInteger Struct (System.Numerics)|url=https://docs.microsoft.com/en-us/dotnet/api/system.numerics.biginteger|access-date=2022-02-22|website=docs.microsoft.com|language=en-us}}</ref><ref>{{Cite web|title=PEP 237 -- Unifying Long Integers and Integers|url=https://peps.python.org/pep-0237/|access-date=2022-05-23|website=Python.org|language=en}}</ref><ref>{{Cite web|title=BigInteger (Java Platform SE 7 )|url=https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html|access-date=2022-02-22|website=docs.oracle.com}}</ref><ref>{{Cite web|title=BigInt - JavaScript {{!}} MDN|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt|access-date=2022-02-22|website=developer.mozilla.org|language=en-US}}</ref> और अन्य के पास आर्बिट्ररी-स्पष्टता पूर्णांक (कंप्यूटर विज्ञान) और [[तैरनेवाला स्थल|फ़्लोटिंग-पॉइंट]] गणित के लिए लाइब्रेरी उपलब्ध हैं। [[प्रोसेसर रजिस्टर]] के आकार से संबंधित बिट्स की निश्चित संख्या के रूप में मानों को संग्रहीत करने के अतिरिक्त, ये कार्यान्वयन सामान्यतः अंकों की चर-लंबाई [[सरणी डेटा संरचना]] का उपयोग करते हैं।

आर्बिट्ररी स्पष्टता का उपयोग उन अनुप्रयोगों में किया जाता है जहां [[अंकगणित]] की गति सीमित कारक नहीं है, या जहां बहुत बड़ी संख्या के साथ [[फ़्लोटिंग पॉइंट त्रुटि शमन]] की आवश्यकता होती है। इसे कई कंप्यूटर बीजगणित सिस्टम्स द्वारा प्रदान की जाने वाली प्रतीकात्मक संगणना के साथ भ्रमित नहीं होना चाहिए, जो भावों द्वारा संख्याओं का प्रतिनिधित्व करते हैं जैसे कि {{math|''π''·sin(2)}}, और इस प्रकार अनंत स्पष्टता के साथ किसी भी [[गणना योग्य संख्या]] का प्रतिनिधित्व कर सकता है।

== अनुप्रयोग ==

एक सामान्य अनुप्रयोग [[सार्वजनिक कुंजी क्रिप्टोग्राफी|सार्वजनिक कीय क्रिप्टोग्राफी]] है, जिसके एल्गोरिदम सामान्यतः सैकड़ों अंकों वाले पूर्णांक वाले अंकगणित का उपयोग करते हैं।<ref>{{cite web |url=https://arstechnica.com/news.ars/post/20070523-researchers-307-digit-key-crack-endangers-1024-bit-rsa.html |title=Researchers: 307-digit key crack endangers 1024-bit RSA |author=Jacqui Cheng |date=May 23, 2007}}</ref><ref>{{cite web|url=http://www.rsa.com/rsalabs/node.asp?id%3D2218 |title=RSA Laboratories - 3.1.5 How large a key should be used in the RSA cryptosystem? |access-date=2012-03-31 |url-status=dead |archive-url=https://web.archive.org/web/20120401144624/http://www.rsa.com/rsalabs/node.asp?id=2218 |archive-date=2012-04-01 }} recommends important RSA keys be 2048 bits (roughly 600 digits).</ref> और स्थिति में है जहां कृत्रिम सीमाएं और [[अंकगणितीय अतिप्रवाह]] अनुचित होता है। यह निश्चित-स्पष्ट गणनाओं के परिणामों की जाँच के लिए भी उपयोगी है, और सूत्रों में आवश्यक गुणांकों के लिए इष्टतम या निकट-इष्टतम मान निर्धारित करने के लिए, उदाहरण के लिए <math display=inline>\sqrt{\frac{1}{3}}</math> जो गॉसियन एकीकरण में प्रकट होता है।<ref>{{cite report|url=https://tel.archives-ouvertes.fr/tel-00477243/en |title=Intégration numérique avec erreur bornée en précision arbitraire. Modélisation et simulation | author=Laurent Fousse | publisher=Université Henri Poincaré - Nancy I | language=fr | date=2006 }} </ref>

इच्छानुसार स्पष्ट अंकगणित का उपयोग मौलिक [[गणितीय स्थिरांक]] जैसे pi|π को लाखों या अधिक अंकों तक करने और अंकों के तार के गुणों का विश्लेषण करने के लिए भी किया जाता है।<ref>{{cite journal |author=R. K. Pathria |author-link=Raj Pathria |title=A Statistical Study of the Randomness Among the First 10,000 Digits of Pi |year=1962 |journal=Mathematics of Computation |volume=16 |issue=78 |pages=188–197 |url=https://www.ams.org/journals/mcom/1962-16-078/S0025-5718-1962-0144443-7/ |access-date=2014-01-10 |doi=10.1090/s0025-5718-1962-0144443-7|doi-access=free }} A quote example from this article: "Such an extreme pattern is dangerous even if diluted by one of its neighbouring blocks"; this was the occurrence of the sequence 77 twenty-eight times in one block of a thousand digits.</ref> या अधिक सामान्यतः [[रीमैन जीटा फ़ंक्शन]] जैसे कार्यों के स्पष्ट व्यवहार की जांच करने के लिए जहां विश्लेषणात्मक विधियों के माध्यम से कुछ प्रश्नों का पता लगाना कठिन होता है। अन्य उदाहरण [[भग्न|फ्रैक्टल]] छवियों को अत्यधिक उच्च आवर्धन के साथ प्रस्तुत करना है, जैसे कि [[मैंडेलब्रॉट सेट]] में पाए जाते हैं।

अंकगणितीय अतिप्रवाह से बचने के लिए आर्बिट्ररी-स्पष्टता अंकगणित का भी उपयोग किया जा सकता है, जो निश्चित-स्पष्टता अंकगणित की अंतर्निहित सीमा है। 5-अंकीय [[ओडोमीटर]] के प्रदर्शन के समान, जो 99999 से 00000 में बदलता है, निश्चित-स्पष्टता पूर्णांक [[पूर्णांक अतिप्रवाह]] प्रदर्शित कर सकता है यदि संख्या स्पष्टता के निश्चित स्तर पर प्रतिनिधित्व करने के लिए बहुत बड़ी हो जाती है। इसके अतिरिक्त कुछ प्रोसेसर [[संतृप्ति अंकगणित]] द्वारा अतिप्रवाह से निपट सकते हैं, जिसका अर्थ है कि यदि परिणाम अप्राप्य होगा, तो इसे निकटतम प्रतिनिधित्व योग्य मान से बदल दिया जाता है। (16-बिट अहस्ताक्षरित संतृप्ति के साथ, 65535 में कोई सकारात्मक राशि जोड़ने से 65535 निकलेगा।) कुछ प्रोसेसर अपवाद हैंडलिंग उत्पन्न कर सकते हैं यदि अंकगणितीय परिणाम उपलब्ध स्पष्टता से अधिक है। जहां आवश्यक हो, अपवाद को पकड़ा जा सकता है और इससे पुनर्प्राप्त किया जा सकता है उदाहरण के लिए, इच्छानुसार स्पष्ट अंकगणित का उपयोग करके सॉफ़्टवेयर में ऑपरेशन को पुनरारंभ किया जा सकता है।

कई स्थितियों में, कार्य या प्रोग्रामर इस बात की गारंटी दे सकता है कि किसी विशिष्ट एप्लिकेशन में पूर्णांक मान अतिप्रवाह उत्पन्न करने के लिए पर्याप्त रूप से बड़े नहीं होते है। इस तरह की गारंटी व्यावहारिक सीमाओं पर आधारित हो सकती है: स्कूल उपस्थिति प्रोग्राम में 4,000 छात्रों की कार्य सीमा हो सकती है। प्रोग्रामर अभिकलन को डिज़ाइन कर सकता है जिससे मध्यवर्ती परिणाम निर्दिष्ट स्पष्ट सीमाओं के अन्दर रहते है।

कुछ प्रोग्रामिंग लैंग्वेज जैसे कि [[लिस्प (प्रोग्रामिंग भाषा)|लिस्प (प्रोग्रामिंग लैंग्वेज)]], पायथन (प्रोग्रामिंग लैंग्वेज), [[पर्ल]], [[हास्केल (प्रोग्रामिंग भाषा)|हास्केल (प्रोग्रामिंग लैंग्वेज)]], [[रूबी (प्रोग्रामिंग भाषा)|रूबी (प्रोग्रामिंग लैंग्वेज)]] और [[राकू (प्रोग्रामिंग भाषा)|राकू (प्रोग्रामिंग लैंग्वेज)]] का उपयोग करें, या उपयोग करने का विकल्प है, इच्छानुसार स्पष्ट संख्याएँ सभी पूर्णांक अंकगणित चूँकि यह प्रदर्शन को कम करता है, यह सरल अतिप्रवाह के कारण गलत परिणाम (या अपवाद) की संभावना को समाप्त करता है। यह गारंटी देना भी संभव बनाता है कि किसी विशेष मशीन के वर्ड (डेटा प्रकार) की परवाह किए बिना अंकगणितीय परिणाम सभी मशीनों पर समान होते है। प्रोग्रामिंग लैंग्वेज में आर्बिट्ररी-स्पष्टता संख्याओं का अनन्य उपयोग भी लैंग्वेज को सरल करता है, क्योंकि संख्या संख्या है और स्पष्टता के विभिन्न स्तरों का प्रतिनिधित्व करने के लिए कई प्रकारों की आवश्यकता नहीं होती है।

== कार्यान्वयन के उद्देश्य ==

प्रोसेसर रजिस्टरों के अन्दर पूरी तरह से फिट होने वाली संख्याओं का उपयोग करते हुए आर्बिट्ररी-स्पष्ट अंकगणित अंकगणित की तुलना में अधिक धीमा है, क्योंकि पश्चात् वाले सामान्यतः अंकगणितीय तर्क इकाई में प्रयुक्त होते हैं जबकि पूर्व को सॉफ्टवेयर में प्रयुक्त किया जाना चाहिए। यहां तक कि यदि [[संगणक]] में कुछ संचालन (जैसे पूर्णांक विभाजन, या सभी फ़्लोटिंग-पॉइंट ऑपरेशंस) के लिए हार्डवेयर की कमी है और इसके अतिरिक्त सॉफ़्टवेयर प्रदान किया गया है, जिससे यह उपलब्ध हार्डवेयर रजिस्टरों से संबंधित संख्या आकारों का उपयोग करता है: केवल या दो शब्द और निश्चित रूप से एन नहीं शब्द अपवाद हैं, क्योंकि 1950 और 1960 के दशक की कुछ चर शब्द लंबाई वाली मशीन मशीनें, विशेष रूप से [[IBM 1620|आईबीएम 1620]], [[IBM 1401|आईबीएम 1401]] और हनीवेल लिबरेटर श्रृंखला, केवल उपलब्ध स्टोरेज से बंधी संख्याओं में हेरफेर कर सकती हैं, अतिरिक्त बिट के साथ जो मूल्य को सीमांकित करती है।

संख्याओं को [[निश्चित-बिंदु अंकगणित]] में संग्रहीत किया जा सकता है। निश्चित-बिंदु प्रारूप, या फ़्लोटिंग-पॉइंट प्रारूप में [[महत्व]] के रूप में और इच्छानुसार घातांक द्वारा गुणा किया जा सकता है। चूँकि, चूंकि विभाजन लगभग तुरंत अंकों के असीम रूप से दोहराए जाने वाले अनुक्रमों (जैसे दशमलव में 4/7, या बाइनरी में 1/10) का परिचय देता है, क्या यह संभावना उत्पन्न होती है या तो प्रतिनिधित्व को कुछ संतोषजनक आकार में छोटा कर दिया जाएगा या फिर परिमेय संख्या होगी प्रयुक्त: अंश और हर के लिए बड़ा पूर्णांक। किन्तु सबसे बड़े सामान्य [[भाजक]] के विभाजित होने पर भी, परिमेय संख्याओं के साथ अंकगणित बहुत जल्दी भारी हो सकता है: 1/99 − 1/100 = 1/9900, और यदि 1/101 जोड़ा जाता है, तो परिणाम 10001/999900 होता है।

आर्बिट्ररी-स्पष्ट संख्याओं का आकार अभ्यास में उपलब्ध कुल स्टोरेज और गणना समय द्वारा सीमित है।

आर्बिट्ररी स्पष्टता के साथ संग्रहीत संख्याओं पर कुशलतापूर्वक अंकगणितीय संचालन करने के लिए कई [[एल्गोरिदम]] विकसित किए गए हैं। विशेष रूप से, मान लीजिए {{math|''N''}} अंक नियोजित हैं, एल्गोरिदम को बड़े माप पर एसिम्प्टोटिक [[कम्प्यूटेशनल जटिलता सिद्धांत|कम्प्यूटेशनल समिश्रता सिद्धांत]] {{math|''N''}} को कम करने के लिए डिज़ाइन किया गया है .

सबसे सरल एल्गोरिद्म जोड़ और [[घटाव]] के लिए हैं, जहां कोई अंकों को अनुक्रम में जोड़ता या घटाता है, आवश्यकतानुसार ले जाता है, जिससे {{math|O(''N'')}} एल्गोरिदम अंक प्राप्त होता है। ([[बिग ओ नोटेशन]] देखें)।

[[तुलना (कंप्यूटर प्रोग्रामिंग)]] भी बहुत सरल है। अंतर मिलने तक उच्च-क्रम के अंकों (या मशीन शब्द) की तुलना करें। शेष अंकों/शब्दों की तुलना करना आवश्यक नहीं है। किन्तु {{math|<math>\Theta</math>(''N'')}} सबसे व्यर्थ समय है , किन्तु सामान्यतः यह बहुत तेज हो जाता है।

गुणन के लिए, संख्याओं को हाथ से [[गुणा]] करने के लिए उपयोग किए जाने वाले सबसे सरल एल्गोरिदम (जैसा कि प्राथमिक विद्यालय में पढ़ाया जाता है) को {{math|<math>\Theta</math>(''N''<sup>2</sup>)}} संचालन की आवश्यकता होती है, किन्तु गुणन एल्गोरिदम जो {{math|O(''N''&nbsp;log(''N'')&nbsp;log(log(''N'')))}} समिश्रता प्राप्त करते हैं, तैयार किए गए हैं, जैसे कि शॉनहेज-स्ट्रैसन एल्गोरिदम, जो तेजी से फूरियर परिवर्तनों पर आधारित है, और थोड़े व्यर्थ समिश्रता वाले एल्गोरिदम भी हैं, किन्तु कभी-कभी छोटे {{math|''N''}} के लिए उत्तम वास्तविक संसार के प्रदर्शन के साथ करात्सुबा गुणन एक ऐसा एल्गोरिदम है।

डिवीजन (गणित) के लिए, [[विभाजन एल्गोरिथ्म]] देखें।

समिश्रता अनुमानों के साथ एल्गोरिदम की सूची के लिए, [[गणितीय कार्यों की कम्प्यूटेशनल जटिलता|गणितीय कार्यों की कम्प्यूटेशनल समिश्रता]] देखें।

उदाहरण के लिए x[[86]] असेंबली में, बाहरी लिंक देखें।

== प्री-सेट स्पष्ट ==
कुछ लैंग्वेज जैसे [[REXX|रेक्स]] में, गणना करने से पहले सभी गणनाओं की स्पष्टता निर्धारित की जानी चाहिए। अन्य लैंग्वेजएँ, जैसे कि पायथन (प्रोग्रामिंग लैंग्वेज) और रूबी (प्रोग्रामिंग लैंग्वेज), अतिप्रवाह को रोकने के लिए स्वचालित रूप से स्पष्टता का विस्तार करती हैं।

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

किन्तु यदि बड़े फैक्टोरियल के लिए स्पष्ट मान वांछित हैं, तो विशेष सॉफ्टवेयर की आवश्यकता होती है, जैसा कि छद्म कोड में होता है, जो 1, 1×2, 1×2×3, 1×2×3×4 की गणना करने के लिए क्लासिक एल्गोरिदम को प्रयुक्त करता है। आदि क्रमिक भाज्य संख्याएँ है।<syntaxhighlight lang="abl">
constants:
  Limit = 1000                   % Sufficient digits.                                                                   
  Base = 10                      % The base of the simulated arithmetic.                                                
  FactorialLimit = 365           % Target number to solve, 365!                                                               
  tdigit: Array[0:9] of character = ["0","1","2","3","4","5","6","7","8","9"]                                           
                                                                                                                          
variables:                                                                                                             
  digit: Array[1:Limit] of 0..9  % The big number.                                                                           
  carry, d: Integer              % Assistants during multiplication.                                                           
  last: Integer                  % Index into the big number's digits.                                                                            
  text: Array[1:Limit] of character % Scratchpad for the output.                                                                  
                                                                                                                              
digit[*] := 0                    % Clear the whole array.                                                                                               
last := 1                        % The big number starts as a single-digit,                                                      
digit[1] := 1                    % its only digit is 1.                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                 
for n := 1 to FactorialLimit:    % Step through producing 1!, 2!, 3!, 4!, etc.                                                                                                                       
                                                                                                                        
  carry := 0                     % Start a multiply by n.                                                                                                                                    
  for i := 1 to last:            % Step along every digit.                                                                                                                             
    d := digit[i] * n + carry    % Multiply a single digit.                                                              
    digit[i] := d mod Base       % Keep the low-order digit of the result.                                                   
    carry := d div Base          % Carry over to the next digit.                                                                   
                                                                                                                                                   
  while carry > 0:               % Store the remaining carry in the big number.
    if last >= Limit: error("overflow")                                                                                                               
    last := last + 1             % One more digit.                                                                             
    digit[last] := carry mod Base                                                                                                
    carry := carry div Base      % Strip the last digit off the carry.                                                         
                                                                                                                          
  text[*] := " "                 % Now prepare the output.                                                                      
  for i := 1 to last:            % Translate from binary to text.                                                                
    text[Limit - i + 1] := tdigit[digit[i]]  % Reversing the order.                                                                                                
  print text[Limit - last + 1:Limit], " = ", n, "!"                                                                    
</syntaxhighlight>उदाहरण को ध्यान में रखते हुए, कई विवरणों पर चर्चा की जा सकती है। सबसे महत्वपूर्ण बड़ी संख्या के प्रतिनिधित्व का चुनाव है। इस स्थितियों में, अंकों के लिए केवल पूर्णांक मानों की आवश्यकता होती है, इसलिए निश्चित-चौड़ाई वाले पूर्णांकों की सरणी पर्याप्त होती है। सरणी के निरंतर अवयवो को आधार की उच्च शक्तियों का प्रतिनिधित्व करना सुविधाजनक है।

दूसरा सबसे महत्वपूर्ण निर्णय अंकगणित के आधार के चुनाव में है, यहाँ दस कई तथ्य हैं। स्क्रैचपैड चर {{mvar|d}} एक-अंक के गुणा के परिणाम को धारण करने में सक्षम होना चाहिए और पिछले अंक के गुणन से वहन करना चाहिए। आधार दस में, सोलह-बिट पूर्णांक निश्चित रूप से पर्याप्त है क्योंकि यह 32767 तक की अनुमति देता है। चूँकि, यह उदाहरण धोखा देता है, जिसमें का मान {{mvar|n}} स्वयं अंक तक सीमित नहीं है। इसका परिणाम यह होता है कि यह विधि विफल हो जाएगी {{math|''n'' > 3200}} या ऐसा अधिक सामान्य कार्यान्वयन में, {{mvar|n}} बहु-अंकीय प्रतिनिधित्व का भी उपयोग करता है। शॉर्टकट का दूसरा परिणाम यह है कि मल्टी-डिजिट गुणा पूरा होने के पश्चात्, कैरी के अंतिम मूल्य को केवल ही नहीं, किन्तु कई उच्च-क्रम अंकों में ले जाने की आवश्यकता हो सकती है।

मानव तथ्य के लिए परिणाम को आधार दस में प्रिंट करने का उद्देश्य भी है। क्योंकि आधार पहले से ही दस है, परिणाम केवल सरणी अंकों के क्रमिक अंकों को प्रिंट करके दिखाया जा सकता है, किन्तु वे उच्चतम-क्रम अंक के साथ अंतिम रूप से दिखाई देंगे (जिससे 123 321 के रूप में दिखाई दे)। पूरे सरणी को उल्टे क्रम में मुद्रित किया जा सकता है, किन्तु वह संख्या को अग्रणी शून्य ( 00000...000123 ) के साथ प्रस्तुत करता है, जिसकी गुण नहीं की जा सकती है, इसलिए यह कार्यान्वयन अंतरिक्ष-गद्देदार पाठ चर में प्रतिनिधित्व बनाता है और फिर उसे प्रिंट करता है। पहले कुछ परिणाम (प्रत्येक पाँचवें अंक में रिक्ति और यहाँ जोड़े गए एनोटेशन के साथ) हैं:

{| style="text-align: right; white-space: nowrap; line-height: 80%"
! colspan=2 style="text-align: center" | भाज्य संख्याएँ
! colspan=2 style="text-align: center" | कंप्यूटर पूर्णांकों की पहुंच
|-
|                                                 1 = ||  1!
|-
|                                                 2 = ||  2!
|-
|                                                 6 = ||  3!
|-
|                                                24 = ||  4!
|-
|                                               120 = ||  5!
| 8-bit || style="text-align: left" | 255
|-
|                                               720 = ||  6!
|-
|                                              5040 = ||  7!
|-
|                                             40320 = ||  8!
| 16-bit || style="text-align: left" | 65535
|-
|                                           3 62880 = ||  9!  
|-
|                                          36 28800 = || 10!  
|-
|                                         399 16800 = || 11!
|-
|                                        4790 01600 = || 12!
| 32-bit || style="text-align: left" | 42949 67295
|-
|                                       62270 20800 = || 13!  
|-
|                                     8 71782 91200 = || 14!  
|-
|                                   130 76743 68000 = || 15!  
|-
|                                  2092 27898 88000 = || 16!  
|-
|                                 35568 74280 96000 = || 17!  
|-
|                               6 40237 37057 28000 = || 18!  
|-
|                             121 64510 04088 32000 = || 19!  
|-
|                            2432 90200 81766 40000 = || 20!
| 64-bit || style="text-align: left" | 18446 74407 37095 51615
|-
|                           51090 94217 17094 40000 = || 21!  
|-
|                        11 24000 72777 76076 80000 = || 22!  
|-
|                       258 52016 73888 49766 40000 = || 23!  
|-
|                      6204 48401 73323 94393 60000 = || 24!  
|-
|                   1 55112 10043 33098 59840 00000 = || 25!  
|-
|                  40 32914 61126 60563 55840 00000 = || 26!  
|-
|                1088 88694 50418 35216 07680 00000 = || 27!  
|-
|               30488 83446 11713 86050 15040 00000 = || 28!  
|-
|             8 84176 19937 39701 95454 36160 00000 = || 29!  
|-
|           265 25285 98121 91058 63630 84800 00000 = || 30!  
|-
|          8222 83865 41779 22817 72556 28800 00000 = || 31!
|-
|       2 63130 83693 36935 30167 21801 21600 00000 = || 32!
|-
|      86 83317 61881 18864 95518 19440 12800 00000 = || 33!
|-
|    2952 32799 03960 41408 47618 60964 35200 00000 = || 34!
| 128-bit || style="text-align: left" | 3402 82366 92093 84634 63374 60743 17682 11455
|-
| 1 03331 47966 38614 49296 66651 33752 32000 00000 = || 35!
|}
यह कार्यान्वयन कंप्यूटर के अंतर्निहित अंकगणित का अधिक प्रभावी उपयोग कर सकता है। आधार 100 (आउटपुट के लिए अनुवाद प्रक्रिया में संबंधित परिवर्तनों के साथ) का उपयोग करने के लिए साधारण वृद्धि होगी, या, पर्याप्त रूप से विस्तृत कंप्यूटर चर (जैसे 32-बिट पूर्णांक) के साथ हम 10,000 जैसे बड़े आधारों का उपयोग कर सकते हैं। कंप्यूटर के बिल्ट-इन पूर्णांक संचालन के निकट पावर-ऑफ-2 बेस में कार्य करने से लाभ मिलता है, चूँकि आउटपुट के लिए दशमलव आधार में रूपांतरण अधिक कठिन हो जाता है। विशिष्ट आधुनिक कंप्यूटरों पर, परिवर्धन और गुणन, संकार्यों के मूल्यों से स्वतंत्र निरंतर समय लेते हैं (जब तक कि संकार्य एकल मशीन शब्दों में फिट होते हैं), इसलिए प्रत्येक तत्व में जितना संभव हो उतना बड़ी संख्या में पैकिंग में बड़े लाभ होते हैं। अंकों की सरणी कंप्यूटर किसी उत्पाद को अंक में विभाजित करने और उदाहरण के रूप में मॉड और डिव के दो संचालन की आवश्यकता के बिना ले जाने की सुविधा भी प्रदान कर सकता है, और लगभग सभी अंकगणितीय इकाइयाँ [[झंडा ले जाना|कैरी फ्लैग]] प्रदान करती हैं जिसका उपयोग बहु-स्पष्ट जोड़ और घटाव में किया जा सकता है। इस प्रकार का विवरण मशीन-कोड प्रोग्रामर का ग्रिस्ट है, और उपयुक्त असेंबली-लैंग्वेज बिगनंबर रूटीन उच्च-स्तरीय लैंग्वेज के संकलन के परिणाम की तुलना में बहुत तेजी से चल सकता है, जो ऐसी सुविधाओं तक पहुंच प्रदान नहीं करता है।

एकल-अंकों के गुणा के लिए कार्यशील चर को मान (आधार-1){{sup|2}} + कैरी रखने में सक्षम होना चाहिए, जहां कैरी का अधिकतम मूल्य (आधार-1) है। इसी तरह, अंकों की सरणी को अनुक्रमित करने के लिए उपयोग किए जाने वाले चर स्वयं चौड़ाई में सीमित होते हैं। सूचकांकों का विस्तार करने का सरल विधि कुछ सुविधाजनक आकार के ब्लॉक में बड़ी संख्या के अंकों से निपटना होगा जिससे एड्रेसिंग (ब्लॉक i, अंक j) के माध्यम से होते है, जहां i और j छोटे पूर्णांक होंगे, या कोई आगे बढ़ सकता है इंडेक्सिंग वेरिएबल्स के लिए बिगनंबर तकनीकों को नियोजित करता है। अंततः, मशीन स्टोरेज क्षमता और निष्पादन समय समस्या के आकार पर सीमाएँ लगाते हैं।

== इतिहास ==
1950 के दशक के मध्य में आईबीएम का पहला व्यावसायिक कंप्यूटर, [[IBM 702|आईबीएम 702]] (एक [[वेक्यूम - ट्यूब]] मशीन), पूर्णांक अंकगणित को 1 से 511 अंकों की किसी भी लंबाई के अंकों के तार पर पूरी तरह से हार्डवेयर में प्रयुक्त किया था। आर्बिट्ररी-स्पष्ट अंकगणित का सबसे पहला व्यापक सॉफ्टवेयर कार्यान्वयन संभवतः [[Maclisp|मैकलिस्प]] में था। पश्चात् में, 1980 के आसपास, [[ऑपरेटिंग सिस्टम]] वैक्स/वीएमएस और वीएम/सीएमएस ने स्थितियों में [[शाब्दिक स्ट्रिंग|स्ट्रिंग फ़ंक्शंस]] [[Subprogram|सबप्रोग्राम]] के संग्रह के रूप में और दूसरे में [[EXEC 2|ऐक्सेस 2]] और रेक्स लैंग्वेज में बिग्नम सुविधाओं की प्रस्तुति की थी।

1959-1970 के आईबीएम 1620 के माध्यम से प्रारंभिक व्यापक कार्यान्वयन उपलब्ध था। 1620 दशमलव-अंकीय मशीन थी जो असतत ट्रांजिस्टर का उपयोग करती थी, फिर भी इसमें लंबाई के अंकों के तार पर पूर्णांक अंकगणित करने के लिए हार्डवेयर (जो [[तालिका देखो]] का उपयोग किया गया था) था जो दो से लेकर जो भी मेमोरी उपलब्ध थी। फ़्लोटिंग-पॉइंट अंकगणित के लिए, मंटिसा सौ अंकों या उससे कम तक सीमित था, और एक्सपोनेंट केवल दो अंकों तक ही सीमित था। आपूर्ति की गई सबसे बड़ी मेमोरी 60 000 अंकों की प्रस्तुति करती है, चूँकि 1620 के लिए [[फोरट्रान]] कंपाइलर निश्चित आकार जैसे 10 पर बसे, चूँकि इसे नियंत्रण कार्ड पर निर्दिष्ट किया जा सकता है यदि डिफ़ॉल्ट संतोषजनक नहीं था।

== सॉफ्टवेयर लाइब्रेरी ==
{{See also|आर्बिट्ररी-स्पष्टता अंकगणित सॉफ्टवेयर की सूची}}
अधिकांश कंप्यूटर सॉफ़्टवेयर में आर्बिट्ररी-स्पष्टता अंकगणित बाहरी [[पुस्तकालय (कंप्यूटर विज्ञान)|लाइब्रेरी (कंप्यूटर विज्ञान)]] को कॉल करके कार्यान्वित किया जाता है जो अनुरोधित स्पष्टता के साथ संख्याओं को संग्रहीत करने और संगणना करने के लिए [[डेटा प्रकार]] और [[सबरूटीन]] प्रदान करता है।

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

== यह भी देखें                                                                                                                                                                                          ==
* फ्यूरर का एल्गोरिदम
* करत्सुबा एल्गोरिथम
* [[मिश्रित-परिशुद्धता अंकगणित|मिश्रित-स्पष्टता अंकगणित]]
* शॉनहेज-स्ट्रैसन एल्गोरिथम
* टॉम-कुक गुणन

== संदर्भ ==

{{reflist}}
== आगे की पढाई ==
* {{Cite book|last=Knuth |first=Donald |author-link=Donald Knuth |title=Seminumerical Algorithms |series=[[The Art of Computer Programming]] |volume=2 |year=2008 |edition=3rd |publisher=Addison-Wesley |isbn=978-0-201-89684-8}}, Section 4.3.1: The Classical Algorithms
*{{cite book|author=Derick Wood|year=1984|title=Paradigms and Programming with Pascal|publisher=Computer Science Press|isbn=0-914894-45-5}}
*{{cite book|author=Richard Crandall, Carl Pomerance|year=2005|title=Prime Numbers|publisher=Springer-Verlag|isbn=9780387252827}}, Chapter 9: Fast Algorithms for Large-Integer Arithmetic
== बाहरी सम्बन्ध ==
* [https://web.archive.org/web/20101019002107/http://oopweb.com/Assembly/Documents/ArtOfAssembly/Volume/Chapter_9/CH09-3.html#HEADING3-1 Chapter 9.3 of ''The Art of Assembly''] by [[Randall Hyde]] discusses multiprecision arithmetic, with examples in [[x86]]-assembly.
* Rosetta Code task [http://rosettacode.org/wiki/Arbitrary-precision_integers_%28included%29 Arbitrary-precision integers] Case studies in the style in which over 95 programming languages compute the value of 5**4**3**2 using arbitrary precision arithmetic.

[[Category:Articles with hatnote templates targeting a nonexistent page]]
[[Category:CS1 English-language sources (en)]]
[[Category:CS1 français-language sources (fr)]]
[[Category:Created On 27/01/2023]]
[[Category:Lua-based templates]]
[[Category:Machine Translated Page]]
[[Category:Pages with script errors]]
[[Category:Short description with empty Wikidata description]]
[[Category:Templates Vigyan Ready]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that generate short descriptions]]
[[Category:Templates using TemplateData]]
[[Category:कंप्यूटर अंकगणित]]
[[Category:कंप्यूटर अंकगणितीय एल्गोरिदम]]