दद्दा मल्टीप्लायर: Difference between revisions

Latest revision as of 10:25, 22 August 2023

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

दद्दा और वालेस मल्टीप्लायरों में दो बिट स्ट्रिंग के लिए समान तीन चरण होते हैं $w_{1}$ और $w_{2}$ लंबाई का $\ell _{1}$ और $\ell _{2}$ क्रमश:

प्रत्येक बिट को गुणा (तार्किक संयोजन) करें $w_{1}$ , के प्रत्येक बिट द्वारा $w_{2}$ , उपज $\ell _{1}\cdot \ell _{2}$ परिणाम, स्तंभों में वजन के आधार पर समूहीकृत
योजक (इलेक्ट्रॉनिक्स) के चरणों द्वारा आंशिक उत्पादों की संख्या कम करें जब तक कि हमारे पास प्रत्येक भार के अधिकतम दो बिट न रह जाएं।
अंतिम परिणाम को पारंपरिक योजक के साथ जोड़ें।

वालेस गुणक की तरह, पहले चरण के गुणन उत्पाद अलग-अलग भार रखते हैं जो गुणन में मूल बिट मानों के परिमाण को दर्शाते हैं। उदाहरण के लिए, बिट्स का उत्पाद $a_{n}b_{m}$ वजन है $n+m$ ।

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

विवरण

पूर्ण-योजक सर्किट का उदाहरण है।

अधिक इष्टतम अंतिम उत्पाद प्राप्त करने के लिए, कटौती प्रक्रिया की संरचना वालेस मल्टीप्लायरों की समानता में थोड़े अधिक जटिल नियमों द्वारा नियंत्रित होती है।

कमी की प्रगति को अधिकतम-ऊंचाई अनुक्रम द्वारा नियंत्रित किया जाता है $d_{j}$ , द्वारा परिभाषित:

d_{1}=2{\text{ and }}d_{j+1}=\operatorname {floor} (1.5d_{j}).

इससे इस प्रकार अनुक्रम प्राप्त होता है:

d_{1}=2,d_{2}=3,d_{3}=4,d_{4}=6,d_{5}=9,d_{6}=13,\ldots

का प्रारंभिक मूल्य $j$ को सबसे बड़े मान के रूप में चुना जाता है $d_{j}<\min {(n_{1},n_{2})}$ , कहाँ $n_{1}$ और $n_{2}$ इनपुट गुणक और गुणक में बिट्स की संख्या है। गुणन के पहले चरण के बाद दो बिट लंबाई में से जो कम होगी वह वजन के प्रत्येक कॉलम की अधिकतम ऊंचाई होगी। प्रत्येक चरण के लिए $j$ कटौती के लिए, एल्गोरिथ्म का लक्ष्य प्रत्येक कॉलम की ऊंचाई को कम करना है जिससे यह के मूल्य से कम या उसके सामान्तर हो $d_{j}$ ।

से प्रत्येक चरण के लिए $,\ldots ,1$ , सबसे कम वजन वाले कॉलम से प्रारंभ करके प्रत्येक कॉलम को छोटा करें, $c_{0}$ इन नियमों के अनुसार:

यदि $\operatorname {height} (c_{i})\leqslant d_{j}$ कॉलम में कमी की आवश्यकता नहीं है, कॉलम पर जाएँ $c_{i+1}$
यदि $\operatorname {height} (c_{i})=d_{j}+1$ शीर्ष दो तत्वों को अर्ध-योजक में जोड़ें, परिणाम को कॉलम के नीचे रखें और कैरी को कॉलम के नीचे रखें $c_{i+1}$ , फिर कॉलम पर जाएँ $c_{i+1}$
अन्यथा, शीर्ष तीन तत्वों को पूर्ण-योजक में जोड़ें, परिणाम को कॉलम के नीचे रखें और कैरी को कॉलम के नीचे रखें $c_{i+1}$ , पुनः आरंभ करें $c_{i}$ चरण 1 पर

एल्गोरिथम उदाहरण

7 अर्ध योजक (दो बिंदु) और 35 पूर्ण योजक (तीन बिंदु) का उपयोग करके, 8x8 आंशिक उत्पाद आव्यूह की 4 परत दद्दा कटौती। प्रत्येक कॉलम में बिंदु समान वजन के बिट हैं। कम वजन वाले बिट्स सबसे दाहिने होते हैं।

