Почему Double.NaN == Double.NaN возвращает false?

Я только изучал вопросы OCPJP и нашел этот странный код:

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

Когда я запустил код, я получил:

false
true

Как получается, falseкогда мы сравниваем две вещи, которые выглядят одинаково друг с другом? Что NaNзначит?

NaN означает «не число».

Спецификация языка Java (JLS) третьего издания гласит :

Операция, которая переполняется, производит бесконечность со знаком, операция, которая переполняется, производит денормализованное значение или нулевой знак, и операция, которая не имеет математически определенного результата, производит NaN. Все числовые операции с NaN в качестве операнда в результате дают NaN. Как уже было описано, NaN неупорядочен, поэтому операция числового сравнения, включающая один или два возврата NaN , falseи любое !=сравнение, включающее возврат NaN true, в том числе x!=xкогда xравен NaN.

NaN по определению не равен ни одному числу, включая NaN. Это является частью стандарта IEEE 754 и реализуется процессором / FPU. Это не то, что JVM должна добавить какую-либо логику для поддержки.

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

Сравнение с NaN всегда возвращает неупорядоченный результат даже при сравнении с самим собой. ... Предикаты равенства и неравенства не сигнализируют, поэтому x = x, возвращающий false, можно использовать для проверки, является ли x спокойным NaN.

Ява рассматривает весь NaN как тихий NaN.

Почему эта логика

NaNзначит Not a Number. Что не число? Что-нибудь. У вас может быть что угодно с одной стороны и что угодно с другой стороны, поэтому ничто не гарантирует, что оба равны. NaNрассчитывается с Double.longBitsToDouble(0x7ff8000000000000L)и, как вы можете видеть в документации longBitsToDouble:

Если аргумент является любое значение в диапазоне 0x7ff0000000000001Lчерез 0x7fffffffffffffffLили в диапазоне от 0xfff0000000000001Lсквозной 0xffffffffffffffffL, то результат будет NaN.

Кроме того, NaNлогически рассматривается внутри API.

Документация

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

Кстати, NaN это тестирование в качестве образца кода:

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

Решение

Что вы можете сделать, это использовать compare/ compareTo:

Double.NaNэтот метод считается равным самому себе и большим, чем все другие doubleзначения (в том числе Double.POSITIVE_INFINITY).

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

Или equals:

Если thisи argumentоба представляют Double.NaN, то equalsметод возвращается true, хотя и Double.NaN==Double.NaNимеет значение false.

Double.NaN.equals(Double.NaN);

Это может быть не прямой ответ на вопрос. Но если вы хотите проверить, что-то равно Double.NaNвам, следует использовать это:

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

Это вернется true

Javadoc для Double.NaN говорит все это:

Константа, содержащая значение типа Not-a-Number (NaN) типа double. Это эквивалентно значению, возвращаемому Double.longBitsToDouble(0x7ff8000000000000L).

Интересно, что источник для Doubleопределяет NaNтаким образом:

public static final double NaN = 0.0d / 0.0;

Особое поведение, которое вы описываете, встроено в JVM.

согласно стандарту IEEE для арифметики с плавающей запятой для чисел двойной точности,

Стандартное представление IEEE двойной точности с плавающей запятой требует 64-битного слова, которое может быть представлено как пронумерованное от 0 до 63, слева направо

где,

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

Если E=2047(все Eони 1) и Fотличны от нуля, то V=NaN(«Не число»)

Что значит,

Если все Eбиты равны 1, и если есть какой-либо ненулевой бит, Fто число равно NaN.

Поэтому, в частности, все последующие номера NaN,

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

В частности, вы не можете проверить

if (x == Double.NaN) 

проверить, равен ли конкретный результат Double.NaN, потому что все значения «не числа» считаются различными. Однако вы можете использовать Double.isNaNметод:

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

NaN - это специальное значение, которое обозначает «не число»; это результат некоторых недопустимых арифметических операций, таких как sqrt(-1), и имеет (иногда раздражающее) свойство that NaN != NaN.

Не число представляет результат операций, результат которых не может быть представлен числом. Самая известная операция - 0/0, результат которой неизвестен.

По этой причине NaN не равен ничему (включая другие не-числовые значения). Для получения дополнительной информации, просто посетите страницу википедии: http://en.wikipedia.org/wiki/NaN

По этой ссылке , он имеет различные ситуации и трудно запомнить. Вот как я их помню и различаю. NaNозначает «математически не определено», например: «результат 0, деленный на 0, не определен», и поскольку он не определен, то «сравнение, связанное с неопределенным, конечно, не определено». Кроме того, это больше похоже на математические предпосылки. С другой стороны, как положительная, так и отрицательная бесконечность предопределены и окончательны, например, «положительное или отрицательное бесконечно большое хорошо определено математически».