Pourquoi ne Double.NaN==Double.NaN return false?

Je viens de l'étude de OCPJP questions et j'ai trouvé cet étrange code:

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

Quand j'ai couru le code, je l'ai eu:

false
true

Comment est la sortie false lorsque nous comparons deux choses qui se ressemblent les uns que les autres? Ce n' NaN veux dire?

  • C'est vraiment bizarre. Parce Que Double.NaN est statique final, la comparaison avec == doit retourner true. +1 pour la question.
  • La même chose est vraie en python: In [1]: NaN==NaN Out[1]: False
  • La même chose est vraie dans toutes les langues de suivre correctement la norme IEEE 754.
  • L'Intuition: "Bonjour" n'est pas un nombre, vrai (boolean) n'est pas un nombre. NaN != NaN, pour la même raison "Bonjour" != vrai
  • Mais quand je fais Double.comparer(Double.NaN, Double.NaN), je suis 0 en sortie je.e les deux sont égaux
  • La comparaison avec Double.NaN==Double.NaN convient en effet de retourner vrai si Double.NaN étaient de type java.lang.Double. Cependant, son type est la primitive double, et l'opérateur règles de double appliquer (ce qui demande cette inégalité pour assurer la conformité avec la norme IEEE 754, comme expliqué dans les réponses).
  • Oui, c'est en effet un peu incohérent. Cependant, il est explicitement décrite dans la documentation Javadoc: "Double.NaN est considéré par cette méthode pour être égal à lui-même " (voir file:///C:/Users/sle/Downloads/Docs/jdk-6u25-fcs-bin-b04-apidocs-04_Apr_2011/docs/api/java/lang/Double.html#compareTo%28java.lang.Double%29 )
  • Voir aussi Pourquoi est indéfini == undefined, mais NaN != NaN? et en fait NaN est égal à NaN (ce sont des propos de JS, mais comme noté au-dessus et au-dessous, c'est indépendant de la langue).
  • mais: String h = "Hello"; // not a number assertFalse(h != h); // is false Double.NaN comportement certainement n'est pas intuitif...

InformationsquelleAutor Maverick | 2012-01-11
  1. 138

    NaN signifie "Pas un Nombre".

    Java Langage de Spécification (JLS) Troisième Édition dit:

    Une opération qui déborde produit signé de l'infini, une opération qui underflows produit une valeur anormale ou un signé zéro, et une opération qui n'a pas mathématiquement définie résultat produit NaN. Toutes les opérations numériques avec NaN comme un opérande produire NaN comme un résultat. Comme cela a déjà été décrit, NaN n'est pas ordonné, donc une comparaison numérique de l'opération impliquant un ou deux NaNs retourne false et tout != comparaison impliquant NaN retourne true, y compris x!=x quand x est NaN.

    • Il n'est pas juste de Java; il est en virgule flottante, la norme.
    • true. Une comparaison avec une norme IEEE-conforme à flotteur va produire false. Alors que la norme diffère de Java dans ce IEEE exige que (NAN != NAN) == false.
    • L'ouverture de cette boîte de Pandore - où voyez-vous que "IEEE exige que (NAN != NAN) == false"?
    InformationsquelleAutor Adrian Mitev
  2. 61

    NaN est, par définition, n'est pas égale à un nombre quelconque, y compris NaN. Cela fait partie de la norme IEEE 754 et mis en œuvre par le CPU/FPU. Il n'est pas quelque chose de la JVM a pour ajouter de la logique à l'appui.

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

    Une comparaison avec un NaN retourne toujours une suite non ordonnée même si l'on compare avec lui-même. ... L'égalité et de l'inégalité des prédicats sont non-signalisation donc x = x renvoyer false peut être utilisé pour tester si x est un endroit calme NaN.

    Java traite tous NaN tranquille NaN.

    • Est-il mis en œuvre par le CPU, ou est-il câblé dans la JVM comme Bohème mentionne?
    • La JVM dispose d'appel quel que soit le mettre en œuvre correctement. Sur un PC, le PROCESSEUR qui fait le travail en tant que tel. Sur une machine sans ce soutien, la JVM a à mettre en œuvre. (Je ne sais pas du tout cette machine)
    • Retour dans la journée quand le 8087 était une option, la bibliothèque C contenait une FP de l'émulateur. Des programmes comme la JVM ne pas avoir à vous soucier de la manière.
    InformationsquelleAutor Peter Lawrey
  3. 48

    Pourquoi cette logique

    NaN signifie Not a Number. Ce n'est pas un nombre? Quoi que ce soit. Vous pouvez avoir tout dans un côté et rien de l'autre côté, 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 comprise 0x7ff0000000000001L par
    0x7fffffffffffffffL ou dans la gamme 0xfff0000000000001L par
    0xffffffffffffffffL, le résultat est un NaN.

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

    Par la voie, NaN est testé en tant que 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 est d'utiliser compare/compareTo:

    Double.NaN est considéré par cette méthode pour être égal à lui-même
    et plus grand que tous les autres double valeurs (y compris les
    Double.POSITIVE_INFINITY).

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

    Ou, equals:

    Si this et argument représentent tous les deux Double.NaN, puis
    le equals méthode renvoie true, même si
    Double.NaN==Double.NaN a la valeur false.

    Double.NaN.equals(Double.NaN);
    • Connaissez-vous des cas où le fait d'avoir NaN != NaN être faux aurait de rendre les programmes plus compliqué que d'avoir NaN != NaN être vrai? Je sais IEEE pris la décision il y a longtemps, mais à partir d'un point de vue pratique, je n'ai jamais vu des cas où c'est utile. Si une opération est censé fonctionner jusqu'à ce que itérations consécutives à donner le même résultat, ayant deux itérations consécutives de rendement NaN serait "naturellement" détecté comme une condition de sortie il n'y avait pas ce comportement.
    • Comment pouvez-vous dire que les deux aléatoire non nombre sont naturellement égaux? Ou dire, primitivement l'égalité? Pensez NaN comme un exemple, pas quelque chose de primitif. Chaque résultat anormal est un autre exemple de quelque chose d'étrange et même si les deux doivent représenter la même, à l'aide de == pour les différents cas, il doit retourner false. D'autre part, lors de l'utilisation d'égal à égal, il peut être manipulé correctement comme vous le souhaitez. [docs.oracle.com/javase/7/docs/api/java/lang/...
    • Le problème n'est pas de savoir si deux nombres aléatoires devraient être considérées comme "certainement l'égalité", mais plutôt dans quels cas est-il utile d'avoir un nombre quelconque de comparer comme "certainement inégale" à lui-même. Si l'on cherche à calculer la limite de f(f(f...f(x))), et l'on retrouve un y=f[n](x) pour certains n tels que le résultat de f(y) est impossible de distinguer les y, puis y sera impossible de distinguer le résultat de tout plus profondément imbriquée f(f(f(...f(y))). Même si l'on voulait NaN==NaN faux, ayant Nan!=Nan aussi faux serait moins "surprenant" que d'avoir x!=x être vrai pour certaines valeurs de x.
    • Si vous jouez avec le Double (pas de double) et vous écrivez une condition à l'aide == (ce qui serait étrange de ne pas utiliser égaux ici), cela signifie que vous seriez prêt à exécuter le bloc interne lorsque les deux côtés sont égaux (évidemment), et probablement utiliser tem (disons, dans une équation), de sorte que le moins "surprenant", pour moi, serait d'entrer dans mon bloc quand NaN = NaN et causer une surprise inattendue erreur! Je n'ai pas de vitrine pour vous et probablement peu de gens ont passé par le biais de ce problème. C'est un OCPJP question et le point est de clarifier et de résoudre les OP du problème.
    • Je crois que le type de Double.NaN n'est pas Double, mais double, donc la question est celle du comportement de double. Bien qu'il existe des fonctions qui peuvent tester une relation d'équivalence impliquant double valeurs, la seule réponse convaincante je sais de "pourquoi" (qui fait partie de la question d'origine) est "parce que certaines personnes à l'IEEE ne pense pas que l'égalité de l'expérimentation de définir une relation d'équivalence". BTW, est-il concise idiomatiques moyen de tester x et y pour l'équivalence à l'aide de seulement primitive-opérateurs? Toutes les formules que je connais sont plutôt maladroit.
    • peut-être que les tests de mathématiques de la série de convergence? Je pense que +/- inf serait probablement utilisé à la place, mais je peux imaginer un cas où une série qui diverge est représenté à l'aide de NaN, et deux de ces séries ne serait pas nécessairement une égalité
    • Si une séquence mathématique devraient converger, mais une itération rendements NaN, de multiples itérations ne sont pas capables de faire beaucoup de bien. Je pense que le fait d'avoir des valeurs NaN comparer que l'égalité serait la cause de la plupart des algorithmes d'annoncer, dans ce cas, la séquence convergé NaN, tout en ayant leur permettant de comparer inégalité serait la cause de la programme pour itérer pour toujours absent délibérée d'une sortie de test pour NaN.
    • La documentation dit aussi, par exemple, que l'une des raisons qui equals retourne true lorsque l'on compare les deux NaN's, c'est qu'il va faire des tables de hachage pour fonctionner correctement.
    • Le equals méthode en Java tests si x est supérieur à y, ou si c'est moins de y, et si aucune condition s'applique, il convertit les 64 bits de chaque valeur à un long avec le même motif et examine les valeurs résultantes. Pas particulièrement concis. Si l'on accepte positifs et négatifs de zéro, comme équivalent (à mon humble avis, ils ne devraient pas être, mais une définition de l'égalité, qui les considéraient comme équivalent serait au moins une relation d'équivalence), (x >= y && x <= y) || (x != x && y != y) serait probablement plus rapide à moins qu'une implémentation de Java utilisé une implémentation native.
    • Je suis d'accord: c'est plus rapide. Je voulais juste ajouter que les comportements sont différents.
    • meilleure réponse simple et. Merci
    • Double.NaN.equals/compareTo n'est pas un code valide! Double.NaN est un double et vous ne pouvez pas appeler la méthode d'elle.

    InformationsquelleAutor falsarella
  4. 14

    Il pourrait ne pas être une réponse directe à la question.
    Mais si vous voulez vérifier si quelque chose est égale à Double.NaN vous devez utiliser ce:

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

    Ce sera le retour de true

    InformationsquelleAutor JREN
  5. 6

    La javadoc pour le Double.NaN dit tout:

    Une tenue constante qui n'est Pas un Nombre (NaN) valeur de type double. Il est équivalent à la valeur retournée par Double.longBitsToDouble(0x7ff8000000000000L).

    Fait intéressant, la source de Double définit NaN ainsi:

    public static final double NaN = 0.0d / 0.0;

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

    • Est-il difficile de câble dans la JVM, ou est-il mis en œuvre par le PROCESSEUR Pierre mentionne?
    InformationsquelleAutor Bohemian
  6. 4

    que par, La norme IEEE pour l'arithmétique à virgule flottante pour les nombres Double Précision,

    L'IEEE en virgule flottante double précision représentation standard
    nécessite une version 64 bits du mot, qui peut être représenté comme numérotées de 0 à
    63, de gauche à droite

    Pourquoi ne Double.NaN==Double.NaN return false?
    où,

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

    Si E=2047 (tous les E sont 1) et F est différent de zéro, alors V=NaN ("Pas un nombre")

    Ce qui signifie,

    Si tous les E bits sont à 1, et s'il est non nul peu dans F le nombre est NaN.

    donc, entre autres, tous les numéros 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 le résultat est égal à Double.NaN, parce que tous les “pas un nombre”, les valeurs sont considérées comme distinctes. Toutefois, vous pouvez utiliser le Double.isNaN méthode:

    if (Double.isNaN(x)) //check whether x is "not a number"
    InformationsquelleAutor Sufiyan Ghori
  7. 3

    NaN est une valeur spéciale qui indique "pas un nombre"; c'est le résultat de certains invalides opérations arithmétiques, comme sqrt(-1), et a la (parfois ennuyeux) des biens qui NaN != NaN.

    InformationsquelleAutor Fred Foo
  8. 2

    Pas un certain nombre représente le résultat des opérations dont le résultat n'est pas représentable par un nombre. Le plus célèbre de l'opération est 0/0, dont le résultat n'est pas connu.

    Pour cette raison, NaN n'est pas égal à quoi que ce soit (y compris d'autres pas-un-certain nombre de valeurs). Pour plus d'informations, consultez la page wikipédia: http://en.wikipedia.org/wiki/NaN

    • -1: Il n' pas représente le résultat de 0/0. 0/0 est toujours NaN, mais NaN peut être le résultat d'autres opérations telles que 2+NaN: an operation that has no mathematically definite result produces NaN, que par la réponse par @AdrianMitev
    • En effet, NaN signifie "Pas un Nombre", et c'est le résultat de toutes les activités qui ont comme résultat une indéfini ou irreprésentable de la valeur. Le plus célèbre et l'exploitation commune est 0/0, mais évidemment il y a des tonnes d'autres opérations qui a le même résultat. Je suis d'accord que ma réponse pourrait être amélioré, mais je suis en désaccord sur l'-1... je viens de vérifier également que wikipedia utilise la 0/0 des opérations comme le premier exemple de fonctionnement avec un NaN résultat (en.wikipedia.org/wiki/NaN).
    • Aussi, c'est dans le source Java pour le Double: public static final double NaN = 0.0 d / 0.0;
    • maintenant que la fausse déclaration est allé. Et mon -1 ou +1 ne sont pas pour vous d'accepter ou de refuser; mais il est bon de laisser un commentaire avec un -1, de sorte que l'auteur ne peut comprendre pourquoi sa réponse est considérée comme inutile - et de le changer, s'il le souhaite.
    • si ce commentaire a été fait pour moi, merci de la reformuler: je ne comprends pas.
    • Je suis d'accord que le but est de donner la meilleure réponse à la question. Cependant, je pense qu'il y a plusieurs façons d'expliquer la même chose. De plus, je pense que les débutants peuvent exploiter un exemple simple de ce phénomène, et puis, ils peuvent re-développer.

    InformationsquelleAutor Matteo
  9. 0

    Selon cette lien, il a diverses situations et difficile à mémoriser. C'est la façon dont je me souviens et de les distinguer. NaN signifie "mathématiquement non définie", par exemple: "le résultat de 0 divisé par 0 n'est pas défini" et parce qu'il n'est pas défini, de sorte que la "comparaison liées à l'indéfini est bien sûr pas défini". En outre, il fonctionne plus comme mathématique locaux. D'autre part, à la fois positifs et négatifs infini est prédéfini et définitive, par exemple "positive ou négative de l'infini grand est bien défini mathématiquement".

    InformationsquelleAutor Tiina