😕 🏂🏿 🔤 फ्लोटिंग पॉइंट नंबरों को समझना (भाग ०) ✔️ 👝 👐

हैलो, खब्रोविट्स। मैं लंबे समय से फ्लोटिंग पॉइंट रजिस्टर के विषय का शौकीन रहा हूं। मैं हमेशा इस बात को लेकर चिंतित रहती थी कि स्क्रीन का आउटपुट कैसे हो, आदि। मुझे याद है, बहुत समय पहले विश्वविद्यालय में मैं अपनी कक्षा को फ्लोटिंग-पॉइंट संख्याओं से जोड़ रहा था जिसमें 512 बिट्स थे। केवल एक चीज जिसे मैं किसी भी तरह से महसूस नहीं कर सका, वह थी स्क्रीन का आउटपुट।

जैसे ही मेरे पास खाली समय था, मैंने पुराने को ले लिया। मैंने अपने आप को एक नोटबुक दी और हम चले गए। मैं खुद ही सबकुछ सोचना चाहता था, केवल कभी-कभार IEEE 754 मानक देख रहा था।
और यह वही है जो यह सब आया है। रुचि रखने वालों के लिए, मैं बिल्ली के लिए पूछना।

इस लेख में महारत हासिल करने के लिए, आपको निम्नलिखित जानने की आवश्यकता है: नकारात्मक डिग्री के ज्ञान के स्तर पर एक बिट, एक बाइनरी सिस्टम, अंकगणित क्या है। लेख प्रोसेसर के स्तर पर कार्यान्वयन के इंजीनियरिंग विवरणों के साथ-साथ सामान्यीकृत और सामान्यीकृत संख्याओं को प्रभावित नहीं करेगा। एक संख्या को द्विआधारी रूप में परिवर्तित करने पर अधिक जोर दिया जाता है और इसके विपरीत, साथ ही साथ यह भी बताया जाता है कि फ्लोटिंग पॉइंट संख्याओं को आम तौर पर बिट्स के रूप में कैसे संग्रहीत किया जाता है।

फ्लोटिंग-पॉइंट नंबर एक बहुत शक्तिशाली उपकरण है जिसका आपको सही उपयोग करने में सक्षम होना चाहिए। वे पूर्णांक रजिस्टरों के रूप में आम नहीं हैं, लेकिन यह भी जटिल नहीं है अगर वे सक्षम और धीरे-धीरे प्रवेश कर रहे हैं।

आज के लेख में, मैं एक उदाहरण के रूप में 32-बिट रजिस्टरों का उपयोग करूंगा। डबल सटीक संख्या (64-बिट) बिल्कुल एक ही तर्क पर काम करती है।

सबसे पहले, आइए बात करते हैं कि फ्लोटिंग पॉइंट नंबर कैसे संग्रहीत किए जाते हैं। सबसे पुराने 31 बिट्स महत्वपूर्ण हैं। एक एकल का मतलब है कि संख्या नकारात्मक है, और शून्य, क्रमशः, विपरीत है। अगला घातांक के 8 बिट आते हैं। ये 8 बिट्स सामान्य अहस्ताक्षरित संख्या हैं। और अंत में मंटिसा के 23 बिट्स हैं। सुविधा के लिए, हम एस के रूप में संकेत को दर्शाते हैं, ई के रूप में प्रतिपादक, और मंटिसा, अजीब तरह से पर्याप्त, एम।

हमें सामान्य सूत्र मिलते हैं

(- 1)^{s} ट ा इ म ् स M ग ु न ा 2^{E - 127}

$(- 1) ^ s \ टाइम्स M \ गुना 2 ^ {E-127}$

मंटिसा को एक अंतर्निहित एकल बिट माना जाता है। यही है, मंटिसा 24 बिट होगा, लेकिन चूंकि उच्चतम 23 वां बिट हमेशा एक होता है, आप इसे नीचे नहीं लिख सकते। इस प्रकार, यह "प्रतिबंध" हमें किसी भी संख्या का प्रतिनिधित्व करने की विशिष्टता देगा।

मंटिसा एक साधारण बाइनरी नंबर है, लेकिन पूर्णांकों के विपरीत, सबसे महत्वपूर्ण बिट 2 ^ 0 डिग्री और फिर घटती डिग्री में है। यह वह जगह है जहाँ प्रदर्शक काम आता है। इसके मूल्य के आधार पर, उच्च बिट दो की शक्ति बढ़ती या घटती है। यही इस विचार की पूरी प्रतिभा है।

आइए इसे एक अच्छे उदाहरण के साथ दिखाने की कोशिश करें:

बाइनरी फॉर्म में 3.625 नंबर की कल्पना करें। सबसे पहले, हम इस संख्या को दो की शक्तियों में विभाजित करते हैं।