निकटवर्ती छवि में उदाहरण 8×8 गुणक की कमी को दर्शाता है, जिसे यहां समझाया गया है।

प्रारंभिक अवस्था $j=4$ के रूप में चुना गया है $d_{4}=6$ , सबसे बड़ा मान 8 से कम।

अवस्था $j=4$ , $d_{4}=6$ * $\operatorname {height} (c_{0}\cdots c_{5})$ सभी की ऊंचाई छह बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है

$\operatorname {height} (c_{6})=d_{4}+1=7$ , इसलिए आधा-योजक लागू किया जाता है, इसे छह बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है $c_{7}$
$\operatorname {height} (c_{7})=9$ से कैरी बिट सहित $c_{6}$ , इसलिए हम इसे छह बिट तक कम करने के लिए पूर्ण-योजक और आधा-योजक लागू करते हैं
$\operatorname {height} (c_{8})=9$ जिसमें से दो कैरी बिट्स सम्मिलित हैं $c_{7}$ , इसलिए हम इसे छह बिट तक कम करने के लिए फिर से पूर्ण-योजक और आधा-योजक लागू करते हैं
$\operatorname {height} (c_{9})=8$ जिसमें से दो कैरी बिट्स सम्मिलित हैं $c_{8}$ , इसलिए हम पूर्ण-योजक लागू करते हैं और इसे छह बिट्स तक कम करते हैं
$\operatorname {height} (c_{10}\cdots c_{14})$ कैरी बिट्स सहित ऊंचाई में सभी छह बिट्स से कम या उसके सामान्तर हैं, इसलिए कोई बदलाव नहीं किया गया है

अवस्था $j=3$ , $d_{3}=4$ * $\operatorname {height} (c_{0}\cdots c_{3})$ सभी की ऊंचाई चार बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है

$\operatorname {height} (c_{4})=d_{3}+1=5$ , इसलिए आधा-योजक लागू किया जाता है, इसे चार बिट तक कम कर दिया जाता है और इसके कैरी बिट को जोड़ दिया जाता है $c_{5}$
$\operatorname {height} (c_{5})=7$ से कैरी बिट सहित $c_{4}$ , इसलिए हम इसे चार बिट तक कम करने के लिए पूर्ण-योजक और आधा-योजक लागू करते हैं
$\operatorname {height} (c_{6}\cdots c_{10})=8$ पिछले कैरी बिट्स सहित, इसलिए हम उन्हें चार बिट्स तक कम करने के लिए दो पूर्ण-योजक लागू करते हैं
$\operatorname {height} (c_{11})=6$ पिछले कैरी बिट्स सहित, इसलिए हम इसे चार बिट्स तक कम करने के लिए पूर्ण-योजक लागू करते हैं
$\operatorname {height} (c_{12}\cdots c_{14})$ कैरी बिट्स सहित ऊंचाई में सभी चार बिट्स से कम या उसके सामान्तर हैं, इसलिए कोई बदलाव नहीं किया गया है

अवस्था $j=2$ , $d_{2}=3$ * $\operatorname {height} (c_{0}\cdots c_{2})$ सभी की ऊंचाई तीन बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है

$\operatorname {height} (c_{3})=d_{2}+1=4$ , इसलिए आधा-योजक लागू किया जाता है, इसे तीन बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है $c_{4}$
$\operatorname {height} (c_{4}\cdots c_{12})=5$ पिछले कैरी बिट्स सहित, इसलिए हम उन्हें तीन बिट्स तक कम करने के लिए पूर्ण-योजक लागू करते हैं
$\operatorname {height} (c_{13}\cdots c_{14})$ कैरी बिट्स सहित ऊंचाई में सभी तीन बिट्स से कम या उसके सामान्तर हैं, इसलिए कोई बदलाव नहीं किया गया है

अवस्था $j=1$ , $d_{1}=2$ * $\operatorname {height} (c_{0}\cdots c_{1})$ सभी की ऊंचाई दो बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है

