Java मध्ये NaN

Java मध्ये, “NaN” म्हणजे “Not a Number”. हा अपवादाचा प्रकार नाही, उलट आश्चर्याची गोष्ट म्हणजे, NaN चा डेटाटाइप देखील एक संख्या आहे. पण अनेकदा जेव्हा नवशिक्या प्रोग्रामरना ते अजाणतेपणी मिळते तेव्हा ते त्यांच्या गणनेत त्याचा वापर करतात. म्हणून, Java मधील विसंगत डेटा प्रकार एकत्र वापरल्यास थ्रो करण्यायोग्य त्रुटी होऊ शकते. हे देखील सामान्यतः पाहिले जाते जे java.lang.ArithmeticException: / by zeroNaN सारखेच मानले जाते. तथापि, जावा दोघांनाही वेगळ्या पद्धतीने वागवतो. पुरेशी गोंधळात टाकणारे? तुमच्या सर्वसमावेशक आकलनासाठी आम्ही हे एकमेकांपासून कसे वेगळे आहेत ते शोधू. या लेखाच्या शेवटी तुम्ही संख्या (नॅन) न बनवणार्‍या संभाव्य ऑपरेशन्स आणि ते हाताळण्याचे काही सोपे मार्ग जाणून घ्याल.

NaN म्हणजे काय?

तर, NaN म्हणजे काय? तुमच्यापैकी अनेकांनी अंदाज लावलेला “NaN”, Java मध्ये “Not a Number” चे प्रतिनिधित्व करण्यासाठी वापरला जातो. ओव्हरफ्लो आणि त्रुटी दर्शविण्यासाठी हे एक विशेष फ्लोटिंग पॉइंट मूल्य आहे. फ्लोटिंग पॉइंट नंबरला शून्याने भागल्यावर किंवा ऋण संख्येचे वर्गमूळ मोजले गेल्यास ते व्युत्पन्न होते. उदाहरणार्थ, खालील स्निपेट पहा.

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

वरील स्निपेटमध्ये, तुम्ही हे पाहू शकता की 3 सोप्या ऑपरेशन्सच्या परिणामी NaN तयार होते:

• float / doubleशून्याला शून्याने विभाजित करणे .
• ऋण संख्या (Math.sqrt(-x)) च्या मुळाखाली घेणे. गणितात, ऋण संख्येचे वर्गमूळ घेतल्यास काल्पनिक संख्या मिळते . हे प्रकरण Java मध्ये NaN परत करून हाताळले जाते.
• शून्य असलेल्या संख्येचा मोड घेतल्यास, मूल्याला शून्याने विभाजित केल्यानंतर उर्वरित परत मिळेल. म्हणून, NaN परत केला जातो.

NaN हे सकारात्मक आणि नकारात्मक अनंतापेक्षा वेगळे कसे आहे?

IEEE 754 तपशीलानुसार, सीमा प्रकरणे हाताळण्यासाठी तीन विशेष फ्लोटिंग पॉइंट आणि दुहेरी मूल्ये आहेत:

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

सकारात्मक संख्येला 0 ने भाग घेतल्याचा परिणाम म्हणजे धन अनंत. त्याचप्रमाणे, ऋण संख्याला शून्याने विभाजित केल्याने ऋण अनंत उत्पन्न होते. कृपया लक्षात घ्या की सर्व फ्लोटिंग पॉइंट मूल्ये डेटा प्रकार दुहेरीवर देखील लागू आहेत. फ्लोट्सची मर्यादित अचूकता कधीकधी पुरेशी नसते. तथापि, आम्ही नंतरच्या विभागात फ्लोट आणि दुहेरीसाठी NaN कसे कार्य करते ते पाहू.

NaN() पद्धत काय आहे?

isNaN()हे NaN मूल्य आहे की नाही हे तपासण्यासाठी Java मधील मूलभूत पद्धतींपैकी एक आहे. आम्ही वरील तीन प्रकरणांवर चर्चा केल्याप्रमाणे, isNaN() पद्धत +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 नाही का हे तपासण्याची थोडीशी सवय लावून घेतल्यास तुम्हाला बर्‍याच त्रासांपासून वाचवता येईल. जरी आपण सुरुवातीला हे विसरलात तरीही ते पूर्णपणे ठीक आहे. किरकोळ समस्यानिवारणासाठी तुम्ही नेहमी या लेखाचा सल्ला घेऊ शकता. संकलित करण्यायोग्य, त्रुटी-मुक्त कोड एकाच वेळी तयार करणे अनेक वर्षांच्या अनुभवानंतर येते. चला तर मग कोडमध्ये हात घाण करूया आणि काहीतरी छान तयार करूया!