🛌 🤟🏽 😌 जावा में फ्लोटिंग पॉइंट नंबर के बारे में कुछ शब्द 🧒🏽 🧘🏽 👏🏼

कुछ दिनों पहले मुझे एक मनोरंजक सवाल आया जैसे इस कोड को निष्पादित करने का परिणाम क्या होगा:

double a = 2.0 - 1.1;

या ऐसे:

 double f = 0.0; for (int i=1; i <= 10; i++) { f += 0.1; }

मेरी सभी अपेक्षाओं के विपरीत, उत्तर में 0.89999999999999991 और दूसरे में 0.9999999999999989 है।

उन लोगों के लिए जो यह जानना चाहते हैं कि क्यों, साथ ही इस प्रकार के डेटा के बारे में कुछ और दिलचस्प तथ्य, स्वागत करते हैं।

सामान्य शब्दों में, ऊपर दिए गए प्रश्न का उत्तर कुछ इस तरह से आएगा: “इसी तरह की त्रुटियां संख्याओं के आंतरिक बाइनरी प्रतिनिधित्व से जुड़ी हैं। जिस तरह दशमलव प्रणाली में विभाजन 1/3 के परिणाम का सही प्रतिनिधित्व करना असंभव है, उसी तरह बाइनरी सिस्टम में 1/10 का सही प्रतिनिधित्व करना असंभव है। यदि आपको राउंडिंग त्रुटियों को समाप्त करने की आवश्यकता है, तो आपको BigDecimal वर्ग का उपयोग करना चाहिए। "

अमूर्त वास्तविक संख्याओं, जैसे 0.2 या 0.2 और जावा में डबल डेटा प्रकार के बीच एक महत्वपूर्ण अंतर है। सबसे पहले, वास्तविक संख्याओं का प्लेटोनिक आदर्श प्रतिनिधित्व अनंत है, जबकि जावा में प्रतिनिधित्व बिट्स की संख्या से सीमित है। हालांकि, कम्प्यूटेशनल सटीकता संख्याओं के आकार को सीमित करने की तुलना में एक और भी अधिक आवश्यक समस्या है। और भी अधिक "पेचीदा" गोल संख्याओं का एक पूरी तरह से मूल तरीका है, लेकिन क्रम में सब कुछ के बारे में।

शायद आपको पूर्णांक के द्विआधारी प्रतिनिधित्व के साथ शुरू करना चाहिए। यह पैराग्राफ बाद में काम आएगा। So. पूर्णांकों का प्रतिनिधित्व करने के लिए सबसे सरल विकल्प तथाकथित "डायरेक्ट कोड" है, जिसमें सबसे महत्वपूर्ण बिट का उपयोग संख्या के चिह्न (0 - सकारात्मक, 1 - नकारात्मक) को रिकॉर्ड करने के लिए किया जाता है, और शेष बिट्स का उपयोग मूल्य को रिकॉर्ड करने के लिए सीधे किया जाता है। इस प्रकार, आठ-बिट प्रतिनिधित्व में "-9" संख्या 10001001 की तरह दिखाई देगी। इस दृष्टिकोण का नुकसान दो शून्य ("+0" और "-0") की उपस्थिति और नकारात्मक संख्याओं के साथ अंकगणितीय संचालन की जटिलता है। एक अन्य विकल्प जो हमें रुचता है, वह है "एक बदलाव के साथ कोड", जिसमें, सरल शब्दों में, हम इस तरह के प्रतिनिधित्व के लिए एक निश्चित निरंतरता जोड़ते हैं, 2 ^ (n-1) के बराबर, जहां n बिट्स (बिट्स) की संख्या है । हमारे मामले में, आठ-बिट प्रतिनिधित्व में "-9" संख्या के साथ एक उदाहरण इस तरह दिखाई देगा:

