¿Cómo puedo probar el cero negativo?

Question

Inicialmente pensé que Math.Sign sería la manera correcta de hacerlo, pero después de ejecutar una prueba parece que trata a -0.0 y +0.0 de la misma manera.

Answer 1

Aquí está una manera horrible truco de hacerlo:

private static readonly long NegativeZeroBits = 
    BitConverter.DoubleToInt64Bits(-0.0); 

public static bool IsNegativeZero(double x) 
{ 
    return BitConverter.DoubleToInt64Bits(x) == NegativeZeroBits; 
} 

Básicamente esa es la prueba para el patrón de bits exacta de -0.0, pero sin tener que codificar la misma.

Answer 2

Después de un poco de búsqueda finalmente llegué al Section 7.7.2 de la especificación C# y se me ocurrió esta solución.

private static bool IsNegativeZero(double x) 
{ 
    return x == 0.0 && double.IsNegativeInfinity(1.0/x); 
} 

Answer 3

El cero negativo tiene el bit de signo configurado. Por lo tanto:

public static bool IsNegativeZero(double value) { 
     if (value != 0) return false; 
     int index = BitConverter.IsLittleEndian ? 7 : 0; 
     return BitConverter.GetBytes(value)[index] == 0x80; 
    } 

Editar: como lo señaló OP, esto no funciona en el modo de lanzamiento. El optimizador x86 JIT toma en serio la sentencia if() y carga cero directamente en lugar de cargar el valor . Que de hecho es más eficiente. Pero eso hace que se pierda el cero negativo. El código debe ser de-sintonizado para evitar esto:

public static bool IsNegativeZero(double value) { 
     int index = BitConverter.IsLittleEndian ? 7 : 0; 
     if (BitConverter.GetBytes(value)[index] != 0x80) return false; 
     return value == 0; 
    } 

Este comportamiento es bastante típica de la fluctuación de fase 86 por cierto, que no se ocupa de casos de esquina muy bien cuando se optimiza el código de punto flotante. El jitter x64 es mucho mejor en ese sentido. Aunque podría decirse que no hay peor caso de esquina que darle significado al cero negativo. Ser prevenido

Answer 4

Aquí hay otro truco. Se aprovecha del hecho de que Equals en un struct va a hacer una comparación bit a bit en lugar de llamar Equals de sus miembros:

struct Negative0 
{ 
    double val; 
    public static bool Equals(double d) 
    { 
     return new Negative0 { val = -0d }.Equals(new Negative0 { val = d }); 
    } 
} 

Negative0.Equals(0); // false
Negative0.Equals(-0.0); // true

Answer 5

x == 0 && 1/x < 0 

Answer 6

De manera más general, se puede hacer,

bool IsNegative(double value) 
{ 
    const ulong SignBit = 0x8000000000000000; 
    return ((ulong)BitConverter.DoubleToInt64Bits(value) & SignBit) == SignBit; 
} 

---

o, alternativamente, si lo prefiere,

[StructLayout(LayoutKind.Explicit)] 
private struct DoubleULong 
{ 
    [FieldOffset(0)] 
    public double Double; 

    [FieldOffset(0)] 
    public readonly ulong ULong; 
} 

bool IsNegative(double value) 
{ 
    var du = new DoubleULong { Double = value }; 
    return ((du.ULong >> 62) & 2) == 2; 
} 

La tarde da una mejora a un rendimiento del 50% aproximado en depuración, pero. Una vez compilado en modo de lanzamiento y ejecutado desde la línea de comando , no hay una diferencia significativa.

No pude generar una mejora en el rendimiento utilizando un código inseguro tampoco, pero esto puede deberse a mi inexperiencia.