NaN sa Java

Sa Java, ang "NaN" ay nangangahulugang "Not a Number". Ito ay hindi isang uri ng pagbubukod, sa halip nakakagulat, ang datatype ng NaN ay isang numero din. Ngunit madalas kapag hindi sinasadyang nakuha ng mga baguhang programmer, mas ginagamit nila ito sa kanilang mga kalkulasyon. Samakatuwid, ang mga hindi tugmang uri ng data sa Java kapag ginamit nang magkasama ay maaaring magdulot ng isang natapon na error. Karaniwan din itong nakikita na java.lang.ArithmeticException: / by zeroitinuturing na kapareho ng NaN. Gayunpaman, naiiba ang pagtrato sa kanila ng Java. Nakakapagtaka? Para sa iyong komprehensibong pag-unawa, hihiwalayin namin kung paano ito naiiba sa isa't isa. Sa pagtatapos ng artikulong ito matututunan mo ang tungkol sa mga posibleng pagpapatakbo na hindi gumagawa ng numero (nan), at ilang madaling paraan upang mahawakan ito.

Ano ang NaN?

Kaya, ano ang NaN? Ang "NaN" gaya ng nahulaan ng marami sa inyo, ay ginagamit upang kumatawan sa "Not a Number" sa Java. Ito ay isang espesyal na halaga ng floating point upang tukuyin ang mga overflow at error. Ito ay nabuo kapag ang isang floating point na numero ay hinati sa zero o kung ang square root ng isang negatibong numero ay nakalkula. Halimbawa, tingnan ang sumusunod na snippet.

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	
    }
}

Output

NaN                                                                                                                                           
NaN                                                                                                                                           
NaN

Sa snippet sa itaas, maaari mong obserbahan na ang NaN ay ginawa bilang resulta ng 3 simpleng operasyon:

• Paghahati ng float / doublezero na may zero.
• Pagkuha ng under-root ng isang negatibong numero (Math.sqrt(-x)). Sa matematika, ang pagkuha ng square root ng isang negatibong numero ay nagreresulta sa isang haka-haka na numero . Ang kasong ito ay hinarap sa pamamagitan ng pagbabalik ng NaN sa Java.
• Ang pagkuha ng mod ng isang numero na may zero, ay ibabalik ang natitira pagkatapos hatiin ang isang halaga sa zero. Samakatuwid, ibinalik ang NaN.

Paano Naiiba ang NaN sa Positive at Negative Infinity?

Ayon sa detalye ng IEEE 754, mayroong tatlong espesyal na floating-point at dobleng halaga upang pangasiwaan ang mga boundary case:

• Positibong infinity
• Negatibong infinity
• NaN

Ang resulta ng paghahati ng positibong numero sa 0 ay positibong infinity. Katulad nito, ang negatibong infinity ay nagbubunga bilang resulta ng paghahati ng negatibong numero sa zero. Pakitandaan na ang lahat ng value ng floating point ay naaangkop din sa double type ng data. Ang limitadong katumpakan ng mga float ay minsan ay hindi sapat. Gayunpaman, makikita natin kung paano gumagana ang NaN para sa parehong float at double sa susunod na seksyon.

Ano ang NaN() Method?

isNaN()ay isa sa mga pangunahing pamamaraan sa Java upang suriin kung ito ay isang halaga ng NaN o hindi. Tulad ng tinalakay namin ang tatlong kaso sa itaas, oras na upang subukan kung paano naiiba ang isNaN() method sa pagitan ng +infinity , -infinity at NaN values.

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());
  }
}

Output

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

Paano Ihambing ang mga Halaga ng NaN?

Ang bawat halaga ng NaN ay itinuturing na naiiba. Nangangahulugan ito, hindi isang solong NaN ang katumbas ng anumang iba pang NaN. Sa pamamagitan ng prinsipyong ito, Kung ihahambing mo ang isang halaga sa isa pa ang resulta ay palaging negatibo. Dahil, ang NaN ay hindi nakaayos, kaya ang isang numeric na paghahambing na kinasasangkutan ng kahit isang solong NaN ay nagbabalik ng false. Nagbibigay ang Java ng Float.NaN at Double.NaN para sa mga pare-parehong field sa parehong klase upang maisagawa ang mga paghahambing. Maaari nating pag-iba-ibahin ang mga ito sa dalawang magkahiwalay na senaryo:

• Tama: Sa kaso lang ng In-equality (!=)
• Mali: Para sa lahat ng operand ng paghahambing (==, <=, >=, <, >)

Narito ang isang gumaganang halimbawa para sa inyo:

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
  }
}

Paano Bumuo ng Mga Halaga ng NaN?

Bago magtapos, tingnan natin ang ilang karaniwang halimbawa ng pagkuha ng Not a Number (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));
  }
}

Output:

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

Konklusyon

Matapos tingnan ang maraming mga operasyon na gumagawa ng NaN, dapat ay pamilyar ka na dito ngayon. Maaaring palaisipan ka nito sa simula, ngunit walang kumplikadong pagharap dito. Sa pamamagitan ng pagbuo ng isang maliit na ugali ng pagsuri kung ang isang halaga ay hindi NaN sa double/floating point kalkulasyon ay maaaring magligtas sa iyo mula sa maraming abala. Kahit na nakalimutan mo ito sa simula, ito ay ganap na maayos. Maaari mong palaging kumonsulta sa artikulong ito para sa maliit na pag-troubleshoot. Ang paggawa ng compilable, walang error na code nang sabay-sabay ay darating pagkatapos ng mga taon ng karanasan. Kaya hayaang marumi ang ating mga kamay sa code, at bumuo ng isang mahusay na bagay!