Algorithme de la potence

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

L'algorithme de la potence est un algorithme pour extraire la racine n-ième d'un nombre réel. Itératif, il procède en décalant n chiffres du radicande à partir du chiffre le plus significatif et retourne un chiffre à chaque itération. Il doit son nom[1] à la disposition des calculs qui ressemble à celle de la division.

Cet algorithme, très ancien, apparaît dès l'introduction de la notation décimale des nombres par position. On en trouve mention pour la racine carrée et la racine cubique dans un ouvrage du mathématicien indien Aryabhata, vers 499 après J.-C.[2]. Il a été utilisé pour le calcul des racines carrées jusqu'au milieu du XXe siècle.

Description[modifier | modifier le code]

Soit x le nombre dont on cherche la racine n-ième y. On calcule y chiffre par chiffre en regroupant les chiffres de x par blocs successifs de n chiffres.

Notation[modifier | modifier le code]

On note B la base du système de nombres, x la partie du radicande déjà traitée, y la racine extraite jusqu'à maintenant, α le prochain bloc de n chiffres du radicande, et β le prochain chiffre à déterminer de la racine. On note x' la nouvelle valeur de x dans la prochaine itération, obtenue en adjoignant à x le bloc α de chiffres non encore traités, et y' la nouvelle valeur de y dans la prochaine itération, obtenue en complétant y par le nouveau chiffre β. Ces nombres peuvent être supposés entiers, le cas des nombres décimaux pouvant être réglé en multipliant x par une puissance adéquate de Bn.

Invariant[modifier | modifier le code]

À chaque itération, la relation y^n \le x < (y+1)^n est conservée, exprimant le fait que y est le plus grand entier inférieur ou égal à la racine n-ième de x.

Initialisation[modifier | modifier le code]

Les valeurs initiales de x et y sont 0. Pour la première itération, la valeur de α est le bloc le plus significatif de n chiffres du radicande. En cas de nombre décimal, l'alignement se fait à partir de la virgule. Par exemple, dans 123,4 le bloc le plus significatif de 2 chiffres est 01, le prochain est 23 et le troisième est 40.

Boucle principale[modifier | modifier le code]

