C# Pourquoi la division est plus lente que la multiplication ?

Dans les langages de programmation et plus particulièrement C#, 4 opérations arithmétiques peuvent être effectuées: addition, soustraction, multiplication et division.

Et d'un point de vue extérieur, il peut sembler qu'ils sont tous similaires en termes de performances, mais il s'avère que l'un d'eux est beaucoup plus lent que les 3 autres.

Lequel est le plus lent, demandez-vous ? Division.

D'après ce papier HP:

La division en virgule flottante et la racine carrée prennent beaucoup plus de temps à calculer que l'addition et la multiplication. Les deux derniers sont calculés directement tandis que les premiers sont généralement calculés avec un algorithme itératif. L'approche la plus courante consiste à utiliser une itération de Newton-Raphson sans division pour obtenir une approximation de l'inverse du dénominateur (division) ou de la racine carrée réciproque, puis à multiplier par le numérateur (division) ou l'argument d'entrée (racine carrée).

Pour vérifier la déclaration ci-dessus, j'ai décidé d'exécuter un test simple en utilisant le code ci-dessous:

        //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");

En gros, j'ai effectué un million d'additions, soustractions, multiplications et divisions pour les deux nombres aléatoires et j'ai mesuré le temps que chacun d'eux a mis à traiter, le test a été répété 5 fois, et voici le résultat:

• L'ajout a pris en moyenne 0,0004 seconde
• La soustraction a pris en moyenne 0,0003 secondes
• La multiplication a pris en moyenne 0,0003 seconde
• La division prenait en moyenne 0,0044 seconde

Le résultat a montré que l’addition, la soustraction et la multiplication sont similaires en termes de performances, mais que la division semble être environ 1 100 % plus lente.

Ce n'est pas une petite différence, ce qui conduit à la conclusion qu'il est toujours préférable d'utiliser la multiplication plutôt que la division autant que possible. Par exemple, lorsque vous devez diviser le nombre par 2, il est préférable de le multiplier par 0,5.