दिलचस्प पोस्ट
रूबी तरीके में विस्मयादिबोधक चिह्न क्यों उपयोग किए जाते हैं? Matplotlib xticks हिस्टोग्राम के साथ अस्तर नहीं है सी # में रीड-ओनली फाइलों के साथ मैं एक निर्देशिका कैसे हटाऊं? WWW सर्वर डेल्फी में इंटरनेट डायरेक्ट कॉन्ट्रैक्ट्स के द्वारा POST अनुरोध के बाद त्रुटि रिपोर्ट करता है कोण 2.1.0 मक्खी पर बच्चे के घटक बनाते हैं, गतिशील रूप से कुकी मूल्य पर आधारित htaccess रीडायरेक्ट कैसे करें ऑब्जेक्ट की प्रॉपर्टी नाम प्राप्त करना XCode में EXC_BAD_ACCESS को तोड़ दिया? कई Aptana परियोजनाओं के लिए एक Github भंडार कनेक्ट डिवाइस को एक्लिप्स से कैसे कनेक्ट करें? C में scanf () में "\ n" का उपयोग करना क्यों हस्ताक्षर किए गए विधानसभाओं लोड करने के लिए धीमा हैं? क्या मैं jQuery के साथ पृष्ठभूमि छवि (सीएसएस: पृष्ठभूमि-छवि) में फीका कर सकता हूं? अगर कोई फ़ंक्शन किसी वैध रिटर्न प्रकार के साथ कोई मान नहीं देता है, क्या कचरा को फेंकने के लिए क्या यह ठीक है? एक्शन बार बैक बटन काम नहीं कर रहा है

हम दो फ्लोट या दो नंबरों की तुलना करने के लिए '==' का उपयोग क्यों नहीं कर सकते

मैं यहोशू ब्लोच द्वारा प्रभावी जावा पढ़ रहा हूं और मद 8: जब ओवरराइडिंग बराबर होता है तो सामान्य अनुबंध का पालन करें , यह कथन लिखा है

नाव क्षेत्रों के लिए, Float.compare विधि का उपयोग करें; और डबल फ़ील्ड के लिए, Double.compare का उपयोग करें फ़्लोट। एनएएन, -0.0 एफ और समान डबल स्थिरांक के अस्तित्व के कारण फ्लोट और डबल फ़ील्ड के विशेष उपचार की आवश्यकता होती है;

क्या कोई मुझे उदाहरण के साथ बता सकता है कि हम फ्लोट या डबल तुलना के लिए == उपयोग क्यों नहीं कर सकते

Solutions Collecting From Web of "हम दो फ्लोट या दो नंबरों की तुलना करने के लिए '==' का उपयोग क्यों नहीं कर सकते"

एपीआईडोक से, Float.compare :

दो निर्दिष्ट फ्लोट मूल्यों की तुलना करता है पूर्णांक मान का चिह्न वापस पूर्णांक के समान होता है जिसे कॉल द्वारा वापस किया जाएगा:

नया फ्लोट (एफ 1)। कॉम्पेरेट करें (नया फ्लोट (एफ 2))

Float.compareTo :

संख्यात्मक रूप से दो फ्लोट वस्तुओं की तुलना करता है इस पद्धति द्वारा निष्पादित किए जाने वाले दो तरीके हैं जो जावा भाषा संख्यात्मक तुलना ऑपरेटर (<, <=, ==,> =>) द्वारा निष्पादित किए गए हैं, जब आदिम फ्लोट मानों पर लागू होते हैं:

  • फ्लोट। एनएएन को इस पद्धति द्वारा अपने समतुल्य और सभी अन्य फ्लोट मानों (फ्लोट सहित। POSITIVE_INFINITY) से अधिक माना जाता है।
  • 0.0f को इस पद्धति द्वारा -0.0f से बड़ा माना जाता है।

यह सुनिश्चित करता है कि इस पद्धति द्वारा लगाए गए फ़्लोट ऑब्जेक्ट्स की प्राकृतिक व्यवस्था बराबर के बराबर है।

निम्नलिखित कोड पर विचार करें:

  System.out.println(-0.0f == 0.0f); //true System.out.println(Float.compare(-0.0f, 0.0f) == 0 ? true : false); //false System.out.println(Float.NaN == Float.NaN);//false System.out.println(Float.compare(Float.NaN, Float.NaN) == 0 ? true : false); //true System.out.println(-0.0d == 0.0d); //true System.out.println(Double.compare(-0.0d, 0.0d) == 0 ? true : false);//false System.out.println(Double.NaN == Double.NaN);//false System.out.println(Double.compare(Double.NaN, Double.NaN) == 0 ? true : false);//true 