$\operatorname {height} (c_{2})=d_{1}+1=3$ , इसलिए आधा-योजक लागू किया जाता है, इसे दो बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है $c_{3}$
$\operatorname {height} (c_{3}\cdots c_{13})=4$ पिछले कैरी बिट्स सहित, इसलिए हम उन्हें दो बिट्स तक कम करने के लिए पूर्ण-योजक लागू करते हैं
$\operatorname {height} (c_{14})=2$ से कैरी बिट सहित $c_{13}$ , इसलिए कोई परिवर्तन नहीं किया गया है

जोड़ना

अंतिम चरण का आउटपुट दो या उससे कम ऊंचाई के 15 कॉलम छोड़ता है जिन्हें मानक योजक में पारित किया जा सकता है।

यह भी देखें

बूथ का गुणन एल्गोरिथ्म
फ़्यूज्ड गुणा-जोड़ें
वालेस का ट्री
जटिल लघुगणक और घातांक के लिए एल्गोरिथम कितना है?
मॉड्यूलर अंकगणितीय गुणन के लिए कोचानस्की गुणन

संदर्भ

↑ Dadda, Luigi (May 1965). "Some schemes for parallel multipliers". Alta Frequenza. 34 (5): 349–356.
Dadda, L. (1976). "Some schemes for parallel multipliers". In Swartzlander, Earl E. (ed.). Computer Design Development: Principal Papers. Hayden Book Company. pp. 167–180. ISBN 978-0-8104-5988-5. OCLC 643640444.
↑ Townsend, Whitney J.; Swartzlander, Jr., Earl E.; Abraham, Jacob A. (December 2003). "A Comparison of Dadda and Wallace Multiplier Delays" (PDF). SPIE Advanced Signal Processing Algorithms, Architectures, and Implementations XIII. The International Society. doi:10.1117/12.507012.

अग्रिम पठन

Savard, John J. G. (2018) [2006]. "Advanced Arithmetic Techniques". quadibloc. Archived from the original on 2018-07-03. Retrieved 2018-07-16.

[Dadda_1965-1] Dadda, Luigi (May 1965). "Some schemes for parallel multipliers". Alta Frequenza. 34 (5): 349–356.
Dadda, L. (1976). "Some schemes for parallel multipliers". In Swartzlander, Earl E. (ed.). Computer Design Development: Principal Papers. Hayden Book Company. pp. 167–180. ISBN 978-0-8104-5988-5. OCLC 643640444.

[Townsend_2003-2] Townsend, Whitney J.; Swartzlander, Jr., Earl E.; Abraham, Jacob A. (December 2003). "A Comparison of Dadda and Wallace Multiplier Delays" (PDF). SPIE Advanced Signal Processing Algorithms, Architectures, and Implementations XIII. The International Society. doi:10.1117/12.507012.

[1]

[2]

@@ Line 1: / Line 1: @@
 {{short description|Hardware multiplier design}}
-दद्दा मल्टीप्लायर एक हार्डवेयर [[ द्विआधारी गुणक ]] डिज़ाइन है जिसका आविष्कार कंप्यूटर वैज्ञानिक [[लुइगी दद्दा]] ने 1965 में किया था।<ref name="Dadda_1965"/>यह आंशिक उत्पादों को चरणों (दद्दा वृक्ष या दद्दा कमी) में तब तक जोड़ने के लिए [[योजक (इलेक्ट्रॉनिक्स)]] के चयन का उपयोग करता है जब तक कि दो संख्याएँ शेष न रह जाएँ। डिज़ाइन [[वालेस गुणक]] के समान है, लेकिन अलग-अलग रिडक्शन ट्री [[ तर्क द्वार ]] की आवश्यक संख्या को कम कर देता है (छोटे ऑपरेंड आकारों को छोड़कर सभी के लिए) और इसे थोड़ा तेज़ बनाता है (सभी ऑपरेंड आकारों के लिए)।<ref name="Townsend_2003"/>
+'''दद्दा मल्टीप्लायर''' हार्डवेयर [[ द्विआधारी गुणक |द्विआधारी गुणक]] डिज़ाइन है जिसका आविष्कार कंप्यूटर वैज्ञानिक [[लुइगी दद्दा]] ने 1965 में किया था।<ref name="Dadda_1965"/>यह आंशिक उत्पादों को चरणों (दद्दा वृक्ष या दद्दा कमी) में तब तक जोड़ने के लिए [[योजक (इलेक्ट्रॉनिक्स)]] के चयन का उपयोग करता है जब तक कि दो संख्याएँ शेष न रह जाएँ। डिज़ाइन [[वालेस गुणक]] के समान है, किन्तु अलग-अलग रिडक्शन ट्री [[ तर्क द्वार |तर्क द्वार]] की आवश्यक संख्या को कम कर देता है (छोटे ऑपरेंड आकारों को छोड़कर सभी के लिए) और इसे थोड़ा तेज़ बनाता है (सभी ऑपरेंड आकारों के लिए)।<ref name="Townsend_2003"/>
 दद्दा और वालेस मल्टीप्लायरों में दो बिट स्ट्रिंग के लिए समान तीन चरण होते हैं <math>w_1</math> और <math>w_2</math> लंबाई का <math>\ell_1</math> और <math>\ell_2</math> क्रमश:
