करत्सुबा एल्गोरिथम: Difference between revisions
No edit summary |
No edit summary |
||
Line 37: | Line 37: | ||
=== बुनियादी कदम === | === बुनियादी कदम === | ||
करात्सुबा के एल्गोरिथ्म का मूल सिद्धांत विभाजित और | करात्सुबा के एल्गोरिथ्म का मूल सिद्धांत एक सूत्र का उपयोग करके विभाजित और जीतना है, जो किसी को दो बड़ी संख्याओं <math>x</math> और <math>y</math> के उत्पाद की गणना करने की अनुमति देता है, छोटी संख्याओं के तीन गुणन का उपयोग करके, प्रत्येक में <math>x</math> या <math>y</math> के रूप में लगभग आधे अंक होते हैं, साथ ही कुछ जोड़ और अंक बदलाव। यह बुनियादी कदम, वास्तव में, एक समान जटिल गुणन एल्गोरिथ्म का एक सामान्यीकरण है, जहां [[काल्पनिक इकाई]] {{mvar|i}} [[मूलांक]] की घात द्वारा प्रतिस्थापित किया जाता है। | ||
होने देना <math>x</math> और <math>y</math> के रूप में प्रतिनिधित्व किया जाए <math>n</math>- | होने देना <math>x</math> और <math>y</math> के रूप में प्रतिनिधित्व किया जाए <math>n</math>-संख्या रेखा कुछ आधार में <math>B</math>. किसी भी सकारात्मक पूर्णांक के लिए <math>m</math> से कम <math>n</math>, दी गई दो संख्याओं को इस प्रकार लिख सकते हैं | ||
:<math>x = x_1 B^m + x_0,</math> | :<math>x = x_1 B^m + x_0,</math> | ||
:<math>y = y_1 B^m + y_0,</math> | :<math>y = y_1 B^m + y_0,</math> | ||
कहाँ <math>x_0</math> और <math>y_0</math> से कम | कहाँ <math>x_0</math> और <math>y_0</math> से कम <math>B^m</math>. उत्पाद है तो | ||
<math> | <math> | ||
Line 72: | Line 72: | ||
=== उदाहरण === | === उदाहरण === | ||
12345 और 6789 के उत्पाद की गणना करने के लिए, जहां | 12345 और 6789 के उत्पाद की गणना करने के लिए, जहां b = 10, M = 3 चुनें। हम परिणामी आधार (b) का उपयोग करके इनपुट ऑपरेंड को विघटित करने के लिए M<sup>m</sup> = 1000) राइट शिफ्ट का उपयोग करते हैं, जैसा: | ||
: 12345 = '12' · 1000 + '345' | : 12345 = '12' · 1000 + '345' | ||
: 6789 = '6' · 1000 + '789' | : 6789 = '6' · 1000 + '789' | ||
केवल तीन गुणन, जो छोटे पूर्णांकों पर संचालित होता है, का उपयोग तीन आंशिक परिणामों की गणना करने के लिए किया जाता है: | केवल तीन गुणन, जो छोटे पूर्णांकों पर संचालित होता है, का उपयोग तीन आंशिक परिणामों की गणना करने के लिए किया जाता है: | ||
: | : Z<sub>2</sub> = 12 × 6 = 72 | ||
: '' | : ''Z''<sub>0</sub> = 345 × 789 = 272205 | ||
: '' | : ''Z''<sub>1</sub> = (12 + 345) × (6 + 789) - ''Z''<sub>2</sub> - Z<sub>0</sub> = 357 × 795 − 72 − 272205 = 283815 − 72 − 272205 = 11538 | ||
हम केवल इन तीन आंशिक परिणामों को जोड़कर परिणाम प्राप्त करते हैं, तदनुसार स्थानांतरित कर दिया जाता है (और फिर इनपुट ऑपरेंड के लिए इन तीन इनपुटों को आधार ''1000'' में विघटित करके ध्यान में रखा जाता है): | हम केवल इन तीन आंशिक परिणामों को जोड़कर परिणाम प्राप्त करते हैं, तदनुसार स्थानांतरित कर दिया जाता है (और फिर इनपुट ऑपरेंड के लिए इन तीन इनपुटों को आधार ''1000'' में विघटित करके ध्यान में रखा जाता है): | ||
: परिणाम = '' | : परिणाम = ''Z''<sub>2</sub> · (B<sup>m</sup>)<sup>2</sup> + के Z<sub>1</sub> · (B<sup>m</sup>)<sup>1</sup> + के Z<sub>0</sub> · (B<sup>m</sup>)<sup>0</sup>, अर्थात् | ||
: परिणाम = 72 · 1000<sup>2</sup> + 11538 · 1000 + 272205 = '83810205'। | : परिणाम = 72 · 1000<sup>2</sup> + 11538 · 1000 + 272205 = '83810205'। | ||
ध्यान दें कि मध्यवर्ती तीसरा गुणन इनपुट डोमेन पर संचालित होता है जो पहले दो गुणाओं की तुलना में दो गुना बड़ा होता है, इसका आउटपुट डोमेन चार गुना से कम बड़ा होता है, और पहले दो गुणाओं से गणना की गई आधार-1000 | ध्यान दें कि मध्यवर्ती तीसरा गुणन इनपुट डोमेन पर संचालित होता है जो पहले दो गुणाओं की तुलना में दो गुना बड़ा होता है, इसका आउटपुट डोमेन चार गुना से कम बड़ा होता है, और इन दो घटावों की गणना करते समय पहले दो गुणाओं से गणना की गई आधार-1000 को ध्यान में रखा जाना चाहिए। | ||
=== पुनरावर्ती अनुप्रयोग === | === पुनरावर्ती अनुप्रयोग === | ||
यदि n चार या अधिक है, तो करात्सुबा के मूल चरण में तीन गुणन में n अंकों से कम वाले ऑपरेंड शामिल हैं। इसलिए, उन उत्पादों की गणना करत्सुबा एल्गोरिथम की पुनरावर्ती कॉल द्वारा की जा सकती है। पुनरावर्तन तब तक लागू किया जा सकता है जब तक कि संख्याएं इतनी छोटी न हों कि उन्हें सीधे (या आवश्यक) गणना की जा सके। | यदि n चार या अधिक है, तो करात्सुबा के मूल चरण में तीन गुणन में n अंकों से कम वाले ऑपरेंड शामिल हैं। इसलिए, उन उत्पादों की गणना करत्सुबा एल्गोरिथम की पुनरावर्ती कॉल द्वारा की जा सकती है। पुनरावर्तन तब तक लागू किया जा सकता है जब तक कि संख्याएं इतनी छोटी न हों कि उन्हें सीधे (या आवश्यक) गणना की जा सके। | ||
पूर्ण 32-बिट गुणा 32-बिट [[बाइनरी गुणक]] वाले कंप्यूटर में, उदाहरण के लिए, कोई B = 2 | पूर्ण 32-बिट गुणा 32-बिट [[बाइनरी गुणक]] वाले कंप्यूटर में, उदाहरण के लिए, कोई B = 2<sup>31</sup> चुन सकता है और प्रत्येक अंक को अलग 32-बिट बाइनरी शब्द के रूप में संग्रहीत करें। फिर योग x<sub>1</sub> + x<sub>0</sub> और y<sub>1</sub> + y<sub>0</sub> कैरी-ओवर डिजिट ([[कैरी-सेव योजक]] के रूप में) को स्टोर करने के लिए अतिरिक्त बाइनरी शब्द की आवश्यकता नहीं होगी, और करत्सुबा रिकर्सन को तब तक लागू किया जा सकता है जब तक कि संख्याओं को गुणा करने के लिए केवल अंक लंबा न हो। | ||
=== [[समय जटिलता]] विश्लेषण === | === [[समय जटिलता]] विश्लेषण === | ||
करात्सुबा का मूल चरण किसी भी आधार | करात्सुबा का मूल चरण किसी भी आधार b और किसी भी m के लिए काम करता है, लेकिन पुनरावर्ती एल्गोरिथ्म सबसे अधिक कुशल होता है जब MN / 2 के बराबर होता है, और गोल होता है। विशेष रूप से, यदि n 2<sup>k</sup> है , कुछ पूर्णांक k के लिए, और पुनरावर्तन केवल तभी रुकता है जब n 1 हो, तो एकल-अंक गुणन की संख्या 3<sup>k</sup> है, जो कि n<sup>c</sup> है जहाँ c = log<sub>2</sub>3. | ||
चूंकि कोई भी इनपुट शून्य अंकों के साथ बढ़ा सकता है जब तक कि उनकी लंबाई दो की | चूंकि कोई भी इनपुट शून्य अंकों के साथ बढ़ा सकता है जब तक कि उनकी लंबाई दो की घात न हो, यह निम्नानुसार है कि किसी भी एन के लिए प्राथमिक गुणन की संख्या अधिकतम है <math>3^{ \lceil\log_2 n \rceil} \leq 3 n^{\log_2 3}\,\!</math>. | ||
चूंकि करात्सुबा के बुनियादी कदम में जोड़, घटाव और अंकों की शिफ्ट ( | चूंकि करात्सुबा के बुनियादी कदम में जोड़, घटाव और अंकों की शिफ्ट (b की घातयों से गुणा) n के अनुपात में समय लेती है, इसलिए n बढ़ने पर उनकी लागत नगण्य हो जाती है। अधिक सटीक रूप से, यदि T (n) प्राथमिक संचालन की कुल संख्या को दर्शाता है जो एल्गोरिदम दो एन-अंकीय संख्याओं को गुणा करते समय करता है, तो | ||
:<math>T(n) = 3 T(\lceil n/2\rceil) + cn + d</math> | :<math>T(n) = 3 T(\lceil n/2\rceil) + cn + d</math> | ||
कुछ स्थिरांक c और d के लिए। इस पुनरावर्तन संबंध के लिए, [[मास्टर प्रमेय (एल्गोरिदम का विश्लेषण)]] | कुछ स्थिरांक c और d के लिए। इस पुनरावर्तन संबंध के लिए, [[मास्टर प्रमेय (एल्गोरिदम का विश्लेषण)]] [[पुनरावृत्ति संबंध]] लिए मास्टर प्रमेय [[बिग ओ नोटेशन]] सीमा देता है | ||
<math>T(n) = \Theta(n^{\log_2 3})\,\!</math>. | |||
यह इस प्रकार है कि, पर्याप्त रूप से बड़े n के लिए, करत्सुबा का एल्गोरिथ्म लांगहैंड गुणन की तुलना में कम बदलाव और एकल-अंक जोड़ देगा, भले ही इसका मूल चरण सीधे सूत्र की तुलना में अधिक जोड़ और बदलाव का उपयोग करता है। n के छोटे मूल्यों के लिए, हालांकि, अतिरिक्त शिफ्ट और ऐड ऑपरेशंस इसे लांगहैंड विधि से धीमा कर सकते हैं। सकारात्मक रिटर्न का बिंदु [[कंप्यूटर मंच]] और संदर्भ पर निर्भर करता है। अंगूठे के नियम के रूप में, करात्सुबा की विधि आमतौर पर तेज़ होती है जब गुणक 320-640 बिट्स से अधिक होते हैं।<ref>{{Cite web|url=http://www.cburch.com/proj/karat/comment1.html|title=Karatsuba multiplication|website=www.cburch.com}}</ref> | |||
Line 107: | Line 110: | ||
यहाँ इस एल्गोरिथम के लिए स्यूडोकोड है, आधार दस में प्रदर्शित संख्याओं का उपयोग करते हुए। पूर्णांकों के द्विआधारी प्रतिनिधित्व के लिए, यह हर जगह 10 को 2 से बदलने के लिए पर्याप्त है।<ref>{{cite book |last= Weiss |first= Mark A. |date= 2005 |title= Data Structures and Algorithm Analysis in C++ |publisher= Addison-Wesley|page= 480|isbn= 0321375319}}</ref> | यहाँ इस एल्गोरिथम के लिए स्यूडोकोड है, आधार दस में प्रदर्शित संख्याओं का उपयोग करते हुए। पूर्णांकों के द्विआधारी प्रतिनिधित्व के लिए, यह हर जगह 10 को 2 से बदलने के लिए पर्याप्त है।<ref>{{cite book |last= Weiss |first= Mark A. |date= 2005 |title= Data Structures and Algorithm Analysis in C++ |publisher= Addison-Wesley|page= 480|isbn= 0321375319}}</ref> | ||
< | विभाजन_पर फलन का दूसरा तर्क दाईं ओर से निकाले जाने वाले अंकों की संख्या निर्दिष्ट करता है: उदाहरण के लिए, विभाजन_पर( 12345 , 3) 3 अंतिम अंक निकालेगा, जो देगा: उच्च= 12 , निम्न= 345 ।<syntaxhighlight lang="d"> | ||
function karatsuba(num1, num2) | |||
if (num1 < 10 or num2 < 10) | |||
return num1 × num2 /* fall back to traditional multiplication */ | |||
/ * | /* Calculates the size of the numbers. */ | ||
m = max(size_base10(num1), size_base10(num2)) | |||
m2 = floor(m / 2) | |||
/* | /* m2 = ceil (m / 2) will also work */ | ||
/* | /* Split the digit sequences in the middle. */ | ||
high1, low1 = split_at(num1, m2) | |||
high2, low2 = split_at(num2, m2) | |||
/* 3 | /* 3 recursive calls made to numbers approximately half the size. */ | ||
z0 = | z0 = karatsuba(low1, low2) | ||
z1 = | z1 = karatsuba(low1 + high1, low2 + high2) | ||
z2 = | z2 = karatsuba(high1, high2) | ||
return (z2 × 10 ^ (m2 × 2)) + ((z1 - z2 - z0) × 10 ^ m2) + z0 | |||
</ | </syntaxhighlight>समस्या जो तब होती है जब कार्यान्वयन यह है कि उपरोक्त गणना <math>(x_1 + x_0)</math> और <math>(y_1 + y_0)</math> के लिए <math>z_1</math> परिणाम अतिप्रवाह हो सकता है (परिणाम श्रेणी में उत्पन्न करेगा <math>B^m \leq \text{result} < 2 B^m</math>), जिसके लिए अतिरिक्त बिट वाले गुणक की आवश्यकता होती है। इसका ध्यान रखकर इससे बचा जा सकता है | ||
समस्या जो तब होती है जब कार्यान्वयन यह है कि उपरोक्त गणना <math>(x_1 + x_0)</math> और <math>(y_1 + y_0)</math> के लिए <math>z_1</math> परिणाम अतिप्रवाह हो सकता है (परिणाम श्रेणी में उत्पन्न करेगा <math>B^m \leq \text{result} < 2 B^m</math>), जिसके लिए अतिरिक्त बिट वाले गुणक की आवश्यकता होती है। इसका ध्यान रखकर इससे बचा जा सकता है | |||
:<math>z_1 = (x_0 - x_1)(y_1 - y_0) + z_2 + z_0.</math> | :<math>z_1 = (x_0 - x_1)(y_1 - y_0) + z_2 + z_0.</math> | ||
यह गणना <math>(x_0 - x_1)</math> और <math>(y_1 - y_0)</math> की सीमा | यह गणना <math>(x_0 - x_1)</math> और <math>(y_1 - y_0)</math> की सीमा <math>-B^m < \text{result} < B^m</math> में परिणाम देगा. यह विधि ऋणात्मक संख्याओं का उत्पादन कर सकती है, जिसके लिए अतिरिक्त बिट की आवश्यकता होती है, और फिर भी गुणक के लिए अतिरिक्त बिट की आवश्यकता होगी। हालाँकि, इससे बचने का तरीका यह है कि चिन्ह को रिकॉर्ड किया जाए और फिर के निरपेक्ष मान <math>(x_0 - x_1)</math> और <math>(y_1 - y_0)</math> अहस्ताक्षरित गुणन करने के लिए का उपयोग किया जाए, जिसके बाद दोनों संकेतों के मूल रूप से भिन्न होने पर परिणाम को नकारा जा सकता है। और लाभ यह है कि चाहे <math>(x_0 - x_1)(y_1 - y_0)</math> नकारात्मक हो सकता है, की अंतिम गणना <math>z_1</math> केवल जोड़ शामिल है। | ||
==संदर्भ== | ==संदर्भ== |
Revision as of 10:58, 15 February 2023
करात्सुबा एल्गोरिथ्म तेज़ गुणन एल्गोरिथ्म है। इसकी खोज 1960 में अनातोली करत्सुबा द्वारा की गई थी और 1962 में प्रकाशित हुई थी।[1][2][3] यह फूट डालो और जीतो एल्गोरिथ्म है जो दो n-अंकीय संख्याओं के गुणन को घटाकर n/2-अंकीय संख्याओं के तीन गुणा तक कम कर देता है और, इस कमी को, अधिकतम एकल अंकों का गुणन में दोहराता है। इसलिए यह लंबे गुणन एल्गोरिथ्म की तुलना में स्पर्शोन्मुख जटिलता है, जो प्रदर्शन करता है एकल अंक वाले उत्पाद। उदाहरण के लिए, दो 1024-अंकीय संख्याओं (n = 1024 = 210) को गुणा करने के लिए, पारंपरिक एल्गोरिथम को (210)2 = 1,048,576 एकल-अंकीय गुणन की आवश्यकता है, जबकि करात्सुबा एल्गोरिदम के लिए 310 = 59,049 की आवश्यकता होती है, इस प्रकार ~17.758 गुना तेज है।
करात्सुबा एल्गोरिथम द्विघात ग्रेड स्कूल एल्गोरिथम की तुलना में एसिम्प्टोटिक रूप से तेज़ पहला गुणन एल्गोरिथम था।
टूम-कुक एल्गोरिथम (1963) करात्सुबा की विधि का तेज़ सामान्यीकरण है, और शॉनहेज-स्ट्रैसन एल्गोरिथम (1971) पर्याप्त रूप से बड़े n के लिए और भी तेज़ है।
इतिहास
दो n-अंकीय संख्याओं के गुणा के लिए मानक प्रक्रिया के लिए बिग-ओ नोटेशन में , या के समानुपातिक कई प्राथमिक संक्रियाओं की आवश्यकता होती है। एंड्री कोलमोगोरोव ने अनुमान लगाया कि पारंपरिक एल्गोरिदम असीमित रूप से इष्टतम था, जिसका अर्थ है कि उस कार्य के लिए किसी भी एल्गोरिदम प्राथमिक संचालन की आवश्यकता होगी।
1960 में, कोलमोगोरोव ने मॉस्को स्टेट यूनिवर्सिटी में साइबरनेटिक्स में गणितीय समस्याओं पर संगोष्ठी का आयोजन किया, जहाँ उन्होंने कहा कि कम्प्यूटेशनल जटिलता सिद्धांत में अनुमान और अन्य समस्याओं को बताया। सप्ताह के भीतर, 23 वर्षीय छात्र करत्सुबा ने एल्गोरिदम पाया जो दो एन-अंकीय संख्याओं को से गुणा करता है, प्रारंभिक चरण, इस प्रकार अनुमान को अस्वीकार करते हैं। कोलमोगोरोव इस खोज को लेकर बहुत उत्साहित थे; उन्होंने संगोष्ठी की अगली बैठक में इसकी सूचना दी, जिसे तब समाप्त कर दिया गया था। कोलमोगोरोव ने दुनिया भर के सम्मेलनों में करात्सुबा परिणाम पर कुछ व्याख्यान दिए (उदाहरण के लिए देखें, गणितज्ञों की अंतर्राष्ट्रीय कांग्रेस की कार्यवाही 1962, पीपी। 351-356, और स्टॉकहोम में गणितज्ञों की अंतर्राष्ट्रीय कांग्रेस में दिए गए 6 व्याख्यान, 1962 ) और यूएसएसआर एकेडमी ऑफ साइंसेज की कार्यवाही में 1962 में विधि प्रकाशित किया था। लेख कोल्मोगोरोव द्वारा लिखा गया था और इसमें गुणन पर दो परिणाम शामिल थे, करात्सुबा के एल्गोरिथ्म और यूरी पेट्रोविच ऑफमैन द्वारा अलग परिणाम; इसमें ए. करत्सुबा और यू. लेखक के रूप में ऑफमैन। करत्सुबा को केवल कागज के बारे में पता चला जब उन्हें प्रकाशक से पुनर्मुद्रण प्राप्त हुआ।[2]
एल्गोरिथम
बुनियादी कदम
करात्सुबा के एल्गोरिथ्म का मूल सिद्धांत एक सूत्र का उपयोग करके विभाजित और जीतना है, जो किसी को दो बड़ी संख्याओं और के उत्पाद की गणना करने की अनुमति देता है, छोटी संख्याओं के तीन गुणन का उपयोग करके, प्रत्येक में या के रूप में लगभग आधे अंक होते हैं, साथ ही कुछ जोड़ और अंक बदलाव। यह बुनियादी कदम, वास्तव में, एक समान जटिल गुणन एल्गोरिथ्म का एक सामान्यीकरण है, जहां काल्पनिक इकाई i मूलांक की घात द्वारा प्रतिस्थापित किया जाता है।
होने देना और के रूप में प्रतिनिधित्व किया जाए -संख्या रेखा कुछ आधार में . किसी भी सकारात्मक पूर्णांक के लिए से कम , दी गई दो संख्याओं को इस प्रकार लिख सकते हैं
कहाँ और से कम . उत्पाद है तो
कहाँ
इन सूत्रों के लिए चार गुणन की आवश्यकता होती है और वे चार्ल्स बैबेज के लिए जाने जाते थे।[4] करत्सुबा ने देखा कुछ अतिरिक्त परिवर्धन की कीमत पर, केवल तीन गुणा में गणना की जा सकती है। साथ और जैसा कि पहले कोई देख सकता है
उदाहरण
12345 और 6789 के उत्पाद की गणना करने के लिए, जहां b = 10, M = 3 चुनें। हम परिणामी आधार (b) का उपयोग करके इनपुट ऑपरेंड को विघटित करने के लिए Mm = 1000) राइट शिफ्ट का उपयोग करते हैं, जैसा:
- 12345 = '12' · 1000 + '345'
- 6789 = '6' · 1000 + '789'
केवल तीन गुणन, जो छोटे पूर्णांकों पर संचालित होता है, का उपयोग तीन आंशिक परिणामों की गणना करने के लिए किया जाता है:
- Z2 = 12 × 6 = 72
- Z0 = 345 × 789 = 272205
- Z1 = (12 + 345) × (6 + 789) - Z2 - Z0 = 357 × 795 − 72 − 272205 = 283815 − 72 − 272205 = 11538
हम केवल इन तीन आंशिक परिणामों को जोड़कर परिणाम प्राप्त करते हैं, तदनुसार स्थानांतरित कर दिया जाता है (और फिर इनपुट ऑपरेंड के लिए इन तीन इनपुटों को आधार 1000 में विघटित करके ध्यान में रखा जाता है):
- परिणाम = Z2 · (Bm)2 + के Z1 · (Bm)1 + के Z0 · (Bm)0, अर्थात्
- परिणाम = 72 · 10002 + 11538 · 1000 + 272205 = '83810205'।
ध्यान दें कि मध्यवर्ती तीसरा गुणन इनपुट डोमेन पर संचालित होता है जो पहले दो गुणाओं की तुलना में दो गुना बड़ा होता है, इसका आउटपुट डोमेन चार गुना से कम बड़ा होता है, और इन दो घटावों की गणना करते समय पहले दो गुणाओं से गणना की गई आधार-1000 को ध्यान में रखा जाना चाहिए।
पुनरावर्ती अनुप्रयोग
यदि n चार या अधिक है, तो करात्सुबा के मूल चरण में तीन गुणन में n अंकों से कम वाले ऑपरेंड शामिल हैं। इसलिए, उन उत्पादों की गणना करत्सुबा एल्गोरिथम की पुनरावर्ती कॉल द्वारा की जा सकती है। पुनरावर्तन तब तक लागू किया जा सकता है जब तक कि संख्याएं इतनी छोटी न हों कि उन्हें सीधे (या आवश्यक) गणना की जा सके।
पूर्ण 32-बिट गुणा 32-बिट बाइनरी गुणक वाले कंप्यूटर में, उदाहरण के लिए, कोई B = 231 चुन सकता है और प्रत्येक अंक को अलग 32-बिट बाइनरी शब्द के रूप में संग्रहीत करें। फिर योग x1 + x0 और y1 + y0 कैरी-ओवर डिजिट (कैरी-सेव योजक के रूप में) को स्टोर करने के लिए अतिरिक्त बाइनरी शब्द की आवश्यकता नहीं होगी, और करत्सुबा रिकर्सन को तब तक लागू किया जा सकता है जब तक कि संख्याओं को गुणा करने के लिए केवल अंक लंबा न हो।
समय जटिलता विश्लेषण
करात्सुबा का मूल चरण किसी भी आधार b और किसी भी m के लिए काम करता है, लेकिन पुनरावर्ती एल्गोरिथ्म सबसे अधिक कुशल होता है जब MN / 2 के बराबर होता है, और गोल होता है। विशेष रूप से, यदि n 2k है , कुछ पूर्णांक k के लिए, और पुनरावर्तन केवल तभी रुकता है जब n 1 हो, तो एकल-अंक गुणन की संख्या 3k है, जो कि nc है जहाँ c = log23.
चूंकि कोई भी इनपुट शून्य अंकों के साथ बढ़ा सकता है जब तक कि उनकी लंबाई दो की घात न हो, यह निम्नानुसार है कि किसी भी एन के लिए प्राथमिक गुणन की संख्या अधिकतम है .
चूंकि करात्सुबा के बुनियादी कदम में जोड़, घटाव और अंकों की शिफ्ट (b की घातयों से गुणा) n के अनुपात में समय लेती है, इसलिए n बढ़ने पर उनकी लागत नगण्य हो जाती है। अधिक सटीक रूप से, यदि T (n) प्राथमिक संचालन की कुल संख्या को दर्शाता है जो एल्गोरिदम दो एन-अंकीय संख्याओं को गुणा करते समय करता है, तो
कुछ स्थिरांक c और d के लिए। इस पुनरावर्तन संबंध के लिए, मास्टर प्रमेय (एल्गोरिदम का विश्लेषण) पुनरावृत्ति संबंध लिए मास्टर प्रमेय बिग ओ नोटेशन सीमा देता है
.
यह इस प्रकार है कि, पर्याप्त रूप से बड़े n के लिए, करत्सुबा का एल्गोरिथ्म लांगहैंड गुणन की तुलना में कम बदलाव और एकल-अंक जोड़ देगा, भले ही इसका मूल चरण सीधे सूत्र की तुलना में अधिक जोड़ और बदलाव का उपयोग करता है। n के छोटे मूल्यों के लिए, हालांकि, अतिरिक्त शिफ्ट और ऐड ऑपरेशंस इसे लांगहैंड विधि से धीमा कर सकते हैं। सकारात्मक रिटर्न का बिंदु कंप्यूटर मंच और संदर्भ पर निर्भर करता है। अंगूठे के नियम के रूप में, करात्सुबा की विधि आमतौर पर तेज़ होती है जब गुणक 320-640 बिट्स से अधिक होते हैं।[5]
कार्यान्वयन
यहाँ इस एल्गोरिथम के लिए स्यूडोकोड है, आधार दस में प्रदर्शित संख्याओं का उपयोग करते हुए। पूर्णांकों के द्विआधारी प्रतिनिधित्व के लिए, यह हर जगह 10 को 2 से बदलने के लिए पर्याप्त है।[6]
विभाजन_पर फलन का दूसरा तर्क दाईं ओर से निकाले जाने वाले अंकों की संख्या निर्दिष्ट करता है: उदाहरण के लिए, विभाजन_पर( 12345 , 3) 3 अंतिम अंक निकालेगा, जो देगा: उच्च= 12 , निम्न= 345 ।
function karatsuba(num1, num2)
if (num1 < 10 or num2 < 10)
return num1 × num2 /* fall back to traditional multiplication */
/* Calculates the size of the numbers. */
m = max(size_base10(num1), size_base10(num2))
m2 = floor(m / 2)
/* m2 = ceil (m / 2) will also work */
/* Split the digit sequences in the middle. */
high1, low1 = split_at(num1, m2)
high2, low2 = split_at(num2, m2)
/* 3 recursive calls made to numbers approximately half the size. */
z0 = karatsuba(low1, low2)
z1 = karatsuba(low1 + high1, low2 + high2)
z2 = karatsuba(high1, high2)
return (z2 × 10 ^ (m2 × 2)) + ((z1 - z2 - z0) × 10 ^ m2) + z0
समस्या जो तब होती है जब कार्यान्वयन यह है कि उपरोक्त गणना और के लिए परिणाम अतिप्रवाह हो सकता है (परिणाम श्रेणी में उत्पन्न करेगा ), जिसके लिए अतिरिक्त बिट वाले गुणक की आवश्यकता होती है। इसका ध्यान रखकर इससे बचा जा सकता है
यह गणना और की सीमा में परिणाम देगा. यह विधि ऋणात्मक संख्याओं का उत्पादन कर सकती है, जिसके लिए अतिरिक्त बिट की आवश्यकता होती है, और फिर भी गुणक के लिए अतिरिक्त बिट की आवश्यकता होगी। हालाँकि, इससे बचने का तरीका यह है कि चिन्ह को रिकॉर्ड किया जाए और फिर के निरपेक्ष मान और अहस्ताक्षरित गुणन करने के लिए का उपयोग किया जाए, जिसके बाद दोनों संकेतों के मूल रूप से भिन्न होने पर परिणाम को नकारा जा सकता है। और लाभ यह है कि चाहे नकारात्मक हो सकता है, की अंतिम गणना केवल जोड़ शामिल है।
संदर्भ
- ↑
A. Karatsuba and Yu. Ofman (1962). "Multiplication of Many-Digital Numbers by Automatic Computers". Proceedings of the USSR Academy of Sciences. 145: 293–294. Translation in the academic journal Physics-Doklady, 7 (1963), pp. 595–596
{{cite journal}}
: CS1 maint: postscript (link) - ↑ 2.0 2.1
A. A. Karatsuba (1995). "The Complexity of Computations" (PDF). Proceedings of the Steklov Institute of Mathematics. 211: 169–183. Translation from Trudy Mat. Inst. Steklova, 211, 186–202 (1995)
{{cite journal}}
: CS1 maint: postscript (link) - ↑ Knuth D.E. (1969) The Art of Computer Programming. v.2. Addison-Wesley Publ.Co., 724 pp.
- ↑ Charles Babbage, Chapter VIII – Of the Analytical Engine, Larger Numbers Treated, Passages from the Life of a Philosopher, Longman Green, London, 1864; page 125.
- ↑ "Karatsuba multiplication". www.cburch.com.
- ↑ Weiss, Mark A. (2005). Data Structures and Algorithm Analysis in C++. Addison-Wesley. p. 480. ISBN 0321375319.
बाहरी संबंध
- Karatsuba's Algorithm for Polynomial Multiplication
- Weisstein, Eric W. "Karatsuba Multiplication". MathWorld.
- Bernstein, D. J., "Multidigit multiplication for mathematicians". Covers Karatsuba and many other multiplication algorithms.