Simulation de variables aléatoires, loi des grands nombres

École Polytechnique
Année 2
Mathématiques Appliquées
TP1
MAP441 – Modal SNA
Florent Benaych-Georges
Stefano De Marco
Stéphane Gaiffas
Emmanuel Gobet
Christelle Vergé
Simulation de variables aléatoires, loi des grands nombres, théorème central limite
1. Préambule
Dans le cadre de ce Modal nous utiliserons le langage python. Nous ferons appel intensivement aux librairies
numpy, scipy et matplotlib. Il s’agit de libraries permettant de faire très simplement du calcul matriciel, du
calcul scientifique, de la simulation, et des représentations graphiques. La syntaxe de ces librairies est similaire
à celle de Matlab. Nous les utiliserons pour faire du calcul numérique, en évitant quand cela est possible de faire
des boucles.
En appendice de ce document est donné un exemple de programme Python. Un coup d’oeil à ce programme
permettra un bon départ. Les élèves non encore familiers avec Python pourront (sans y passer trop de temps)
télécharger les programmes et "jouer avec" (les exécuter, puis changer certains paramètres pour voir l’effet
sur l’exécution). Les fichiers de ces programmes sont disponibles (comme le seront, tout au long du cours, les
corrigés des TP), à l’adresse http://www.cmap.polytechnique.fr/~gaiffas/teaching_X.html. Un tutoriel
plus détaillé que ce qui est décrit dans cet énoncé de TP est disponible à l’adresse
http://www.cmap.polytechnique.fr/~gaiffas/intro_python.html
Un fichier de script (ou fichier de module) en python est un fichier texte avec l’extension .py. On s’interdira
l’utilisation de caractères accentués dans un script python. Nous écrirons un script par question dans
les corrections.
1.1. Import de fonction, utilisation de librairies. Il y a un très grand nombre de librairires python, et ces
librairies contiennent beaucoup de fonctions. Pour pouvoir utiliser une fonction ou une classe dans une librairie,
il est nécessaire de l’importer dans chaque script avant de s’en servir, de préférence en début de script, mais
ça n’est pas obligatoire. Il y a plusieurs manières d’importer des fonctions en python. Dans l’exemple qui suit,
nous chargeons et utilisons la fonction randn qui permet de simuler une matrice avec des entrées gaussiennes
i.i.d. Nous le faisons de cinq façons différentes, mais la fonction randn importée est à chaque fois exactement la
même.
# Methode 1
from numpy.random import randn
X = randn(3, 3)
# Methode 2
import numpy
X = numpy.random.randn(3, 3)
# Methode 3 : on cree un alias de numpy.random que l’on appelle npr
import numpy.random as npr
X = npr.randn(3, 3)
# Methode 4 : on importe toute les fonction de numpy.random
from numpy.random import *
X = randn(3, 3)
# Methode 5 : on importe les fonctions les plus utilisees de numpy, scipy, matplotlib
from pylab import *
X = randn(3, 3)
# Pour importer plusieurs fonction d’une meme librairie
from numpy import ones, zeros, empty
La librairie pylab utilisée dans la cinquième méthode permet d’importer de façon concise toutes les fonctions les
plus courantes des librairies numpy, scipy et matplotlib. C’est cette méthode que nous utiliserons dans les TP.
Tous vos scripts devront donc commencer par la commande : from pylab import *
Il y aura quelques cas exceptionnels, où nous aurons besoin, dans un même script, de deux fonctions qui portent
le même nom mais qui sont différentes. Dans l’exemple suivant, nous utilisons deux fonctions s’appelant toutes
1
2
les deux poisson. La première fonction est dans numpy.random et permet de simuler des variables de loi de
Poisson, alors que la deuxième est dans scipy.stats et permet d’obtenir la valeur de la densité de probabilité
de la loi de Poisson.
from pylab import *
import numpy.random as npr
import scipy.stats as sps
mu = 0.5
n = 1000
m = 20
X = npr.poisson(mu, n) # Simulation de variables de loi de Poisson d’intensite mu
x = arange(m+1) # x contient le vecteur d’entiers [0, 1, 2, ..., m]
f = sps.poisson.pmf(x, mu) # Densite de probabilite de la loi de Poisson d’intensite mu aux points x
1.2. Remarques fondamentales sur python. Nous listons ici quelques remarques fondamentales sur python,
qui vont vous éviter de faire les erreurs les plus habituelles, et vous faire gagner du temps.
• Par défaut, les objects en python ne sont pas copiés. Considérons l’exemple suivant
x = [4, 2, 10, 9, "toto"]
y = x # y est juste une reference au tableau x, pas de copie effectuee ici
y[2] = "tintin"
print x # Cela affiche [4, 2, "tintin", 9, "toto"]
x = [4, 2, 10, 9, "toto"]
y = x[:] # On demande une copie
y[2] = "tintin"
print x # Cela affiche [4, 2, 10, 9, "toto"]
• L’indexation des tableaux commence a zéro : si x = [4, 3, 12] alors x[1] vaut 3.
• La division est entière (dans python2). En effet la division 1 / 2 est une division entière, et vaut donc
0, alors que 1. / 2 ou 1 / 2. donne bien 0.5
• L’échange de deux variables a et b peut se faire en une ligne, sans variable intermédiaire : a, b = b, a
• L’indentation est fondamentale en python. Voici un exemple.
def fib(n):
"""Fonction qui calcule le n-ieme element de la suite de Fibonacci"""
a, b = 0, 1
for i in range(n):
a, b = b, a + b
return a
print fib(10) # donne 55
Tout le contenu de la fonction fib est indenté d’une tabulation. Tout le contenu de la boucle for
est également indenté d’une tabulation (donc deux en tout). La ligne return a n’est pas dans la boucle
for, donc est indenté d’une tabulation en moins. La ligne print fib(10) est en dehors de la définition
de la fonction fib.
• L’élevation à la puissance : x ** 2 calcule le carré du nombre x. Encore une fois, attention à la division
entière : 1000 ** (3/2) vaut 1. alors que 1000 ** (3/2.) vaut 464.158883361
• La boucle for : si on veut faire varier un indice i entre 0 et 10 (compris) on écrit for i in range(11):
Si on veut faire varier un indice i entre 2 et 7 (compris) on écrit for i in range(2, 8):
• On peut itérer sur beaucoup de types d’objets python (on les appelle des iterable), par exemple :
X = [10., [1, 2, 3], "Bonjour", 4]
for x in X:
print x
# affiche successivement 10 puis [1, 2, 3] puis Bonjour puis 4
• Déclaration d’une fonction. La déclaration d’une fonction python se fait avec le mot-clé def. On doit
déclarer en premier les paramètres sans valeurs par défaut, puis ceux avec une valeur par défauts. Les
paramètres avec une valeur par défaut sont nommés. On peut alors se servir du nom des paramètres
dans l’appel à la fonction. C’est plus clair sur un exemple :
def f(tata, toto=2, tintin=4):
print tata, toto, tintin
3
f(3) # affiche 3 2 4
f(3, 5, 12) # affiche 3 5 12
f(3, tintin=5, toto=12) # affiche 3 12 5
1.3. Calcul matriciel, la librarie numpy. Donnons un premier exemple de calcul numérique avec numpy.
Imaginons que l’on cherche une valeur approchée de la probabilité que le sinus d’une v.a. gaussienne standard
soit < 1/2. On peut procéder comme cela :
from pylab import *
n = 1000
X = randn(n)
p = mean(sin(X) < 0.5)
print "Proba que sin(X) < 0.5 quand X est de loi N(0, 1)=", p
Quelques remarques fondamentales sur numpy:
• Le premier élément d’un tableau numpy est indexé par 0. Si x = array([4, 1, 2]) alors x[0] contient
4.
• Si x est un tableau numpy, alors y = x ne fait pas une copie de x dans y (x et y sont deux noms pour le
même object). Pour avoir une copie, il faut utiliser y = x.copy(). Si on a deux tableaux numpy x et y
de même taille, alors y[:] = x copie le contenu de x dans y (pas de création mémoire).
• arange(5) donne le tableau d’entiers [0, 1, 2, 3, 4]
• Les valeurs dans un tableau numpy sont typées (int, float, double, etc.) et ont le même type (ce qui
n’est pas le cas d’un tableau python). La plupart des fonctions de numpy ont un argument optionnel
appelé dtype. Par exemple zeros((2, 3), dtype=int) donne une matrice de taille 2×3 à valeurs entières,
alors que zeros((2, 3), dtype=double) donne une matrice à valeurs réelles (double précision). Le type
de valeurs dans un tableau numpy peut être très important, comme illustré dans l’exemple suivant.
from pylab import *
n = 4
x = arange(n) # x contient [0, 1, 2, 3]
y = x / 4
# y contient [0, 0, 0, 0], car c’est une division entiere
y = x / 4.
# y contient [ 0. 0.25 0.5 0.75]
x = array(x, dtype=double)
y = x / 4
# y contient [ 0. 0.25 0.5 0.75]
•
•
•
•
•
•
•
Si x est un tableau numpy alors x.shape donne sa dimension
ones((3, 4)) donne une matrice de taille 3 × 4 qui ne contient que des 1 (par defaut réels)
zeros((3, 4)) donne une matrice de taille 3 × 4 qui ne contient que des 0 (par defaut réels)
eye(4) donne la matrice identité de taille 4 × 4 (qui contient par defaut des valeurs réelles)
ones(X.shape) donne une matrice de même taille que X qui ne contient que des 1.
X.T est la matrice transposee de X
Les opérations +, -, *, /, **, +=, *=, /=, -=, etc. sont programmées de façon à être appliquées terme
à terme aux tableaux numpy. Par exemple, si A et B sont des matrices de même taille, alors A * B calcule
la matrice qui contient les produits terme à terme des matrices A et B. Pour calculer le produit matriciel
entre A et B on utilise dot(A, B).
• La plupart des fonctions mathématiques classiques sont programmées de façon matricielle. Si X est une
matrice (ou vecteur) numpy, alors exp(X), sin(X), etc. correspondent aux applications des fonctions exp,
sin, etc. à chaque terme de X. De même, pour x un scalaire, X + x correspond à l’addition de x terme
à terme dans X.
• Pour X matrice et a un scalaire, X < a est la matrice de même taille que X où les entrées sont remplacées
par des booléens True (=vrai) et des False (=faux) selon qu’elles soient ou non < a. Cela se généralise
à des opérations à valeurs booléennes plus compliquées (encadrements, ...) et permet souvent d’éviter
le recours à des boucles et/ou des tests.
from pylab import *
x = array([4, 2, 1, 5, 1, 10])
logical_and(x >= 3, x <= 9, x != 1) # vaut [ True False False True False False]
Les fonctions logical_and, logical_or, logical_not, logical_xor sont disponibles pour appliquer des
opérations logiques termes à terme des tableaux numpy
4
• Il y a de nombreux générateurs de nombres aléatoires dans numpy.random : randn génère des gaussiennes
et rand des lois uniformes sur [0, 1]. Toutes les lois classiques sont disponibles, cf http://docs.scipy.
org/doc/numpy/reference/routines.random.html
• On peut construire une matrice par blocs, à partir de sous-matrices. Voici un exemple.
from pylab import *
A = array([[2, 1, 1], [4, 3, 0]])
B = array([[1, 2], [12, 0]])
C = array([[1, 2], [12, 0], [-1, 2]])
D = array([[1, 2, -4], [2, 0, 0], [1, 2, 3]])
print bmat([[A, B], [C, D]])
# affiche la matrice
# [[ 2 1 1 1 2]
# [ 4 3 0 12 0]
# [ 1 2 1 2 -4]
# [12 0 2 0 0]
# [-1 2 1 2 3]]
• Beaucoup de fonctions de numpy ont un argument nommé axis. Par exemple sum(X, axis=1) calcule la
somme de chaque ligne de X, cumsum(X, axis=0) calcule la somme cumulée des colonnes de X.
1.4. Commandes principales de matplotlib.
• plot(x, y) affiche la courbe affine par morceaux reliant les points d’abscisses x et d’ordonnée y
• hist trace un histogramme. Il faut spécifier l’option normed=True pour afficher l’histogramme normalisé
(d’aire égale à 1).
• bar trace un diagramme en bâton
• scatter(x, y) affiche le nuage de points d’abscisses x et d’ordonnée y
• stem(x, y) affiche des barres verticales en position x et de hauteur y
• show() affiche les fenêtres créées dans le script
• figure crée une nouvelle fenêtre graphique
• title donne un titre à une figure
• legend() affiche la légende d’un graphique
• subplot subdivise la fenêtre graphique de façon à y afficher plusieurs graphiques dans la même figure
2. Simulation de variables aléatoires discrètes
2.1. Un exemple simple de loi discrète. On considère la loi P sur l’ensemble {1, 2, 3} donnée par les
probabilités P ({1}) = 0.3, P ({2}) = 0.6, P ({3}) = 0.1. Simulez un grand nombre de v.a. i.i.d. de loi P , en
faire l’histogramme à l’aide des fonctions bincount et bar et comparer le résultat obtenu avec la représentation
en bâtons, sur le même graphique, de la loi P (que l’on obtient à l’aide de la fonction stem).
2.2. Les lois discrètes classiques.
(1) On considère B(n, p) la loi binomiale de paramètres n, p. Ecrire une procédure dans laquelle on simule
un grand nombre de v.a. de loi B(n, p) (avec la fonction binomial de numpy.random), faire l’histogramme
de l’échantillon obtenu et comparer avec la représentation en bâtons, sur le même graphique, de la loi
B(n, p) (que l’on obtient à l’aide de la fonction binom.pmf de scipy.stats).
(2) Faire de même avec une loi de Poisson (on utilisera la fonction poisson de numpy.random et la fonction
poisson.pmf de scipy.stats).
(3) Un calcul simple montre que lorsque n tend vers l’infini, la loi B(n, λ/n) tend vers la loi de Poisson de
paramètre λ. En pratique, on assimile B(n, p) à la loi de Poisson de paramètre np dès que np2 < 0.1.
Illustrer cette proximité de lois en affichant, sur le même graphique, leurs histogrammes en bâtons (sans
faire aucune simulation).
3. Simulation de variables aléatoires continues (1)
(1) Simuler un grand nombre de variables aléatoires gaussiennes standard, représenter l’histogramme associé
et comparer à la densité gaussienne. Faire de même avec des variables aléatoires de loi gamma. On
utilisera les fonctions randn, linspace, hist, plot et la fonction norm.pdf de la librairie scipy.stats
(2) Un des programmes donnés dans le tutoriel joint illustre la propriété d’absence de mémoire de la loi
exponentielle : si X suit une telle loi, alors pour tout t > 0, la loi de X − t sachant X > t est la loi de
X. Charger ce programme, l’exécuter, et faire la même expérience en remplaçant la loi exponentielle
par des (autres) lois gamma. A-t-on encore absence de mémoire ? On utilisera la fonction gamma de
numpy.random et la fonction gamma.pdf de scipy.stats
5
4. Programmation matricielle
4.1. Motivation. En python, la programmation matricielle proposée dans numpy est plus rapide que celle reposant
Pn 1 sur des boucles. Le programme suivant compare le calcul d’une valeur approchée du nombre γ ≈
i=1 i − ln(n) pour n 1 en programmation matricielle et via une boucle. Le récupérer à l’adresse http:
//www.cmapx.polytechnique.fr/~benaych/MODAL_MAP441/ et le faire tourner. Quel est le facteur de temps
de calcul entre les deux méthodes ?
from pylab import *
from time import time
n = 1000000
# Methode 1. Boucle for
print "-" * 40
print "Methode 1. Boucle
print "-" * 40
t1 = time()
x = 0
for i in range(1, n):
x += 1. / i
print "gamma=", sum(x) t2 = time()
print "Cela a pris ", t2
# Methode 2. Numpy
print "-" * 40
print "Methode 2. Numpy"
t1 = time()
print "gamma=", sum(1. /
t2 = time()
print "Cela a pris ", t2
print "-" * 40
for"
log(n)
- t1, " secondes"
arange(1, n)) - log(n)
- t1, " secondes"
4.2. Chacune des deux questions suivantes est à traiter sans boucle. On essayera de ne pas passer trop de
temps sur ces questions (notamment, les probabilités seront estimées sans intervalle de confiance).
(1) Soit, pour N = 100, X(1) < · · · < X(N ) le réordonnement croissant d’une famille X1 , . . . , XN de v.a.
i.i.d. de loi gaussienne standard. Estimer la probabilité que cos(X(b0.8N c) ) < 0.6. On pourra simuler
M × N v.a. gaussiennes, utiliser la fonction sort(., axis=1) puis utiliser le fait que si V est une matrice,
pour tout j, V[:, j] désigne la jème colonne de V (la première est la colonne numéro 0).
(2) Soit (Xi )i≥1 des v.a. i.i.d. de loi uniforme sur [0, 1]. Estimer n0 , la plus petite valeur de l’entier n telle
que
P[X1 + · · · + Xn < 5] ≤ 0.2
L’inégalité de Markov nous permet d’affirmer que n0 ≤ 20. On pourra donc simuler M × 20 v.a., utiliser
les fonctions cumsum(., axis=1) et sum(., axis=0), ainsi que la fonction argwhere.
5. Simulation de variables aléatoires continues (2) : inversion de la fonction de répartition
a
La loi de Cauchy de paramètre a est la loi de densité fa (x) = π1 x2 +a
2 sur R. Simuler un grand nombre de
variables aléatoires de loi de Cauchy de paramètre a, représenter l’histogramme associé et le comparer à la
densité. Que se passe-t-il lorsque a s’approche de 0 ?
Rappel : On rappelle que si U est une v.a. uniforme sur ]0, 1[ et F la fonction de répartition d’une loi µ, alors
F −1 (U ) est distribuée selon µ.
6. Loi des grands nombres
On rappelle que si (Xn ) est une suite de variables aléatoires indepéndantes identiquement distribuées et ayant
une espérance m, alors la suite de variables aléatoires
X1 + · · · + Xn
n
converge presque sûrement vers m lorsque n tend vers l’infini. Simuler un grand nombre N de variables aléatoires
de loi uniforme sur [0, 1], tracer sur un même graphe la représentation de la suite X̄n pour n variant de 1 à N et
la courbe d’équation y = m, et observer cette convergence. On pourra utiliser la fonction axhline(y) qui trace
une droite horizontale à la hauteur y.
X̄n =
6
7. Théorème central limite
7.1. Le théorème. On rappelle que si (Xn ) est une suite de variables aléatoires indepéndantes identiquement
distribuées et de carré intégrable, d’espérance et écart-type communs notés respectivement m et s, alors en
définissant
X1 + · · · + Xn
,
X̄n =
n
la suite
√
n(X̄n − m)/s
converge en loi vers la loi gaussienne standard lorsque n tend vers l’infini.
√ √
(1) Lorsque la loi des Xi est√la loi uniforme sur [− 3, 3], que valent m et s ? Visualiser, pour n 1,
la proximité de la loi de n(X̄n − m)/s avec la loi gaussienne
√ standard (à l’aide d’un histogramme, en
simulant un grand nombre de réalisations indépendantes de n(X̄n − m)/s).
(2) Afin d’illustrer la différence de nature profonde entre la√convergence presque sûre et la convergence en
loi, tracer la représentation d’une réalisation de la suite n(X̄n − m)/s, pour n variant de 1 à N . Cette
suite semble-t-elle converger ?
7.2. Intervalles de confiance. Le théorème central limite explique que pour n assez grand, X̄
√n − m est
approximativement distribuée comme une variable aléatoire normale standard multipliée par s/ n. Ainsi,
puisque pour G une variable aléatoire normale standard, on a
P[−1.96 ≤ G ≤ 1.96] = 0.95,
on sait que pour n assez grand, on a approximativement
h
1.96s
1.96s i
P X̄n − √ ≤ m ≤ X̄n + √
≈ 0.95.
n
n
On dit alors que l’intervalle
h
1.96s
1.96s i
X̄n − √ , X̄n + √
n
n
est un intervalle de confiance au niveau 95% pour m, c’est à dire qu’avec une probabilité 0.95, le paramètre
m sera bien entre les bornes (aléatoires) de cet intervalle. Bien souvent, l’écart-type s n’est pas plus connu que
l’espérance m. On peut alors le remplacer par son estimateur
n
1 X
1/2
(Xi − X̄n )2
sb =
.
n − 1 i=1
On suppose encore que les Xi sont des v.a. i.i.d. de loi uniforme sur [0, 1]. Afin d’illustrer clairement la notion
d’intervalle de confiance à 95%, fixer des valeurs élevées pour n et M , simuler M fois X̄n , et vérifier que dans
√
√ .
95% des cas, m se situe bien entre X̄n − 1.96ŝ
et X̄n + 1.96ŝ
n
n
8. Calcul de probabilités d’événements rares : approximation gaussienne vs poissonienne
Soient X1 , X2 , · · · des v.a. i.i.d. de loi de Bernoulli de paramètre p et Sn = X1 + · · · + Xn . Par ce qui
précède, pour de grandes valeurs de n, la loi de Sn peut être approximée par une loi de Poisson ou par une loi
gaussienne, selon que p soit faible ou pas. Illustrer ces deux paradigmes en affichant, sur une même figure, les
histogrammes en bâtons de la loi de Sn et de la loi de Poisson correspondante, ainsi que la densité de la loi
gaussienne correspondante.
9. Application du TCL : intervalles de confiance pour la méthode de Monte-Carlo
(1) On veut calculer l’intégrale,
par rapport à la mesure de Lebesgue sur [0, 1]10 , de la fonction f (x) =
p
2
2
2
π (x1 + · · · + x10 ) x1 + · · · + x210 . Soit I cette intégrale.
(a) Peut-on espérer résoudre ce problème avec des sommes de Riemann, comme on le fait pour les
intégrales de fonctions suffisamment régulières sur R ?
(b) Donner, en utilisant les fonctions mean(., axis=1) (moyenne des lignes), norm(., axis=1) (norme
euclidienne des lignes) et std (ecart-type), des valeurs approchées de l’espérance et la variance de
f (U ), avec U variable aléatoire de loi uniforme sur [0, 1]10 . En déduire un intervalle de confiance
à 95% pour I. Donner une estimation du nombre de simulations nécessaires pour que l’intervalle
de confiance ait une amplitude au plus égale à 2% de I.
(2) Calculer la probabilité (dont on donnera une estimation avec un intervalle de confiance) qu’un vecteur
aléatoire gaussien centré de taille 9 et de matrice de covariance diag([1, 2, 3, 4, 5, 4, 3, 2, 1]) + M , avec
1
M=
10(i + j) 1≤i,j≤9
7
se trouve dans l’hypercube [−5, 3]9 . L’amplitude de l’intervalle pourra atteindre 4% de la probabilité
estimée. On pourra utiliser la fonction multivariate_normal pour simuler des vecteurs gaussiens.
(3) Soit d un entier positif (on le fixera par exemple à 10). Pour x = (x1 , · · · , xd ) un vecteur réel, on appelle
record de x tout indice i dans 1, · · · , d tel que xi = max(x1 , · · · , xi ). On considère ici le cas où x est
un vecteur aléatoire à coordonnées indépendantes uniformes sur [0, 1].
(a) Donner, en appliquant la même méthode que au dessus, le nombre moyen d’indices i dans {2, · · · , d}
tels que i et i − 1 sont tous les deux des records. L’amplitude de l’intervalle pourra atteindre 4%
du nombre estimé. On pourra par exemple utiliser la fonction maximum.accumulate(., axis=1) qui
permet de calculer le maximum cumulé des lignes d’un tableau.
(b) Donner la loi du nombre d’indices i dans {2, · · · , d} tels que i et i − 1 sont tous les deux des records
(en affichant l’histogramme).
(c) Essayer de faire la même chose avec un vecteur aléatoire x dont les coordonnées ne sont pas des
v.a. i.i.d. (par exemple un vecteur gaussien d’espérance et de matrice de covariance non standard).
10. Simulation de variables aléatoires continues (3) : méthode de rejet
√
1
4 − x2 . Simuler un grand nombre de variables
La loi de Wigner est la loi de support [−2, 2] et de densité 2π
aléatoires de loi de Wigner, représenter l’histogramme associé et le comparer à la densité.
Rappel : Pour simuler une v.a. de densité f de support [a, b] et telle que 0 ≤ f ≤ M , on utilise une suite
(Un , Vn )n≥1 de couples indépendants de variables aléatoires telles que pour tout n, Un , Vn sont indépendantes et
de lois uniformes sur respectivement [a, b], [0, M ], on pose
τ = min{n ≥ 1 ; Vn ≤ f (Un )},
et la variable aléatoire Uτ suit alors la loi de densité f . C’est la méthode de simulation par rejet. Notons que
plus M est petit, plus cette méthode est rapide, on a donc intérêt à choisir M = kf k∞ .
11. Appendice : syntaxe standard d’un script Python
Voici un exemple de script python
from pylab import *
import scipy.stats as sps
# Nombre de simulation
n = 1000
# Dimension
d = 2
m = zeros(d)
cov = array([[2., 1.], [1., 2.]])
X = multivariate_normal(m, cov, size=n)
figure()
scat = scatter(X[:, 0], X[:, 1], label="1000 simulations d’un vecteur gaussien en dimension 2")
legend()
y
#
x
s
= 2 * X[:, 0] - 3 * X[:, 1]
Calcul de l’ecart-type de 2 * X - 3 * X
= array([2., -3.])
= sqrt(dot(dot(x.T, cov), x))
figure()
hist(y, normed=True, label="Histogramme de 2 * X_1 - 3 * X_2", bins=15)
x = linspace(min(y), max(y), 100)
f_x = sps.norm.pdf(x, loc=0., scale=s)
plot(x, f_x, "r", label="Densite theorique de 2 * X_1 - 3 * X_2")
legend()
show()