@@ Line 7: / Line 8: @@
 # अंतिम परिणाम को पारंपरिक योजक के साथ जोड़ें।
-वालेस गुणक की तरह, पहले चरण के गुणन उत्पाद अलग-अलग भार रखते हैं जो गुणन में मूल बिट मानों के परिमाण को दर्शाते हैं। उदाहरण के लिए, बिट्स का उत्पाद <math>a_n b_m</math> वजन है <math>n+m</math>.
+वालेस गुणक की तरह, पहले चरण के गुणन उत्पाद अलग-अलग भार रखते हैं जो गुणन में मूल बिट मानों के परिमाण को दर्शाते हैं। उदाहरण के लिए, बिट्स का उत्पाद <math>a_n b_m</math> वजन है <math>n+m</math>।
-वालेस मल्टीप्लायरों के विपरीत, जो प्रत्येक परत पर जितना संभव हो उतना कम करते हैं, दद्दा मल्टीप्लायर उपयोग किए गए गेटों की संख्या, साथ ही इनपुट/आउटपुट विलंब को कम करने का प्रयास करते हैं। इस वजह से, दद्दा मल्टीप्लायरों में कम खर्चीला कटौती चरण होता है, लेकिन अंतिम संख्या कुछ बिट लंबी हो सकती है, इस प्रकार थोड़े बड़े योजक की आवश्यकता होती है।
+वालेस मल्टीप्लायरों के विपरीत, जो प्रत्येक परत पर जितना संभव हो उतना कम करते हैं, दद्दा मल्टीप्लायर उपयोग किए गए गेटों की संख्या, साथ ही इनपुट/आउटपुट विलंब को कम करने का प्रयास करते हैं। इस वजह से, दद्दा मल्टीप्लायरों में कम खर्चीला कटौती चरण होता है, किन्तु अंतिम संख्या कुछ बिट लंबी हो सकती है, इस प्रकार थोड़े बड़े योजक की आवश्यकता होती है।
 == विवरण ==
-[[File:Full-adder.svg|thumb | पूर्ण-योजक सर्किट का एक उदाहरण.]]अधिक इष्टतम अंतिम उत्पाद प्राप्त करने के लिए, कटौती प्रक्रिया की संरचना वालेस मल्टीप्लायरों की तुलना में थोड़े अधिक जटिल नियमों द्वारा नियंत्रित होती है।
+[[File:Full-adder.svg|thumb | पूर्ण-योजक सर्किट का उदाहरण है।]]अधिक इष्टतम अंतिम उत्पाद प्राप्त करने के लिए, कटौती प्रक्रिया की संरचना वालेस मल्टीप्लायरों की समानता में थोड़े अधिक जटिल नियमों द्वारा नियंत्रित होती है।
 कमी की प्रगति को अधिकतम-ऊंचाई अनुक्रम द्वारा नियंत्रित किया जाता है <math>d_j</math>, द्वारा परिभाषित:
 : <math>d_1 = 2 \text{ and } d_{j+1} = \operatorname{floor}(1.5 d_j).</math>
-इससे इस प्रकार एक अनुक्रम प्राप्त होता है:
+इससे इस प्रकार अनुक्रम प्राप्त होता है:
 : <math>d_1=2, d_2=3, d_3=4, d_4=6, d_5=9, d_6=13, \ldots </math>
