मैंने हाल ही में एक वेक्टर 3 कक्षा लिखी है, और मैंने अपने सामान्य() फ़ंक्शन को किसी मित्र के लिए समीक्षा के लिए सबमिट किया है। उन्होंने कहा कि यह अच्छा था, लेकिन मुझे जहां संभव हो, पारस्परिक रूप से गुणा करना चाहिए क्योंकि "CPU गुणा में गुणा करना सस्ता है"।विभाजन से सस्ता गुणा क्यों बढ़ रहा है?
मेरा प्रश्न बस है, वह क्यों है?
प्राथमिक संचालन के संदर्भ में इसके बारे में सोचें कि हार्डवेयर अधिक आसानी से कार्यान्वित कर सकता है - जोड़ें, घटाना, स्थानांतरित करना, तुलना करना। एक छोटे से सेटअप में भी गुणा करने के लिए कम ऐसे प्राथमिक कदमों की आवश्यकता होती है - साथ ही, यह आगे बढ़ने वाले एल्गोरिदम को आगे बढ़ाता है - उदाहरण के लिए here देखें ... लेकिन हार्डवेयर आमतौर पर उन लोगों का लाभ नहीं उठाता है (शायद अत्यधिक विशिष्ट हार्डवेयर को छोड़कर)। उदाहरण के लिए, विकिपीडिया यूआरएल कहता है, "टूम-कुक पांच आकार-एन गुणाओं की लागत के लिए आकार-एन क्यूब्ड गुणा कर सकता है" - यह वास्तव में बहुत बड़ी संख्या के लिए बहुत तेज़ है (फ्यूरर एल्गोरिदम, एक सुंदर हालिया विकास, Θ(n ln(n) 2Θ(ln*(n))) कर सकते हैं - फिर से, विकिपीडिया पेज और वहां से लिंक देखें)।
डिवीजन की केवल धीमी गति से धीमी, प्रति - wikipedia; यहां तक कि सर्वश्रेष्ठ एल्गोरिदम (जिनमें से कुछ एचडब्ल्यू में लागू होते हैं, सिर्फ इसलिए कि वे गुणा के लिए सबसे अच्छे एल्गोरिदम के रूप में परिष्कृत और जटिल नहीं हैं ;-) गुणा करने के लिए मोमबत्ती नहीं रख सकते हैं।
बस नहीं-तो-बड़ी संख्या के साथ इस मुद्दे अंदाजा लगाना, यहाँ gmpy साथ कुछ परिणाम, एक आसान से उपयोग अजगर आवरण के आसपास GMP, जो जाता है गणित की बहुत अच्छी कार्यान्वयन हालांकि जरूरी latest- नहीं है करने के लिए कर रहे हैं और सबसे महान घरों।
$ python -mtimeit -s'import gmpy as g; a=g.mpf(198792823083408); b=g.mpf(7230824083); ib=1.0/b' 'a*ib'
1000000 loops, best of 3: 0.186 usec per loop
$ python -mtimeit -s'import gmpy as g; a=g.mpf(198792823083408); b=g.mpf(7230824083); ib=1.0/b' 'a/b'
1000000 loops, best of 3: 0.276 usec per loop
जैसा कि आप देख, यहां तक कि इस छोटे आकार (संख्या में बिट्स) की संख्या में, और वास्तव में एक ही गति-आसक्त लोगों द्वारा अनुकूलित पुस्तकालयों के साथ: एक धीमी गति से (पहली पीढ़ी ;-) मैकबुक प्रो पर , पारस्परिक द्वारा गुणा विभाजन के समय 1/3 बचा सकता है।
यह केवल दुर्लभ स्थितियों में हो सकता है कि ये कुछ नैनोसेकंड एक जीवन या मौत मुद्दा जब वे हैं, लेकिन, और निश्चित रूप से आप बार-बार एक ही मूल्य से विभाजित कर रहे हैं (दूर amortize करने 1.0/b ऑपरेशन!), तो यह ज्ञान एक जीवन बचा सकता है।
(समान नस में बहुत - और होर्नर के scheme बहुपद गणना के लिए बेहद पसंद किया जाता है - x*x अक्सर करने के लिए x**2 [भाषाओं में अजगर और फोरट्रान की तरह एक ** "सत्ता में उठाना" ऑपरेटर है,] की तुलना में समय की बचत करेंगे उठाए जाने के लिए बिजली के संचालन को दोहराया! -)।
[असेंबली निर्देशों पर उपयोगी तथ्यों।] (Http://www.agner.org/optimize/instruction_tables.pdf) पारस्परिक कैश करने की आवश्यकता के बारे में आवश्यक टिप्पणी के लिए – nonsensickle
(फ्लोट) विभाजन के लिए सीपीयू ऑपरेशन गुणा से कहीं अधिक जटिल है। सीपीयू को और करना है। मैं हार्डवेयर के बारे में जानकार से बहुत दूर हूं, लेकिन आप सामान्य विभाजन कार्यान्वयन के बारे में बहुत सारी जानकारी प्राप्त कर सकते हैं (उदाहरण के लिए newton-raphson एल्गोरिदम पर आधारित)।
मैं हमेशा सीपीयू प्रदर्शन प्राप्त करने के लिए विभाजन के बजाय पारस्परिक के गुणा का उपयोग करने के बारे में भी सावधान रहूंगा: वे बिल्कुल वही परिणाम नहीं दे सकते हैं। यह आपके आवेदन के आधार पर कोई फर्क नहीं पड़ता है या नहीं।
यदि आप ग्रेड स्कूल में वापस सोचते हैं, तो आपको याद होगा कि गुणा अधिक से अधिक कठिन था और विभाजन गुणा से कठिन था। सीपीयू के लिए चीजें अलग नहीं हैं।
याद रखें कि पारस्परिक गणना की गणना एक विभाजन शामिल है, इसलिए जब तक कि आप एक बार पारस्परिक गणना की गणना न करें और इसे तीन बार उपयोग न करें, आपको गति दिखाई नहीं देगी।
क्या आप इनट्स या फ्लोट से निपट रहे हैं? वेक्टर 3, पूर्णांक के लिए – Uri
। क्यूं कर? – jkeys
डुप्लिकेट: http://stackoverflow.com/questions/655537/is-multiplying-the-inverse-better-or-worse – womp