2010-01-28 12 views
8

documentation for java.lang.Double.NaN कहना है कि यहअन्य NaN मान क्या हैं?

प्रकार double की एक निरंतर एक नहीं एक नंबर (NaN) मूल्य पकड़े है। यह Double.longBitsToDouble(0x7ff8000000000000L) द्वारा लौटाए गए मान के बराबर है।

ऐसा लगता है कि अन्य हैं। यदि हां, तो मैं उन्हें कैसे पकड़ूं, और क्या यह पोर्टेबल किया जा सकता है?

स्पष्ट है कि, मैं खोजने के लिए double मूल्यों x ऐसी है कि

Double.doubleToRawLongBits(x) != Double.doubleToRawLongBits(Double.NaN) 

और

Double.isNaN(x) 

दोनों सही हैं चाहते हैं।

+0

तुम्हारा मतलब वहाँ अन्य 'java.lang हैं * NaN' करें।।? –

+0

@ डोमिनिक: नहीं - मैंने जो जोड़ा है वह मुझे प्रश्न के लिए एक स्पष्टीकरण मिला है। –

उत्तर

8

आपको doubleToLongBits के बजाय doubleToRawLongBits की आवश्यकता है।

doubleToRawLongBits वास्तविक बाइनरी प्रतिनिधित्व निष्कर्ष निकालता है। doubleToLongBits नहीं, यह सभी NaN एस को डिफ़ॉल्ट NaN पर परिवर्तित करता है।

double n = Double.longBitsToDouble(0x7ff8000000000000L); // default NaN 
double n2 = Double.longBitsToDouble(0x7ff8000000000100L); // also a NaN, but M != 0 

System.out.printf("%X\n", Double.doubleToLongBits(n)); 
System.out.printf("%X\n", Double.doubleToRawLongBits(n)); 
System.out.printf("%X\n", Double.doubleToLongBits(n2)); 
System.out.printf("%X\n", Double.doubleToRawLongBits(n2)); 

उत्पादन:

7FF8000000000000 
7FF8000000000000 
7FF8000000000000 
7FF8000000000100 
+0

'DoubleToRawLongBits' के बारे में टिप के लिए धन्यवाद! –

2

आईईईई 754 सभी एक्सपोनेंट बिट्स के साथ एक नाइन को परिभाषित करता है जो 1 और मंटिसा में एक गैर शून्य संख्या है। इसलिए इस तरह

S  E   M 
x 11111111 xxxxxx....xxx (with M != 0) 

जावा संभालती है:

तो एक एकल परिशुद्धता संख्या के लिए आप देख रहे हैं

Double n = Double.longBitsToDouble(0x7ff8000000000000L); // default NaN 
Double n2 = Double.longBitsToDouble(0x7ff8000000000100L); // also a NaN, but M != 0 

System.out.println(n.isNaN()); // true 
System.out.println(n2.isNaN()); // true 
System.out.println(n2 != Double.doubleToLongBits(Double.NaN)); // true 

संक्षेप में, आप किसी भी NaN आप चाहते हैं जो के अनुरूप उपयोग कर सकते हैं उपर्युक्त नियम (एक्सपोनेंट और मंटिसा में सभी बिट्स 1! = 0)।

+0

अंतिम बयान कोई समझ नहीं आता है। 'Double.doubleToLongBits (...) 'एक' लंबा 'है, जिसे स्पष्ट रूप से' डबल 'में परिवर्तित किया गया है, ऑटोबॉक्साइड और * संदर्भ * से' n2' की तुलना में। – finnw

+0

संभावित रूप से अंतिम पंक्ति में 'Double.doubleToLongBits (n2) होना चाहिए! = Double.doubleToLongBits (Double.NaN) '? –

+0

वह प्रिंट 'झूठा' है, क्योंकि 'डबल टोलोंग बिट्स' सभी 'NaN' को समान मान में परिवर्तित करता है। लेकिन यह सच है यदि आप 'DoubleToRawLongBits' का उपयोग करते हैं। – finnw

5

जावा अपने फ़्लोटिंग पॉइंट नंबरों के लिए IEEE 754 का उपयोग करता है और इसलिए उनके नियमों का पालन करता है।

Wikipedia page on NaN के अनुसार इसे इस तरह परिभाषित किया गया है:

एक आईईईई फ्लोटिंग प्वाइंट मानक एकल परिशुद्धता NaN के बारे में थोड़ी-वार उदाहरण: x111 1111 1axx xxxx xxxx xxxx xxxx xxxx जहां x मतलब है परवाह नहीं है।

तो वहां कुछ बिट-पैटर्न हैं जिनमें से सभी NaN मान हैं।

+0

धन्यवाद। क्या यह वीएम में पोर्टेबल होने की गारंटी है? –

+1

@ सिमोन: वह प्रश्न मुझे एक पल के लिए रुक जाएगा: आप वास्तव में उस तथ्य का उपयोग कैसे करना चाहते हैं? क्या आप 'डबल' के NaN मान के अंदर इन-बैंड जानकारी जमा करने का प्रयास करते हैं? –

+0

का क्रमबद्ध करें। मैं एक ऐसे सिस्टम के अर्थशास्त्र का अनुकरण करने की कोशिश कर रहा हूं जहां कई अलग-अलग मूल्य हैं जो सभी नाएन की तरह कार्य करते हैं, लेकिन वे अलग-अलग हैं। –

संबंधित मुद्दे