pi
Algorithme du compte-gouttes
  robinet Formule d'Euler
Rappelons l'écriture de pi grâce à la formule d'Euler :
p1
Regardez ici les explications de cette jolie formule.
Sous forme développée cela s'écrit :
pi2
Ecrivons ceci en utilisant l'algorithme d'Horner qui utilise moins de multiplications.







p3







Cette écriture est à rapprocher de l'écriture décimale de pi :
p4

Dans notre base dix le pas 1/10 qui permet de passer aux différents digits de l'écriture est constant. Notons cette base
p5
En comparant avec la série d'Euler nous dirons que dans la base à pas variable
p6²
pi  s'écrit : [2,2,2,2,2,...] Le problème est de construire un algorithme qui opère le changement de base. C'est l'objet de l'algorithme du compte-gouttes. Initialement c'est A. Sale en 1968 qui a eu l'idée de ce procédé et l'a utilisé pour calculer e.

Le nombre de décimales

La série  p7 est obtenue en sommant la suite de terme général  p8 .

Les termes un sont tous positifs et sn converge vers pi/2 en croissant.
Le rapport de termes consécutifs est  un/un-1=n/(2n+1) est inférieur à 1/2. Donc on a :
p9

Par suite l'erreur commise en s'arrétant au terme de rang n est inférieure à : 1//2n .
Pour obtenir k décimales pour pi on doit majorer l'erreur par 10-k, soit : 2-n<10-k. Ceci impose n=k*ln(10)/ln(2) soit n>3,32*k.
Par exemple pour obtenir 14 chifres pour p il faut aller jusqu'a : n=3,32× 14 soit u47 , c'est à dire sommer 47 termes.
La convergence n'est pas trés rapide mais par contre l'algorithme est particulièrement simple. C'est là tout son intérêt.

 Changement de base

Avant d'expliquer l'algorithme du compte-goutte qui est un algorithme de changement de base spécial, décrivons l'algorithme du compte-goutte qui convertit un nombre écrit en base 3 en son écriture décimale. Ceci permettra de comprendre comment cela se passe pour pi.
Soit un base B, c'està dire un nombre entier. Un nombre x ayant une partie entière inérieure à B s'ècrit dans la base B de la manière suivante : 
p10





xi est un entier inférieur à B. C'est le ième caractère après la virgule de l'écriture de x dans la base B . Prenons x=3,1415 en base dix cela signifie bien évidemment :
p11
Soit alors x=0,10213 l'écriture en base 3 d'un nombre x.

p12
Nous allons multiplier x par 10 pour faire sortir son premier chiffre après la virgule en base 10.

p13
soit avec Horner :
p14
et faisons la division euclidienne de 10 par 3 : 10=3× 3+1, et remplaçons le derier 10 à droite par l'écriture obtenue.
p15
et faisons la division euclidienne de 23 par 3  ; 23=3× 7+2
p16
et faisons la division euclidienne de 7 par 3 7=3× 2+1
p17
et faisons la division euclidienne de 12 par 3 : 12=3× 4+0
p18

Nous obtenons 10x=4+r, soit  4 plus un reste r. r=(0,0121)3 ou encore
p19
r<1. Donc la partie entière de 10x est 4. Comme le reste est inférieur à 1 le premier chiffre après la virgule de x est 4. Il suffit de recommencer le processus précédent avec le reste r obtenu pour convertir ainsi x en base 10.
On peut faire les calculs à la main dans le tableau ci-dessous.
Voici la première étape.
A   1 1 1 1
B   3 3 3 3
x 0 1 0 2 1
× 10   10 0 20 10
retenue 4 2 7 3 0
somme   12 7 23 10
reste 0 0 1 2 1

