TD: Calcul de

1 Position du probl`
eme
On se propose detudier differentes methodes pour calculer les decimales du nombre .

1.1 Convergence dune suite

M
ethode dArchim`
ede
Le premier calcul mathematique de remonte `a Archim`ede de Syracuse (287-212 avant J.-C.). Celui-ci
reposait sur un encadrement du perim`etre du cercle par ceux de polygones reguliers inscrit et circonscrits. Soit
pn le perim`etre dun polygone regulier `
a n cotes inscrit dans un cercle de diam`etre unite et pn celui dun polygone
regulier `
a n c
otes circonscrit au meme cercle. En utilisant linegalite pn < < pn pour n = 6 2k , on peut
obtenir une approximation de avec:

1 1u2n
pn = n.un o`
u un = sin n , u6 = 12 et u2n =
2
et pn = n.un o`
u un = tan n , u6 =

1
3

et u2n = un

1u2n

Programmer le calcul de la suite un par une methode iterative et par une methode recursive. Pour evaluer
la vitesse de convergence de cette suite, tracer log( pn ) en fonction de n.
M
ethode de Monte-Carlo

Tirer au sort un couple (xi , yi ) de nombres compris entre 0 et 1. Evaluer

ri = x2i + yi2 . Si ri 1,
alors incrementer un compteur c. Reiterer le calcul pour un tr`es grand nombre n de couples {(xi , yi )}. Tracer
un = 4 c/n en fonction de n.

1.2 Convergence dune s

erie
S
erie Arctan
+

Dapr`es la formule de J. Gregory (1638-1675): Arctan x =

k=0

rang n, lerreur commise est inferieure ou de lordre de

|x|2n+3
2n+3 .
+

On en deduit la formule de Leibniz:

(1)k .x2k+1
. Lorsque lon arrete la serie au
2k + 1

= Arctan 1 =
k=0

(1)k
.
2k + 1

(1)k
Programmer le calcul de la serie Sn = 4
.
2k + 1
k=0
Pour evaluer la vitesse de convergence de cette suite, tracer log(| Sn |) en fonction de n.
Cette serie convergeant assez lentement (car x = 1), on peut - pour accelerer la convergence - utiliser
des combinaisons de fonctions Arctan x avec x
1. Programmer une serie utilisant la formule de Gauss:
1
1
1
= 48. Arctan 18
+ 32. Arctan 57
20. Arctan 239
S
erie de Ramanujan
Au debut du vingti`eme si`ecle, S. Ramanujan, mathematicien autodidacte indien, proposa la serie:

+
1
2. 2
(4k)!.(1103 + 26390.k)
.
=

9801
(n!)4 .3934n
k=0

ISEN-Brest. Kany.
Programmer le calcul de la serie Sn =

TD: Calcul de
9801

2. 2

k=0

(4k)!.(1103 + 26390.k)
(n!)4 .3934n

Cette serie converge tr`es vite: verifier quau bout de 2 termes, on a dej`a `a 8 decimales. Mais les termes

supplementaires ne permettent de gagner quune precision relativement faible. Evaluer

levolution de la precision
Pn = Sn en tracant log(|Pn+1 Pn |) en fonction de n.

2 Code avec Mathematica

Calcul de Pi
Archim`
ede
Methode par recurrence
In[1]:=U[n ] := If[n == 6, 1/2, Sqrt[(1 - Sqrt[1 - U[n/2]^2])/2]];
Archimede[n ] := n*U[n]; Erreur[n ] := N[Pi - Archimede[n], 100];
liste = Table[Log[10, Erreur[6*2^n]], {n, 0, 10}];
ListPlot[liste, PlotJoined -> False, PlotRange -> Automatic]
Out[1]=

Methode iterative
In[2]:=k = 6; u = 1/2; liste = Table[n, {n, 1, 10}]; For[n = 1, n <= 10, n++, k = 2*k;
u = Sqrt[(1 - Sqrt[1 - u^2])/2];
liste = ReplacePart[liste, N[Log[10, Pi - k*u], 100], n]]; ListPlot[liste]
Out[2]=

Monte-Carlo
In[3]:=SeedRandom[];

ISEN-Brest. Kany.

TD: Calcul de

In[4]:=TirageMax = 10000; inclus = 0; liste = Table[n, {n, 1, TirageMax}];

For[tirage = 1, tirage <= TirageMax, tirage++, If[Random[]^2 + Random[]^2 <= 1,
inclus++]; liste = ReplacePart[liste, N[4*inclus/tirage, 100], tirage]; ];
ListPlot[liste]
Out[4]=

In[5]:=Erreur = liste - N[Pi, 10]; ListPlot[Erreur]

Out[5]=

Arctan
In[6]:=SerieArcTan[x , n ] := Sum[(-1)^k*x^(2*k + 1)/(2*k + 1), {k, 0, n}];
In[7]:=Erreur[n ] := N[Abs[Pi - 4*SerieArcTan[1, n]], 10]
In[8]:=liste = Table[Log[10, Erreur[n]], {n, 1, 500}];
In[9]:=ListPlot[liste]
Out[9]=

In[10]:=$ MaxExtraPrecision = 500;

3

ISEN-Brest. Kany.

TD: Calcul de

In[11]:=Gauss[n ] := 48*SerieArcTan[1/18, n] + 32*SerieArcTan[1/57, n] 20*SerieArcTan[1/239, n]

In[12]:=Erreur[n ] := N[Abs[Pi - Gauss[n]], 500]
In[13]:=liste = Table[Log[10, Erreur[n]], {n, 1, 100}];
In[14]:=ListPlot[liste]
Out[14]=

Ramanujan
In[15]:=S[n ] := Sum[(4*k)!*(1103 + 26390*k)/(k!^4*393^(4*k)), {k, 0, n}];
In[16]:=Ramanujan[n ] := 9801/(2*Sqrt[2]*S[n]);
In[17]:=Erreur[n ] := N[Pi - Ramanujan[n], 1000]
In[18]:=liste = Table[Log[10, Erreur[n]], {n, 1, 25}];
In[19]:=ListPlot[liste]
Out[19]=

La serie converge donc tr`es vite puisque - au bout de 2 termes - on a dej`

a Pi `
a 8 decimales mais ensuite
on gagne une precision relativement faible. On va donc tracer levolution de la precision en echelle log.
In[20]:=liste2 = Table[Log[10, Erreur[i + 1] - Erreur[i]], {i, 1, 24}];
In[21]:=ListPlot[liste2, PlotJoined -> False, PlotRange -> Automatic]

ISEN-Brest. Kany.

TD: Calcul de

Out[21]=

3 Code avec Python

import
import
import
import
import

math
decimal #biblioth`
eque pour pouvoir faire des calculs pr
ecis
sympy
matplotlib.pyplot as plt
numpy as np

0
1
2
3
4
5
6
70

1
2
3
4
5
6
70

3.5

0.5

3.0

0.0

0.0
0.5

0.5

2.5

1.0

1.0

2.0

1.5
1.5
1.0

2.0

2.5

0.5
0.00

1.5

2.0

2.5

3.0
2000

4000

6000

8000

10000

20

40

60

80

100

3.50

2000

4000

6000

8000

0
50
100
150
200
250
3000

10000

3.00

100

200

300

400

500

ISEN-Brest. Kany.

TD: Calcul de

1.4 1e 8+6.58230055

0
50

1.2

100

1.0

150

0.8

200
0.6

250

0.4

300

0.2
0.00

350
10

20

30

40

50

4000

10

20

30

40

50