NaN di Jawa

Di Jawa, "NaN" adalah singkatan dari "Bukan Angka". Ini bukan pengecualian, agak mengejutkan, tipe data NaN juga berupa angka. Namun seringkali ketika pemrogram pemula mendapatkannya secara tidak sengaja, mereka selanjutnya menggunakannya dalam perhitungan mereka. Oleh karena itu, tipe data yang tidak kompatibel di Java saat digunakan bersama dapat menyebabkan error yang dapat dibuang. Juga sering terlihat java.lang.ArithmeticException: / by zerodianggap sama dengan NaN. Namun, Java memperlakukan keduanya secara berbeda. Cukup membingungkan? Untuk pemahaman komprehensif Anda, kami akan membedah bagaimana ini berbeda satu sama lain. Pada akhir artikel ini Anda akan belajar tentang kemungkinan operasi yang menghasilkan bukan angka (nan), dan beberapa cara mudah untuk menanganinya.

Apa itu NaN?

Jadi, apa itu NaN? "NaN" seperti yang sudah Anda duga, digunakan untuk mewakili "Bukan Angka" di Jawa. Ini adalah nilai floating point khusus untuk menunjukkan luapan dan kesalahan. Itu dihasilkan ketika angka floating point dibagi dengan nol atau jika akar kuadrat dari angka negatif dihitung. Sebagai contoh, lihat cuplikan berikut.

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

Keluaran

NaN                                                                                                                                           
NaN                                                                                                                                           
NaN

Dalam cuplikan di atas, Anda dapat mengamati bahwa NaN dihasilkan sebagai hasil dari 3 operasi sederhana:

• Membagi float / doublenol dengan nol.
• Mengambil akar dari bilangan negatif (Math.sqrt(-x)). Dalam matematika, mengambil akar kuadrat dari bilangan negatif menghasilkan bilangan imajiner . Kasus ini ditangani dengan mengembalikan NaN di Jawa.
• Mengambil mod dari angka dengan nol, akan mengembalikan sisanya setelah membagi nilai dengan nol. Oleh karena itu, NaN dikembalikan.

Bagaimana NaN Berbeda dari Infinity Positif dan Negatif?

Menurut spesifikasi IEEE 754, ada tiga nilai floating-point & double khusus untuk menangani kasus batas:

• Tak terhingga positif
• Tak terhingga negatif
• NaN

Hasil pembagian bilangan positif dengan 0 adalah bilangan positif tak terhingga. Demikian pula, infinity negatif menghasilkan hasil membagi angka negatif dengan nol. Harap perhatikan bahwa semua nilai floating point juga berlaku untuk tipe data double. Ketepatan pelampung yang terbatas terkadang tidak cukup. Namun, kita akan melihat bagaimana NaN bekerja untuk float dan double di bagian selanjutnya.

Apa itu Metode NaN()?

isNaN()adalah salah satu metode dasar di Java untuk memeriksa apakah itu nilai NaN atau tidak. Seperti yang kita bahas tiga kasus di atas, saatnya untuk menguji bagaimana metode isNaN() membedakan antara nilai +infinity , -infinity dan 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());
  }
}

Keluaran

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

Bagaimana Membandingkan Nilai NaN?

Setiap nilai NaN dianggap berbeda. Artinya, tidak ada satu NaN yang sama dengan NaN lainnya. Dengan prinsip ini, Jika Anda membandingkan satu nilai dengan nilai lainnya, hasilnya selalu negatif. Karena, NaN tidak terurut, jadi perbandingan numerik yang melibatkan bahkan satu NaN menghasilkan false. Java menyediakan Float.NaN dan Double.NaN untuk bidang konstanta di kedua kelas untuk melakukan perbandingan. Kami dapat membedakan ini dalam dua skenario terpisah:

• Benar: Hanya untuk In-equality (!=)
• Salah: Untuk semua operan perbandingan (==, <=, >=, <, >)

Berikut adalah contoh kerja untuk kalian:

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

Bagaimana Cara Menghasilkan Nilai NaN?

Sebelum mengakhiri, mari kita lihat beberapa contoh umum mendapatkan 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));
  }
}

Keluaran:

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

Kesimpulan

Setelah melihat banyak operasi yang menghasilkan NaN, Anda pasti sudah familiar dengannya sekarang. Ini mungkin membingungkan Anda pada awalnya, tetapi tidak ada yang rumit untuk menangani hal ini. Dengan mengembangkan sedikit kebiasaan untuk memeriksa apakah suatu nilai bukan NaN dalam perhitungan double/floating point dapat menyelamatkan Anda dari banyak kerumitan. Bahkan jika Anda melupakan ini pada awalnya, tidak apa-apa. Anda selalu dapat membaca artikel ini untuk pemecahan masalah kecil. Membuat kode yang dapat dikompilasi dan bebas kesalahan sekaligus datang setelah pengalaman bertahun-tahun. Jadi mari kita kotori kode kita, dan bangun sesuatu yang hebat!