Le procédé est le suivant:
1) Multiplier chaque caractère de l'écriture de x par la 10 et ajouter le résultat à la retenue. (La première retenue à droite est 0 )
2) Partant de la droite faire la division euclidienne de la somme obtenue par la base 3. Le reste est mis dans la colonne considérée et dans la ligne reste.
3) Le quotient est multiplié par le 1 de la ligne A puis il est mis dans la ligne retenue de la colonne précédente.
4) On recommence en se déplaçant d'un rang à gauche jusqu'à atteindre la première colonne. La retenue sortante est le digit à récupérer.
5) On recommence un nouveau tableau en remplaçant x par le reste obtenu.

Algorithme du compte goutte pour pi
D'après l'écriture de pi : [2,2,2,2...] dans la base variable p6 ,on va procéder de façon analogue : passer de son écriture dans la base p6 à son écriture en base 10. Voici le tableau représentant les calculs pour les premiers digits .

A pi r 1 2 3 4 5 6 7 8 9 10 11 12
B =   3 5 7 9 11 13 15 17 19 21 23 25
initiali   2 2 2 2 2 2 2 2 2 2 2 2 2
× 10   20 20 20 20 20 20 20 20 20 20 20 20 20
retenue   10 12 12 12 10 12 7 8 9 0 0 0 0
somme 3 30 32 32 32 30 32 27 28 29 20 20 20 20
reste   0 2 2 4 3 10 1 13 12 1 20 20 20
×10   0 20 20 40 30 100 10 130 120 10 200 200 200
retenue   13 20 33 40 65 48 98 88 72 150 132 96 0
somme 1 13 40 53 80 95 148 108 218 192 160 332 296 200
reste   3 1 3 3 5 5 4 8 5 8 17 20 0
× 10   30 10 30 30 50 50 40 80 50 80 170 200 0
retenue   11 24 30 40 40 42 63 64 90 120 88 0 0
somme 4 41 34 60 70 90 92 103 144 140 200 258 200 0
reste   1 1 0 0 0 4 12 9 4 10 6 16 0
× 10   10 10 0 0 0 40 120 90 40 100 60 160 0
retenue   4 2 9 24 55 84 63 48 72 60 66 0 0
somme 1 14 12 9 24 55 124 183 138 112 160 126 160 0
reste   4 0 4 3 1 3 1 3 10 8 0 22 0

Expliquons l'algorithme. On reconnaît aux deux premières lignes les numérateurs et dénominateurs des pas de la base à pas variable. A la troisième ligne , initialisation, on place l'écriture de pi ans cette base. On la multiplie par 10 pour obtenir 10pi dans la base à pas variable , mais dans cette base le digit correspondant ne doit pas dépasser le dénominateur : (le nombre écrit dans la ligne de B juste au dessus) . C'est la même situation que dans la base dix ou les chiffres sont de 0 à 9. Pour obtenir l'écriture normalisée dans la base à pas variable , nous devons donc faire la division euclidienne par le nombre correspondant de la ligne de B , ce qui donnera un quotient q qu'il faudra multiplier par le nombre de la ligne de A placé dans la colonne précédente et un reste que l'on conserve en le mettant dans la ligne reste. Expliquons en détail cette situation qui se produit pour la première fois (avec une retenue non nulle ) dans la colonne située à droite des caractères gras.
p20
on a par la division euclidienne de 20 par 19 : 20=1× 19+1 q=1, r=1. On doit donc effectuer :
p21
Le reste 1 est mis dans la ligne du reste juste en dessous , le quotient q=1 doit lui être multiplié par le 9 du  9/19.
Il joue le rôle d'une retenue. On le met donc dans la ligne retenue, située dans la colonne précédente . C'est le 9 en caractère gras ,la première retenue non nulle, située dans la ligne retenue du premier sous tableau , en partant de la droite et en se déplaçant vers la gauche bien entendu.
On procède donc de la droite vers la gauche de la manière suivante : (on prend comme exemple la colonne avec les caractères gras)
1) On remplit la ligne × 10 en multipliant la ligne précédente par 10.
2) On place dans la ligne somme la somme de la ligne × 10 avec la ligne retenue soit : 20+9=29
3) On effectue la division euclidienne de somme par le nombre situé dans la ligne B et la même colonne soit :29=17× 1+12
4) On place le reste 12 dans la ligne" reste" et dans la même colonne. Ensuite , on multiplie le quotient 1 par le nombre précédent de la ligne A et on met le résultat dans la ligne "retenue" précédente: 1× 8=8
5) On recommence le processus dans la nouvelle colonne et on progresse de la droite vers la gauche.
On obtient 30 comme dernière somme.
On obtient donc à la dernière ligne le développement de 10pi dans la base à pas variable :
p22
Autrement dit :
p23
Il est facile de voir que 10pi-30 est inférieur à 4,et que pi-3<0.4.  Donc 3 est la partie entière de l'écriture de pi en base 10.
On poursuit ce principe au tableau suivant. L'écriture de 10p dans la base à pas variable est remplaceé par celle 10(p -3) dans la nouvelle ligne × 10.
Le dernier r obtenu est 13 qui nous donne le premier chiffre de l'écriture décimale de pi.
Remarquons que notre majoration précédente suffit ici à le démontrer car le développement peut être majoré par 3+4 . Le problème se pose lorsque l'on a l'unité de r qui dépasse 6.
Nous verrons par la suite qu'effectivement, parfois on n'obtient pas le digit cherché. Des retenues ultérieures vont le modifier.
Nous allons faire un premier programme qui correspond point par point à ce calcul . Nous verrons alors qu'il se pose parfois le problème suivant :
La "décimale" qui sort en bout de colonne peut dépasser 10 et peut donc modifier la décimale précédente. Nous verrons ensuite comment résoudre cette question.

