à simuler des expériences simples, à analyser les données simulées avec Python et à les visualiser à l’aide de graphiques en coordonnées.
EXEMPLE
Example 1: Simulation d’un dé
À l’aide de nombres aléatoires, tu simules le lancer d’un dé. La fonction randint(1, 6)randint(1, 6) du module random fournit des nombres aléatoires correspondant aux faces du dé (1, 2, …, 6).
Dans ce programme, 1000 lancers sont générés et les fréquences d’apparition des différentes valeurs sont enregistrées dans une liste p et représentées sous forme d’histogramme. p = [0] * 7 crée une liste contenant 7 zéros.
Expérimente avec différentes valeurs de n. Plus n est grand, plus la distribution des fréquences devrait être régulière.
Programme:
#Gp14.pyfrom gpanel import *
from random import randint
n = 1000
print("Anzahl Wuerfe = " + str(n))
makeGPanel(-1, 8, -2*n/100, n/4 + n/100)
drawGrid(0, 7, 0, n/4, 7, 10)p = [0] * 7repeat n:
a = randint(1, 6)if a == 1:
p[1] += 1
elif a == 2:
p[2] += 1
elif a == 3:
p[3] += 1
elif a == 4:
p[4] += 1
elif a == 5:
p[5] += 1
elif a == 6:
p[6] += 1
setColor("blue")
for i in range(1, 7):
fillRectangle(i-0.3 , 0, i + 0.3, p[i])
Example 2: Temps d’attente moyen dans un jeu de dé
Tu lances un dé et tu te demandes combien de lancers sont nécessaires en moyenne pour obtenir un certain nombre, par exemple un 6.
Si l’on suppose que chaque lancer prend le même temps, il s’agit d’un problème de temps d’attente moyen.
Au lieu d’utiliser une méthode mathématique, tu simules les lancers avec des nombres aléatoires 1, 2, 3, …, 6 et tu répètes l’expérience jusqu’à ce que le nombre 6 apparaisse.
Le nombre d’essais nécessaires est stocké dans la variable k.
Tu répètes cette expérience 10 000 fois et représentes les fréquences sous forme d’histogramme. En même temps, tu calcules la somme des valeurs de k afin de déterminer le temps d’attente moyen, affiché à la fin.
Pour mieux comprendre la simulation, commence par expérimenter avec de petites valeurs de n (par exemple n = 5, n = 10, n = 100).
Programme:
# Gp14a.pyfrom gpanel import *
from random import randint
n = 10000
def sim():
k = 1
r = randint(1, 6)
while r != 6:
r = randint(1, 6)
k += 1
return k
makeGPanel(-5, 55, -200, 2200)
drawGrid(0, 50, 0, 2000)
print("Waiting on a 6")
setColor("blue")
h = [0] * 51
lineWidth(5)
count = 0
repeat n:
k = sim()
print k
count += k
if k <= 50:
h[k] += 1
line(k, 0, k, h[k])
mean = count / n
print("Mean waiting time = " + str(mean))
Example 3: Calcul du nombre π avec la méthode de Monte-Carlo
Il s’agit d’un exemple classique de simulation informatique.
On lance un grand nombre n de points aléatoires dans un carré de côté 1. La proportion de points situés à l’intérieur du quart de cercle correspond approximativement à sa proportion de surface.
Si hits représente le nombre de points dans le quart de cercle, alors :
hits / n = surface du quart de cercle / surface du carré
Avec GPanel, tu peux résoudre le problème graphiquement et numériquement.
Pour générer les points aléatoires, tu utilises la fonction random(), qui fournit des nombres aléatoires entre 0 et 1.
Programme:
# Gp14b.pyfrom gpanel import *
from random import random
makeGPanel(-0.3, 1.3, -0.3, 1.3)
rectangle(0, 0, 1, 1)
arc(1, 0, 90)
hits = 0
n = input("Number of rain drops")
i = 0
while i < n:
x = random()
y = random()
if x*x + y*y < 1:
hits = hits + 1
setColor("red")
else:
setColor("green")
i = i + 1
point(x, y)
pi = 4 * hits / nprint("Result: pi = " + str(pi))
Example 4: Simulation d’un lancer vertical
Avec l’accélération a, la nouvelle vitesse pendant un petit intervalle de temps dt est vnouveau= v + a * dt et la nouvelle position :xnouveau = x + v * dt. Ici, l’accélération vaut a = -g. Le nouvel état est calculé toutes les 0,05 secondes.
Programme:
# Gp14c.pyfrom gpanel import *
import time
makeGPanel(-130, 130, -170, 70)
setColor("red")
enableRepaint(False)
g = 9.81
dt= 0.05
t = 0; y = 0
v = 25
while t < 10:
v = v - g * dt
y = y + v * dt
t = t + dt
drawGrid(-100, 100, -150, 50, "gray")
pos(0, y)
fillCircle(5)
repaint()
time.sleep(dt)
clear()
Pour les simulations, tu utilises des nombres aléatoires. La fonction random() du module random fournit des nombres aléatoires avec 12 décimales, compris entre 0 et 1. La fonction randint(a, b) fournit des nombres entiers aléatoires entre a et b (bornes incluses.
À FAIRE PAR TOI-MÊME
1)
Dans un jeu, on lance simultanément 3 dés.
Le joueur A gagne si au moins un 6 apparaît.
Le joueur B gagne si aucun 6 n’apparaît.
Qui a la meilleure probabilité de gagner si le jeu est répété un grand nombre de fois ?
2)
On se demande combien de lancers sont nécessaires en moyenne pour obtenir au moins une fois toutes les faces 1, 2, 3, 4, 5, 6.
Résous ce problème avec une simulation.
3)
Simule le lancer de deux pièces et représente les fréquences des événements suivants avec un histogramme :
-
deux fois pile
-
une fois pile et une fois face
-
deux fois face
4)
Dans l’exemple 4, on simule un lancer vertical.
De manière analogue, on peut aussi simuler un lancer oblique. Un corps est lancé avec un angle de 45° et une vitesse initiale de 32. Représente graphiquement sa trajectoire pendant 10 secondes. Pour utiliser les fonctions sin et cos, ajoute la ligne d’importation suivante : from math import sin, cos, pi
Tu peux utiliser l’exemple 4 comme modèle et remplacer les formules physiques par celles du lancer oblique
g = 9.81
dt = 0.05
v = 32
alpha = pi/4
t = 0; x = 0; y = 0
vx = v * math.cos(alpha)
vy = v * math.sin(alpha)
while t < 10:
vy = vy - g * dt
x = x + vx * dt
y = y + vy * dt
Remarque :
L’angle dans les fonctions sin() et cos() doit être donné en radians.
pi / 4 correspond à un angle de 45°.
Pour convertir des degrés en radians, tu peux utiliser la fonction radians(alpha), qu’il faut également importer.
