ஜாவாவில் NaN

ஜாவாவில், "NaN" என்பது "ஒரு எண் அல்ல". இது ஒரு வகை விதிவிலக்கு அல்ல, மாறாக ஆச்சரியப்படும் விதமாக, NaN இன் தரவு வகையும் ஒரு எண்ணாகும். ஆனால் பெரும்பாலும் புதிய புரோகிராமர்கள் தற்செயலாக அதைப் பெறும்போது, ​​​​அவர்கள் அதை தங்கள் கணக்கீடுகளில் பயன்படுத்துகிறார்கள். எனவே, ஜாவாவில் பொருந்தாத தரவு வகைகளை ஒன்றாகப் பயன்படுத்தும்போது எறியக்கூடிய பிழை ஏற்படலாம். java.lang.ArithmeticException: / by zeroNaN போலவே கருதப்படுவதும் பொதுவாகக் காணப்படுகிறது . இருப்பினும், ஜாவா இருவரையும் வித்தியாசமாக நடத்துகிறது. போதுமா குழப்பமா? உங்களின் விரிவான புரிதலுக்காக இவை எப்படி ஒன்றுக்கொன்று வேறுபடுகின்றன என்பதை நாங்கள் பிரிப்போம். இந்தக் கட்டுரையின் முடிவில், எண்ணை (நான்) உருவாக்காத சாத்தியமான செயல்பாடுகள் மற்றும் அதைக் கையாளும் சில எளிய வழிகளைப் பற்றி நீங்கள் அறிந்து கொள்வீர்கள்.

NaN என்றால் என்ன?

எனவே, 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

மேலே உள்ள துணுக்கில், 3 எளிய செயல்பாடுகளின் விளைவாக NaN உருவாக்கப்படுவதை நீங்கள் அவதானிக்கலாம்:

• float / doubleபூஜ்ஜியத்தை பூஜ்ஜியத்துடன் வகுத்தல் .
• எதிர்மறை எண்ணின் அடி மூலத்தை எடுத்துக்கொள்வது (Math.sqrt(-x)). கணிதத்தில், எதிர்மறை எண்ணின் வர்க்க மூலத்தை எடுத்துக்கொள்வது ஒரு கற்பனை எண்ணில் விளைகிறது . ஜாவாவில் NaN ஐ திருப்பி அனுப்புவதன் மூலம் இந்த வழக்கு தீர்க்கப்படுகிறது.
• பூஜ்ஜியத்துடன் ஒரு எண்ணின் மோட் எடுத்தால், ஒரு மதிப்பை பூஜ்ஜியத்தால் வகுத்த பிறகு மீதியை வழங்கும். எனவே, NaN திரும்பியது.

நேர்மறை மற்றும் எதிர்மறை முடிவிலியிலிருந்து NaN எவ்வாறு வேறுபடுகிறது?

IEEE 754 விவரக்குறிப்பின்படி, எல்லை நிகழ்வுகளைக் கையாள மூன்று சிறப்பு மிதக்கும் புள்ளி மற்றும் இரட்டை மதிப்புகள் உள்ளன:

• நேர்மறை முடிவிலி
• எதிர்மறை முடிவிலி
• NaN

நேர்மறை எண்ணை 0 ஆல் வகுத்தால் நேர்மறை முடிவிலி. இதேபோல், எதிர்மறை எண்ணை பூஜ்ஜியத்துடன் வகுப்பதன் விளைவாக எதிர்மறை முடிவிலி விளைகிறது. எல்லா மிதக்கும் புள்ளி மதிப்புகளும் டேட்டா டைப் டபுளுக்கும் பொருந்தும் என்பதை நினைவில் கொள்ளவும். மிதவைகளின் வரையறுக்கப்பட்ட துல்லியம் சில நேரங்களில் போதுமானதாக இருக்காது. இருப்பினும், ஃப்ளோட் மற்றும் டபுள் இரண்டிற்கும் NaN எவ்வாறு செயல்படுகிறது என்பதை அடுத்த பகுதியில் பார்ப்போம்.

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 இல்லையா என்பதைச் சரிபார்க்கும் ஒரு சிறிய பழக்கத்தை வளர்த்துக் கொள்வதன் மூலம், உங்களை நிறைய தொந்தரவுகளில் இருந்து காப்பாற்ற முடியும். இதை நீங்கள் முதலில் மறந்தாலும் பரவாயில்லை. சிறிய பிழைகாணலுக்கு நீங்கள் எப்போதும் இந்தக் கட்டுரையைப் பார்க்கலாம். ஒரே நேரத்தில் தொகுக்கக்கூடிய, பிழை இல்லாத குறியீட்டை உருவாக்குவது பல வருட அனுபவத்திற்குப் பிறகு வருகிறது. எனவே குறியீட்டில் நம் கைகளை அழுக்கு செய்து, சிறப்பான ஒன்றை உருவாக்குவோம்!