-9 + 2 ^ (8-1) = -9 + 128 = 119. बाइनरी रूप में, हमें 01110111 मिलता है। यह विकल्प सुविधाजनक है क्योंकि हमारे पास केवल एक शून्य है, लेकिन जब अंकगणितीय संचालन होते हैं तो ऑफसेट को ध्यान में रखना आवश्यक होगा।

यहां यह ध्यान देने योग्य है। जावा भाषा के घोषित लक्ष्यों में से एक मशीन स्वतंत्रता है। गणना को उसी परिणाम का उत्पादन करना चाहिए, जिसकी परवाह किए बिना आभासी मशीन उन्हें निष्पादित करती है। फ्लोटिंग-पॉइंट नंबरों पर अंकगणितीय गणनाओं के लिए, यह अप्रत्याशित रूप से एक मुश्किल काम था। संख्यात्मक प्रकारों को संग्रहीत करने के लिए डबल प्रकार 64 बिट्स का उपयोग करता है, लेकिन कुछ प्रोसेसर 80-बिट फ्लोटिंग-पॉइंट रजिस्टरों का उपयोग करते हैं। ये रजिस्टर गणना के मध्यवर्ती चरणों में अतिरिक्त सटीकता प्रदान करते हैं, अर्थात्। मध्यवर्ती गणना परिणाम एक 80-बिट रजिस्टर में संग्रहीत किया जाता है, जिसके बाद प्रतिक्रिया 64 बिट्स तक होती है। हालाँकि, यह परिणाम भिन्न हो सकता है यदि सभी गणनाओं में 64-बिट प्रोसेसर का उपयोग किया जाता है। इस कारण से, जेवीएम के मूल विवरण में कहा गया है कि सभी मध्यवर्ती गणनाओं को गोल किया जाना चाहिए। इसने कई विशेषज्ञों के विरोध का कारण बना, क्योंकि इस तरह की गोलाई न केवल अतिप्रवाह का कारण बन सकती है, बल्कि गणना स्वयं धीमी होती है। यह इस तथ्य के कारण है कि JDK 1.2 ने सख्त कीवर्ड के लिए समर्थन पेश किया, जो इस पद्धति, वर्ग या इंटरफ़ेस (या बल्कि, इसके कार्यान्वयन) के अंदर की गई सभी गणनाओं के परिणामों की प्रतिलिपि प्रस्तुत करने की गारंटी देता है। दूसरे शब्दों में, सख्त कीवर्ड यह सुनिश्चित करता है कि प्रत्येक प्लेटफ़ॉर्म पर, फ़्लोटिंग-पॉइंट गणना एक ही व्यवहार करेगी और एक निश्चित सटीकता के साथ, भले ही कुछ प्लेटफ़ॉर्म अधिक सटीकता के साथ गणना कर सकें। दिलचस्प बात यह है कि प्रोसेसर के x86 परिवार के लिए, फ्लोटिंग-पॉइंट मॉड्यूल को एक अलग चिप में अलग किया गया था जिसे गणितीय बिंदु-प्रोसेसिंग यूनिट (फ्लोटिंग पॉइंट यूनिट (FPU)) कहा जाता है। पेंटियम एमएमएक्स प्रोसेसर से शुरू होकर, फ्लोटिंग पॉइंट मॉड्यूल केंद्रीय प्रोसेसर में एकीकृत होता है। अधिक जानकारी ।

अगला। IEEE 754 मानक हमें बताता है कि वास्तविक संख्याओं का प्रतिनिधित्व तेजी से लिखा जाना चाहिए। इसका मतलब है कि बिट्स का हिस्सा संख्या के तथाकथित मंटिसा को एन्कोड करता है, दूसरा हिस्सा ऑर्डर (डिग्री) का एक संकेतक है, और नंबर का संकेत इंगित करने के लिए एक और बिट का उपयोग किया जाता है (0 - यदि संख्या सकारात्मक है, 1 - यदि संख्या नकारात्मक है)। गणितीय रूप से, इसे इस तरह लिखा जाता है:

