¿Por qué double.NaN no es igual a sí mismo?

¿Alguien puede explicarme esto? En C # double.NaN no es igual a double.NaN

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

¿Qué constante puedo comparar con un double.NaN y volverme verdadera?

Si tiene curiosidad, esto es lo que Double.IsNaNparece:

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

Funky, ¿eh?

Utilice Double.IsNaN .

bool isNaN = Double.IsNaN(yourNumber)

El comportamiento es a propósito. La razón por la que NaN representa algo que no es un número y, por lo tanto, es una especie de comodín para muchas cosas.

La forma correcta de comparar algo con ser NaN es usar el función IsNaN .

Utilice Double.IsNan () para probar la igualdad aquí. La razón es que NaN no es un número.

Hay una función especializada para esto:

double.IsNan(huh);

Utilice el método "Double.IsNaN (valor)" para comprobar esta condición.

En realidad, ya encontró la manera de verificar si un número de punto flotante IEEE-754 es NaN : es el único valor de punto flotante (o rango de valores, porque hay varios NaN) que evalúa Falsesi se compara con él mismo, es decir:

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

Bajo el capó, el método Double.IsNaN en realidad podría hacer lo mismo. Aún debe usarlo, porque el comportamiento es bastante sorprendente para cualquiera que no conozca el estándar FP.

Lo único que sabemos sobre NaN es que "no es un número". Eso no significa que tenga un valor asociable a su estado. Por ejemplo:

∞ + (-∞) = NaN

0/0 = NaN

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

Aquí hay algo de C # para demostrar

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);

La razón Double.NaN != Double.NaNes simple:

¿Esperas 0/0ser igual que Math.Sqrt(-3)? ¿Y lo mismo que Math.Sqrt(-7)?

Hay un error en C # en mi opinión donde Equals()no se anula para NaN.

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

Al mismo tiempo

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

Utilice funciones estáticas para Doubley Single, p. Ej.

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

O más específico:

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

El operador de Igualdad considera que dos valores de NaN no son iguales entre sí. En general, los operadores Double no se pueden usar para comparar Double.NaN con otros valores Double, aunque los métodos de comparación (como Equals y CompareTo ) sí pueden. ver ejemplos a continuación

Referenciado de 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");
        }
    }
}

aquí está .net violín para el mismo.