Почему double.NaN не равно самому себе?

Может кто-то объяснить это мне? В C # double.NaN не равно double.NaN.

bool huh = double.NaN == double.NaN; // huh = false
bool huh2 = double.NaN >= 0; // huh2 = false
bool huh3 = double.NaN <= 0; // huh3 = false

Какую константу я могу сравнить с double.NaN и получить истину?

Если вам интересно, вот как Double.IsNaNвыглядит:

public static bool IsNaN(double d)
{
    return (d != d);
}

Обалденный, да?

Используйте Double.IsNaN .

bool isNaN = Double.IsNaN(yourNumber)

Это намеренное поведение. Причина, по которой NaN представляет собой нечто, не являющееся числом и поэтому это своего рода уловка для многих вещей.

Правильный способ сравнить что-то с NaN - использовать функцию IsNaN .

Используйте Double.IsNan (), чтобы проверить здесь равенство. Причина в том, что NaN не является числом.

Для этого есть специальная функция:

double.IsNan(huh);

Используйте метод Double.IsNaN (value), чтобы проверить это условие.

Фактически, вы уже нашли способ проверить, является ли число с плавающей запятой IEEE-754 NaN : это единственное значение с плавающей запятой (или диапазон значений, поскольку существует несколько NaN), которое оценивается по Falseсравнению с самим собой, то есть:

bool isNaN(double v) {
    return v != v;
}

Под капотом метод Double.IsNaN может делать то же самое. Вы все равно должны использовать его, потому что поведение довольно удивительно для любого, кто не знает о стандарте FP.

Единственное, что мы знаем о NaN, - это то, что это «не число». Это не означает, что у него есть значение, связанное с его состоянием. Например:

∞ + (-∞) = NaN

0/0 = NaN

(∞ + (-∞)) <> (0/0)

Вот немного C # для демонстрации

var infinity = 100d / 0;
var negInfinity = -100d / 0;

var notANumber = infinity + negInfinity;
Console.WriteLine("Negative Infinity plus Infinity is NaN: {0}", double.IsNaN(notANumber));

var notANumber2 = 0d / 0d;
Console.WriteLine("Zero divided by Zero is NaN: {0}", double.IsNaN(notANumber2));

Console.WriteLine("These two are not equal: {0}", notANumber == notANumber2);

Причина Double.NaN != Double.NaN проста:

Вы рассчитываете 0/0быть таким же, как Math.Sqrt(-3)? И так же, какMath.Sqrt(-7) ?

На мой взгляд, есть ошибка в C #, Equals()которая не отменяется для NaN.

Assert.IsTrue(Double.NaN != Double.NaN);
Assert.IsTrue(Double.NaN.Equals(Double.NaN));

В то же время

Assert.IsTrue(Double.PositiveInfinity == Double.NegativeInfinity);
Assert.IsTrue(Double.PositiveInfinity.Equals(Double.PositiveInfinity));
// same for Double.NegativeInfinity and Single

Используйте статические функции для Doubleи Single, например

Double.IsNaN(value) && Double.IsInfinity(value);

Или более конкретно:

Double.IsPositiveInfinity(value);
Double.IsNegativeInfinity(value);

Оператор Equality считает, что два значения NaN не равны друг другу. Как правило, операторы Double нельзя использовать для сравнения Double.NaN с другими значениями Double, хотя методы сравнения (например, Equals и CompareTo ) могут. см. ниже примеры

Ссылка из msdn

class Program
{
    static void Main(string[] args)
    {
        Double i = Double.NaN;
        while (!i.Equals(i)) //this would be result in false
        //while(i != i) // this would result in true.
        {
            Console.WriteLine("Hello");
        }
    }
}

вот скрипка .net для того же самого.