¿Es posible escribir la función InvSqrt() rápida de Quake en C#?

Question

Esto es solo para satisfacer mi propia curiosidad.

¿Existe una implementación de este:

float InvSqrt (float x) 
{ 
    float xhalf = 0.5f*x; 
    int i = *(int*)&x; 
    i = 0x5f3759df - (i>>1); 
    x = *(float*)&i; 
    x = x*(1.5f - xhalf*x*x); 
    return x; 
} 

en C#? Si existe, publique el código.

Supongo que debería haber mencionado que estaba buscando una implementación "segura" ... En cualquier caso, el código BitConverter resuelve el problema. La idea de unión es interesante. Lo probaré y publicaré mis resultados.

Edit: Como era de esperar, el método inseguro es el más rápido, seguido por el uso de una unión (dentro de la función), seguido por el BitConverter. Las funciones se ejecutaron 10000000 veces, y utilicé la clase System.Diagnostics.Stopwatch para medir el tiempo. Los resultados de los cálculos se muestran entre paréntesis.

Input: 79.67 
BitConverter Method: 00:00:01.2809018 (0.1120187) 
Union Method: 00:00:00.6838758 (0.1120187) 
Unsafe Method: 00:00:00.3376401 (0.1120187) 

Para completar, he probado el método integrado Math.pow, y el método "naive" (1/sqrt (x)).

Math.Pow(x, -0.5): 00:00:01.7133228 (0.112034710535584) 
1/Math.Sqrt(x): 00:00:00.3757084 (0.1120347) 

La diferencia entre 1/Math.Sqrt() es tan pequeño que no creo que uno tiene que recurrir al método inseguro InvSqrt rápido() en C# (o cualquier otro método inseguro). A menos que uno realmente necesite exprimir el último bit de jugo de la CPU ... 1/Math.Sqrt() también es mucho más preciso.

Answer 1

Usted debe ser capaz de utilizar el StructLayout y FieldOffset atribuye la falsificación de una unión a datos simples antiguos como flotantes y enteros.

[StructLayout(LayoutKind.Explicit, Size=4)] 
private struct IntFloat { 
    [FieldOffset(0)] 
    public float floatValue; 

    [FieldOffset(0)] 
    public int intValue; 

    // redundant assignment to avoid any complaints about uninitialized members 
    IntFloat(int x) { 
     floatValue = 0; 
     intValue = x; 
    } 

    IntFloat(float x) { 
     intValue = 0; 
     floatValue = x; 
    } 

    public static explicit operator float (IntFloat x) { 
     return x.floatValue; 
    } 

    public static explicit operator int (IntFloat x) { 
     return x.intValue; 
    } 

    public static explicit operator IntFloat (int i) { 
     return new IntFloat(i); 
    } 
    public static explicit operator IntFloat (float f) { 
     return new IntFloat(f); 
    } 
} 

Luego, traducir InvSqrt es fácil.

Answer 2

No veo por qué no sería posible usar la opción de compilador inseguro .

Answer 3

Utilice BitConverter si desea evitar el código inseguro.

float InvSqrt(float x) 
{ 
    float xhalf = 0.5f * x; 
    int i = BitConverter.ToInt32(BitConverter.GetBytes(x), 0); 
    i = 0x5f3759df - (i >> 1); 
    x = BitConverter.ToSingle(BitConverter.GetBytes(i), 0); 
    x = x * (1.5f - xhalf * x * x); 
    return x; 
} 

De lo contrario, el código C# es exactamente el mismo que el código C que diste, excepto que el método tiene que ser marcado como inseguro:

unsafe float InvSqrt(float x) { ... } 

Answer 4

Definitivamente es posible en modo inseguro. Tenga en cuenta que, aunque en el código fuente de Quake 3 se usó la constante 0x5f3759df, numerical research showed, la constante 0x5f375a86 en realidad produce mejores resultados para las aproximaciones de Newton.