Perché Double.NaN == Double.NaN restituisce false?

Stavo solo studiando le domande OCPJP e ho trovato questo strano codice:

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

Quando ho eseguito il codice, ho ottenuto:

false
true

Come è l'output falsequando stiamo confrontando due cose che sembrano uguali tra loro? Cosa NaNsignifica?

NaN significa "Not a Number".

La terza edizione di Java Language Specification (JLS) dice :

Un'operazione che trabocca produce un infinito con segno, un'operazione che trabocca produce un valore denormalizzato o uno zero con segno e un'operazione che non ha un risultato matematicamente definito produce NaN. Tutte le operazioni numeriche con NaN come operando producono di conseguenza NaN. Come è già stato descritto, NaN non è ordinata, quindi un'operazione di confronto numerico che coinvolge uno o due ritorni NaN falsee qualsiasi !=confronto che coinvolge ritorni NaN true, incluso x!=xquando xè NaN.

NaN non è per definizione uguale a nessun numero incluso NaN. Questo fa parte dello standard IEEE 754 e implementato dalla CPU / FPU. Non è qualcosa che la JVM debba aggiungere qualsiasi logica per supportare.

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

Un confronto con una NaN restituisce sempre un risultato non ordinato anche quando si confronta con se stesso. ... I predicati di uguaglianza e disuguaglianza non segnalano, quindi x = x return false può essere usato per verificare se x è un NaN silenzioso.

Java considera tutto NaN come NaN silenzioso.

Perché quella logica

NaNsignifica Not a Number. Cosa non è un numero? Nulla. Puoi avere qualsiasi cosa da una parte e qualsiasi cosa dall'altra parte, quindi nulla garantisce che entrambi siano uguali. NaNviene calcolato con Double.longBitsToDouble(0x7ff8000000000000L)e come puoi vedere nella documentazione di longBitsToDouble:

Se l'argomento è un valore nell'intervallo 0x7ff0000000000001Lattraverso 0x7fffffffffffffffLo nell'intervallo 0xfff0000000000001Lattraverso 0xffffffffffffffffL, il risultato è a NaN.

Inoltre, NaNviene logicamente trattato all'interno dell'API.

Documentazione

/** 
 * 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;

A proposito, NaN viene testato come esempio di codice:

/**
 * 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);
}

Soluzione

Quello che puoi fare è usare compare/ compareTo:

Double.NaNè considerato da questo metodo uguale a se stesso e maggiore di tutti gli altri doublevalori (incluso Double.POSITIVE_INFINITY).

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

Oppure equals:

Se thised argumententrambi rappresentano Double.NaN, quindi il equalsmetodo ritorna true, anche se Double.NaN==Double.NaNha il valore false.

Double.NaN.equals(Double.NaN);

Potrebbe non essere una risposta diretta alla domanda. Ma se vuoi verificare se qualcosa è uguale a Double.NaNte dovresti usare questo:

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

Questo tornerà true

Il javadoc per Double.NaN dice tutto:

Una costante che contiene un valore Not-a-Number (NaN) di tipo double. È equivalente al valore restituito da Double.longBitsToDouble(0x7ff8000000000000L).

È interessante notare che la fonte per Doubledefinisce NaNcosì:

public static final double NaN = 0.0d / 0.0;

Il comportamento speciale che descrivi è cablato nella JVM.

secondo, lo standard IEEE per l'aritmetica in virgola mobile per i numeri a doppia precisione,

La rappresentazione standard in virgola mobile a precisione doppia IEEE richiede una parola a 64 bit, che può essere rappresentata come numerata da 0 a 63, da sinistra a destra

dove,

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

Se E=2047(tutti Esono 1) ed Fè diverso da zero, allora V=NaN("Non un numero")

Che significa,

Se tutti i Ebit sono 1 e se è presente un bit diverso da zero, Fil numero è NaN.

pertanto, tra gli altri, tutti i seguenti numeri sono NaN,

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

In particolare, non è possibile eseguire il test

if (x == Double.NaN) 

per verificare se un determinato risultato è uguale Double.NaN, perché tutti i valori "non un numero" sono considerati distinti. Tuttavia, è possibile utilizzare il Double.isNaNmetodo:

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

NaN è un valore speciale che indica "non un numero"; è il risultato di alcune operazioni aritmetiche non valide, come ad esempio sqrt(-1), e ha la proprietà (a volte fastidiosa) che NaN != NaN.

Non un numero rappresenta il risultato di operazioni il cui risultato non è rappresentabile con un numero. L'operazione più famosa è 0/0, il cui risultato non è noto.

Per questo motivo, NaN non è uguale a nulla (compresi altri valori non numerici). Per maggiori informazioni, basta consultare la pagina di Wikipedia: http://it.wikipedia.org/wiki/NaN

Secondo questo link , ha varie situazioni e difficili da ricordare. È così che li ricordo e li distinguo. NaNsignifica "matematicamente indefinito", ad esempio: "il risultato di 0 diviso per 0 non è definito" e poiché non è definito, quindi "il confronto correlato a indefinito è ovviamente indefinito". Inoltre, funziona più come premesse matematiche. D'altra parte, sia l'infinito positivo che quello negativo sono predefiniti e definitivi, ad esempio "l'infinito positivo o negativo è ben definito matematicamente".