Mengapa Double.NaN == Double.NaN menghasilkan false?

Saya baru saja mempelajari pertanyaan OCPJP dan saya menemukan kode aneh ini:

public static void main(String a[]) {
    System.out.println(Double.NaN==Double.NaN);
    System.out.println(Double.NaN!=Double.NaN);
}

Ketika saya menjalankan kode, saya mendapat:

false
true

Bagaimana hasilnya falseketika kita membandingkan dua hal yang terlihat sama satu sama lain? Apa NaNartinya

NaN berarti "Bukan Angka".

Spesifikasi Bahasa Jawa (JLS) Edisi Ketiga mengatakan :

Operasi yang meluap menghasilkan infinity yang ditandatangani, operasi yang melimpah menghasilkan nilai yang dinormalisasi atau nol yang ditandatangani, dan operasi yang tidak memiliki hasil pasti secara matematis menghasilkan NaN. Semua operasi numerik dengan NaN sebagai operan menghasilkan NaN sebagai hasilnya. Seperti yang telah dijelaskan, NaN tidak berurutan, sehingga operasi perbandingan numerik yang melibatkan satu atau dua pengembalian NaN falsedan !=perbandingan apa pun yang melibatkan pengembalian NaN true, termasuk x!=xkapan xNaN.

NaN secara definisi tidak sama dengan angka apa pun termasuk NaN. Ini adalah bagian dari standar IEEE 754 dan diimplementasikan oleh CPU / FPU. Ini bukan sesuatu yang JVM harus tambahkan logika untuk mendukung.

http://en.wikipedia.org/wiki/NaN

Perbandingan dengan NaN selalu mengembalikan hasil yang tidak terurut bahkan ketika membandingkan dengan itu sendiri. ... Predikat persamaan dan ketidaksetaraan adalah non-pensinyalan sehingga x = x return false dapat digunakan untuk menguji apakah x adalah NaN yang sunyi.

Java memperlakukan semua NaN sebagai NaN yang senyap.

Kenapa logika itu

NaNberarti Not a Number. Apa yang bukan angka? Apa pun. Anda dapat memiliki apa pun di satu sisi dan apa pun di sisi lain, jadi tidak ada yang menjamin keduanya sama. NaNdihitung dengan Double.longBitsToDouble(0x7ff8000000000000L)dan seperti yang Anda lihat dalam dokumentasi longBitsToDouble:

Jika argumennya adalah nilai apa pun dalam rentang 0x7ff0000000000001Lmelalui 0x7fffffffffffffffLatau dalam rentang 0xfff0000000000001Lmelalui 0xffffffffffffffffL, hasilnya adalah a NaN.

Juga, NaNdiperlakukan secara logis di dalam API.

Dokumentasi

/** 
 * A constant holding a Not-a-Number (NaN) value of type
 * {@code double}. It is equivalent to the value returned by
 * {@code Double.longBitsToDouble(0x7ff8000000000000L)}.
 */
public static final double NaN = 0.0d / 0.0;

By the way, NaN yang diuji sebagai sampel kode Anda:

/**
 * Returns {@code true} if the specified number is a
 * Not-a-Number (NaN) value, {@code false} otherwise.
 *
 * @param   v   the value to be tested.
 * @return  {@code true} if the value of the argument is NaN;
 *          {@code false} otherwise.
 */
static public boolean isNaN(double v) {
    return (v != v);
}

Larutan

Yang bisa Anda lakukan adalah menggunakan compare/ compareTo:

Double.NaNdianggap oleh metode ini sama dengan dirinya sendiri dan lebih besar dari semua doublenilai lainnya (termasuk Double.POSITIVE_INFINITY).

Double.compare(Double.NaN, Double.NaN);
Double.NaN.compareTo(Double.NaN);

Atau, equals:

Jika thisdan argumentkeduanya mewakili Double.NaN, maka equalsmetode kembali true, meskipun Double.NaN==Double.NaNmemiliki nilai false.

Double.NaN.equals(Double.NaN);

Itu mungkin bukan jawaban langsung untuk pertanyaan itu. Tetapi jika Anda ingin memeriksa apakah ada sesuatu yang sama dengan Double.NaNAnda, Anda harus menggunakan ini:

double d = Double.NaN
Double.isNaN(d);

Ini akan kembali true

The javadoc untuk Double.NaN mengatakan itu semua:

Konstanta yang memegang nilai Not-a-Number (NaN) tipe double. Ini setara dengan nilai yang dikembalikan oleh Double.longBitsToDouble(0x7ff8000000000000L).

Menariknya, sumber untuk Doublemendefinisikan sebagai NaNberikut:

public static final double NaN = 0.0d / 0.0;

Perilaku khusus yang Anda gambarkan adalah terprogram ke dalam JVM.

sesuai, Standar IEEE untuk aritmatika titik apung untuk angka Presisi Ganda,

Representasi standar floating point presisi ganda IEEE membutuhkan 64 bit kata, yang dapat direpresentasikan sebagai nomor dari 0 hingga 63, dari kiri ke kanan

dimana,

S: Sign – 1 bit
E: Exponent – 11 bits
F: Fraction – 52 bits 

Jika E=2047 (semua Eadalah 1) dan Fadalah nol, maka V=NaN( "Bukan angka")

Yang berarti,

Jika semua Ebit adalah 1, dan jika ada bit yang bukan nol Fmaka angkanyaNaN .

oleh karena itu, antara lain, semua nomor berikut adalah NaN ,

0 11111111 0000000000000000010000000000000000000000000000000000 = NaN
1 11111111 0000010000000000010001000000000000001000000000000000 = NaN
1 11111111 0000010000011000010001000000000000001000000000000000 = NaN

Secara khusus, Anda tidak dapat menguji

if (x == Double.NaN) 

untuk memeriksa apakah hasil tertentu sama dengan Double.NaN, karena semua nilai "bukan angka" dianggap berbeda. Namun, Anda dapat menggunakan Double.isNaNmetode ini:

if (Double.isNaN(x)) // check whether x is "not a number"

NaN adalah nilai khusus yang menunjukkan "bukan angka"; itu adalah hasil dari operasi aritmatika tertentu yang tidak valid, seperti sqrt(-1), dan memiliki (kadang-kadang mengganggu) properti itu NaN != NaN.

Bukan angka yang mewakili hasil operasi yang hasilnya tidak dapat diwakili dengan angka. Operasi paling terkenal adalah 0/0, yang hasilnya tidak diketahui.

Untuk alasan ini, NaN tidak sama dengan apa pun (termasuk nilai bukan angka lainnya). Untuk info lebih lanjut, cukup periksa halaman wikipedia: http://en.wikipedia.org/wiki/NaN

Menurut tautan ini , ia memiliki berbagai situasi dan sulit diingat. Beginilah cara saya mengingat dan membedakan mereka. NaNberarti "secara matematis tidak terdefinisi" misalnya: "hasil 0 dibagi dengan 0 adalah tidak terdefinisi" dan karena itu tidak terdefinisi, jadi "perbandingan yang terkait dengan undefined tentu saja tidak terdefinisi". Selain itu, ini berfungsi lebih seperti premis matematika. Di sisi lain, baik tak terbatas positif dan negatif sudah ditentukan sebelumnya dan pasti, misalnya "positif atau negatif besar tak terbatas didefinisikan dengan baik secara matematis".