-का प्रारंभिक मूल्य <math>j</math> को सबसे बड़े मान के रूप में चुना जाता है <math>d_j < \min{(n_1, n_2)}</math>, कहाँ <math>n_1</math> और <math>n_2</math> इनपुट गुणक और गुणक में बिट्स की संख्या है। गुणन के पहले चरण के बाद दो बिट लंबाई में से जो कम होगी वह वजन के प्रत्येक कॉलम की अधिकतम ऊंचाई होगी। प्रत्येक चरण के लिए <math>j</math> कटौती के लिए, एल्गोरिथ्म का लक्ष्य प्रत्येक कॉलम की ऊंचाई को कम करना है ताकि यह के मूल्य से कम या उसके बराबर हो <math>d_j</math>.
+का प्रारंभिक मूल्य <math>j</math> को सबसे बड़े मान के रूप में चुना जाता है <math>d_j < \min{(n_1, n_2)}</math>, कहाँ <math>n_1</math> और <math>n_2</math> इनपुट गुणक और गुणक में बिट्स की संख्या है। गुणन के पहले चरण के बाद दो बिट लंबाई में से जो कम होगी वह वजन के प्रत्येक कॉलम की अधिकतम ऊंचाई होगी। प्रत्येक चरण के लिए <math>j</math> कटौती के लिए, एल्गोरिथ्म का लक्ष्य प्रत्येक कॉलम की ऊंचाई को कम करना है जिससे यह के मूल्य से कम या उसके सामान्तर हो <math>d_j</math>।
-से प्रत्येक चरण के लिए <math>,\ldots,1</math>, सबसे कम वजन वाले कॉलम से शुरू करके प्रत्येक कॉलम को छोटा करें, <math>c_0</math> इन नियमों के अनुसार:
+से प्रत्येक चरण के लिए <math>,\ldots,1</math>, सबसे कम वजन वाले कॉलम से प्रारंभ करके प्रत्येक कॉलम को छोटा करें, <math>c_0</math> इन नियमों के अनुसार:
-# अगर <math>\operatorname{height}(c_i) \leqslant d_j</math> कॉलम में कमी की आवश्यकता नहीं है, कॉलम पर जाएँ <math>c_{i+1}</math>
+# यदि <math>\operatorname{height}(c_i) \leqslant d_j</math> कॉलम में कमी की आवश्यकता नहीं है, कॉलम पर जाएँ <math>c_{i+1}</math>
-# अगर <math>\operatorname{height}(c_i) = d_j + 1</math> शीर्ष दो तत्वों को अर्ध-योजक में जोड़ें, परिणाम को कॉलम के नीचे रखें और कैरी को कॉलम के नीचे रखें <math>c_{i+1}</math>, फिर कॉलम पर जाएँ <math>c_{i+1}</math>
+# यदि <math>\operatorname{height}(c_i) = d_j + 1</math> शीर्ष दो तत्वों को अर्ध-योजक में जोड़ें, परिणाम को कॉलम के नीचे रखें और कैरी को कॉलम के नीचे रखें <math>c_{i+1}</math>, फिर कॉलम पर जाएँ <math>c_{i+1}</math>
 # अन्यथा, शीर्ष तीन तत्वों को पूर्ण-योजक में जोड़ें, परिणाम को कॉलम के नीचे रखें और कैरी को कॉलम के नीचे रखें <math>c_{i+1}</math>, पुनः आरंभ करें <math>c_i</math>चरण 1 पर
 == एल्गोरिथम उदाहरण ==
-[[File:dadda tree 8x8.svg|thumb | 7 अर्ध योजक (दो बिंदु) और 35 [[पूर्ण योजक]] (तीन बिंदु) का उपयोग करके, 8x8 आंशिक उत्पाद मैट्रिक्स की 4 परत दद्दा कटौती। प्रत्येक कॉलम में बिंदु समान वजन के बिट हैं। कम वजन वाले बिट्स सबसे दाहिने होते हैं।]]निकटवर्ती छवि में उदाहरण 8×8 गुणक की कमी को दर्शाता है, जिसे यहां समझाया गया है।
+[[File:dadda tree 8x8.svg|thumb | 7 अर्ध योजक (दो बिंदु) और 35 [[पूर्ण योजक]] (तीन बिंदु) का उपयोग करके, 8x8 आंशिक उत्पाद आव्यूह की 4 परत दद्दा कटौती। प्रत्येक कॉलम में बिंदु समान वजन के बिट हैं। कम वजन वाले बिट्स सबसे दाहिने होते हैं।]]निकटवर्ती छवि में उदाहरण 8×8 गुणक की कमी को दर्शाता है, जिसे यहां समझाया गया है।
 प्रारंभिक अवस्था <math>j = 4</math> के रूप में चुना गया है <math>d_4 = 6</math>, सबसे बड़ा मान 8 से कम।
