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

¿Alguien me puede explicar 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 ser cierto?

Si tiene curiosidad, así es como se ve Double.IsNaN :

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

Funky, ¿eh?

Use 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, es una especie de catch-all para muchas cosas.

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

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

Use el método “Double.IsNaN (value)” para verificar esta condición.

En realidad, ya encontraste la forma de comprobar si un número de coma flotante IEEE-754 es NaN : es el único valor de coma flotante (o rango de valores, porque hay varios NaN) que se evalúa como False si se compara con él mismo, es decir:

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

Bajo el capó, el método Double.IsNaN podría hacer lo mismo. Debería seguir utilizándolo, porque el comportamiento es bastante sorprendente para cualquiera que no conozca el estándar FP.

Lo único que sabemos sobre NaN es que es “No es un número”. Eso no significa que tenga un valor que sea asociable con su estado. Por ejemplo:

∞ + (-∞) = NaN

0/0 = NaN

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

Aquí hay algunos 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 de Double.NaN != Double.NaN es simple:

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

Hay un error en C # en mi opinión, donde Equals() no se reemplaza por 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 Double e Single , por 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 son desiguales entre sí. En general, los operadores dobles no se pueden usar para comparar Double.NaN con otros valores dobles, aunque sí los métodos de comparación (como Equals y CompareTo ). ver ejemplos a continuación

Remitido desde 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.