¿Cómo puedo comparar un flotante con NaN si las comparaciones con NaN siempre devuelven falso?

Question

que tienen un valor flotante fijado a NaN (visto en la ventana de visualización), pero no puedo encontrar la manera de detectar que en el código:

if (fValue == float.NaN) // returns false even though fValue is NaN 
{ 
} 

Answer 1

Usted quiere float.IsNaN(...). Las comparaciones con NaN siempre devuelven falso, sin importar el valor del flotante. Es una de las peculiaridades de los puntos flotantes.

Eso significa que usted puede hacer esto:

if (f1 != f1) { // This conditional will be true if f1 is NaN. 

De hecho, eso es exactamente cómo funciona isNaN().

Answer 2

Prueba esto:

if (float.IsNaN(fValue)) 
{ 
} 

Answer 3

if(float.isNaN(fValue)) 
{ 
} 

Answer 4

if (fValue.CompareTo(float.NaN) == 0) 

Nota: Lo sé, el hilo está muerto.

Answer 5

En el código de rendimiento crítico float.IsNaN podría ser demasiado lento porque involucra FPU. En ese caso se puede utilizar cheque máscara binaria (de acuerdo con IEEE 754 specification) de la siguiente manera:

public static unsafe bool IsNaN (float f) 
{ 
    int binary = *(int*)(&f); 
    return ((binary & 0x7F800000) == 0x7F800000) && ((binary & 0x007FFFFF) != 0); 
} 

Es 5 veces más rápido que float.IsNaN. Me pregunto por qué Microsoft no implementó IsNaN de esa manera. Si prefiere no usar código no seguro todavía se puede utilizar la unión-como la estructura:

[StructLayout (LayoutKind.Explicit)] 
struct FloatUnion 
{ 
    [FieldOffset (0)] 
    public float value; 

    [FieldOffset (0)] 
    public int binary; 
} 

public static bool IsNaN (float f) 
{ 
    FloatUnion union = new FloatUnion(); 
    union.value = f; 

    return ((union.binary & 0x7F800000) == 0x7F800000) && ((union.binary & 0x007FFFFF) != 0); 
} 

Todavía es 3 veces más rápido que IsNaN.