Pourquoi Double.NaN == Double.NaN renvoie false?

J'étudiais juste les questions OCPJP et j'ai trouvé ce code étrange:

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

Quand j'ai exécuté le code, j'ai obtenu:

false
true

Comment est le résultat falselorsque nous comparons deux choses qui se ressemblent? Que veut NaNdire?

NaN signifie "Pas un nombre".

La troisième édition de Java Language Specification (JLS) dit :

Une opération qui déborde produit un infini signé, une opération qui déborde produit une valeur dénormalisée ou un zéro signé, et une opération qui n'a pas de résultat mathématiquement défini produit NaN. Toutes les opérations numériques avec NaN comme opérande produisent NaN en conséquence. Comme cela a déjà été décrit, NaN n'est pas ordonné, donc une opération de comparaison numérique impliquant un ou deux retours NaN falseet toute !=comparaison impliquant des retours NaN true, y compris x!=xquand xest NaN.

NaN n'est par définition égal à aucun nombre, y compris NaN. Cela fait partie de la norme IEEE 754 et est implémenté par le CPU / FPU. Ce n'est pas quelque chose que la JVM doit ajouter de logique à prendre en charge.

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

Une comparaison avec un NaN renvoie toujours un résultat non ordonné même en comparant avec lui-même. ... Les prédicats d'égalité et d'inégalité sont non signalants, donc x = x retournant false peut être utilisé pour tester si x est un NaN silencieux.

Java traite tous les NaN comme des NaN silencieux.

Pourquoi cette logique

NaNsignifie Not a Number. Qu'est-ce qui n'est pas un nombre? N'importe quoi. Vous pouvez avoir n'importe quoi d'un côté et n'importe quoi de l'autre côté, donc rien ne garantit que les deux sont égaux. NaNest calculé avec Double.longBitsToDouble(0x7ff8000000000000L)et comme vous pouvez le voir dans la documentation de longBitsToDouble:

Si l'argument est une valeur dans la plage 0x7ff0000000000001Ljusqu'à 0x7fffffffffffffffLou dans la plage 0xfff0000000000001Ljusqu'à 0xffffffffffffffffL, le résultat est a NaN.

En outre, NaNest traité logiquement à l'intérieur de l'API.

Documentation

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

En passant, NaN est testé comme exemple de code:

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

Solution

Ce que vous pouvez faire, c'est utiliser compare/ compareTo:

Double.NaNest considérée par cette méthode comme égale à elle-même et supérieure à toutes les autres doublevaleurs (y compris Double.POSITIVE_INFINITY).

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

Ou, equals:

Si thiset les argumentdeux représentent Double.NaN, alors la equalsméthode retourne true, même si elle Double.NaN==Double.NaNa la valeur false.

Double.NaN.equals(Double.NaN);

Ce n'est peut-être pas une réponse directe à la question. Mais si vous voulez vérifier si quelque chose est égal à, Double.NaNvous devez utiliser ceci:

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

Cela reviendra true

Le javadoc pour Double.NaN dit tout:

Une constante contenant une valeur de type Not-a-Number (NaN) double. Il équivaut à la valeur renvoyée par Double.longBitsToDouble(0x7ff8000000000000L).

Fait intéressant, la source de Doubledéfinit NaNainsi:

public static final double NaN = 0.0d / 0.0;

Le comportement spécial que vous décrivez est câblé dans la JVM.

selon, La norme IEEE pour l'arithmétique à virgule flottante pour les nombres à double précision,

La représentation standard à virgule flottante double précision IEEE nécessite un mot de 64 bits, qui peut être représenté comme numéroté de 0 à 63, de gauche à droite

où,

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

Si E=2047(tous Esont 1) et Fest différent de zéro, alors V=NaN("Pas un nombre")

Ce qui signifie,

Si tous les Ebits sont 1 et s'il y a un bit différent de zéro, Fle nombre est NaN.

par conséquent, entre autres, tous les nombres suivants sont NaN,

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

En particulier, vous ne pouvez pas tester

if (x == Double.NaN) 

pour vérifier si un résultat particulier est égal Double.NaN, car toutes les valeurs «pas un nombre» sont considérées comme distinctes. Cependant, vous pouvez utiliser la Double.isNaNméthode:

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

NaN est une valeur spéciale qui indique "pas un nombre"; c'est le résultat de certaines opérations arithmétiques invalides, telles que sqrt(-1), et possède la propriété (parfois ennuyeuse) qui NaN != NaN.

Pas un nombre représente le résultat d'opérations dont le résultat n'est pas représentable par un nombre. L'opération la plus connue est 0/0, dont le résultat n'est pas connu.

Pour cette raison, NaN n'est égal à rien (y compris les autres valeurs not-a-number). Pour plus d'informations, il suffit de consulter la page wikipedia: http://en.wikipedia.org/wiki/NaN

Selon ce lien , il y a des situations diverses et difficiles à retenir. C'est ainsi que je me souviens et je les distingue. NaNsignifie "mathématiquement indéfini" par exemple: "le résultat de 0 divisé par 0 est indéfini" et parce qu'il n'est pas défini, donc "la comparaison liée à undefined est bien sûr indéfinie". En outre, cela fonctionne plus comme des prémisses mathématiques. D'autre part, l'infini positif et négatif est prédéfini et définitif, par exemple "l'infini grand positif ou négatif est bien défini mathématiquement".