आउटपुट सही नहीं है, क्योंकि जो कुछ एक नंबर नहीं है, वह केवल एक संख्या नहीं है, और इसे संख्या तुलना बिंदु के बराबर माना जाना चाहिए। यह भी स्पष्ट है कि 0=-0

देखते हैं कि Float.compare क्या करता है:

 public static int compare(float f1, float f2) { if (f1 < f2) return -1; // Neither val is NaN, thisVal is smaller if (f1 > f2) return 1; // Neither val is NaN, thisVal is larger int thisBits = Float.floatToIntBits(f1); int anotherBits = Float.floatToIntBits(f2); return (thisBits == anotherBits ? 0 : // Values are equal (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN) 1)); // (0.0, -0.0) or (NaN, !NaN) } 

Float.floatToIntBits :

आईईईई 754 फ़्लोटिंग-पॉइंट "सिंगल फॉर्मेट" बिट लेआउट के अनुसार निर्दिष्ट फ्लोटिंग-प्वाइंट वेल्यू का प्रतिनिधित्व करता है बिट 31 (बिट जो 0x80000000 मुखौटा द्वारा चुना गया है) फ़्लोटिंग-बिंदु संख्या का संकेत दर्शाता है। बीट्स 30-23 (बिट्स जो 0x7f800000 मुखौटा द्वारा चुने गए हैं) प्रतिपादक का प्रतिनिधित्व करते हैं बिट्स 22-0 (बिट्स जिसे मुखौटा 0x007fffff द्वारा चुना गया है) फ़्लोटिंग-पॉइंट नंबर के महत्व और (कभी-कभी मंथिसा कहा जाता है) का प्रतिनिधित्व करते हैं

यदि तर्क सकारात्मक अनन्तता है, तो परिणाम 0x7f800000 है।

यदि तर्क ऋणात्मक अनंत है, तो परिणाम 0xff800000 है

यदि तर्क NaN है, तो परिणाम 0x7fc00000 है

सभी मामलों में, परिणाम एक पूर्णांक होता है, जब इंट बिट्सटॉफ्लॉट (इंट) पद्धति को दिया जाता है, तो फ्लोटिंग-प्वाइंट वैल्यू का उत्पादन होगा जो फ्लोटटॉइंटबिट के तर्क के समान होगा ( सिवाय सभी नाएनएन वैल्यू एक "कैनोनिकल" नाएन वैल )।

जेएलएस 15.20.1 से संख्यात्मक तुलना ऑपरेटर <, <=,>, और> =

आईपीईई 754 मानक के विनिर्देश द्वारा निर्धारित एक फ्लोटिंग-प्वाइंट तुलना का नतीजा यह है:

  • यदि या तो ऑपरेशन ना एनएएन है, तो परिणाम झूठा है।

  • नाएनओ के अलावा सभी मूल्यों का आदेश दिया जाता है, सभी अनंत मानों से भी कम नकारात्मक अन्तराल और सभी परिमित मूल्यों से सकारात्मक अंतर।

  • सकारात्मक शून्य और नकारात्मक शून्य बराबर माना जाता है। उदाहरण के लिए, -0.0 <0.0 गलत है, लेकिन -0.0 <= 0.0 सच है।

  • ध्यान दें, हालांकि, गणित और मैथ। मैक्स के तरीकों का नकारात्मक शून्य से व्यवहार सकारात्मक शून्य से कम से कम है।

कठोर तुलना के लिए जहां परिपथ सकारात्मक शून्य और नकारात्मक शून्य हैं, परिणाम गलत होगा।

जेएलएस 15.21.1 से संख्यात्मक समानता ऑपरेटर == और! = :

आईपीईई 754 मानक के विनिर्देश द्वारा निर्धारित एक फ्लोटिंग-प्वाइंट तुलना का नतीजा यह है:

फ़्लोटिंग-पॉइंट समता परीक्षण आईईईई 754 मानक के नियमों के अनुसार किया जाता है:

  • यदि या तो ऑपरेशन ना एनएएन है, तो == का नतीजा झूठा है, लेकिन इसका परिणाम है! = सच है। दरअसल, परीक्षण x! = X सच है अगर और केवल अगर एक्स का मान नाएन है तरीकों Float.isNaN और Double.isNaN का उपयोग भी परीक्षण के लिए किया जा सकता है कि क्या मान NaN है

  • सकारात्मक शून्य और नकारात्मक शून्य बराबर माना जाता है। उदाहरण के लिए, -0.0 == 0.0 सच है।

  • अन्यथा, दो अलग-अलग फ़्लोटिंग-पॉइंट वैल्यू समानता ऑपरेटरों द्वारा असमान मानी जाती है। विशेष रूप से, सकारात्मक अनन्तता का प्रतिनिधित्व करने वाला एक मान और नकारात्मक अनंत का प्रतिनिधित्व करने वाला एक मान है; प्रत्येक अपने समान के बराबर की तुलना करता है, और प्रत्येक अन्य सभी मूल्यों के लिए असमान तुलना करता है।

समानता की तुलना के लिए जहां दोनों प्रचालन नाओएन हैं, परिणाम गलत होगा।

चूंकि कुल ऑर्डरिंग ( = , < , > , <= , >= ) कई महत्वपूर्ण एल्गोरिदम द्वारा उपयोग की जाती है ( तुलनात्मक इंटरफ़ेस को कार्यान्वित करने वाले सभी वर्गों को देखें) यह विधि की तुलना करने के लिए बेहतर है क्योंकि यह अधिक सुसंगत व्यवहार उत्पन्न करेगा।

आईईईई -754 मानक के संदर्भ में कुल आदेश का परिणाम सकारात्मक और नकारात्मक शून्य के बीच का अंतर है।

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

यह संभवतः नाएनएन मूल्यों की राशि / दर के अनुपात में कार्यक्रम के व्यवहार में त्रुटि पैदा कर सकता है। और अगर आपके पास बहुत अधिक सकारात्मक और ऋणात्मक शून्य हैं, तो यह त्रुटि के साथ आपके तर्क को प्रभावित करने के लिए केवल एक जोड़ी है।

फ्लोट आईईईई -754 32 बिट प्रारूप का उपयोग करता है और डबल आईईईई -754 64 बिट प्रारूप का उपयोग करता है ।

float (और double ) के कुछ विशेष बिट अनुक्रम हैं जो विशेष अर्थों के लिए आरक्षित होते हैं जो "संख्या" नहीं हैं:

  • नकारात्मक अनन्तता, आंतरिक प्रतिनिधित्व 0xff800000
  • सकारात्मक अनन्तता, आंतरिक प्रतिनिधित्व 0x7f800000
  • एक संख्या नहीं, आंतरिक प्रतिनिधित्व 0x7fc00000

इनमें से प्रत्येक रिटर्न 0 (जिसका अर्थ है कि वे "समान" हैं) जब Float.compare() उपयोग करते हैं, परन्तु Float.compare() लिए निम्नलिखित तुलना == इस से भिन्न Float.NaN :

 Float.NEGATIVE_INFINITY == Float.NEGATIVE_INFINITY // true Float.POSITIVE_INFINITY == Float.POSITIVE_INFINITY // true Float.NaN == Float.NaN // false 

तो float वैल्यू की तुलना करते हुए, विशेष Float.NaN वैल्यू सहित सभी मूल्यों के अनुरूप हो, Float.compare() सबसे अच्छा विकल्प है

वही double पर लागू होता है

अस्थायी बिंदु वस्तुओं की तुलना करने के दो कारण हैं:

  • मैं गणित कर रहा हूं, इसलिए मैं अपने संख्यात्मक मूल्यों की तुलना करना चाहता हूं। संख्यात्मक रूप से, -0 बराबर +0, और एक एनएएन कुछ भी के बराबर नहीं है, यहां तक ​​कि खुद भी नहीं, क्योंकि "बराबर" एक संपत्ति है जो केवल संख्याएं हैं, और NaN संख्या नहीं है
  • मैं कंप्यूटर में वस्तुओं के साथ काम कर रहा हूं, इसलिए मुझे अलग-अलग ऑब्जेक्ट्स को अलग-अलग करने और उन्हें व्यवस्थित करने की आवश्यकता है। उदाहरण के लिए, किसी पेड़ या अन्य कंटेनर में वस्तुओं को क्रमबद्ध करने के लिए यह आवश्यक है।

== ऑपरेटर गणितीय तुलना प्रदान करता है यह NaN == NaN और -0.f == +0.f लिए सही के लिए गलत देता है

compare और compareTo दिनचर्या वस्तु तुलना प्रदान करते हैं। खुद को नाएन की तुलना करते हुए, वे संकेत देते हैं कि यह वही है (शून्य लौटने के द्वारा) जब -0.f से +0.f -0.f तुलना करते हैं, वे संकेत करते हैं कि वे अलग-अलग हैं (गैर शून्य लौटने के द्वारा)