-अवस्था <math>j=4</math>, <math>d_4 = 6</math>* <math>\operatorname{height}(c_0\cdots c_5)</math> सभी की ऊंचाई छह बिट से कम या उसके बराबर है, इसलिए कोई बदलाव नहीं किया गया है
+अवस्था <math>j=4</math>, <math>d_4 = 6</math>* <math>\operatorname{height}(c_0\cdots c_5)</math> सभी की ऊंचाई छह बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है
-* <math>\operatorname{height}(c_6) = d_4 + 1 = 7</math>, इसलिए एक आधा-योजक लागू किया जाता है, इसे छह बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है <math>c_7</math>
+* <math>\operatorname{height}(c_6) = d_4 + 1 = 7</math>, इसलिए आधा-योजक लागू किया जाता है, इसे छह बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है <math>c_7</math>
-* <math>\operatorname{height}(c_7) = 9</math> से कैरी बिट सहित <math>c_6</math>, इसलिए हम इसे छह बिट तक कम करने के लिए एक पूर्ण-योजक और एक आधा-योजक लागू करते हैं
+* <math>\operatorname{height}(c_7) = 9</math> से कैरी बिट सहित <math>c_6</math>, इसलिए हम इसे छह बिट तक कम करने के लिए पूर्ण-योजक और आधा-योजक लागू करते हैं
-* <math>\operatorname{height}(c_8) = 9</math> जिसमें से दो कैरी बिट्स शामिल हैं <math>c_7</math>, इसलिए हम इसे छह बिट तक कम करने के लिए फिर से एक पूर्ण-योजक और एक आधा-योजक लागू करते हैं
+* <math>\operatorname{height}(c_8) = 9</math> जिसमें से दो कैरी बिट्स सम्मिलित हैं <math>c_7</math>, इसलिए हम इसे छह बिट तक कम करने के लिए फिर से पूर्ण-योजक और आधा-योजक लागू करते हैं
-* <math>\operatorname{height}(c_9) = 8</math> जिसमें से दो कैरी बिट्स शामिल हैं <math>c_8</math>, इसलिए हम एक पूर्ण-योजक लागू करते हैं और इसे छह बिट्स तक कम करते हैं
+* <math>\operatorname{height}(c_9) = 8</math> जिसमें से दो कैरी बिट्स सम्मिलित हैं <math>c_8</math>, इसलिए हम पूर्ण-योजक लागू करते हैं और इसे छह बिट्स तक कम करते हैं
-* <math>\operatorname{height}(c_{10}\cdots c_{14})</math> कैरी बिट्स सहित ऊंचाई में सभी छह बिट्स से कम या उसके बराबर हैं, इसलिए कोई बदलाव नहीं किया गया है
+* <math>\operatorname{height}(c_{10}\cdots c_{14})</math> कैरी बिट्स सहित ऊंचाई में सभी छह बिट्स से कम या उसके सामान्तर हैं, इसलिए कोई बदलाव नहीं किया गया है
-अवस्था <math>j=3</math>, <math>d_3 = 4</math>* <math>\operatorname{height}(c_0\cdots c_3)</math> सभी की ऊंचाई चार बिट से कम या उसके बराबर है, इसलिए कोई बदलाव नहीं किया गया है
+अवस्था <math>j=3</math>, <math>d_3 = 4</math>* <math>\operatorname{height}(c_0\cdots c_3)</math> सभी की ऊंचाई चार बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है
-* <math>\operatorname{height}(c_4) = d_3 + 1 = 5</math>, इसलिए एक आधा-योजक लागू किया जाता है, इसे चार बिट तक कम कर दिया जाता है और इसके कैरी बिट को जोड़ दिया जाता है <math>c_5</math>
+* <math>\operatorname{height}(c_4) = d_3 + 1 = 5</math>, इसलिए आधा-योजक लागू किया जाता है, इसे चार बिट तक कम कर दिया जाता है और इसके कैरी बिट को जोड़ दिया जाता है <math>c_5</math>
-* <math>\operatorname{height}(c_5) = 7</math> से कैरी बिट सहित <math>c_4</math>, इसलिए हम इसे चार बिट तक कम करने के लिए एक पूर्ण-योजक और एक आधा-योजक लागू करते हैं
+* <math>\operatorname{height}(c_5) = 7</math> से कैरी बिट सहित <math>c_4</math>, इसलिए हम इसे चार बिट तक कम करने के लिए पूर्ण-योजक और आधा-योजक लागू करते हैं
 * <math>\operatorname{height}(c_6\cdots c_{10}) = 8</math> पिछले कैरी बिट्स सहित, इसलिए हम उन्हें चार बिट्स तक कम करने के लिए दो पूर्ण-योजक लागू करते हैं