(-1) ^ s × M × 2 ^ E , जहाँ s चिन्ह है, M mantissa है, और E प्रतिपादक है। प्रदर्शक को एक बदलाव के साथ दर्ज किया गया है, जिसे उपरोक्त सूत्र द्वारा प्राप्त किया जा सकता है।

मंटिसा और प्रतिपादक क्या है? मंटिसा एक निश्चित लंबाई का पूर्णांक है जो एक वास्तविक संख्या के सबसे महत्वपूर्ण बिट्स का प्रतिनिधित्व करता है। मान लीजिए कि हमारे मंटिसा में चार बिट्स (| M | = 4) हैं। उदाहरण के लिए, संख्या "9", जो बाइनरी सिस्टम में 1001 होगी।

प्रतिपादक (इसे "आदेश" या "प्रतिपादक" भी कहा जाता है) उच्चतम रैंक के आधार (दो) की डिग्री है। संख्या के भिन्नात्मक भाग को अलग करने से पहले आप इसे अंकों की संख्या के रूप में मान सकते हैं। यदि घातांक एक चर है जिसे रजिस्टर में लिखा गया है और संकलन में अज्ञात है, तो संख्या को "फ्लोटिंग पॉइंट नंबर" कहा जाता है। यदि प्रतिपादक पहले से जाना जाता है, तो संख्या को "निश्चित-बिंदु संख्या" कहा जाता है। फिक्स्ड-पॉइंट नंबर केवल मंटिसा को स्टोर करके साधारण पूर्णांक चर (रजिस्टर) को लिखा जा सकता है। फ्लोटिंग-पॉइंट नंबरों की रिकॉर्डिंग के मामले में, मंटिस और एक्सपोनेंट दोनों तथाकथित मानक रूप में दर्ज किए जाते हैं, उदाहरण के लिए, "1.001e + 3"। यह तुरंत स्पष्ट है कि मंटिसा में चार लक्षण होते हैं, और प्रतिपादक तीन होते हैं।

मान लीजिए कि हम मंटिसा के 3 बिट्स का उपयोग करके एक भिन्नात्मक संख्या प्राप्त करना चाहते हैं। हम ऐसा कर सकते हैं यदि हम लेते हैं, कहते हैं, ई = 1। तब हमारी संख्या बराबर होगी

1.001 + 1 = 1 × 2 ^ 2 + 0 × 2 ^ 1 + 0 × 2 ^ 0 + 1 × 2 ^ (- 1) = 4 + 0.5 = 4.5

इस दृष्टिकोण के साथ समस्याओं में से एक एक ही मंटिसा लंबाई के भीतर एक ही संख्या का एक अलग प्रतिनिधित्व हो सकता है। हमारा "9-कू", मंटिसा की लंबाई 5 के बराबर है, इसे 1.00100e + 3 और 0.10010e + 4 और 0.01001e + 5 के रूप में दर्शाया जा सकता है। यह उपकरण के लिए सुविधाजनक नहीं है, जैसा कि संख्याओं की तुलना करते समय और उन पर अंकगणितीय संचालन करते समय अभ्यावेदन की बहुलता को ध्यान में रखना आवश्यक है। इसके अलावा, यह किफायती नहीं है क्योंकि अभ्यावेदन की संख्या परिमित है, और पुनरावृत्ति उन संख्याओं की संख्या को कम कर देती है जिनका प्रतिनिधित्व किया जा सकता है। हालाँकि, थोड़ा ट्रिक है। यह पता चला है कि पहले बिट के मूल्य की गणना करने के लिए, आप घातांक का उपयोग कर सकते हैं। यदि प्रतिपादक के सभी बिट्स 0 हैं, तो मंटिसा का पहला बिट भी शून्य के बराबर माना जाता है, अन्यथा यह एक के बराबर है। फ्लोटिंग-पॉइंट नंबर जिसमें मंटिसा का पहला बिट एक के बराबर होता है। फ्लोटिंग-पॉइंट संख्याएं, मंटिसा का पहला बिट जिसमें शून्य के बराबर है, को अपभ्रंश कहा जाता है। उनकी मदद से, बहुत कम मात्रा का प्रतिनिधित्व किया जा सकता है। चूंकि पहले बिट को हमेशा गणना की जा सकती है, इसलिए इसे स्पष्ट रूप से संग्रहीत करने की कोई आवश्यकता नहीं है। यह एक बिट बचाता है, क्योंकि अंतर्निहित इकाई को मेमोरी में संग्रहीत करने की आवश्यकता नहीं है, और संख्या का एक अनूठा प्रतिनिधित्व प्रदान करता है। "9" के साथ हमारे उदाहरण में, सामान्यीकृत प्रतिनिधित्व 1.00100 + 3 होगा, और मंटिसा को मेमोरी में "00100" के रूप में संग्रहीत किया जाएगा, क्योंकि वरिष्ठ इकाई को निहितार्थ माना जाता है। इस दृष्टिकोण के साथ समस्या शून्य का प्रतिनिधित्व करने की असंभवता है, जिसके बारे में मैं थोड़ी देर बाद बात करूंगा। आप इस बारे में और बहुत कुछ यहाँ और यहाँ पढ़ सकते हैं।

