Page 1/2
π et la méthode de Monte-Carlo
Résumé
La méthode de Monte-Carlo consiste à calculer certaines valeurs, ici le nombre π, à l’aide de tirages au hasard. Ce
document présente la méthode appliquée à π, ainsi que le code source python permettant de calculer une estimation
de π et de tracer le graphique correspondant.
La méthode de Monte-Carlo appliquée à π
Prenons un cercle inscrit dans un carré de côté 2r. La surface du cercle est πr2, celle du carré est 4r2.
D’où,
.
Tirons deux nombres x et y au hasard entre -1 et +1 et vérifions
1
si le point (x, y) est ou non à l’intérieur du cercle.
Répétons l’opération un grand nombre de fois.
.
Cette méthode est en réalité très peu efficace. Le nombre de décimales exactes obtenu n’augmente pas forcément avec
le nombre de tirages.
Nb de tirages
10
100
1 000
10 000
100 000
Estimation de
3,6
3,2
3,164
3,154
3,14136
1
Pour un cercle de rayon r centré sur (0, 0), si la puissance du point par rapport au cercle P = x2 + y2 – r2 est positive, le point est à
l’extérieur du cercle.
Page 2/2
Code python
'''
Méthode de Monte-Carlo appliquée au calcul de pi
'''
from math import pi, sin, cos
import random as rd
from matplotlib import pyplot as plt, mathtext
from decimal import Decimal as D, getcontext()
#garantit la répétabilité des tirages
rd.seed(4224821)
#fonction lambda pour calcul de la puissance du point / cercle
puiss = lambda x, y, r : x*x + y*y - r*r
#trace le cercle de rayon 2
x0 = list()
y0 = list()
pas = 2 * pi / 400
delta = 0.
for k in range(401):
x0.append(2*cos(delta))
y0.append(2*sin(delta))
delta += pas
plt.scatter(0., 0., c='k', marker="o", linewidths=2)
plt.plot(x0, y0, color="k", lw=2)
#demande le nombre de points à traiter : nb
nb = 0
while nb <= 0:
txt = input("Saisir le nombre d'itérations : ")
if txt.isdigit():
nb = int(txt)
else:
nb = 0
#on tire nb points au hasard et on calcule combien sont à l'intérieur
#les points à l’intérieur sont rouges, les points à l'extérieur sont bleus
nb_inside = 0
pimc = 0.
for i in range(nb + 1):
x = D(rd.uniform(-2., 2.))
y = D(rd.uniform(-2., 2.))
if puiss(x, y, 2) < 0: #puissance négative : point à l’intérieur
nb_inside += 1
color = "r"
else:
color = "b"
plt.scatter(x, y, c=color, marker="o", linewidths=2)
#calcul de la valeur approchée de pi
#le rapport nb_inside / nb est approximativement égal à pi/4
pimc = D(4 * nb_inside) / D(nb) #valeur approchée de pi
print(f'Valeur approchée de pi : {pimc}')
plt.axis('scaled')
plt.title('Méthode de Monte-Carlo', pad=15.)
plt.gca().xaxis.set_ticks(range(-2, 3))
plt.gca().yaxis.set_ticks(range(-2, 3))
plt.xlim(-2., 2.)
plt.ylim(-2., 2.)
plt.figtext(0.22,0.01,
str(nb) + " points : " + r'$\pi \approx $' + str(pimc),
color="k",
size="large")
plt.show()
### fin du programme ###
1
/
2
100%