3.625 = 2 + 1 + 0.5 + 0.125 = 1 ग ु न ा 2^{1} + 1 2 ब ा र 2^{0} + 1 2 ब ा र 2^{- 1} + 0 ब ा र 2^{- 2} + 1 2 ब ा र 2^{- 3}

$3.625 = 2 + 1 + 0.5 + 0.125 = 1 \ गुना 2 ^ 1 + 1 \ 2 बार 2 ^ 0 + 1 \ 2 बार 2 ^ {-1} + 0 \ बार 2 ^ {-2} + 1 \ 2 बार 2 ^ { -3}$

सीनियर दो की डिग्री एक के बराबर है। ई - 127 = 1. ई = 128।

0 1,000,000 1,101,000,000,000,000,000,000

वह सब हमारी संख्या है।

आइए विपरीत दिशा में भी प्रयास करें। मान लीजिए कि हमारे पास 32 बिट्स हैं, 32 बिट्स की मनमानी है।

0 10000100 (1) 11011100101000000000000

समान अंतर्निहित उच्च-क्रम बिट को कोष्ठक में इंगित किया गया है।

सबसे पहले, घातांक की गणना करें। ई = 132. तदनुसार, वरिष्ठ दो की डिग्री 5 के बराबर होगी। कुल हमारे पास निम्नलिखित संख्या है:

2^{5} + 2^{4} + 2^{3} + 2^{1} + 2^{0} + 2^{- 1} + 2^{- 4} + 2^{- 6} =

$2 ^ 5 + 2 ^ 4 + 2 ^ 3 + 2 ^ 1 + 2 ^ 0 + 2 ^ {-1} + 2 ^ {-4} + 2 ^ {-6} =$

= 32 + 16 + 8 + 2 + 1 + 0.5 + 0.0625 + 0.015625 = 59.578125

$= 32 + 16 + 8 + 2 + 1 + 0.5 + 0.0625 + 0.015625 = 59.578125$

यह अनुमान लगाना आसान है कि हम केवल 24 डिग्री दो की एक श्रृंखला को स्टोर कर सकते हैं। तदनुसार, यदि दो संख्याएँ 24 से अधिक समय तक भिन्न होती हैं, तो जब जोड़ा जाता है, तो संख्या उनके बीच बड़े के बराबर रहती है।

सुविधाजनक रूपांतरण के लिए, मैंने सी में एक छोटा कार्यक्रम अपलोड किया।

#include <stdio.h> union IntFloat { unsigned int integerValue; float floatValue; }; void printBits(unsigned int x) { int i; for (i = 31; i >= 0; i--) { if ((x & ((unsigned int)1 << i)) != 0) { printf("1"); } else { printf("0"); } if (i == 31) { printf(" "); } if (i == 23) { printf(" "); } } printf("\n"); } int main() { union IntFloat b0; b0.floatValue = 59.578125; printBits(b0.integerValue); b0.integerValue = 0b01000010011011100101000000000000; printf("%f\n", b0.floatValue); return 0; }

ग्रिड कदम दो आसन्न फ्लोटिंग पॉइंट संख्याओं के बीच न्यूनतम अंतर है। यदि हम एक नियमित पूर्णांक के रूप में ऐसी संख्या के बिट्स के अनुक्रम का प्रतिनिधित्व करते हैं, तो पड़ोसी फ़्लोटिंग-पॉइंट संख्या बिट्स में प्रति इकाई पूर्णांक के रूप में भिन्न होगी।

इसे अन्यथा व्यक्त किया जा सकता है। दो आसन्न फ़्लोटिंग पॉइंट नंबर 2 ^ (ई - 127 - 23) से भिन्न होंगे। यही है, कम से कम महत्वपूर्ण बिट के मूल्य के बराबर अंतर से।

प्रमाण के रूप में, आप कोड में मुख्य परिवर्तन कर सकते हैं और फिर से संकलित कर सकते हैं।

 union IntFloat b0, b1, b2; b0.floatValue = 59.578125F; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); short exp1 = 0b10000100; short exp2 =0b01101101; /*  ,       */ b0.integerValue = 0b01000010011111111111111111111111; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); /*   */ printf("%d %d\n", exp1, exp2);

मुझे लगता है कि आज के लिए आप गोल कर सकते हैं, अन्यथा यह बहुत लंबा हो जाता है। अगली बार मैं फ़्लोटिंग पॉइंट नंबर जोड़ने और राउंडिंग के दौरान सटीक खोने के बारे में लिखूंगा।

पुनश्च: मैं समझता हूं कि मैंने असंबद्ध संख्याओं के विषय पर स्पर्श नहीं किया, आदि। मैं अभी लेख को बहुत अधिक लोड नहीं करना चाहता था, और यह जानकारी IEEE 754 मानक में लगभग शुरुआत में ही आसानी से मिल सकती है।

फ्लोटिंग पॉइंट नंबरों को समझना (भाग ०)

More articles: