जावा में नाएन

जावा में, "NaN" का अर्थ "नॉट ए नंबर" है। यह एक प्रकार का अपवाद नहीं है, बल्कि आश्चर्य की बात यह है कि NaN का डेटाटाइप भी एक संख्या है। लेकिन अक्सर जब नौसिखिया प्रोग्रामर इसे अनायास ही प्राप्त कर लेते हैं, तो वे इसे अपनी गणनाओं में आगे उपयोग करते हैं। इसलिए, जावा में असंगत डेटा प्रकार जब एक साथ उपयोग किए जाते हैं, तो फेंकने योग्य त्रुटि हो सकती है। आमतौर पर यह भी देखा जाता है कि java.lang.ArithmeticException: / by zeroइसे NaN के समान ही माना जाता है। हालाँकि, जावा उन दोनों को अलग तरह से मानता है। काफी पेचीदा? आपकी व्यापक समझ के लिए हम विश्लेषण करेंगे कि ये एक दूसरे से कैसे भिन्न हैं। इस लेख के अंत तक आप उन संभावित संक्रियाओं के बारे में जानेंगे जो एक संख्या (नैन) उत्पन्न नहीं करती हैं, और इसे संभालने के कुछ आसान तरीके।

एनएएन क्या है?

तो, नाएन क्या है? "NaN" जैसा कि आप में से कई ने अनुमान लगाया है, जावा में "नॉट ए नंबर" का प्रतिनिधित्व करने के लिए उपयोग किया जाता है। अतिप्रवाह और त्रुटियों को दर्शाने के लिए यह एक विशेष फ़्लोटिंग पॉइंट मान है। यह तब उत्पन्न होता है जब फ्लोटिंग पॉइंट संख्या को शून्य से विभाजित किया जाता है या यदि किसी ऋणात्मक संख्या के वर्गमूल की गणना की जाती है। उदाहरण के लिए, निम्न स्निपेट पर एक नज़र डालें।

public class NaN
{
    public static void main(String[]args)
    {
        System.out.println(0.0 / 0.0);	  //zero divided by zero
        System.out.println(Math.sqrt(-1)); //take sqrt of negative number
        System.out.println(10.0 % 0);      //taking mod by zero	
    }
}

उत्पादन

NaN                                                                                                                                           
NaN                                                                                                                                           
NaN

उपरोक्त स्निपेट में, आप देख सकते हैं कि NaN 3 सरल ऑपरेशनों के परिणामस्वरूप उत्पन्न होता है:

• float / doubleशून्य को शून्य से विभाजित करना ।
• ऋणात्मक संख्या (Math.sqrt(-x)) का मूल निकालना। गणित में, किसी ऋणात्मक संख्या का वर्गमूल निकालने पर एक काल्पनिक संख्या प्राप्त होती है । जावा में NaN को वापस करके इस मामले को निपटाया जाता है।
• शून्य के साथ एक संख्या का मॉड लेना, शेष को शून्य से विभाजित करने के बाद शेष वापस कर देगा। इसलिए, NaN लौटाया जाता है।

NaN धनात्मक और ऋणात्मक अनन्तता से किस प्रकार भिन्न है?

IEEE 754 विनिर्देशन के अनुसार, सीमा मामलों को संभालने के लिए तीन विशेष फ़्लोटिंग-पॉइंट और दोहरे मान हैं:

• सकारात्मक अनंत
• नकारात्मक अनंत
• नेन

किसी धनात्मक संख्या को 0 से भाग देने का परिणाम धनात्मक अनंत होता है। इसी प्रकार, ऋणात्मक संख्या को शून्य से विभाजित करने के परिणामस्वरूप ऋणात्मक अनंतता उत्पन्न होती है। कृपया ध्यान दें कि सभी फ़्लोटिंग पॉइंट मान डेटा प्रकार डबल पर भी लागू होते हैं। फ्लोट्स की सीमित सटीकता कभी-कभी पर्याप्त नहीं होती है। हालाँकि, हम बाद के अनुभाग में देखेंगे कि कैसे NaN फ्लोट और डबल दोनों के लिए काम करता है।

एनएएन () विधि क्या है?

isNaN()जावा में बुनियादी तरीकों में से एक है यह जांचने के लिए कि यह NaN मान है या नहीं। जैसा कि हमने ऊपर तीन मामलों पर चर्चा की है, यह परीक्षण करने का समय है कि कैसे NaN () विधि +infinity , -infinity और NaN मानों के बीच अंतर करती है।

public class isNaN
{ public static void main(String[]args)
  { 
    Double posInfinity = +2.0 / 0.0;
    Double negInfinity = -3.5 / 0.0;
    Double nanVal = 50 % 0.0;


    System.out.println ("+" + posInfinity + ".IsNaN() = " + posInfinity.isNaN());
    System.out.println ( negInfinity + ".IsNaN() = " + negInfinity.isNaN());
    System.out.println ( nanVal +  ".IsNaN() = " + nanVal.isNaN());
  }
}

उत्पादन

+Infinity.IsNaN() = false                                                                                                                       
-Infinity.IsNaN() = false                                                                                                                       
NaN.IsNaN() = true