-* <math>\operatorname{height}(c_{11}) = 6</math> पिछले कैरी बिट्स सहित, इसलिए हम इसे चार बिट्स तक कम करने के लिए एक पूर्ण-योजक लागू करते हैं
+* <math>\operatorname{height}(c_{11}) = 6</math> पिछले कैरी बिट्स सहित, इसलिए हम इसे चार बिट्स तक कम करने के लिए पूर्ण-योजक लागू करते हैं
-* <math>\operatorname{height}(c_{12}\cdots c_{14})</math> कैरी बिट्स सहित ऊंचाई में सभी चार बिट्स से कम या उसके बराबर हैं, इसलिए कोई बदलाव नहीं किया गया है
+* <math>\operatorname{height}(c_{12}\cdots c_{14})</math> कैरी बिट्स सहित ऊंचाई में सभी चार बिट्स से कम या उसके सामान्तर हैं, इसलिए कोई बदलाव नहीं किया गया है
-अवस्था <math>j=2</math>, <math>d_2 = 3</math>* <math>\operatorname{height}(c_0\cdots c_2)</math> सभी की ऊंचाई तीन बिट से कम या उसके बराबर है, इसलिए कोई बदलाव नहीं किया गया है
+अवस्था <math>j=2</math>, <math>d_2 = 3</math>* <math>\operatorname{height}(c_0\cdots c_2)</math> सभी की ऊंचाई तीन बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है
-* <math>\operatorname{height}(c_3) = d_2 + 1 = 4</math>, इसलिए एक आधा-योजक लागू किया जाता है, इसे तीन बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है <math>c_4</math>
+* <math>\operatorname{height}(c_3) = d_2 + 1 = 4</math>, इसलिए आधा-योजक लागू किया जाता है, इसे तीन बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है <math>c_4</math>
-* <math>\operatorname{height}(c_4\cdots c_{12}) = 5</math> पिछले कैरी बिट्स सहित, इसलिए हम उन्हें तीन बिट्स तक कम करने के लिए एक पूर्ण-योजक लागू करते हैं
+* <math>\operatorname{height}(c_4\cdots c_{12}) = 5</math> पिछले कैरी बिट्स सहित, इसलिए हम उन्हें तीन बिट्स तक कम करने के लिए पूर्ण-योजक लागू करते हैं
-* <math>\operatorname{height}(c_{13}\cdots c_{14})</math> कैरी बिट्स सहित ऊंचाई में सभी तीन बिट्स से कम या उसके बराबर हैं, इसलिए कोई बदलाव नहीं किया गया है
+* <math>\operatorname{height}(c_{13}\cdots c_{14})</math> कैरी बिट्स सहित ऊंचाई में सभी तीन बिट्स से कम या उसके सामान्तर हैं, इसलिए कोई बदलाव नहीं किया गया है
-अवस्था <math>j=1</math>, <math>d_1 = 2</math>* <math>\operatorname{height}(c_0\cdots c_1)</math> सभी की ऊंचाई दो बिट से कम या उसके बराबर है, इसलिए कोई बदलाव नहीं किया गया है
+अवस्था <math>j=1</math>, <math>d_1 = 2</math>* <math>\operatorname{height}(c_0\cdots c_1)</math> सभी की ऊंचाई दो बिट से कम या उसके सामान्तर है, इसलिए कोई बदलाव नहीं किया गया है
-* <math>\operatorname{height}(c_2) = d_1 + 1 = 3</math>, इसलिए एक आधा-योजक लागू किया जाता है, इसे दो बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है <math>c_3</math>
+* <math>\operatorname{height}(c_2) = d_1 + 1 = 3</math>, इसलिए आधा-योजक लागू किया जाता है, इसे दो बिट तक कम किया जाता है और इसके कैरी बिट को जोड़ा जाता है <math>c_3</math>
-* <math>\operatorname{height}(c_3\cdots c_{13}) = 4</math> पिछले कैरी बिट्स सहित, इसलिए हम उन्हें दो बिट्स तक कम करने के लिए एक पूर्ण-योजक लागू करते हैं
+* <math>\operatorname{height}(c_3\cdots c_{13}) = 4</math> पिछले कैरी बिट्स सहित, इसलिए हम उन्हें दो बिट्स तक कम करने के लिए पूर्ण-योजक लागू करते हैं
 * <math>\operatorname{height}(c_{14}) = 2</math> से कैरी बिट सहित <math>c_{13}</math>, इसलिए कोई परिवर्तन नहीं किया गया है
 जोड़ना
-अंतिम चरण का आउटपुट दो या उससे कम ऊंचाई के 15 कॉलम छोड़ता है जिन्हें एक मानक योजक में पारित किया जा सकता है।
+अंतिम चरण का आउटपुट दो या उससे कम ऊंचाई के 15 कॉलम छोड़ता है जिन्हें मानक योजक में पारित किया जा सकता है।
 ==यह भी देखें==
 * बूथ का गुणन एल्गोरिथ्म
 * फ़्यूज्ड गुणा-जोड़ें
-*[[वालेस का पेड़]]
+*[[वालेस का पेड़|वालेस का ट्री]]
 * जटिल लघुगणक और घातांक के लिए [[एल्गोरिथम कितना है?]]
 * [[मॉड्यूलर अंकगणित]]ीय गुणन के लिए कोचानस्की गुणन
@@ Line 68: / Line 69: @@
 <ref name="Townsend_2003">{{cite conference |last1=Townsend |first1=Whitney J. |last2=Swartzlander, Jr. |first2=Earl E. |last3=Abraham |first3=Jacob A. |author-link3=Jacob A. Abraham |title=A Comparison of Dadda and Wallace Multiplier Delays |book-title=SPIE Advanced Signal Processing Algorithms, Architectures, and Implementations XIII |date=December 2003 |doi=10.1117/12.507012 |publisher=[[The International Society]] |url=https://ieeemilestones.ethw.org/w/images/d/db/A_comparison_of_Dadda_and_Wallace_multiplier_delays.pdf  }}</ref>
 }}
 ==अग्रिम पठन==
 * {{cite web |title=Advanced Arithmetic Techniques |first=John J. G. |last=Savard |date=2018 |orig-year=2006 |work=quadibloc |url=http://www.quadibloc.com/comp/cp0202.htm |access-date=2018-07-16 |url-status=live |archive-url=https://web.archive.org/web/20180703001722/http://www.quadibloc.com/comp/cp0202.htm |archive-date=2018-07-03}}
-[[Category: अंकगणित तर्क सर्किट]] [[Category: कंप्यूटर अंकगणित]] [[Category: गुणा]] [[Category: 1965 परिचय]] [[Category: 1965 कंप्यूटिंग में]]
-[[Category: Machine Translated Page]]
+[[Category:1965 कंप्यूटिंग में]]
+[[Category:1965 परिचय]]
 [[Category:Created On 07/08/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:कंप्यूटर अंकगणित]]
+[[Category:गुणा]]

Anonymous

Search

दद्दा मल्टीप्लायर: Difference between revisions

Namespaces

More

Page actions

Latest revision as of 10:25, 22 August 2023

Contents

विवरण

एल्गोरिथम उदाहरण

यह भी देखें

संदर्भ

अग्रिम पठन

Navigation

Navigation

Wiki tools

Wiki tools

Anonymous

Search

दद्दा मल्टीप्लायर: Difference between revisions

Latest revision as of 10:25, 22 August 2023

विवरण

एल्गोरिथम उदाहरण

यह भी देखें

संदर्भ

अग्रिम पठन

Navigation

Wiki tools

Page tools

Other projects

Categories