C# ¿Por qué la división es más lenta que la multiplicación?

En los lenguajes de programación y específicamente C# hay 4 operaciones aritméticas que se pueden realizar: suma, resta, multiplicación y división.

Y desde una perspectiva exterior, puede parecer que todos son similares en términos de rendimiento, pero resulta que uno de ellos es mucho más lento en comparación con los otros 3.

¿Cuál es más lento, te preguntarás? División.

Según este documento de HP:

La división en coma flotante y la raíz cuadrada tardan mucho más en calcularse que la suma y la multiplicación. Los dos últimos se calculan directamente, mientras que los primeros normalmente se calculan con un algoritmo iterativo. El enfoque más común es utilizar una iteración de Newton-Raphson sin división para obtener una aproximación al recíproco del denominador (división) o la raíz cuadrada recíproca, y luego multiplicar por el numerador (división) o el argumento de entrada (raíz cuadrada)..

Para verificar la afirmación anterior, decidí ejecutar una prueba simple usando el siguiente código:

        //Generate two random numbers
        var rand = new System.Random();
        float a = rand.Next();
        float b = rand.Next();

        Debug.Log("Number a: " + a + " Number b: " + b);

        System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();

        watch.Start();
        //Addition
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a + b;
        }
        watch.Stop();
        //Output
        Debug.Log("Addition took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

        watch.Reset();
        watch.Start();
        //Subtraction
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a - b;
        }
        watch.Stop();
        //Output
        Debug.Log("Subtraction took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

        watch.Reset();
        watch.Start();
        //Multiplication
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a * b;
        }
        watch.Stop();
        //Output
        Debug.Log("Multiplication took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

        watch.Reset();
        watch.Start();
        //Division
        for (int i = 1; i < 1000000; i++)
        {
            float tmp = a / b;
        }
        watch.Stop();
        //Division
        Debug.Log("Division took: " + watch.Elapsed.TotalSeconds.ToString("0.0000") + " seconds");

Básicamente, realicé un millón de sumas, restas, multiplicaciones y divisiones para los dos números aleatorios y medí el tiempo que tomó cada uno de ellos para procesarse, la prueba se repitió 5 veces y aquí está el resultado:

• La suma tomó en promedio 0,0004 segundos
• La resta tomó en promedio 0,0003 segundos
• La multiplicación tomó en promedio 0,0003 segundos.
• La división tomó en promedio 0,0044 segundos

El resultado mostró que la suma, la resta y la multiplicación son similares en términos de rendimiento, pero la división parece ser alrededor de un 1100% más lenta.

No es una diferencia pequeña, lo que lleva a la conclusión de que siempre es mejor utilizar la multiplicación en lugar de la división siempre que sea posible. Por ejemplo, cuando necesites dividir el número entre 2, lo mejor es multiplicarlo por 0,5.