आप यह देखने के लिए परीक्षण कैसे करते हैं कि क्या एक डबल NaN के बराबर है?

Question

मेरे पास जावा में एक डबल है और मैं जांचना चाहता हूं कि क्या यह है NaN। इसे करने का बेहतरीन तरीका क्या है?

Answer 1

स्थिर का प्रयोग Double.isNaN(double)विधि, या अपने Doubleकी .isNaN()विधि।

// 1. static method
if (Double.isNaN(doubleValue)) {
    ...
}
// 2. object's method
if (doubleObject.isNaN()) {
    ...
}

बस कर:

if (var == Double.NaN) {
    ...
}

है पर्याप्त नहीं कैसे की वजह से NaN के लिए IEEE मानक और चल बिन्दु संख्या परिभाषित किया गया है।

Comments

ऐसा करने का दूसरा तरीका v! = V होगा। केवल NaN अपने आप से झूठ की तुलना करता है। हालांकि ऐसा मत करो, isNaN एक लाख गुना बेहतर है। :)

— जोरेन

@Joren, कभी नहीं से बेहतर है:'NNN 'वास्तव में v! = V से पठनीयता के लिए उपयोग करना बेहतर है। लेकिन isNaN मेथड का सोर्स कोड ठीक वैसा ही है! V =! V। सोर्स: स्टैटिक पब्लिक बुलियन isNaN (डबल v) {रिटर्न (v! = V); }

— रॉल्फ

Double.isNaN should be (true) अच्छा जवाब

— ओलिवर शॉ

@ जेनोरन एनएनएन बस चेक वी! = वी;), लेकिन यह बेहतर दिखता है

— श्री जेडी

जावा 5 का उपयोग करना: value == Double.NaNकाम नहीं करता है, लेकिन Double.isNaN(value)ठीक काम करता है।

— जीरो01लफा

Answer 2

कोशिश करें Double.isNaN():

सही है अगर यह दोहरा मान एक नॉट-ए-नंबर (NaN) है, तो गलत है।

ध्यान दें कि [ double.isNaN()] काम नहीं करेगा, क्योंकि अनबॉक्स्ड डबल्स में उनके साथ जुड़े तरीके नहीं होते हैं।

Comments

मैंने सोचा कि आप जावा में आदिम प्रकार के तरीकों को नहीं कह सकते। यह वास्तव में होना चाहिए Double.isNan()और नहीं double.IsNan(), है ना?

— जोरेन

जोरेन, वह ऑटोबॉक्सिंग पर भरोसा कर रहा है (कंपाइलर / रनटाइम द्वारा डबल में परिवर्तित किया जा रहा है); 1.5 के बाद से नई सुविधा। इस दिशा में जाने का थोड़ा जोखिम; डबल से डबल में जाने से NullPointerException का जोखिम पैदा होता है।

— M1EK

मैंने सोचा था कि ऑटोबॉक्सिंग ने केवल एक तर्क के रूप में डबल का उपयोग करने पर काम किया, इसे एक संग्रह में जोड़ा, और जैसे। डबल x घोषित करने की कोशिश करें और फिर x को isNaN () से पूछें - मुझे एक संकलक त्रुटि देता है।

— कार्ल

वास्तव में, मुझे संदेह है कि एंड्रयू ने पहली "डबल" टाइपिंग शिफ्ट कुंजी को याद किया।

— कार्ल

Answer 3

यदि कोई मान के माध्यम से परिमित है, तो आप जाँच करने पर भी विचार कर सकते हैं Double.isFinite(value)। Java 8 के बाद से Doubleक्लास में एक नया तरीका है जहाँ आप एक बार में चेक कर सकते हैं कि कहीं वैल्यू NaN और इनफिनिटी तो नहीं है।

/**
 * Returns {@code true} if the argument is a finite floating-point
 * value; returns {@code false} otherwise (for NaN and infinity
 * arguments).
 *
 * @param d the {@code double} value to be tested
 * @return {@code true} if the argument is a finite
 * floating-point value, {@code false} otherwise.
 * @since 1.8
 */
public static boolean isFinite(double d)

Answer 4

आप NaN का उपयोग करके देख सकते हैं var != var। NaNनहीं के बराबर है NaN।

EDIT : यह संभवतः अब तक की सबसे खराब विधि है। यह भ्रामक है, पठनीयता के लिए भयानक है, और समग्र रूप से बुरा व्यवहार है।

Comments

क्या कोई नीच को समझा सकता है? मुझे पता है, यह तरीका बहुत बुरा है, और isNanपठनीयता के लिए बेहतर है, लेकिन यह काम करता है, है ना? और यह isNanतरीका जांचने के लिए इसका उपयोग करता है NaN।

— हाइपरनेत्रिनो

मैं अनुमान लगा रहा हूं कि यह गिरावट बहुत खराब है, और पठनीयता के लिए isNaN बेहतर है।

— एडवर्ड फॉक

मैंने आपको कम नहीं किया, लेकिन मुझे लगता है कि अतिरिक्त टिप्पणी यहां उपयोगी होगी: यदि आप फ्लोट या डबल जैसे रैपर की तुलना करते हैं, तो आप इस तरह से संदर्भों की तुलना करते हैं, न कि उनके मूल्यों की, जो निश्चित रूप से वह नहीं है जो आप चाहते हैं।

— बैटल_सलग

@Battle_Slug टिप्पणी के लिए धन्यवाद। मुझे पता है कि यह एक बहुत बुरा विचार है, लेकिन मैंने इसे पूर्णता के लिए यहां रखा है।

— हाइपरन्यूट्रिनो

isNaNयह हुड के तहत करता है, लेकिन यह कैसे काम करता है? कैसे कुछ अपने आप नहीं के बराबर होता है ??

— विल्मॉल

Answer 5

शुरुआती को व्यावहारिक उदाहरणों की आवश्यकता है। इसलिए निम्न कोड का प्रयास करें।

public class Not_a_Number {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    String message = "0.0/0.0 is NaN.\nsimilarly Math.sqrt(-1) is NaN.";        
    String dottedLine = "------------------------------------------------";     

    Double numerator = -2.0;
    Double denominator = -2.0;      
    while (denominator <= 1) {
        Double x = numerator/denominator;           
        Double y = new Double (x);
        boolean z = y.isNaN();
        System.out.println("y =  " + y);
        System.out.println("z =  " + z);
        if (z == true){
            System.out.println(message);                
        }
        else {
            System.out.println("Hi, everyone"); 
        }
        numerator = numerator + 1;
        denominator = denominator +1;
        System.out.println(dottedLine);         
    } // end of while

} // end of main

} // end of class

Comments

यह उदाहरण बहुत अधिक है, और यह स्पष्ट नहीं है कि आप क्या दिखाना चाह रहे थे। यह खंडित कोड का सिर्फ एक गुच्छा है।

— जेरेड हूपर

ओपी के रूप में, जो एक शुरुआत था जब इस सवाल को '09 में वापस पूछा गया था, मैं आपको आश्वासन दे सकता हूं कि स्वीकृत जवाब इस "व्यावहारिक" उदाहरण से कहीं अधिक उपयोगी था।

— एरिक विल्सन

इस उदाहरण कोड को पोस्ट करने के लिए @pggajendra बाबू को धन्यवाद।

— दत्तांत

Answer 6

नीचे दिए गए कोड स्निपेट आदिम प्रकार पकड़े NaN का मूल्यांकन करने में मदद करेंगे।

double dbl = Double.NaN; Double.valueOf(dbl).isNaN() ? true : false;