జావాలో, “NaN” అంటే “సంఖ్య కాదు”. ఇది ఒక రకమైన మినహాయింపు కాదు, ఆశ్చర్యకరంగా, NaN యొక్క డేటాటైప్ కూడా ఒక సంఖ్య. కానీ తరచుగా అనుభవం లేని ప్రోగ్రామర్లు అనుకోకుండా దానిని పొందినప్పుడు, వారు దానిని వారి గణనలలో ఉపయోగించుకుంటారు. అందువల్ల, జావాలోని అననుకూల డేటా రకాలు కలిసి ఉపయోగించినప్పుడు విసిరివేయదగిన లోపానికి కారణం కావచ్చు. ఇది కూడా సాధారణంగా java.lang.ArithmeticException: / by zeroNaN వలె పరిగణించబడుతుంది. అయితే, జావా వారిద్దరినీ వేర్వేరుగా చూస్తుంది. తగినంత గందరగోళంగా ఉందా? మీ సమగ్ర అవగాహన కోసం ఇవి ఒకదానికొకటి ఎలా భిన్నంగా ఉన్నాయో మేము విడదీస్తాము. ఈ కథనం ముగిసే సమయానికి, మీరు సంఖ్య (నాన్)ని ఉత్పత్తి చేసే సాధ్యం కార్యకలాపాల గురించి మరియు దానిని నిర్వహించడానికి కొన్ని సులభమైన మార్గాల గురించి తెలుసుకుంటారు.

NaN అంటే ఏమిటి?

కాబట్టి, NaN అంటే ఏమిటి? మీలో చాలామంది ఊహించినట్లుగా "NaN" జావాలో "సంఖ్య కాదు"ని సూచించడానికి ఉపయోగించబడుతుంది. ఇది ఓవర్‌ఫ్లోలు మరియు ఎర్రర్‌లను సూచించడానికి ఒక ప్రత్యేక ఫ్లోటింగ్ పాయింట్ విలువ. ఫ్లోటింగ్ పాయింట్ సంఖ్యను సున్నాతో విభజించినప్పుడు లేదా ప్రతికూల సంఖ్య యొక్క వర్గమూలం గణించబడినప్పుడు ఇది ఉత్పత్తి అవుతుంది. జావాలో NaN - 1ఉదాహరణకు, కింది స్నిప్పెట్‌ను చూడండి. 

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)) యొక్క అండర్-రూట్ తీసుకోవడం. గణితంలో, ప్రతికూల సంఖ్య యొక్క వర్గమూలాన్ని తీసుకుంటే ఊహాత్మక సంఖ్య వస్తుంది . జావాలో NaNని తిరిగి ఇవ్వడం ద్వారా ఈ కేసు పరిష్కరించబడుతుంది.
  • సున్నాతో సంఖ్య యొక్క మోడ్‌ని తీసుకుంటే, విలువను సున్నాతో భాగించిన తర్వాత మిగిలిన మొత్తాన్ని తిరిగి అందిస్తుంది. అందువల్ల, NaN తిరిగి ఇవ్వబడుతుంది.

NaN సానుకూల మరియు ప్రతికూల అనంతం నుండి ఎలా భిన్నంగా ఉంటుంది?

IEEE 754 స్పెసిఫికేషన్ ప్రకారం, సరిహద్దు కేసులను నిర్వహించడానికి మూడు ప్రత్యేక ఫ్లోటింగ్ పాయింట్ & డబుల్ విలువలు ఉన్నాయి:
  • సానుకూల అనంతం
  • ప్రతికూల అనంతం
  • NaN
ధన సంఖ్యను 0తో భాగిస్తే వచ్చే ఫలితం ధనాత్మక అనంతం. అదేవిధంగా, ప్రతికూల సంఖ్యను సున్నాతో విభజించడం వల్ల ప్రతికూల అనంతం వస్తుంది. అన్ని ఫ్లోటింగ్ పాయింట్ విలువలు డేటా టైప్ డబుల్‌కి కూడా వర్తిస్తాయని దయచేసి గమనించండి. ఫ్లోట్‌ల పరిమిత ఖచ్చితత్వం కొన్నిసార్లు సరిపోదు. అయితే, ఫ్లోట్ మరియు డబుల్ రెండింటికీ NaN ఎలా పనిచేస్తుందో తర్వాత విభాగంలో చూద్దాం.

నాన్ () పద్ధతి అంటే ఏమిటి?

isNaN()ఇది NaN విలువ కాదా అని తనిఖీ చేయడానికి జావాలోని ప్రాథమిక పద్ధతుల్లో ఒకటి. మేము పైన మూడు కేసులను చర్చించినట్లుగా, isNaN() పద్ధతి +ఇన్ఫినిటీ , -ఇన్ఫినిటీ మరియు 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తో కూడిన సంఖ్యా పోలిక తప్పును అందిస్తుంది. జావా పోలికలను నిర్వహించడానికి రెండు తరగతులలో స్థిరమైన ఫీల్డ్‌ల కోసం 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 కాదా అని తనిఖీ చేసే చిన్న అలవాటును పెంపొందించడం ద్వారా మిమ్మల్ని చాలా అవాంతరాల నుండి రక్షించవచ్చు. మీరు దీన్ని మొదట్లో మరచిపోయినప్పటికీ, ఇది పూర్తిగా మంచిది. మైనర్ ట్రబుల్షూటింగ్ కోసం మీరు ఎల్లప్పుడూ ఈ కథనాన్ని సంప్రదించవచ్చు. సంకలనం చేయగల, ఎర్రర్-రహిత కోడ్‌ను ఒకేసారి సృష్టించడం సంవత్సరాల అనుభవం తర్వాత వస్తుంది. కాబట్టి కోడ్‌లో మన చేతులను డర్టీ చేసి, ఏదైనా గొప్పగా నిర్మించుకుందాం!