NaN मानों की तुलना कैसे करें?

हर NaN मान को अलग माना जाता है। इसका अर्थ है कि एक भी NaN किसी भी अन्य NaN के बराबर नहीं है। इस सिद्धांत के अनुसार, यदि आप एक मूल्य की दूसरे से तुलना करते हैं तो परिणाम हमेशा नकारात्मक होता है। चूंकि, NaN अनियंत्रित है, इसलिए एक एकल NaN वाली संख्यात्मक तुलना झूठी होती है। Java तुलना करने के लिए दोनों वर्गों में निरंतर फ़ील्ड के लिए Float.NaN और Double.NaN प्रदान करता है। हम इन्हें दो अलग-अलग परिदृश्यों में अलग कर सकते हैं:

• सत्य: केवल असमानता (!=) के मामले में
• असत्य: सभी तुलना ऑपरेंड के लिए (==, <=,>=, <,>)

यहाँ आप लोगों के लिए एक कार्यशील उदाहरण है:

public class ComparingNaN
{ public static void main(String[] args)                                                                                                     
  {
    // Comparing NaN values for Float constants
    System.out.println (Float.NaN != Float.NaN); // true
    System.out.println (Float.NaN == Float.NaN); // false
    System.out.println (Float.NaN < Float.NaN);  // false
    System.out.println (Float.NaN > Float.NaN);  // false
    System.out.println (Float.NaN <= Float.NaN); // false
    System.out.println (Float.NaN >= Float.NaN); // false

    // Comparing NaN values for Float constants
    System.out.println (Double.NaN != Double.NaN); // true
    System.out.println (Double.NaN == Double.NaN); // false
    System.out.println (Double.NaN < Double.NaN);  // false
    System.out.println (Double.NaN > Double.NaN);  // false
    System.out.println (Double.NaN <= Double.NaN); // false
    System.out.println (Double.NaN >= Double.NaN); // false
  }
}

NaN मान कैसे उत्पन्न करें?

समाप्त करने से पहले, आइए एक संख्या नहीं (नान) प्राप्त करने के कुछ सामान्य उदाहरण देखें।

public class GenerateNaNValues {  
  static final float ZERO = 0;
  public static void main (String[]args)
  {
    System.out.println("ZERO / ZERO = " + (ZERO / ZERO));
    System.out.println("+INFINITY - INFINITY = " + 
    (Float.POSITIVE_INFINITY + Float.NEGATIVE_INFINITY));
    System.out.println("-INFINITY * ZERO = " + (Float.NEGATIVE_INFINITY * ZERO));
    System.out.println("+INFINITY * ZERO = " + (Float.POSITIVE_INFINITY * ZERO));
    System.out.println("log10(-10) = " +  Math.log(-10));
    System.out.println("√-10 = " + Math.sqrt(-10));
    System.out.println("NaN + 10 = " + (Float.NaN + 10));
    System.out.println("NaN - 10 = " + (Float.NaN - 10));
    System.out.println("NaN * 10 = " + (Float.NaN * 10));
    System.out.println("NaN / 10 = " + (Float.NaN / 10));
    System.out.println("NaN + NaN = " + (Float.NaN + Float.NaN));
    System.out.println("NaN - NaN = " + (Float.NaN - Float.NaN));
    System.out.println("NaN * NaN = " + (Float.NaN * Float.NaN));
    System.out.println("NaN / NaN = " + (Float.NaN / Float.NaN));
  }
}

आउटपुट:

ZERO / ZERO = NaN                                                                                                                               
+INFINITY - INFINITY = NaN                                                                                                                      
-INFINITY * ZERO = NaN                                                                                                                          
+INFINITY * ZERO = NaN                                                                                                                          
log10(-10) = NaN                                                                                                                                
√-10 = NaN                                                                                                                                      
NaN + 10 = NaN                                                                                                                                    
NaN - 10 = NaN                                                                                                                                  
NaN * 10 = NaN                                                                                                                                  
NaN / 10 = NaN                                                                                                                                  
NaN + NaN = NaN                                                                                                                                 
NaN - NaN = NaN                                                                                                                                 
NaN * NaN = NaN                                                                                                                                 
NaN / NaN = NaN

निष्कर्ष

NaN उत्पन्न करने वाले अनेक संक्रियाओं को देखने के बाद, अब आप इससे परिचित हो गए होंगे। यह आपको शुरू में पहेली कर सकता है, लेकिन इससे निपटने में कुछ भी जटिल नहीं है। डबल/फ़्लोटिंग पॉइंट गणनाओं में कोई मान NaN नहीं है या नहीं, इसकी जाँच करने की थोड़ी सी आदत विकसित करने से आप बहुत परेशानी से बच सकते हैं। यहां तक ​​कि अगर आप इसे शुरू में भूल जाते हैं, तो यह पूरी तरह से ठीक है। मामूली समस्या निवारण के लिए आप हमेशा इस लेख से परामर्श कर सकते हैं। वर्षों के अनुभव के बाद एक बार में संकलित करने योग्य, त्रुटि-मुक्त कोड बनाना आता है। तो चलिए कोड में अपने हाथ गंदे करते हैं, और कुछ बढ़िया बनाते हैं!