वैसे, जेडीके 1.5 में हेक्साडेसिमल प्रारूप में फ्लोटिंग पॉइंट संख्या निर्दिष्ट करने की अनुमति है। उदाहरण के लिए, 0.125 को 0x1.0p-3 के रूप में दर्शाया जा सकता है। हेक्साडेसिमल नोटेशन में, वर्णक को इंगित करने के लिए "ई" के बजाय "पी" का उपयोग किया जाता है।

डबल के साथ काम करते समय ध्यान रखने योग्य बातें:

पूर्णांक संख्या के द्वारा पूर्णांक विभाजन एक अपवाद को फेंकता है, जबकि फ्लोटिंग-पॉइंट नंबरों के 0 से विभाजन का परिणाम अनन्तता (या 0.0 / 0 के विभाजन के मामले में NaN) होता है। वैसे, मुझे यह जानने में दिलचस्पी थी कि समान आईईईई 754 मानक के अनुसार, जेवीएम डेवलपर्स, ने क्रमशः क्रमश: -1.0 या 0.0 और 1.0 / 0.0 के बराबर डबल.NEGATIVE_INFINITY और Double.POSITIVE_INFINITY मूल्यों को भी पेश किया।
Double.MIN_VALUE वास्तव में सबसे छोटी संख्या नहीं है जिसे डबल में लिखा जा सकता है। याद रखें, हमने इस तथ्य के बारे में बात की थी कि IEEE 754 मानक के अनुसार, मंटिसा की उच्चतम इकाई अनुमानित रूप से निर्दिष्ट है? तो यहाँ है। जैसा कि पहले ही ऊपर उल्लेख किया गया है, फ्लोटिंग-पॉइंट संख्या के सामान्यीकृत रूप में शून्य का प्रतिनिधित्व करना असंभव है, क्योंकि दो की ऐसी कोई शक्ति नहीं है जो शून्य के बराबर होगी। और इस समस्या को हल करने के लिए विशेष रूप से JVM डेवलपर्स ने वैरिएबल Double.MIN_VALUE को पेश किया, जो वास्तव में, शून्य का निकटतम संभावित मान है। सबसे छोटा मान जिसे आप डबल में सहेज सकते हैं, वह है "-Double.MAX_VALUE"।
```
 System.out.println(0.0 > Double.MIN_VALUE); //  false
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
पिछले विषय को विकसित करते हुए, हम एक और दिलचस्प उदाहरण दे सकते हैं, जिससे हमें पता चलता है कि सब कुछ उतना स्पष्ट नहीं है जितना पहली नज़र में लग सकता है। Double.MAX_VALUE 1.7976931348623157E308 लौटाता है, लेकिन अगर हम एक स्ट्रिंग को फ्लोटिंग-पॉइंट नंबर से डबल में बदल दें तो क्या होगा?
```
 System.out.println(Double.parseDouble("1.7976931348623157E308")); // (...7E308) = 1.7976931348623157E308 max value System.out.println(Double.parseDouble("1.7976931348623158E308")); // (...8E308) = 1.7976931348623157E308 same??? System.out.println(Double.parseDouble("1.7976931348623159E308")); // (...9E308) = Infinity
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
यह पता चला है कि Double.MAX_VALUE और Double.POSITIVE_INFINITY के बीच कुछ और मान हैं, जिनकी गणना करते समय, एक तरफ या दूसरे पर गोल किया जाता है। यहां यह अधिक विस्तार से रहने के लायक है।

