Pourquoi Double.NaN==Double.NaN renvoie-t-il faux ?

Question

J'étais en train d'étudier 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 la sortie false quand on compare deux choses qui se ressemblent ? Que fait NaN C'est-à-dire ?

Answer 1

NaN signifie "Not a Number" (pas un nombre).

Spécification du langage Java (JLS) Troisième édition dit :

Une opération qui déborde produit un infini signé, une opération qui ne déborde pas 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 comme résultat. 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 NaN renvoie false et tout != comparaison impliquant des retours NaN true dont x!=x quand x est NaN.

Answer 2

Par définition, NaN n'est égal à aucun nombre, y compris NaN. Cela fait partie de la norme IEEE 754 et est mis en œuvre par le CPU/FPU. La JVM n'a pas à ajouter de logique pour le supporter.

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

Une comparaison avec un NaN renvoie toujours un résultat non ordonné, même lorsqu'elle est comparée avec elle-même. ... Les prédicats d'égalité et d'inégalité ne signalent rien, de sorte que x = x retournant false peut être utilisé pour tester si x est un NaN silencieux.

Java traite tous les NaN comme des NaN silencieux.

Answer 3

Pourquoi cette logique

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

Si l'argument est une valeur quelconque dans la plage 0x7ff0000000000001L par le biais de 0x7fffffffffffffffL ou dans l'intervalle 0xfff0000000000001L par le biais de 0xffffffffffffffffL le résultat est un NaN .

Aussi, NaN est traitée logiquement dans 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;

Au fait, NaN est testé comme votre échantillon 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.NaN est considéré par cette méthode comme étant égal à lui-même et supérieur à tous les autres double (y compris Double.POSITIVE_INFINITY ).

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

Ou, equals :

Si this et argument les deux représentent Double.NaN alors le site equals La méthode retourne true même si Double.NaN==Double.NaN a la valeur false .

Double.NaN.equals(Double.NaN);

Answer 4

Le site javadoc pour Double.NaN dit tout :

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

Il est intéressant de noter que la source de Double définit NaN ainsi :

public static final double NaN = 0.0d / 0.0;

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

Answer 5

NaN est une valeur spéciale qui signifie "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 gênante) suivante NaN != NaN .