मैं सी सीखने की कोशिश कर रहा हूं और वास्तव में बड़ी संख्या (यानी, 100 अंक, 1000 अंक, आदि) के साथ काम करने में असमर्थता में आया हूं। मुझे पता है कि ऐसा करने के लिए पुस्तकालय मौजूद हैं, लेकिन मैं इसे स्वयं लागू करने का प्रयास करना चाहता हूं।
मैं सिर्फ यह जानना चाहता हूं कि क्या किसी के पास बहुत विस्तृत, मनमानी-सटीक अंकगणित की गूढ़ व्याख्या हो सकती है।
जवाबों:
संख्याओं को छोटे भागों के रूप में व्यवहार करना पर्याप्त भंडारण और एल्गोरिदम की बात है। मान लेते हैं कि आपके पास एक कंपाइलर है, जो intकेवल 99 के माध्यम से 0 हो सकता है और आप 999999 तक संख्याओं को संभालना चाहते हैं (हम इसे सरल रखने के लिए केवल सकारात्मक संख्याओं के बारे में चिंता करेंगे)।
आप ऐसा करते हैं कि प्रत्येक संख्या को तीन intएस देकर और समान नियमों का उपयोग करके (आपके पास) इसके अलावा, घटाव और अन्य बुनियादी कार्यों के लिए प्राथमिक विद्यालय में वापस सीखा है।
एक मनमाने ढंग से सटीक लाइब्रेरी में, हमारी संख्याओं का प्रतिनिधित्व करने के लिए उपयोग किए जाने वाले आधार प्रकारों की संख्या पर कोई निश्चित सीमा नहीं है, बस जो भी मेमोरी पकड़ सकती है।
उदाहरण के लिए 123456 + 78:
12 34 56
78
-- -- --
12 35 34
कम से कम महत्वपूर्ण छोर से कार्य करना:
यह वास्तव में, आपके सीपीयू के अंदर बिट स्तर पर आम तौर पर कैसे काम करता है, इसके अतिरिक्त है।
घटाव समान है (आधार प्रकार के घटाव का उपयोग करना और कैरी के बजाय उधार लेना), गुणा बार-बार परिवर्धन (बहुत धीमी गति से) या क्रॉस-उत्पाद (तेज) के साथ किया जा सकता है और विभाजन पेचीदा होता है, लेकिन संख्याओं के स्थानांतरण और घटाव के द्वारा किया जा सकता है शामिल (लंबे विभाजन को आपने एक बच्चे के रूप में सीखा होगा)।
मैंने वास्तव में पुस्तकालयों को दस की अधिकतम शक्तियों का उपयोग करके इस तरह का सामान करने के लिए लिखा है जो कि एक पूर्णांक में फिट हो सकते हैं जब चुकता (दो से intएक साथ गुणा करने पर अतिप्रवाह को रोकने के लिए , जैसे कि 16-बिट intको 99 से 0 तक सीमित किया जा रहा है। 9,801 (<32,768) उत्पन्न करते हैं, जब चुकता होता है, या int99,80,001 (<2,147,483,648) उत्पन्न करने के लिए 9,999 के माध्यम से 0 का उपयोग करके 32-बिट होता है, जिसने एल्गोरिदम को बहुत कम कर दिया।
बाहर देखने के लिए कुछ ट्रिक्स।
1 / संख्याओं को जोड़ने या गुणा करने पर, आवश्यक अधिकतम स्थान पूर्व-आवंटित करें बाद में कम करें यदि आपको लगता है कि यह बहुत अधिक है। उदाहरण के लिए, दो 100- "अंक" (जहां अंक एक है int) संख्याओं को जोड़ना आपको 101 अंकों से अधिक कभी नहीं देगा। 12 अंकों की संख्या को 3 अंकों की संख्या से गुणा करें, कभी भी 15 अंकों से अधिक नहीं होगा (अंकों की संख्या जोड़ें)।
2 / अतिरिक्त गति के लिए, नंबरों को सामान्य करें (यदि आवश्यक हो तो स्टोरेज को कम करें) केवल अगर पूरी तरह से आवश्यक हो - मेरे पुस्तकालय में यह एक अलग कॉल था, इसलिए उपयोगकर्ता गति और भंडारण चिंताओं के बीच निर्णय ले सकता है।
3 / एक सकारात्मक और ऋणात्मक संख्या का जोड़ घटाना है, और एक ऋणात्मक संख्या को घटाना समान धनात्मक को जोड़ना है। आप ऐड को एडजस्ट करने और संकेतों को एडजस्ट करने के बाद एक-दूसरे को कॉल करने के लिए काफी कोड बचा सकते हैं।
4 / छोटे संख्याओं से बड़ी संख्या को घटाने से बचें क्योंकि जब तक आप संख्याओं को समाप्त नहीं करते हैं, जैसे:
10
11-
-- -- -- --
99 99 99 99 (and you still have a borrow).
इसके बजाय, 11 से 10 घटाएं, फिर इसे नकारें:
11
10-
--
1 (then negate to get -1).
यहां उन पुस्तकालयों में से एक से टिप्पणी (पाठ में बदल गई) जो मुझे इसके लिए करनी थी। कोड ही, दुर्भाग्य से, कॉपीराइट है, लेकिन आप चार बुनियादी कार्यों को संभालने के लिए पर्याप्त जानकारी लेने में सक्षम हो सकते हैं। निम्नलिखित में मान लें कि -aऔर -bऋणात्मक संख्याओं का प्रतिनिधित्व करते हैं aऔर bशून्य या सकारात्मक संख्या हैं।
इसके अलावा , यदि संकेत अलग-अलग हैं, तो नकार के घटाव का उपयोग करें:
-a + b becomes b - a
a + -b becomes a - b
के लिए घटाव , लक्षण अलग हैं, निषेध का उपयोग इसके अलावा:
a - -b becomes a + b
-a - b becomes -(a + b)
यह भी सुनिश्चित करने के लिए कि हम बड़ी संख्या से छोटी संख्या घटा रहे हैं:
small - big becomes -(big - small)
गुणन निम्नानुसार प्रविष्टि स्तर के गणित का उपयोग करता है:
475(a) x 32(b) = 475 x (30 + 2)
= 475 x 30 + 475 x 2
= 4750 x 3 + 475 x 2
= 4750 + 4750 + 4750 + 475 + 475
जिस तरह से इसे हासिल किया जाता है, उसमें एक समय (पीछे की तरफ) 32 अंकों में से प्रत्येक को निकालना शामिल होता है, फिर परिणाम में जोड़े जाने वाले मूल्य की गणना करने के लिए ऐड का उपयोग करना (शुरू में शून्य)।
ShiftLeftऔर ShiftRightऑपरेशन को LongIntरैप वैल्यू (10 के लिए "वास्तविक" गणित) से जल्दी से गुणा या विभाजित करने के लिए उपयोग किया जाता है । ऊपर के उदाहरण में, हम 475 को शून्य से 2 गुना (32 का अंतिम अंक) जोड़कर 950 प्राप्त करते हैं (परिणाम = 0 + 950 = 950)।
फिर हमने 4750 प्राप्त करने के लिए 475 को छोड़ दिया और 3. पाने के लिए दाईं ओर 32 को स्थानांतरित किया। 14250 को प्राप्त करने के लिए 4750 को शून्य से 3 गुना जोड़ें और फिर 950 के परिणाम में जोड़कर 15200 प्राप्त करें।
लेफ्ट शिफ्ट 4750 47500 पाने के लिए, राइट शिफ्ट 3 पाने के लिए 0. क्योंकि राइट शिफ्ट 32 अब शून्य है, हम समाप्त हो चुके हैं और वास्तव में 475 x 32 15200 के बराबर है।
विभाजन भी मुश्किल है लेकिन प्रारंभिक अंकगणित ("" में चला जाता है "" के लिए "gazinta" विधि) पर आधारित है। निम्नलिखित के लिए लंबे विभाजन पर विचार करें 12345 / 27:
457
+-------
27 | 12345 27 is larger than 1 or 12 so we first use 123.
108 27 goes into 123 4 times, 4 x 27 = 108, 123 - 108 = 15.
---
154 Bring down 4.
135 27 goes into 154 5 times, 5 x 27 = 135, 154 - 135 = 19.
---
195 Bring down 5.
189 27 goes into 195 7 times, 7 x 27 = 189, 195 - 189 = 6.
---
6 Nothing more to bring down, so stop.
इसलिए 12345 / 27है 457शेष के साथ 6। सत्यापित करें:
457 x 27 + 6
= 12339 + 6
= 12345
इसे 12345 के सेगमेंट को नीचे लाने के लिए एक ड्रॉ-डाउन वेरिएबल (शुरू में शून्य) का उपयोग करके लागू किया जाता है, जब तक कि यह 27 से अधिक या बराबर न हो।
तब हम केवल 27 को घटाते हैं जब तक कि हम 27 से नीचे नहीं निकल जाते - घटाव की संख्या शीर्ष रेखा में जोड़ा गया खंड है।
जब नीचे लाने के लिए अधिक खंड नहीं हैं, तो हमारे पास हमारा परिणाम है।
ध्यान रखें कि ये बहुत बुनियादी एल्गोरिदम हैं। यदि आपके अंक विशेष रूप से बड़े होने जा रहे हैं तो जटिल अंकगणित करने के बेहतर तरीके हैं। आप ग्नू मल्टीपल प्रिसिजन अरिथमेटिक लाइब्रेरी जैसी किसी चीज़ में देख सकते हैं - यह मेरे अपने पुस्तकालयों की तुलना में काफी बेहतर और तेज़ है।
इसमें यह दुर्भाग्यपूर्ण मिसफिट है कि यह केवल बाहर निकल जाएगा यदि यह स्मृति से बाहर निकलता है (मेरी राय में एक सामान्य उद्देश्य पुस्तकालय के लिए एक घातक दोष) लेकिन, अगर आप अतीत को देख सकते हैं, तो यह क्या करता है पर बहुत अच्छा है।
यदि आप इसका उपयोग लाइसेंसिंग कारणों से नहीं कर सकते हैं (या क्योंकि आप अपने आवेदन को बिना किसी स्पष्ट कारण के बाहर निकालना चाहते हैं), तो आप कम से कम एल्गोरिदम को अपने कोड में एकीकृत करने के लिए वहां से प्राप्त कर सकते हैं।
मैंने यह भी पाया है कि एमपीआईआर (जीएमपी का एक कांटा) पर बॉड्स संभावित परिवर्तनों पर चर्चा करने के लिए अधिक उत्तरदायी हैं - वे एक अधिक डेवलपर-अनुकूल गुच्छा लगते हैं।
पहिया का पुनः आविष्कार करते समय आपके व्यक्तिगत संपादन और सीखने के लिए बहुत अच्छा है, यह एक बहुत बड़ा कार्य भी है। मैं आपको इसके एक महत्वपूर्ण अभ्यास के रूप में मना नहीं करना चाहता हूं और एक जो मैंने खुद किया है, लेकिन आपको पता होना चाहिए कि काम पर सूक्ष्म और जटिल मुद्दे हैं जो बड़े पैकेज को संबोधित करते हैं।
उदाहरण के लिए, गुणा। शाब्दिक रूप से, आप 'स्कूलबॉय' पद्धति के बारे में सोच सकते हैं, यानी एक के बाद एक नंबर लिखेंगे, फिर स्कूल में सीखी गई लंबी गुणा-भाग करें। उदाहरण:
123
x 34
-----
492
+ 3690
---------
4182
लेकिन यह तरीका बेहद धीमा है (O (n ^ 2), n अंकों की संख्या)। इसके बजाय, आधुनिक बिग्नम पैकेज या तो असतत फूरियर ट्रांसफॉर्म या न्यूमेरिक ट्रांसफॉर्म का उपयोग करके इसे अनिवार्य रूप से O (n ln (n)) ऑपरेशन में बदल देते हैं।
और यह केवल पूर्णांकों के लिए है। जब आप संख्या के कुछ वास्तविक प्रतिनिधित्व (लॉग, sqrt, ऍक्स्प, आदि) पर अधिक जटिल कार्यों में शामिल हो जाते हैं तो चीजें और भी जटिल हो जाती हैं।
यदि आप कुछ सैद्धांतिक पृष्ठभूमि चाहते हैं, तो मैं अत्यधिक याप की पुस्तक के पहले अध्याय को पढ़ने की सलाह देता हूं, "फंडामेंटल प्रॉब्लम्स ऑफ अल्गोरिथमिक बीजगणित" । जैसा कि पहले ही उल्लेख किया गया है, gmp bignum पुस्तकालय एक उत्कृष्ट पुस्तकालय है। वास्तविक संख्याओं के लिए, मैंने mpfr का उपयोग किया है और इसे पसंद किया है।
पहिया को सुदृढ़ न करें: यह चौकोर हो सकता है!
जीएनयू एमपी जैसे तीसरे पक्ष के पुस्तकालय का उपयोग करें , जिसे आजमाया और परखा गया।
abort()आवंटन को विफल करता है, जो कुछ निश्चित रूप से बड़े-बड़े कम्प्यूटेशन के साथ होने के लिए बाध्य हैं। यह एक पुस्तकालय के लिए अस्वीकार्य व्यवहार है और अपने स्वयं के मनमाने ढंग से सटीक कोड लिखने के लिए पर्याप्त कारण है।
आप इसे मूल रूप से उसी तरह से करते हैं जैसे आप पेंसिल और कागज के साथ करते हैं ...
mallocऔरrealloc ) के रूप में की जरूरत हैआमतौर पर आप गणना की मूल इकाई के रूप में उपयोग करेंगे
अपनी वास्तुकला के अनुसार।
द्विआधारी या दशमलव आधार का विकल्प आप पर निर्भर करता है कि अधिकतम अंतरिक्ष दक्षता, मानव पठनीयता, और आपकी चिप पर बाइनरी कोडेड डेसीमल (बीसीडी) गणित समर्थन की अनुपस्थिति की उपस्थिति।
आप इसे हाई स्कूल स्तर के गणित के साथ कर सकते हैं। हालांकि वास्तविकता में अधिक उन्नत एल्गोरिदम का उपयोग किया जाता है। उदाहरण के लिए दो 1024-बाइट संख्याओं को जोड़ने के लिए:
unsigned char first[1024], second[1024], result[1025];
unsigned char carry = 0;
unsigned int sum = 0;
for(size_t i = 0; i < 1024; i++)
{
sum = first[i] + second[i] + carry;
carry = sum - 255;
}
one placeअधिकतम मानों की देखभाल करने के लिए परिणाम बड़े होने की स्थिति में होगा। इसे देखो :
9
+
9
----
18
TTMathअगर आप सीखना चाहते हैं तो एक बेहतरीन लाइब्रेरी है। इसे C ++ का उपयोग करके बनाया गया है। उपरोक्त उदाहरण एक मूर्खतापूर्ण था, लेकिन सामान्य रूप से इसके अलावा और घटाव होता है!
विषय के बारे में एक अच्छा संदर्भ गणितीय कार्यों की कम्प्यूटेशनल जटिलता है । यह आपको बताता है कि प्रत्येक ऑपरेशन के लिए कितना स्थान आवश्यक है जिसे आप लागू करना चाहते हैं। उदाहरण के लिए, यदि आपके पास दो हैंN-digit नंबर हैं, तो आपको 2N digitsगुणा के परिणाम को संग्रहीत करने की आवश्यकता है।
जैसा कि मिच ने कहा, यह अब तक लागू करने का आसान काम नहीं है! मेरा सुझाव है कि यदि आप C ++ जानते हैं तो आप TTMath पर एक नज़र डालें।
अंतिम संदर्भों में से एक (IMHO) नथ का TAOCP वॉल्यूम II है। यह संख्याओं का प्रतिनिधित्व करने और इन अभ्यावेदन पर अंकगणितीय संचालन के लिए बहुत सारे एल्गोरिदम की व्याख्या करता है।
@Book{Knuth:taocp:2,
author = {Knuth, Donald E.},
title = {The Art of Computer Programming},
volume = {2: Seminumerical Algorithms, second edition},
year = {1981},
publisher = {\Range{Addison}{Wesley}},
isbn = {0-201-03822-6},
}
यह मानते हुए कि आप स्वयं एक बड़ा पूर्णांक कोड लिखना चाहते हैं, यह करने के लिए आश्चर्यजनक रूप से सरल हो सकता है, किसी ऐसे व्यक्ति के रूप में बोला जाता है जिसने हाल ही में किया था (हालांकि MATLAB में।) यहाँ कुछ चालें हैं जिनका मैंने उपयोग किया है:
मैंने प्रत्येक व्यक्तिगत दशमलव अंक को एक डबल संख्या के रूप में संग्रहीत किया। यह कई कार्यों को सरल बनाता है, विशेष रूप से आउटपुट। हालांकि यह आपकी इच्छा से अधिक भंडारण करता है, यहां मेमोरी सस्ती है, और यह गुणन को बहुत कुशल बनाता है यदि आप एक जोड़ी वैक्टर को कुशलतापूर्वक स्थापित कर सकते हैं। वैकल्पिक रूप से, आप कई दशमलव अंकों को एक दोहरे में संग्रहीत कर सकते हैं, लेकिन फिर उस गुणन को करने के लिए दृढ़ संकल्प बहुत बड़ी संख्याओं पर संख्यात्मक समस्याओं का कारण बन सकता है।
अलग से एक साइन बिट स्टोर करें।
दो नंबरों को जोड़ना मुख्य रूप से अंकों को जोड़ने का मामला है, फिर प्रत्येक चरण में एक कैरी की जाँच करें।
संख्याओं की एक जोड़ी का गुणन सबसे अच्छा किया जाता है, क्योंकि दृढ़ संकल्प एक कैरी स्टेप के बाद होता है, कम से कम यदि आपके पास टैप के लिए एक तेज संकेतन कोड है।
यहां तक कि जब आप संख्याओं को व्यक्तिगत दशमलव अंकों की एक स्ट्रिंग के रूप में संग्रहीत करते हैं, तब भी परिणाम में एक समय में लगभग 13 दशमलव अंकों को प्राप्त करने के लिए विभाजन (मॉड / रेम ऑप्स) किया जा सकता है। यह एक विभाजन से बहुत अधिक कुशल है जो एक समय में केवल 1 दशमलव अंक पर काम करता है।
पूर्णांक की पूर्णांक शक्ति की गणना करने के लिए, घातांक के द्विआधारी प्रतिनिधित्व की गणना करें। फिर जरूरत पड़ने पर शक्तियों की गणना के लिए बार-बार स्क्वेरिंग ऑपरेशन का उपयोग करें।
कई ऑपरेशन (फैक्टरिंग, प्राइमलिटी टेस्ट आदि) एक पावरमॉड ऑपरेशन से लाभान्वित होंगे। यही है, जब आप मॉड (ए ^ पी, एन) की गणना करते हैं, तो परिणाम मॉड एन को घातांक के प्रत्येक चरण पर कम करें जहां पी बाइनरी रूप में व्यक्त किया गया है। पहले ^ p की गणना न करें, और फिर इसे मॉड N से कम करने का प्रयास करें।
यहाँ मैंने PHP में एक सरल (भोली) उदाहरण दिया है।
मैंने "Add" और "Multiply" को लागू किया और एक घातांक उदाहरण के लिए इसका उपयोग किया।
http://adevsoft.com/simple-php-arbitrary-precision-integer-big-num-example/
कोड स्निप
// Add two big integers
function ba($a, $b)
{
if( $a === "0" ) return $b;
else if( $b === "0") return $a;
$aa = str_split(strrev(strlen($a)>1?ltrim($a,"0"):$a), 9);
$bb = str_split(strrev(strlen($b)>1?ltrim($b,"0"):$b), 9);
$rr = Array();
$maxC = max(Array(count($aa), count($bb)));
$aa = array_pad(array_map("strrev", $aa),$maxC+1,"0");
$bb = array_pad(array_map("strrev", $bb),$maxC+1,"0");
for( $i=0; $i<=$maxC; $i++ )
{
$t = str_pad((string) ($aa[$i] + $bb[$i]), 9, "0", STR_PAD_LEFT);
if( strlen($t) > 9 )
{
$aa[$i+1] = ba($aa[$i+1], substr($t,0,1));
$t = substr($t, 1);
}
array_unshift($rr, $t);
}
return implode($rr);
}