वास्तविक संख्याओं का एक सेट असीम रूप से घना है। निम्नलिखित वास्तविक संख्या जैसी कोई चीज नहीं है। किसी भी दो वास्तविक संख्याओं के लिए, उनके बीच के अंतराल में एक वास्तविक संख्या होती है। यह गुण फ्लोटिंग पॉइंट नंबरों के लिए सही नहीं है। प्रत्येक प्रकार की फ्लोट या डबल संख्या के लिए, निम्न संख्या मौजूद है। इसके अलावा, टाइप फ़्लोट या डबल की लगातार दो संख्याओं के बीच एक न्यूनतम परिमित दूरी होती है। Math.nextUp () विधि अगला फ़्लोटिंग-पॉइंट नंबर देता है जो निर्दिष्ट पैरामीटर से अधिक है। उदाहरण के लिए, यह कोड 1.0 और 2.0 के बीच सभी फ्लोट संख्या को सम्मिलित करता है।
```
 float x = 1.0F; int numFloats = 0; while (x <= 2.0) { numFloats++; System.out.println(x); x = Math.nextUp(x); } System.out.println(numFloats);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
यह पता चला है कि 1.0 से 2.0 की सीमा में समावेशी बिल्कुल 8,388,609 फ्लोट-प्रकार संख्याएं हैं। यह एक बहुत है, लेकिन एक ही रेंज में वास्तविक संख्याओं की एक अनंत संख्या से बहुत कम है। निरंतर फ्लोट संख्या की प्रत्येक जोड़ी लगभग 0.0000001 अलग है। इस दूरी को कम से कम परिशुद्धता (ULP) की इकाई कहा जाता है। दोहरे प्रकार के लिए, स्थिति पूरी तरह से समान है, इस तथ्य को छोड़कर कि दशमलव बिंदु के बाद संख्याओं की संख्या बहुत अधिक है।

शायद यही सब है। "थोड़ी गहरी खुदाई" करने के इच्छुक लोग निम्नलिखित कोड का उपयोग कर सकते हैं:

 //           IEEE 754 long lbits = Double.doubleToLongBits(-0.06); long lsign = lbits >>> 63; //  long lexp = (lbits >>> 52 & ((1 << 11) - 1)) - ((1 << 10) - 1); //  long lmantissa = lbits & ((1L << 52) - 1); //  System.out.println(lsign + " " + lexp + " " + lmantissa); System.out.println(Double.longBitsToDouble((lsign << 63) | (lexp + ((1 << 10) - 1)) << 52 | lmantissa));

सभी के लिए धन्यवाद जिन्होंने महारत हासिल की। मुझे रचनात्मक आलोचना और परिवर्धन की खुशी होगी।

संबंधित सामग्री:

नई जावा गणितीय विशेषताएं, भाग 2: फ्लोटिंग-पॉइंट नंबर

IEEE स्टैंडर्ड 754 फ्लोटिंग पॉइंट नंबर

जावा भाषा और आभासी मशीन विनिर्देश

वास्तविक संख्याओं का प्रतिनिधित्व

फ्लोटिंग पॉइंट अंकगणित के बारे में आपको क्या जानने की जरूरत है

फ्लोटिंग पॉइंट नंबरों पर अंकगणित संचालन

जावा में फ्लोटिंग पॉइंट नंबर के बारे में कुछ शब्द

More articles: