CPGE BCPST 2

Année Académique: 2023 - 2024

Travaux Pratiques N°1

Méthodes numériques et statistiques: Simulation de variables aléatoires
Anicet E. T. Ebou

I. Simulation d’une v.a.r. suivant une loi quelconque

I.1. Méthode d’inversion de la fonction de répartition
La méthode d’inversion de la fonction de répartition a été proposée par Von Neumann en 1947. On
rappelle un résultat du cours de probabilité:

Proposition 1: Si F est la fonction de répartition d’une v.a.r. X, c’est-à-dire F (t) = P (X ≤ t) pour

t ∈ R, alors en définissant son inverse généralisée F −1 (u) = inf {t|F (t) ≥ u}, si U suit la loi uniforme
sur [0,1], F −1 (U ) a même loi que X.

Si on peut calculer F −1 , on peut donc simuler X à partir de U .

I.2. Loi géométrique

I.2.1. Simulation à l’aide de la fonction random

Exercice 1: Simulation de la loi géométrique avec random

A partir de la simulation de la loi de Bernoulli, écire une fonction geom(p) qui simule une variable
aléatoire G(p).

Note: Si X ,→ G(p), on sait que X représente le rang du premier succès dans un schéma de Bernoulli,
donc on peut modéliser un résultat aléatoire suivant une loi géométrique en répétant une évaluation selon
une loi de Bernoulli de paramètre p jusqu’à obtenir un premier succès : c’est à dire la valeur 1 avec
probabilité p.
Remarque: La fonction np.random.geometric(p) fournit le même résultat.

I.2.2. Simulation à partir de l’inverse de la fonction de répartition

Pour la loi géométrique, pour une v.a.r. X, q = 1 − p et on a F (x) = 1 − q x pour x > 0, d’où
ln(1 − u)
F − 1(u) = .
ln(1 − p)
Exercice 2: Simulation de la loi géométrique

Ecrire une fonction geoinv(p) qui permet de simuler la loi géométrique.

I.2.3. Diagrammes en bâtons

Exercice 3: Diagrammes en bâtons - loi géométrique

Ecrire un programme permettant de visualiser les données obtenues des deux fonctions de simula-
tions de la loi géométrique et comparer à chaque fois avec l’allure de la fonction de masse de la loi
géométrique.

1
 I.3 Loi de Poisson
I.3.1. Simulation à l’aide de la fonction random
La loi de Poisson P(λ) est plus difficile à modéliser à partir de sa situation d’application. Par contre
on peut la modéliser grâce à sa fonction de répartition F (x).
En effet ∀n ∈ X(Ω) = N , on a P (X = n) = P (X ∈]n − 1, n]) = P (X ≤ n) − P (x ≤ n − 1) =
FX (n) − FX (n − 1), c’est donc la probabilité qu’une évaluation de la fonction ‘random‘ tombe dans
l’intervalle [FX (n − 1), FX (n)[⊂ [0, 1[.
Donc pour modéliser un résultat qui suit une loi de Poisson, il suffit de choisir un nombre p aléatoirement
avec la fonction random(), puis il reste à déterminer pour quelle valeur de n, p est dans l’intervalle
[FX (n − 1), FX (n)[.
Xn
Pour cela, il suffit de calculer successivement pour n = 0, n = 1, n = 2, ...FX (n) = P (X = k) =
k=0
n
X λk
e−λ jusqu’à ce que l’ont ait FX (n) ≥ p.
k!
k=0
Le premier entier n tel que FX (n) ≥ p sera bel et bien un résultat d’une évaluation suivant une loi de
Poisson.

Exercice 4: Simulation de la loi de Poisson

Ecrire une fonction poisson(mu) qui simule une variable aléatoire de loi P(µ).

Remarque: la fonction ‘numpy.random.poisson‘ conduit au même résultat.

I.3.2. Diagrammes en bâtons

Exercice 5: Diagrammes en bâtons - loi de Poisson

Ecrire un programme permettant de visualiser les données obtenues des simulations et comparer
avec avec l’allure de la fonction de masse de la loi de Poisson.

I.3.3 Approximation de la loi de Poisson

On peut aussi approximer la loi de Poisson en utilisant la loi binomiale. En effet on sait que si
X ,→ B(n, np ) alors sa loi se rapproche d’une variable Y ,→ P(p).

Exercice 6: Approximation de la loi de Poisson

Ecrire un code Python permettant de visualiser les données obtenues des simulations et comparer
avec l’allure de la densité de probabilité de la loi normale.

I.4. Loi exponentielle

I.4.1. Simulation à partir de l’inverse de la fonction de répartition
1
Pour la loi Exp(λ), on a F (x) = 1 − e−λx pour x > 0, d’où F −1 (u) = − ln(1 − u).
λ
Exercice 7: Simulation de la loi de exponentielle

Ecrire une fonction expo(lambda) qui simule une v.a.r. suivant la loi exponentielle de paramètre
lambda.

Remarque: la fonction numpy.random.exponential conduit au même résultat.

2
 I.4.2 Histogramme et densité de probabilité

Exercice 8: Diagrammes en bâtons - loi exponentielle

Ecrire un programme permettant de visualiser les données obtenues des simulations et comparer
avec l’allure de la densité de probabilité de la loi exponentielle.

I.5 Loi normale

I.5.1 Simulation à partir de la fonction random
Il est possible de générer une variable aléatoire gausienne directement à l’aide de la transformation de
Box-Muller. Elle s’appuie sur le résultat suivant.
Proposition 2: Soient X et Y deux variables aléatoires gausiennes centrées réduites indépendantes.
Définissons (R, θ) les coordonnées polaires de (X, Y ): X = Rcos(θ), Y = Rsin(θ) avec R ≥ 0 et θ ∈
[0, 2π]. Alors R2 et θ sont deux variables aléatoires indépendantes, la première est de loi Exp( 12 ), la
seconde de loi uniforme sur [0, 2π].
Pour simuler une p variable X aléatoire de N(0, 1), il suffit donc de prendre U, V ∼ U([0, ]) indépendantes
et poser X = −2ln(U )cos(2πV ). Pour simuler une variable X de loi N(µ, σ ), il suffit de prendre
2

X = µ + σY avec Y ∼ N(0, 1).

Exercice 9: Simulation de la loi normale

Ecrire une fonction normale(mu, sigma) qui simule une v.a.r. suivant la loi normale de paramètre
mu et sigma.

Remarque: la fonction numpy.random.normal conduit au même résultat.

I.5.2 Histogramme et densité de probabilité

Exercice 10: Diagrammes en bâtons - loi normale

Ecrire un code Python permettant de visualiser les données obtenues des simulations et comparer
avec l’allure de la densité de probabilité de la loi normale.

II. Illustration numérique de convergence en lois

II.1. Loi faible des grands nombres
Pour illustrer la loi des grands nombres, on peut créer un très grand échantillon de N réalisation d’une
variable aléatoire comme précédemment et afficher la variation de l’espérance estimée sur les k premières
valeurs de l’échantillon quand k augmente.
On peut ainsi à partir des fonctions de simulation de v.a.r réalisées dans les paragraphes précédents,
visualiser l’évolution de la moyenne empirique des réalisations des lois précédentes.

Exercice 11: Visualisation de loi

Complétez le code suivant en utilisant une simulation de la loi géométrique et ensuite une de la loi
normale:

3
from matplotlib import pyplot as plt

def s i m u l a t i o n _ g r a n d _ n o m b r e _ Y (n , N ):
L = ...
# Cette variable servira à calculer la somme
# cumul é e des valeurs de l ’é chantillon
val = 0
xbar = []
f o r i i n range ( N ):
val += L [ i ]
# On enregistre dans xbar la moyenne des i premieres
# valeurs de l ’ echantillon
xbar . append ( val /( i + 1))
return xbar

n = 10
N = 100000
T = [ i + 1 f o r i i n range ( N )]
x = s i m u l a t i o n _ g r a n d _ n o m b r e _ Y (n , N )
plt . plot (T , X )
plt . show ()

On peut aussi mettre sur la même figure la simulation et l’espérance de la loi.

Exercice 12: Visualisation de loi

Afin d’illustrer la Loi des Grands Nombres, visualisons la suite Sn = X1 + X2 + X3 + ... + Xn pour
Xi une suite de variables aléatoires indépendantes de loi uniforme sur [-1, 1].

from matplotlib import pyplot as plt

import numpy as np

n = 1000
x = 2 * np . random . rand ( n ) - 1
s = ...
plt . plot ( range (1 , n +1) , s , ’r ’ , label = ’ simulation ’)
plt . plot ((1 , n ) , (0 , 0) , ’b - - ’ , label = ’ espereance ’)
plt . xlabel ( ’n ’)
plt . legend ( loc = ’ best ’)
plt . title ( ’ loi ␣ faible ␣ des ␣ grands ␣ nombres ’)
plt . show ()

II.2. Théorème centrale limite

Le théorème central limite établit la convergence en loi de la somme d’une suite de variables aléatoires
(indépendantes, et identiquements distribuées) vers la loi normale.
Nous pouvons visualiser cela en utilisant une suite de v.a.r suivant une loi de Poisson et vérifier sa
convergence en loi vers la loi normale.

4
 Exercice 13: Visualisation de loi
Complétez le code suivant:

import numpy as np
import matplotlib . pyplot as plt

# Param è tres pour la distribution

poisson_lambda = 5
normal_mean = 0
normal_std = 1
num_samples = 1000

# G é n é rer les donn é es

poisson_data = ...
normal_data = ...

# Cr é ation des sous figures

fig , axes = plt . subplots ( nrows =1 , ncols =2 , figsize =(10 , 5))

# Plot Poisson histogram

axes [0]. hist (... , bins =20 , color = ’ blue ’ , alpha =0.7)
axes [0]. set_title ( ’ Distribution ␣ de ␣ Poisson ’)
axes [0]. set_xlabel ( ’ Valeur ’)
axes [0]. set_ylabel ( ’ Fr é quence ’)

# Plot Normal histogram

axes [1]. hist (... , bins =20 , color = ’ orange ’ , alpha =0.7)
axes [1]. set_title ( ’ Distribution ␣ normale ’)
axes [1]. set_xlabel ( ’ Valeur ’)
axes [1]. set_ylabel ( ’ Fr é quence ’)

# Ajuster le layout
plt . tight_layout ()

# Affichage de la figure
plt . show ()