Programme compte-goutte imparfait

Voici le programme correspondant exactement à ce que l'on a fait à la main au dessus.( pour la ti92).PrgmLocal u,vClrIO10® a200® c 0® u:10® v1® b0® e newList(c)® fFor b,1,c2® f[b]EndForWhile c>02*c® g:0® d:c® bWhile b>0d+f[b]*a® dg-1® gmod(d,g)® f[b]int(d/g)® d:g-1® g:b-1® bIf b ¹ 0 Thend*b® dEndIfEndWhilec-4® cIf u+v=10 then
Output 0,0,string(e+int(d/a))&"."\\
Else\\
Output u,v,string(e+int(d/a))\\
EndIfv+10® vIf v>150 Then10® v10+u® uEndIfmod(d,a)® eEndWhileEndPrgm

Voici le résultat obtenu:
pi texas
On voit bien à la troisième ligne le digit 10 télescopé par le digit suivant. On aurait du obtenir:3,1415926535897932388462643383279502...

Problème de l'écriture en base variable.La représentation d'un nombre dans la base c=(1;1/3,2/5,3/7,4/9,...,n/2n+1,...) n'est pas unique. Par exemple :
2-2/3=4/3 est représenté par : (0;2,4,6,8,..,2n,..)-(0;2,0,0,0...). Donc 4/3 est représenté par (0;0,4,6,8,..,2n,..).
Par suite 2/3 est représenté par (0;0,2,3,4,...,n,..) , mais aussi par 0;2,0,0,0,...). Une conséquence de tout ceci est que la partie entière de y=(a0;a1,a2,...) est soit a0 soit a0+1 selon que le nombre (0;a1,a2,...)
est dans [0;1[ ou dans [1;2[.
Par suite dans notre algorithme du compte-gouttes le digit a0 obtenu en fin de boucle n'est pas obligatoirement celui de p. On va donc conserver ce digit en mémoire pour l'itération suivante et l'appeler prédigit afin de pouvoir l'augmenter.

  Problème de la retenue

Nous avons vu que la partie entière de (a0;a1,a2,a3,...) était a0 ou a0+1 selon que le nombre (0;a1,a2,...) est dans [0;1[ ou dans [1;2[. Le digit a0 sortant en fin d'itération n'est pas forcément le bon digit de pi. Il faudra peut être l'augmenter de 1. Nous l'appelons prédigit et le gardons temporairement en mémoire. Si à l'itération suivante nous obtenons une retenue de 1 nous l'augmentetrons de 1, mais s'il est 9 son augmentation de 1 va augmenter le digit précédent. Par suite les prédigits égaux à 9 doivent être gardés avec le prédigit qui les précèdent. Cela oblige à faire une queue de prédigits avec les 9 qui se suivent précédés d'un autre prédigit afin de pouvoir être occasionnellement augmentés. Si lors de la prochaine itération on obtient ni un 9 ni une retenue on pourra dire que ce sont les digits véritables de pi.

Algorithme du compte-gouttes

1) Initialisations : Soit A=(2;2,2,2...) un tableau de taille int(3,4n)=p , n étants le nombre de décimales de p que l'on désire.q=retenue =0.
2) Faire n fois la procédure suivante:
2,1) pour i=p jusqu'à 1 par pas de -1 faire:
x=10× A(i)+q ; A(i)=reste de la division euclidienne de x par (2i+1) ; q= quotient de la division euclidienne de x par (2i+1) ;
q=q× i c'est la nouvelle retenue mise un cran à gauche.
2,2) On sort ici de la boucle qui nous donne le prédigit.
Réduire la valeur A(1) du tableau modulo 10 (c'est la dernière valeur du tableau que l'on vient d'obtenir)
q=int(A(1)/10) : q est le nouveau prédigit; A(1)=reste de (A(1)/10) gardé dans le tableau.
2,3) traitement des prédigits :
Si q n'est ni 9 ni 10 l'ancien prédigit est bien le digit de p. Il est affiché.
Si q=9 mettre q dans la queue des prédigits.
Si q=10 le nouveau prédigit est 0. On augmente tous les anciens prédigits de 1, ils deviennent alors les véritable digits de p et sont affichés.

Programme simplifié


Nous allons calculer les caractères de pi en base 10000. Un caractère sera un entier de 4 chiffres allant de 0 à 9 puisque c'est un entier inférieur à 10000. Comme dans les 1000 premières décimales de pi on ne rencontre pas la suite "0000" qui pourrait venir de la queue des prédigits "9999" augmentée de 1, on peut simplifier l'algorithme en ne gardant qu'un caratère (mais en base 10000) en attente.
C'est le rôle de la mémoire tampon e.
Les digits sortiront 4 par 4 et la mémoire tampon sera constituée de 4 digits. Nous avons vu que pour obtenir n décimales on doit prendre n× 3,32 digits pour p dans la base variable. En prenant la base 10000 au lieu de la base 10 , cela revient à regrouper ces digits par 4. Autrement dit le programme affiche p blocks de 4 décimales tels que:
p × 4× 3.32=dimension du tableau. 4× 3,32> 14 . On décrémente donc la variable c qui calcule le nombre de sous tableaux de 14 à chaque sortie des 4 digits.
Programme compte-gouttes de calcul de pi pout ti92 pour 54 digits. On doit utiliser 54 fois 3,32 soit 180 caractères dans la base variable pour pi afin d'en recueillir 54 en base 10.
Le R dans un cercle signifie sto. Ainsi 10000® a signifie a=10000..
Prgm
ClrIO
newList(106)® f
10000® a:180® c:1® b:0® e
For b,1,c
int(a/5)® f[b]
EndFor
While c>0
2*c® g:0® d:c® b
While b>0
d+f[b]*a® d:g-1® g:mod(d,g)® f[b]
int(d/g)® d:g-1® g:b-1® b
If b¹ 0 Then
d*b® d
EndIf
EndWhile
c-14® c:string(e+int(d/a))® x:dim(x)® l
if u+v=4 then
output 0,0, left(x1)&".&right(x,3)
else
output u,v,left("0000",4-l)&x
endif
v+25 ® v
if v>150 then
0 ® v
10+u ® u
endif
mod(d,a)® e
EndWhile
endprgm
Voici ce que l'on obtient:
3.1415926535897932384626433832795022884197169399375105

Programme en C++
#include <stdio.h>
long a=10000,b,c=6000,d,e,f[6001],g;
int main()
{
while (b<c)
{
f[b]=2;b++;
}
while (c>0)
{g=2*c;d=0;b=c;
while (b>0)
{d=d+f[b]*a;g=g-1;f[b]=d%g;d=d/g;g=g-1;b=b-1;if (b!=0)d=d*b; }
c-=14;printf("%.4ld",e+d/a);e=d%a; }}
Voici les résultats obtenus

00031415926535897932384626433832795028841971693993751058209749445923078164062862 08998628034825342117067982148086513282306647093844609550582231725359408128481117 45028410270193852110555964462294895493038196442881097566593344612847564823378678 31652712019091456485669234603486104543266482133936072602491412737245870066063155 88174881520920962829254091715364367892590360011330530548820466521384146951941511 60943305727036575959195309218611738193261179310511854807446237996274956735188575 27248912279381830119491298336733624406566430860213949463952247371907021798609437 02770539217176293176752384674818467669405132000568127145263560827785771342757789 60917363717872146844090122495343014654958537105079227968925892354201995611212902 19608640344181598136297747713099605187072113499999983729780499510597317328160963 18595024459455346908302642522308253344685035261931188171010003137838752886587533 20838142061717766914730359825349042875546873115956286388235378759375195778185778 05321712268066130019278766111959092164201989380952572010654858632788659361533818 27968230301952035301852968995773622599413891249721775283479131515574857242454150 69595082953311686172785588907509838175463746493931925506040092770167113900984882 40128583616035637076601047101819429555961989467678374494482553797747268471040475 34646208046684259069491293313677028989152104752162056966024058038150193511253382 43003558764024749647326391419927260426992279678235478163600934172164121992458631 50302861829745557067498385054945885869269956909272107975093029553211653449872027 55960236480665499119881834797753566369807426542527862551818417574672890977772793 80008164706001614524919217321721477235014144197356854816136115735255213347574184 946843852332390739414333454776241686
 Voici pi dont l'écriture tombe au goutte à goutte.

pi au compte goutte

Cliquez ici pour écouter la partition de pi
partition de pi

Télécharger le programme povray correspondant.
La comptine "que j'aime à faire connaitre ce nombre utile aux sages. Immortel,Archimède, Artiste, Ingénieur, qui de ton jugement peut priser la valeur !" permet de retrouver les ciffres de l'écriture de pi. Le nombre de lettres composant chaque mot donne un chiffre de pi.
Pour l'inverse de pi on utilise la phrase : "Les trois journées de 1830 ont renversé 89": 1/pi=0,3183098.

Calcul de e avec l'algorithme du compte-gouttes

On peut utiliser le même principe pour calculer d'autres nombres remarquables . Soit par exemple le nombre e tel que ln(e)=1.
Le développemet e série de l'exponetielle est :
e1
avec l'écriture habituelle de ! qui se lit factorielle : 5!=1*2*3*4*5.
Donc le nombre se développe en :
e2
e s'écrit (2,1,1,1,1...) dans la base à pas variable (1/1,1/2,1/3,1/4,1/5...).
Le tableau ci-dessous nous montre comment le calculer.
A e 1 1 1 1 1 1 1 1 1 1
B   1 2 3 4 5 6 7 8 9 10
initiali   2 1 1 1 1 1 1 1 1 1
× 10   20 10 10 10 10 10 10 10 10 10
retenue   7 4 3 2 1 1 1 1 1 0
somme 2 27 14 13 12 11 11 11 11 11 10
reste   7 0 1 0 1 5 4 3 2 0

Calcul de e en C avec l'algorithme du compte-gouttes
#include <stdio.h>
long a=10000,b,c=1000,d,e,f[1000];
int main()
{
while (b<c)
{
f[b]=1000;b++;
}
f[1]=2000;

while (c>0)
{d=0;b=c;
while (b>0)
{d=d+f[b]*a;f[b]=d%b;d=d/b;b=b-1; }
c-=10;printf("%.4ld",e+d/a);e=d%a;
}
}

Résultats obtenus :
C:\PI>e
271828182845904523536028747135266249775724709369995957496696762772407663
945713821785251664274274663919320030599218174135966290435729003342952605
132328627943490763233829880753195251019011573834187930702154089149934884
476146066808226480016847741185374234544243710753907774499206955170276183
313845830007520449338265602976067371132007093287091274437470472306969772
e au compte gouttes

Cliquez ici pour écouter la partition.
partition de e

Téléchargez si vous le voulez le programme povray

Calcul du nombre d'or phi avec l'algorithme du compte-gouttes
Le nombre d'or phi s'écrit :
phi1
On connait le développement de (1-x)-n:

phi2
Ceci nous donne le développement de phi-1/2 en remplaçant x par 1/5 :
phi3
Avec la même convention que pour pi, cela s'exprime de la façon suivante :
phi-1/2 s'écrit [1,1,1,1,...] dans la base [1,1/10,3/20,5/30,7/40,...]. Donc phi s'écrit [1,6,1,1,1,...] dans la base
[1,1/10,3/20,5/30,7/40,...].
On en déduit le programme du calcul de phi.
Programme en C
#include <stdio.h>
#include <conio.h>
long a=10000,b,k,c=1000,d,e,f[1001],g;
int main()
{
while (b<c)
{
f[b]=1;b++;
}
f[1]=6;

while (c>0)
{d=0;k=c;
while (k>0)
{d=d+f[k]*a;g=10*k;b=2*k-1;f[k]=d%g ;d=d/g;
if (k!=0) d=d*b;
k=k-1;}
if (c==1000)
printf("1.");
else
printf("%.4ld",e+d/a);
e=d%a;c-=10;
}
getch();}
phi au comte gouttes

Cliquez ici pour écouter la partition
partition du nombre d'or

Téléchargez, si vous le désirez, le programme povray correspondant à l'image ci dessus.

La phrase suivante est un moyen mnémotechnique pour retrouver les décimales du nombre d'or. "O nombre d'élégance ! Toi,toi, toi, grandiose, donnant le nombre d'or."

Calul de la racine carrée de 2

Le développemet de racine(2) s'obtient en utilisant la formule de Taylor de (1-x)-0.5, pour x=1/2.
sqrt(2)1
Soit avec l'algorithme de Hôrner :
sqrt(2)2
Par conséquent on a :
sqrt(2)3
Autrement dit racine de 2 s'écrit [1,1,1,1,..] dans la base [1,1/4,3/8,5/12,...(2n-1)/(4n)]

D'où son écriture décimale infinie :
sqrt(2)
partition de sqrt(2)
Cliquer ici pour écouter racine de 2

Ci-joint le programme povray correspondant.

On fait de même pour avoir racine de 3 en prenant x=2/3.
racine de 3
Voici son programme povray de calcul.

Calcul de ln(2) au compte-gouttes.

Utilisons le développement en série de Taylor de -ln(1-x).taylorAvec x=1/2 on obtient :taylor2
En utilisant l'écriture de Hörner, on obtient :
ln(2)1
Autrement dit ln(2) a pour écriture [1,1,1,1,..] dans la base variable [1/2,1/(2x2),2/(3x2),3/(4x2),..k-1/(2k)]
Ceci nous permet d'avoir l'écriture décimale infinie de ln(2) par le compte-gouttes.
digits de ln(2)

Cliquez ici pour écouter la partition de ln(2)
partition de ln(2)


Regardez le programme povray correspondant.

Calcul de ln(3) au compte-gouttes.

Utilisons le développement en série de Taylor de -ln(1-x).
taylor
Avec x=2/3 on obtient :

ln(3)
Donc ln(3) s'écrit [1,1,1,1..] dans la base variable [2/3,2/(2x3),6/(4x3)...2x(k-1)/(3k)].
L'écriture décimale de ln(3) est alors :
ln(3)
partition de ln(3)

Cliquer ici pour écouter la partition.

Regardez le programme povray correspondant.


Calcul de ln(4) au compte-gouttes.
Utilisons le développement en série de Taylor de -ln(1-x).
taylor
Avec x=1/2 on obtient :
taylor2
En doublant, on obtient le résultat suivant.

ln(4)1
En utilisant l'écriture de Hörner, on obtient :

ln(4)2
ln(4) s'écrit [1,1,1,1,..] dans la base variable [1,1/(2x2),2/(3x2),3/(4x2),4/(5x2),...]

On trouve, par conséquent, le développement décimal infini de ln(4) par l'algorithme du compte-gouttes suivant :
écriture décimale de ln(4)
partition ln(4)
Cliquez ici pour écouter ln(4)

Calcul de pi/6 et pi en utilisant arcsin(x).

Le développement de Taylor de arcsin(x) est intéressant, car il permet une écriture récursive de pi/6 et donc de pi.
arcsin(x)

Ce qui nous donne [1,1,1,1,..]comme écriture de pi/6=arcsin(1/2) dans la base variable[1/2,(2!*x²)/(4*1²*3),(4*3*x²)/(4*2!²*5,(6*5*x²)/(4*3*7),...,(2*(2k-1)²*x²)/(4*k*(2k+1)).

Par suite pi s'écrit dans cette base variable :[6,6,6,...]. Ce calcul est meilleur que celui donné en début de page car le rapport de 2 termes consécutifs de la série
correspondante est inférieure à x²/(2n)<1/(8n). Pour obtenir k décimales il suffit d'aller jusqu'au terme k*1.9.
pi/6 pi

Téléchargez ici le programme correspondant.

Constante d'Euler

La constante d'Euler est la limite nommée gamma de la suite wn=1+1/2+1/3+1/4+....+1/n-ln(n) , lorsque  tend vers l'infini.
surface d'Euler

Wn est représenté par la surface rouge. En effet la somme des surfaces des rectangles
de base [i ; i+1] et de hauteurs 1/n est égale à lasétrie harmonique : 1+1/2+1/3+1/4+..
La surface située entre la courbe d'équation y=1/x   , l'axe des x, et les deux verticales  x=1   et x=n est ln(n), car la primitive de y=1/x  qui s'annule pour x=1 est ln(x).

La différence entre ces deux surfaces donne précisément la surface rouge. Cette surface infinie a une limite finie : la constante d'Euler gamma.
Euler
Euler

Cette convergence est très lente comme nous allons le voir.
Calculons w1024. Pour cela calculons avec lalgorithme du compte-gouttes H(1024)=1+1/2+1/3+..+1/1024. Cette série s'appelle série harmonique et on sait qu'elle croit indéfiniment jusqu'à l'infini.
Pour faire l'algorithme écrivons  wn avec Hörner : wn=1+1/2(1+2/3(1+3/4+....(1+1023/1024).
Alors wns'écrit [1,1,1,1   ,1,0000] dans la base variable [1,1/2,2/3,3/4,...,(k-1)/k..]
Regardez si vous le voulez le programme povray correspondant.
On obtient comme premières décimales  w1024 = 7,5091756722781 ... le dernier chiffre est déjà inexact.
On sait que ln(1024)=ln(210)=10ln(2). On a dejà calculé ln(2) par le compte gouttes. Il suffit de multiplier le résultat trouvé par 10 et de soutraire w1024-10ln(2)
ln(1024)=10ln(2)=6,931471805599...
On trouve alors l'approximation de gamma=0,57770386667786...Seuls les 3 chiffres après la virgule sont exacts. C'est décevant : Aller jusqu'à l'indice 1024 pour obtenir 4 chiffres c'est médiocre !
Gamma vaut en fait : gamma=0,577215664901532866065799...
Il faut utiliser d'autres écritures de gamma pour avoir une meilleure convergence.
Par exemple celle ci :
wn=[1+1/2+1/3+1/4+...+1/n-1/(n+1)-1/(n+2)-..-1/(n²+n)]-1/(6n²)-1/(6n3 ) . Les deux derniers termes sont pour amméliorer l'écriture précédente.

Avec cette écriture on obtient  w1000=0,577215664901. Tous les chiffres sont corrects. Regardez le programme trés simple correspondant.Ou encore celle la :
wn=1+1/2+1/3+1/4+....+1/n-ln(n+0,5)-1/(24*(n+0,5)²)+7/(960*(n+0,5)4)-31/(8064*(n+0,5)6)+127/(30720*(n+0,5)8 ) .
Avec cette écriture on obtient  w1000=0,5772156649015328660. Tous les chiffres sont corrects. Regardez le programme trés simple correspondant.

Calcul du carré de pi.

La somme des carrés des inverse des entiers converge (=tend vers) pi²/6.
pi²/6=1+1/2²+1/3²+1/4²+1/5² +....=1,6449340668482...
Comme cette convergence est trés lente, nous allons prendre une meilleure formule pour calculer pi² avec l'algorithme du compte gouttes.
picarré
Rappelons que 3!=3*2*1 , n!*(n-1)*(n-2)*..*3*2*1 , le "!"  se lit factorielle.
Ceci s'écrit avec la méthode de Hôrner de la façon suivante :
picarre1
Autrement dit  pi²/6 s'écrit  [3,3,3,3,..] dans la base variable [1/2, 1/(4*3), (2*2)/(6*5), (3*3)/(8*7),.., (k-1)²/(2k(k-1)),...].
Si on note un=(n-1)!²/(2n)! le nième de la série définissant pi²/18, le rapport un/un-1 est inférieur à 1/4. Pour avoir k chiffres exacts pour pi²/6 il faut aller jusqu'à n>k*ln(10)/ln(4), soit n>1.7*k.
On obtient donc avec l'algorithme du compte goutte les décimales ci-dessous.
picarré sur 6
y=1/x²
La somme des inverse des carrés des entiers est la somme des rectangles jaunes. Cette surface infinie a une aire infinie celle du rectangle dessinée au-dessus : pi²/6

Téléchargez ici le programme povray.

Par conséquent pi² s'écrit [18 , 18 , 18 , 18 , 18 ,..] dans la base  variable [1/2, 1/(4*3), (2*2)/(6*5), (3*3)/(8*7),.., (k-1)²/(2k(k-1)),...].
D'où les décimales de pi² par l'algorithme du compte-gouttes.

pi carré
partition de pi carré
Cliquer ici pour écouter pi²

Le paradoxe d'Achille et de la tortue.

Ce paradoxe a agité les philosophes de la Grèce antique.
Selon Zénon d'Elée, si on note l la distance qui sépare Achille de la tortue, Achille doit parcourir  l/2, puis encore la moitié de la distance restante soit l/4, puis encore la moitié de ce qui reste soit l/8...
Achile doit donc parcourir l/2+l/4+l/8+l/16+.... Il doit donc toujours parcourir un certaine distance, donc n'atteindra jamais la tortue!
En fait la série 1/2+1/4+1/8+1/16+...=1/2*1/(1-1/2)=1 converge et sera parcourue en un temps fini.
Si on utilise l'algorithme du compte gouttes pour calculer le developpement décimal du nombre 1=1/2+1/4+1/8+1/16+...=1/2*(1+1/2*(1+1/2*(1+1/2(...))), on obtient que 1 s'écrit [1,1,1,1,..] dans la base variable [1/2,1/2,1/2,1/2,..].
Avec cet algorithme on obtient 1=0,99999999.... C'est l'écriture impropre de1.