अधिकांश प्रोग्रामिंग भाषाओं में, फ़्लोटिंग पॉइंट नंबरों को वैज्ञानिक संकेतन की तरह दर्शाया जाता है : एक घातांक और एक मंटिसा (जिसे महत्व भी कहा जाता है)। एक बहुत ही सरल संख्या, कहते हैं 9.2, वास्तव में यह अंश है:
5179139571476070 * 2 -49
जहां प्रतिपादक है -49और मंटिसा है 5179139571476070। इस तरह से कुछ दशमलव संख्याओं का प्रतिनिधित्व करना असंभव है, यह है कि प्रतिपादक और मंटिसा दोनों पूर्णांक होना चाहिए। दूसरे शब्दों में, सब तैरता एक होना चाहिए पूर्णांक एक से गुणा 2 के पूर्णांक शक्ति ।
9.2बस हो सकता है 92/10, लेकिन 10 को 2 एन के रूप में व्यक्त नहीं किया जा सकता है यदि एन पूर्णांक मूल्यों तक सीमित है।
डेटा देखना
सबसे पहले, कुछ घटक 32-और 64-बिट बनाने वाले घटकों को देखने के लिए float। यदि आप केवल उत्पादन (पायथन में उदाहरण) की परवाह करते हैं, तो इन पर चमक डालें:
def float_to_bin_parts(number, bits=64):
if bits == 32: # single precision
int_pack = 'I'
float_pack = 'f'
exponent_bits = 8
mantissa_bits = 23
exponent_bias = 127
elif bits == 64: # double precision. all python floats are this
int_pack = 'Q'
float_pack = 'd'
exponent_bits = 11
mantissa_bits = 52
exponent_bias = 1023
else:
raise ValueError, 'bits argument must be 32 or 64'
bin_iter = iter(bin(struct.unpack(int_pack, struct.pack(float_pack, number))[0])[2:].rjust(bits, '0'))
return [''.join(islice(bin_iter, x)) for x in (1, exponent_bits, mantissa_bits)]
उस फ़ंक्शन के पीछे बहुत जटिलता है, और यह समझाने के लिए काफी स्पर्शरेखा होगी, लेकिन अगर आप रुचि रखते हैं, तो हमारे उद्देश्यों के लिए महत्वपूर्ण संसाधन संरचना मॉड्यूल है।
पायथन floatएक 64-बिट, डबल-सटीक संख्या है। सी, सी ++, जावा और सी # जैसी अन्य भाषाओं में, डबल-सटीक का एक अलग प्रकार है double, जिसे अक्सर 64 बिट्स के रूप में लागू किया जाता है।
जब हम अपने उदाहरण के साथ उस फ़ंक्शन को कॉल करते हैं 9.2, तो यहां हमें क्या मिलेगा:
>>> float_to_bin_parts(9.2)
['0', '10000000010', '0010011001100110011001100110011001100110011001100110']
डेटा की व्याख्या करना
आप देखेंगे कि मैंने रिटर्न वैल्यू को तीन घटकों में विभाजित किया है। ये घटक हैं:
- संकेत
- प्रतिपादक
- मंटिसा (जिसे महत्वपूर्ण भी कहा जाता है, या अंश)
संकेत
संकेत पहले घटक में एकल बिट के रूप में संग्रहीत किया जाता है। यह व्याख्या करना आसान है: 0इसका मतलब है कि फ्लोट एक सकारात्मक संख्या है; 1इसका मतलब नकारात्मक है। क्योंकि 9.2सकारात्मक है, हमारा संकेत मूल्य है 0।
प्रतिपादक
प्रतिपादक को मध्य घटक में 11 बिट्स के रूप में संग्रहीत किया जाता है। हमारे मामले में, 0b10000000010। दशमलव में, जो मान का प्रतिनिधित्व करता है 1026। इस घटक का एक उत्कर्ष यह है कि आपको सही घातांक प्राप्त करने के लिए 2 (# बिट्स) के बराबर संख्या को घटाना चाहिए - 1 - 1 ; हमारे मामले में, इसका मतलब है कि सही घातांक प्राप्त करने के लिए घटाना 0b1111111111(दशमलव संख्या 1023), 0b00000000011(दशमलव संख्या 3)।
अपूर्णांश
मंटिसा को तीसरे घटक में 52 बिट्स के रूप में संग्रहीत किया जाता है। हालाँकि, इस घटक के लिए एक क्विक भी है। इस विचित्रता को समझने के लिए, वैज्ञानिक संकेतन में एक संख्या पर विचार करें, जैसे:
6.0221413x10 23
मंटिसा होगा 6.0221413। याद रखें कि वैज्ञानिक संकेतन में मंटिसा हमेशा एक एकल शून्य अंक से शुरू होती है। बाइनरी के लिए एक ही सही है, सिवाय इसके कि बाइनरी केवल दो अंक हैं: 0और 1। तो बाइनरी मंटिसा हमेशा से शुरू होता है 1! जब एक फ्लोट संग्रहीत होता है, 1तो बाइनरी मंटिसा के सामने अंतरिक्ष को बचाने के लिए छोड़ दिया जाता है; हमें इसे सही मन्तिसा प्राप्त करने के लिए अपने तीसरे तत्व के सामने रखना होगा :
1,0010011001100110011001100110011001100110011001100110
इसमें केवल एक साधारण जोड़ शामिल है, क्योंकि हमारे तीसरे घटक में संग्रहीत बिट्स वास्तव में मंटिसा के आंशिक भाग का प्रतिनिधित्व करते हैं , मूलांक के दाईं ओर ।
दशमलव संख्या के साथ काम करते समय, हम 10. की शक्तियों को गुणा या विभाजित करके "दशमलव बिंदु को स्थानांतरित करते हैं"। द्विआधारी में, हम 2 की शक्तियों को गुणा या विभाजित करके एक ही काम कर सकते हैं। चूंकि हमारे तीसरे तत्व में 52 बिट्स हैं, इसलिए हम विभाजित करते हैं यह द्वारा 2 52 इसे स्थानांतरित करने के सही करने के लिए 52 स्थानों:
0,0010011001100110011001100110011001100110011001100110
दशमलव संकेतन में, कि विभाजित के रूप में ही है 675539944105574के द्वारा 4503599627370496प्राप्त करने के लिए 0.1499999999999999। (यह एक अनुपात का एक उदाहरण है जिसे बाइनरी में बिल्कुल व्यक्त किया जा सकता है, लेकिन केवल दशमलव में लगभग; अधिक विस्तार के लिए, देखें: 675539944105574/4503599627370496 ।)
अब जब हमने तीसरे घटक को एक भिन्नात्मक संख्या में बदल दिया है, तो 1यह सही मंटिसा देता है।
अवयवों का पुनरावर्तन
- हस्ताक्षर (पहला घटक):
0सकारात्मक के लिए, 1नकारात्मक के लिए
- घातांक (मध्य घटक): सही घातांक प्राप्त करने के लिए 2 (# बिट्स) - 1 - 1 को घटाएं
- मंटिसा (अंतिम घटक): 2 (# बिट्स) से विभाजित करें और
1सही मंटिसा पाने के लिए जोड़ें
संख्या की गणना
सभी तीन भागों को एक साथ रखकर, हमें यह बाइनरी नंबर दिया गया है:
1.0010011001100110011001100110011001100110011001100110 x 10 11
जिसे हम बाइनरी से दशमलव में बदल सकते हैं:
1.1499999999999999 x 2 3 ( अनुभवहीन !)
और 9.2एक अस्थायी बिंदु मान के रूप में संग्रहीत होने के बाद हमने ( ) के साथ शुरू की गई संख्या के अंतिम प्रतिनिधित्व को गुणा करने के लिए :
9.1999999999999993
एक अंश के रूप में प्रतिनिधित्व करना
9.2
अब जब हमने संख्या बना ली है, तो इसे एक साधारण अंश में समेटना संभव है:
1.0010011001100110011001100110011001100110011001100110 x 10 11
मंटिसा को पूरी संख्या में शिफ्ट करें:
10010011001100110011001100110011001100110011001100001001 10 x 11-110100
दशमलव में परिवर्तित करें:
5179139571476070 x 2 3-52
घातांक घटाना:
5179139571476070 x 2 -49
नकारात्मक घातांक को विभाजन में बदलें:
5179139571476070/2 49
गुणा विस्तारक:
5179139571476070/562949953421312
जो बराबर है:
9.1999999999999993
9.5
>>> float_to_bin_parts(9.5)
['0', '10000000010', '0011000000000000000000000000000000000000000000000000']
पहले से ही आप देख सकते हैं कि मंटिसा केवल 4 अंक है और इसके बाद पूरे शून्य हैं। लेकिन चलो पेस के माध्यम से चलते हैं।
बाइनरी वैज्ञानिक संकेतन इकट्ठा करें:
1.0011 x 10 11
दशमलव बिंदु को शिफ्ट करें:
10011 x 10 11-100
घातांक घटाना:
10011 x 10 -1
बाइनरी टू दशमलव:
19 x 2 -1
विभाजन के लिए नकारात्मक घातांक:
१ ९ / २ १
गुणा विस्तारक:
19/2
बराबर है:
9.5
आगे की पढाई