À chaque itération, on décale de n chiffres le radicande, de façon à avoir x' = B^n x + \alpha\, et un chiffre de la racine sera produit, de sorte que y' = B y + \beta\,, avec 0 \le \beta < B. La relation y^n \le x < (y+1)^n étant supposée vraie, on choisit \beta\, de façon que y'^n \le x' < (y'+1)^n. Pour cela, on choisit le plus grand \beta tel que :

(B y + \beta)^n \le B^n x + \alpha\,

Il reste à vérifier qu'un tel \beta\, est bien un chiffre en base B. \beta\, est bien positif ou nul, car B^n y^n \le B^n x + \alpha\,. \beta\, est également strictement inférieur à B, car, sachant que \alpha \le B^n-1 et que x+1 \le (y+1)^n, on a :

(By + \beta)^n \le B^nx+\alpha \le B^nx+B^n-1 = B^n(x+1)-1 \le B^n(y+1)^n -1 < B^n(y+1)^n

donc

By + \beta < B(y+1) = By + B et donc \beta < B

Enfin, \beta étant maximal, on a bien :

y'^n = (B y + \beta)^n \le B^n x + \alpha\ = x' < (B y + \beta + 1)^n = (y'+1)^n

et l'invariant est bien conservé au cours de l'itération.

En résumé, à chaque itération :

  1. Soit \alpha\, le prochain bloc de chiffres du radicande
  2. Poser x' = B^n x + \alpha\,
  3. Soit \beta\, le plus grand nombre tel que (B y + \beta)^n \le B^n x + \alpha\,
  4. Poser y' = B y + \beta\,
  5. Assigner x \leftarrow x'\, et y \leftarrow y'\,

Économie de la variable x[modifier | modifier le code]

En posant r = x - y^n et r' = x' - y'^n, la condition (B y + \beta)^n \le B^n x + \alpha\, est équivalente à (B y + \beta)^n - B^n y^n \le B^n r + \alpha\,

et la condition r' = x' - y'^n = B^n x + \alpha - (B y + \beta)^n\, est équivalente à r' = B^n r + \alpha - ((B y + \beta)^n - B^n y ^n)\,. r s'appelle le reste.

On peut donc remplacer l'utilisation de la variable x par la variable r. On réalise ainsi une économie de temps et d'espace par un facteur 1/n. En effet, r = x - y^n\, et x<(y+1)^n\, impliquent que r<(y+1)^n-y^n\, ou r<n y^{n-1}+O(y^{n-2})\,, ou r<n x^{{n-1}\over n} + O(x^{{n-2}\over n})\,. De plus, le facteur B^n y^n\, soustrait dans le nouveau test annule celui de (B y + \beta)^n\,, ainsi la plus grande puissance de y qu'il faut estimer est y^{n-1}\, plutôt que y^n\,.

La forme finale de l'algorithme est :

  1. Initialiser r et y à 0
  2. Répéter jusqu'à la précision désirée :
    1. Soit α le prochain bloc de chiffres du radicande
    2. Soit \beta\, le plus grand nombre tel que (B y + \beta)^n - B^n y^n \le B^n r + \alpha\,
    3. Soit y' = B y + \beta
    4. Soit r' = B^n r + \alpha - ((B y + \beta)^n - B^n y^n)\,
    5. Assigner y \leftarrow y'\, et r \leftarrow r'\,

Les racines ne avec papier crayon[modifier | modifier le code]

Tel qu'indiqué plus haut, cet algorithme ressemble par sa disposition à celle de la division. On donne comme exemple le calcul de la racine cubique de 3. x vaut 3, complété à droite par des blocs de 000. On a B = 10 et n = 3 de sorte que (B y + \beta)^n - B^n y^n= 300y^2\beta + 30y\beta^2+\beta^3. La recherche de β se fait par tests successifs, mais après une ou deux itérations, le premier terme dominant dans (B y + \beta)^n - B^n y^n est n(By)^{n-1}\beta, et on peut obtenir une estimation de β en divisant B r + \alpha par n B^{n-1} y^{n-1}.

                           |  1.  4   4   2   2   4              
3.000 000 000 000 000      |------------------------
1                          | 1      premier chiffre de y qui vaut désormais 1
-                          |
2 000     reste            | 1 744 = 300*1^2*4 + 30*1*4^2 + 4^3   
1 744                      | donc 4 est le deuxième chiffre, et y prend la valeur 14
-----                      |  
  256 000    reste         | 241 984 = 300*14^2*4 + 30*14*4^2 + 4^3  
  241 984                  | donc 4 est le troisième chiffre, et y prend la valeur 144
  -------                  |
   14 016 000   reste      | 12 458 888 = 300*144^2*2 + 30*144*2^2 + 2^3 
   12 458 888              | donc 2 est le chiffre suivant, et y prend la valeur 1442
   ----------              |
    1 557 112 000  reste   | 1 247 791 448 = 300*1442^2*2 + 30*1442*2^2 + 2^3
    1 247 791 448          | donc 2 est le chiffre suivant, et y prend la valeur 14422
    -------------          |
      309 320 552 000      | 249 599 823 424 = 300*14422^2*4 + 30*14422*4^2 + 4^3
      249 599 823 424      | donc 4 est le chiffre suivant, et y prend la valeur 144224
      ---------------
       59 720 728 576

Performance[modifier | modifier le code]

À chaque itération, la tâche qui consomme le plus de temps est le choix de β. Ayant B valeurs possibles, il est possible de trouver β en effectuant O(\log(B)) comparaisons. Chacune exige d'évaluer (B y +\beta)^n - B^n y^n. À la ke itération, y possède k chiffres, et le polynôme peut être évalué en faisant 2 n - 4 multiplications d'au plus k(n-1) chiffres et n - 2 additions d'au plus k(n-1) chiffres, une fois connues les puissances de y et β jusqu'à n-1 pour y et n de β. Par ailleurs, les valeurs de β sont peu nombreuses, il est donc possible d'obtenir β dans un temps constant. Les puissances de y peuvent être calculées n-2 multiplications d'au plus k(n-1) chiffres. En faisant l'hypothèse qu'une multiplication de n chiffres prend O(n^2) et l'addition prend O(n), alors il en coûte O(k^2 n^2) à chaque comparaison, ou O(k^2 n^2 \log(B)), pour choisir β. La portion restante de l'algorithme demande des additions et des soustractions consommant O(k). Donc, chaque itération prend O(k^2 n^2 \log(B)). Pour k chiffres, il faut compter O(k^3 n^2 \log(B)).

La seule mémoire interne nécessaire est r, qui contient O(k) chiffres après la ke itération. Cet algorithme n'ayant pas de limite supérieure sur la mémoire impose une limite supérieure sur le nombre de chiffres que l'on peut calculer de tête, au contraire des algorithmes arithmétiques plus élémentaires. Malheureusement, n'importe quelle machine à états finis avec un intrant périodique ne peut que retourner un extrant périodique. Il n'existe donc pas d'algorithme capable de calculer un nombre irrationnel à partir d'un nombre rationnel. En conséquence, il n'existe pas d'algorithme capable de calculer une racine à l'intérieur d'une mémoire limitée.

Plus la base est grande, plus le temps pour choisir β est grand par un facteur O(log(B)), mais, en même temps, diminue le nombre de chiffres nécessaires pour atteindre la même précision par le même facteur. Puisque l'algorithme est proportionnel au cube du nombre de chiffres, augmenter la base augmente la vitesse d'exécution par le facteur O(\log^2(B)).

Cependant, lorsque la base est plus grande que le radicande, l'algorithme dégénère en une dichotomie. À ce moment, il est inutile puisque la dichotomie est plus efficace.

Exemples de calculs[modifier | modifier le code]

Racine carrée de 2 en binaire[modifier | modifier le code]

On a ici B = 2 et n = 2 donc (By+\beta)^n-(By)^n = 4y\beta+\beta^2. 4 se note 100 en base 2.

                     | 1. 0  1  1  0  1
10.00 00 00 00 00    |------------------   
 1                   | 1   y prend la valeur 1
 -----               |
 1 00                | 0 = 100*1*0 + 0^2
    0                | donc 0 est le deuxième chiffre et y = 10
 --------            |
 1 00 00             | 1001 = 100*10*1 + 1^2
   10 01             | donc 1 est le deuxième chiffre et y = 101
 -----------         |
    1 11 00          | 10101 = 100*101*1 + 1^2
    1 01 01          | donc 1 est le troisième chiffre et y = 1011
    ----------       |
       1 11 00       | 101100 = 100*1011*0 + 0^2
             0       | donc 0 est le chiffre suivant et y = 10110
       ----------    |
       1 11 00 00    | 1011001 = 100*10110*1 + 1^1
       1 01 10 01    | donc 1 est le chiffre suivant et y = 101101
       ----------
          1 01 11 reste

Racine carrée de 3[modifier | modifier le code]

On a ici B = 10 et n = 2 donc (By+\beta)^n-(By)^n = 20y\beta+\beta^2.

                      | 1. 7  3  2  0  5
3.00 00 00 00 00      |--------------------
1                     | 1    est le premier chiffre de y
-                     |
2 00                  | 189 = 20*1*7 + 7^2
1 89                  | donc 7 est le deuxième chiffre et y = 17
----                  |
  11 00               | 1 029 = 20*17*3 + 3^2
  10 29               | donc 3 est le troisième chiffre et y = 173
  -----               |
     71 00            | 6 924 = 20*173*2 + 2^2
     69 24            | donc 2 est le chiffre suivant et y = 1732
     -----            |
      1 76 00         | 0 = 20*1732*0 + 0^2
            0         | donc 0 est le chiffre suivant et y = 17320
      -------         |
      1 76 00 00      | 1 732 025 = 20*17320*5 + 5^2
      1 73 20 25      | donc y est le chiffre suivant et y = 173205
      ----------
         2 79 75

Racine cubique de 5[modifier | modifier le code]

Elle se traite comme la racine cubique de 3 vue plus haut.

                          |  1.  7   0   9   9   7
5.000 000 000 000 000     |------------------------
1                         | 1     est le premier chiffre de y
-                         |
4 000                     | 3 913 = 300*1^2*7 + 30*1*7^2 + 7^3
3 913                     | donc 7 est le deuxième chiffre et y = 17 
-----                     |
   87 000                 | 0 = 300*17^2*0 + 30*17*0^2 + 0^3
        0                 | donc 0 est le troisième chiffre et y = 170
  -------                 |
   87 000 000             | 78 443 829 = 300*170^2*9 + 30*170*9^2 + 9^3
   78 443 829             | donc 9 est le chiffre suivant et y = 1709
   ----------             |
    8 556 171 000         | 7 889 992 299 = 300*1709^2*9 + 30*1709*9^2 + 9^3
    7 889 992 299         | donc 9 est le chiffre suivant et y = 17099
    -------------         |
      666 178 701 000     | 614 014 317 973 = 300*17099^2*7 + 30*17099*7^2 + 7^3
      614 014 317 973     | donc 7 est le chiffre suivant et y = 170997
      ---------------
       52 164 383 027

Racine quatrième de 7[modifier | modifier le code]

On a cette fois B = 10 et n = 4 donc (By+\beta)^n-(By)^n = 4000y^3\beta+ 600y^2\beta^2 + 40y\beta^3 + \beta^4.


                             |  1.   6    2    6    5    7
7.0000 0000 0000 0000 0000   |-----------------------------
1                            | 1     est le premier chiffre de y
1                            |
-                            |
6 0000                       | 55 536 = 4000*1^3*6 + 600*1^2*6^2 + 40*1*6^3 + 6^4
5 5536                       | donc 6 est le deuxième chiffre de y, et y = 16
------                       |
  4464 0000                  | 33 387 536 = 4000*16^3*2 + 600*16^2*2^2 + 40*16*2^3 + 2^4
  3338 7536                  | donc 2 est le troisième chiffre de y, et y = 162
  ---------                  |
  1125 2464 0000             | 102 604 943 376 = 4000*162^3*6 + 600*162^2*6^2 + 40*162*6^3 + 6^4
  1026 0494 3376             | donc 6 est le chiffre suivant et y = 1626
  --------------             |
    99 1969 6624 0000        | 86 018 513 790 625 = 4000*1626^3*5 + 600*1626^2*(5^2) + 40*1626*5^3 + 5^4
    86 0185 1379 0625        | donc 5 est le chiffre suivant et y = 16265
    -----------------        |
    13 1784 5244 9375 0000   | 120 489 241 469 273 201 = 4000*16265^3*7 +600*16265^2*7^2 + 40*16265*7^3 + 7^4
    12 0489 2414 6927 3201   | donc 7 est le chiffre suivant et y = 162657
    ----------------------   |
     1 1295 2830 2447 6799   |

Notes et références[modifier | modifier le code]

(en) Cet article est partiellement ou en totalité issu de l’article de Wikipédia en anglais intitulé « Shifting nth root algorithm » (voir la liste des auteurs)

  1. Jean-Luc Chabert et al., Histoire d'algorithmes, Belin, 1993, p. 234.
  2. (en) Walter Eugene Clark, The Aryabhatiya of Aryabhata — An Ancient Indian Work on Mathematics and Astronomy, University of Chicago Press, 1930.

Article connexe[modifier | modifier le code]

Algorithme de calcul de la racine n-ième