¿Por qué Double.NaN == Double.NaN devuelve falso?

Estaba estudiando preguntas de OCPJP y encontré este código extraño:

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

Cuando ejecuté el código, obtuve:

false
true

¿Cómo es la salida falsecuando estamos comparando dos cosas que se parecen entre sí? Que NaNsignifica

NaN significa "No es un número".

Java Language Specification (JLS) Third Edition dice :

Una operación que se desborda produce un infinito con signo, una operación que se desborda produce un valor desnormalizado o un cero con signo, y una operación que no tiene un resultado matemáticamente definido produce NaN. Todas las operaciones numéricas con NaN como operando producen NaN como resultado. Como ya se ha descrito, NaN no está ordenado, por lo que una operación de comparación numérica que involucra uno o dos retornos de NaN falsey cualquier !=comparación que involucre retornos de NaN true, incluso x!=xcuando xes NaN.

NaN no es, por definición, igual a ningún número, incluido NaN. Esto es parte del estándar IEEE 754 e implementado por la CPU / FPU. No es algo a lo que la JVM tenga que agregar ninguna lógica para soportar.

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

Una comparación con un NaN siempre devuelve un resultado desordenado, incluso cuando se compara con sí mismo. ... Los predicados de igualdad y desigualdad no son señalización, por lo que x = x devuelve falso se puede utilizar para probar si x es un NaN silencioso.

Java trata todo NaN como NaN silencioso.

¿Por qué esa lógica?

NaNsignifica Not a Number. ¿Qué no es un número? Cualquier cosa. Puede tener cualquier cosa en un lado y cualquier cosa en el otro lado, por lo que nada garantiza que ambos sean iguales. NaNse calcula con Double.longBitsToDouble(0x7ff8000000000000L)y como puede ver en la documentación de longBitsToDouble:

Si el argumento es cualquier valor en el rango 0x7ff0000000000001Lmedio 0x7fffffffffffffffLo en el rango 0xfff0000000000001Lmedio 0xffffffffffffffffL, el resultado es una NaN.

Además, NaNse trata lógicamente dentro de la API.

Documentación

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

Por cierto, NaN se prueba como muestra de código:

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

Solución

Lo que puedes hacer es usar compare/ compareTo:

Double.NaNEste método considera que es igual a sí mismo y mayor que todos los demás doublevalores (incluidos Double.POSITIVE_INFINITY).

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

O equals:

Si thisy argumentambos representan Double.NaN, entonces el equalsmétodo regresa true, aunque Double.NaN==Double.NaNtenga el valor false.

Double.NaN.equals(Double.NaN);

Puede que no sea una respuesta directa a la pregunta. Pero si desea verificar si algo es igual a esto Double.NaN, debe usar esto:

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

Esto volverá true

El javadoc para Double.NaN lo dice todo:

Una constante que contiene un valor de tipo Not-a-Number (NaN) double. Es equivalente al valor devuelto por Double.longBitsToDouble(0x7ff8000000000000L).

Curiosamente, la fuente de Doubledefine NaNasí:

public static final double NaN = 0.0d / 0.0;

El comportamiento especial que describe está conectado a la JVM.

según, el estándar IEEE para aritmética de coma flotante para números de doble precisión,

La representación estándar de coma flotante de precisión doble IEEE requiere una palabra de 64 bits, que puede representarse como numerada del 0 al 63, de izquierda a derecha

dónde,

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

Si E=2047(todos Eson 1) y Fno es cero, entonces V=NaN("No es un número")

Lo que significa,

Si todos los Ebits son 1, y si hay algún bit distinto de cero, Fentonces el número esNaN .

por lo tanto, entre otros, todos los siguientes números son NaN,

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

En particular, no puedes probar

if (x == Double.NaN) 

para verificar si un resultado particular es igual Double.NaN, porque todos los valores "no un número" se consideran distintos. Sin embargo, puede usar el Double.isNaNmétodo:

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

NaN es un valor especial que denota "no un número"; es el resultado de ciertas operaciones aritméticas no válidas, como sqrt(-1), y tiene la propiedad (a veces molesta) que NaN != NaN.

Ningún número representa el resultado de operaciones cuyo resultado no es representable con un número. La operación más famosa es 0/0, cuyo resultado no se conoce.

Por esta razón, NaN no es igual a nada (incluidos otros valores que no sean un número). Para obtener más información, solo consulte la página de Wikipedia: http://en.wikipedia.org/wiki/NaN

Según este enlace , tiene varias situaciones y es difícil de recordar. Así es como los recuerdo y los distingo. NaNsignifica "matemáticamente indefinido", por ejemplo: "el resultado de 0 dividido por 0 es indefinido" y porque es indefinido, entonces "la comparación relacionada con indefinido es, por supuesto, indefinida". Además, funciona más como premisas matemáticas. Por otro lado, tanto el infinito positivo como el negativo están predefinidos y son definitivos, por ejemplo, "infinito positivo o negativo grande está bien definido matemáticamente".