simulation de lois - webhost.hec.frwebhost.hec.fr/stoltz/seances/f3/f3-polycopie.pdf · christine...

Christine HEINEMANNECE 2 - Lycee Henri IV - Paris

Formation en ligne a Scilab - Seance enregistree le 11 mars 2014 a HEC Paris

SIMULATION DE LOIS

- SOMMAIRE -

PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPRESENTATIONS SCILAB 1

Quelques remarques generales 1rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2Quelques remarques sur la definition des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 2Quelques remarques sur la definition des vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . 3tabul, bar, plot2d3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3histplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3Trace des fonctions de repartition empiriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Exemple 1 : loi binomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4Exemple 2 : loi normale centree reduite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Simulations classiques 6Loi uniforme discrete sur [[n1, n2]] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Avec plot2d3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Avec bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Loi uniforme sur [a, b[ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Application aux 〈〈douze uniformes 〉〉 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Principe et code associe - comparaison avec grand . . . . . . . . . . . . . . . . . . . . . . . . . 9Comparaison avec Box-Muller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Loi binomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12Illustration du Theoreme Limite Central . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Loi de Poisson via grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Illustration du Theoreme Limite Central . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Loi geometrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Loi binomiale negative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

LA METHODE D’INVERSION 19

Variables discretes 19Variables aleatoires finies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Loi de Bernoulli de parametre p ∈]0, 1[ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Loi binomiale de parametres (n, p), p ∈]0, 1[ et n ∈ N . . . . . . . . . . . . . . . . . . . . . . . 19Comparaison en termes de temps de calcul avec l’algorithme ESSEC 2006 E3 . . . . . . . . . . . 21

Variables aleatoires discretes infinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Loi geometrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23Loi de Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Variables a densite 25Loi exponentielle de parametre λ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Application a la simulation d’une loi geometrique . . . . . . . . . . . . . . . . . . . . . . . . . 26Application a la simulation d’une loi de Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Loi de Laplace (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Loi logistique (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Loi de Pareto (generale) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Loi de Cauchy (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Mise en evidence de la non existence de l’esperance . . . . . . . . . . . . . . . . . . . . . . . . 31

LA METHODE DU REJET 32

Introduction : simulation d’une loi uniforme sur le disque unite 32

Cas d’une densite a support compact et majoree 34Exemple : loi beta de parametres (a, b) ∈ [1,+∞[2 via la methode du rejet . . . . . . . . . . . . 34Quelques autres methodes de simulation de la loi beta . . . . . . . . . . . . . . . . . . . . . . . 36

Via l’algorithme de Jonk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36Via les statistiques d’ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37Via un resultat de convergence - ESSEC 2004 E3 . . . . . . . . . . . . . . . . . . . . . . . . . 38

Extension aux densites a support non compact 39Application a la simulation de la loi normale via la loi de Laplace . . . . . . . . . . . . . . . . . 39Application a la simulation des lois Gamma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Application : loi du χ2 a n degres de liberte via differentes methodes . . . . . . . . . . . . . . . 41

Par la methode du rejet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Par la loi normale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Par un resultat de convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Formation en ligne a Scilab - HEC Paris 11 mars 2014

SIMULATION DE LOIS

I - PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPRESENTATIONS SCILAB

A. Quelques remarques generales

1) rand

rand() est l’equivalent de random en Turbo-Pascal.Il est possible de reinitialiser l’etat interne du generateur aleatoire (specifie par un entier de l’intervalle[0, 231 − 1])) ; s=rand("seed") renvoie la valeur courante de la graine.

A graine fixee, rand() fournira toujours la meme serie de valeurs : essayer par exemple avec

Code Scilab :

N=20

A=zeros(N,5)

rand("seed",0)

for i=1:N A(i,:)=rand(5); end

disp(A)

Cela peut etre utile dans le but de pouvoir obtenir des simulations reproductibles (par defaut la graineest initialisee a s=0 au premier appel, la sequence sera toujours la meme d’une session a l’autre)Si l’on souhaite des sequences moins previsibles, on peut initialiser la graine avec getdate, qui renvoiela date en secondes ecoulees depuis le 1er Janvier 1970 - et change donc toutes les secondes

Code Scilab :

s=getdate("s")

rand("seed",s)

disp(rand())

(on constate que si on va tres vite, les valeurs de rand() ne changent pas...)

Code Scilab :

for i=1:5

s=getdate("s")

rand("seed",s)

disp(rand())

end

:::::::::Quelques

::::::::options :

r=rand(n1,n2,..,nk) renvoie une matrice aleatoire de dimensions n1 × n2 × ... × nk. En particulier,

r=rand(n1,n2) renvoie une matrice aleatoire de dimensions n1 × n2. Pour un vecteur, il faut specifier

ligne ou colonne : r=rand(1,n2) ou r=rand(n1,1) ( r=rand(A) renvoie une matrice aleatoire de meme taille

que la matrice A donc si on entre r=rand(n1) on obtient exactement le meme resultat que r=rand() ...)

rand("uniform") : la loi par defaut est la loi uniforme sur [0, 1].

rand("normal") : la loi par defaut est la loi normale centree reduite.

1/43


Le generateur de nombres aleatoires 〈〈uniform 〉〉 est de type Urand (Universal Random Number Generator).

C’est un generateur lineaire a congruence de la forme x = (ax+ c) mod M avec

a = 843314861

c = 453816693

M = 231.

Le generateur de nombres aleatoires 〈〈normal 〉〉 est obtenu par la methode de Box-Muller (la source denombres uniformes etant toujours Urand).

2) grand

La fonction grand dispose de generateurs aleatoires produisant des sequences de nombres qui possedentde meilleures qualites statistiques que rand. Par consequent, dans les situations ou la qualite statistiquedes sequences de nombres aleatoires est importante, il vaut mieux utiliser la fonction grand. Cettefonction dispose par ailleurs de fonctionnalites tres variees dont voici les plus classiques (les instructionsci-dessous renvoient une matrice de taille N ×M de valeurs obtenues selon la loi choisie) :

X=grand(N,M,"uin",n1,n2) simule une variable aleatoire suivant la loi uniforme sur [[n1, n2]] ;

X=grand(N,M,"bin",n,p) simule une variable aleatoire suivant la binomiale de parametres (n, p) ;

X=grand(N,M,"nbn",r,p) simule une variable aleatoire suivant la binomiale negative de parametres (r, p) ;

X=grand(N,M,"geom",p) simule une variable aleatoire suivant la loi geometrique de parametre p ;

X=grand(N,M,"poi",lambda) simule une variable aleatoire suivant la loi Poisson de parametre λ ;

X=grand(N,M,"def") simule une variable aleatoire suivant la loi uniforme sur [0, 1[ ;

X=grand(N,M,"unf",a,b) simule une variable aleatoire suivant la loi uniforme sur [a, b[ ;

X=grand(N,M,"exp",1/lambda) simule une variable aleatoire suivant la exponentielle de parametre λ ;

X=grand(N,M,"gam",nu,1/b) simule une variable aleatoire suivant la loi gamma de parametres (b, ν) ;

X=grand(N,M,"bet",a,b) simule une variable aleatoire suivant la loi beta de parametres (a, b) ;

X=grand(N,M,"nor",m,sigma) simule une variable aleatoire suivant la loi normale de parametres (m,σ2).

X=grand(N,M,"chi",n) simule une variable aleatoire suivant la loi du chi-2 a n degres de liberte ;

• Pour initialiser la graine avec getdate :

Code Scilab :

s=getdate("s");

grand("setsd",s)

• A noter aussi : X=grand(n,"prm",U) genere n permutations aleatoires d’un vecteur colonne U . Exemple :

Code Scilab :

U=[1:10]’

X=grand(5,"prm",U)

disp(X)

3) Quelques remarques sur la definition des fonctions

On utilisera ici soit deff(’...’,’...’) soit function... endfunction, avec des operations pointees.Pour plus d’options, voir le document pdf d’Herve Chabert (seance E2) p9.

2/43


4) Quelques remarques sur la definition des vecteurs

• Pour des vecteurs espaces regulierement : x=1:n ou x=[1:n] (avec n ∈ N∗) cree le vecteur ligne(1, 2, ..., n) (c’est ce dont on se sert dans les boucles for). Pour un vecteur colonne, il faudra ecrirex=[1:n]’. Remarque : si a est un reel, x=1:a sort le vecteur ligne (1, ..., bac) si a ≥ 1 (et le vecteur ligne〈〈vide 〉〉 si a < 1). Si on souhaite des espacements non entiers : x=1:eps:n ou eps designe le pas (il n’estpas necessaire que cela 〈〈 tombe juste 〉〉 : par exemple, x=1:0.3:2 donnera le vecteur (1, 1.3, 1.6, 1.9). Celapeut aussi servir a obtenir des vecteurs a composantes decroissantes : par exemple, x=n:-1:1 donnera levecteur (n, n− 1, ..., 1) et x=1:-0.25:0 le vecteur (1, 0.75, 0.5, 0.25, 0)...

• Autre option : linspace. Par defaut, le nombre de valeurs est 100. Par exemple, x=linspace(1,1.99)creera un vecteur x de composantes 1, 1.01, 1.02,...,1.99. Sinon, on peut preciser (en dernier argument) lenombre de composantes de x : par exemple, x=linspace(1,2,5) creera le vecteur (1, 1.25, 1.5, 1.75, 2).Pour obtenir des vecteurs colonnes, il suffit de rajouter un 〈〈prime 〉〉 derriere la parenthese. Cela marcheaussi pour des decomposantes decroissantes : x=linspace(1,-1,3) creera le vecteur (1, 0,−1).

• La premiere methode cree ainsi des vecteurs correspondant a des classes de largeur fixee ; leur nombredependra des valeurs minimale et maximale du vecteur, et il est possible que la valeur maximale ne soitpas atteinte (si cela ne tombe pas juste). La seconde methode cree des vecteurs a nombre de classesfixe. Ces classes seront toutes d’une meme largeur, determinee par les valeurs minimale et maximale duvecteur, qui correspondront respectivement a la premiere et a la derniere composante du vecteur.

5) tabul, bar, plot2d3

• si x est un vecteur ou une matrice, tabul(x) est une matrice a deux colonnes, la premiere contenant lesvaleurs prises par les composantes de x rangees dans l’ordre decroissant (ordre par defaut) et la secondecolonne contenant le nombre d’occurrences de chaque valeur ; tabul(x, "i") est construit sur le memeprincipe, mais avec les valeurs rangees dans l’ordre croissant (i pour increase).

• Pour obtenir un diagramme en batons, il suffit d’ecrire le code y = tabul(x,"i"); puis bar(y(:,1), y(:,2)/N);

ou plot2d3(y(:,1), y(:,2)/N); (ou N est le nombre de composantes de x : N=length(x) ).

→ bar trace un diagramme en batons de largeur par defaut 0, 8 (1 etant la 〈〈 largeur maximale autorisee 〉〉,i.e. la distance minimale entre deux valeurs reportees dans l’histogramme). On peut changer cette largeuren rajoutant width=.... On peut egalement changer la couleur (avec color et non style ici).

→ plot2d3 fonctionne comme plot2d (memes possibilites d’options) mais trace les courbes avec desbarres verticales.

6) histplot

On suppose les donnees regroupees dans un vecteur (ou une matrice) y.

• Deux options principales : histplot(x,y) et histplot(n,y) (n ∈ N∗).histplot(x,y) : x est un vecteur aux composantes strictement croissantes definissant les classes.

histplot(n,y) : n designe le nombre de classes. Les classes sont equireparties entre a = min(y) etb = max(y), ce qui reviendrait a ecrire histplot(x,y) avec x le vecteur a n+ 1 composantes defini par

pour tout k ∈ [[1, n + 1]], x(k) = a + (k − 1)

(b− an

)(les vecteurs et matrices en Scilab commencent

toujours a 1). La premiere classe est alors [x(1), x(2)] et les suivantes ]x(i), x(i+ 1)] (i ∈ [[2, n]]).

• On peut rajouter des options de couleur, trace, normalisation, etc. (les memes que pour plot2d).Par exemple, histplot(x,y,style=5,rect=[-1,0,1,2],normalization=%f) renverra un histogramme trace en

rouge (style 5), la zone de trace etant le rectangle [−1, 1]× [0, 2], et les valeurs etant non normalisees.

• Par defaut, les histogrammes sont normalises (inutile, donc, d’ecrire normalization=%t), c’est-a-dire, siN est le nombre de composantes de y (i.e. le nombre total de donnees), n est le nombre de classes, et pourtout i ∈ [[1, n]], Ni est le nombre de donnees appartenant a la classe Ci, la valeur de l’ordonnee correspon-

dant a la classe Ci seraNi

N(x(i+ 1)− x(i)), de maniere a ce que l’aire de l’histogramme correspondant

a Ci soit egale aNi

N, et donc que l’aire totale soit egale a 1.

3/43


7) Trace des fonctions de repartition empiriques

Voici un code simple permettant de tracer la fonction de repartition empirique correspondant a unechantillon u de donnees :

Code Scilab :

function Fr_empirique(u)

L = length(u)

x = gsort(u,’g’,’i’)

y = (1:L) /L

plot2d2(x, y,style=5, leg="Fonction de repartition empirique")

endfunction

length(u) donne la 〈〈 longueur 〉〉 de u, c’est-a-dire son nombre de composantes.

gsort avec l’option ’i’ (il est alors obligatoire de preciser aussi en seconde position l’option ’g’ qui estsinon par defaut) trie les valeurs de u (via l’algorithme 〈〈quick sort 〉〉) par ordre croissant.

a) Exemple 1 : loi binomiale :

Code Scilab :

clf;//pour "nettoyer" la fenetre des figures

clc;//pour "nettoyer" la console Scilab

N = 10000; n=10,p=0.2

u = grand(N,1,"bin",n,p);


L = length(u)


y = (1:L) /L

plot2d2(x, y,style=5,rect=[-0.5,0,n,1], leg="Fonction de repartition empirique")

endfunction

Fr_empirique(u);

a=get("current_axes") ; //pour regler les options des axes

a.font_size=1; //taille de la legende sur les axes

a.x_location="bottom"; //position de l’axe des abscisses

a.y_location="origin";//position de l’axe des ordonnees

4/43


b) Exemple 2 : loi normale centree reduite :

Code Scilab :

clc;clf;

N = 100;

u = grand(N,1,"nor",0,1);


L = length(u)


y = (1:L) /L

plot2d2(x, y,style=5, leg="Fonction de repartition empirique")

endfunction

Fr_empirique(u);

x = -5:0.1:5

y = cdfnor("PQ", x, zeros(x), ones(x));

z=ones(x)

plot2d(x, z, style=1)

plot2d(x, y, style=1,rect=[-5,0,5,1.2])

a=get("current_axes") ;

a.font_size=1;

a.x_location="bottom";

a.y_location="middle";

5/43


B. Simulations classiques

1) Loi uniforme discrete sur [[n1, n2]]

a) Avec plot2d3 :

Code Scilab :

clf;clc;

n1=-2;n2=11;

N=10000;

U =grand(1,N,"uin",n1,n2);

X = tabul(U,"i");

plot2d3(X(:,1), X(:,2)/N,rect= [-3,0,12,.09],style=2)

titre=’Loi uniforme discrete sur l’’intervalle d’’entiers [n1=’+string(n1)+’,n2=’+string(n2)+’]..

- N=’+string(N)

xtitle(titre)

a=get("current_axes") ;

a.font_size=1;

a.x_location="bottom";

a.y_location="left";

6/43


b) Avec bar :

Code Scilab :

clf;clc;

n1=-2; n2=11;

N=10000;

U =grand(1,N,"uin",n1,n2);

X = tabul(U,"i");

bar(X(:,1), X(:,2)/N,width=0.2)

titre=’Loi uniforme discrete sur l’’intervalle d’’entiers [n1=’+string(n1)+’,n2=’+string(n2)+’]..

- N=’+string(N)

xtitle(titre)

a=get("current_axes") ; a.font_size=1; a.x_location="bottom"; a.y_location="left";

::::::::::Remarque : il est aussi possible de simuler une uniforme discrete a partir de rand() et floor en remplacantla ligne U =grand(1,N,"uin",n1,n2); par U =n1+floor((n2-n1+1)*rand(1,N)); .

7/43


2) Loi uniforme sur [a, b[

Code Scilab :

clf;clc;

a=-2;b=5;

N=100000;

U=grand(1,N,"unf",a,b);// Autre option : U=(b-a)*rand(1,N)+a;

titre=’Simulation de loi uniforme continue sur [’+string(a)+’,’+string(b)+’] - N=’+string(N);

histplot(a:0.1:b, U,style=2,rect=[-3,0,6,0.2])

xtitle(titre)

a=get("current_axes") ; a.font_size=1; a.x_location="bottom"; a.y_location="left";

::::::::::Remarque : alternative pour un echantillon de loi uniforme sur [0, 1[ : U=grand(1,N,"def"); .

8/43


3) Application aux 〈〈douze uniformes 〉〉

a) Principe et code associe - comparaison avec grand :

La variable centree-reduite associee a1

12

12∑i=1

Ui est12∑i=1

Ui − 6, donc particulierement simple a ecrire, et

de plus, fournit deja une bonne approximation de la loi normale centree reduite.

Code Scilab :

clf; clc ;

N=10000;

x = [-5 : 0.1 : 5];

y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi )

subplot(1,2,1);

U=grand(N,12,"def");

z=sum(U,’c’)-6;

plot2d(x, y,rect=[-5,0,5,0.45],style=1)

histplot(x, z,style=2)

titre=’Simulation de loi normale via les douze uniformes (N=’+string(N)+’)’

xtitle(titre)

a=get("current_axes"); a.font_size=1; a.x_location="bottom";

subplot(1,2,2);

z = grand(1,N,"nor", 0, 1);

plot2d(x, y,rect=[-5,0,5,0.45])


titre=’Simulation de loi de la loi normale centree reduite avec grand (N=’+string(N)+’)’

xtitle(titre)


9/43


b) Comparaison avec Box-Muller :

Principe : Si U et V sont deux variables aleatoires independantes suivant la loi uniforme sur ]0, 1]alors X =

√−2 lnU cos(2πV ) suit la loi normale centree reduite.

Code Scilab :

clf ;clc ;

N=10000;

x = [-5 : 0.1 : 5];

y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );

subplot(1,2,1);

timer();


z=sum(U,’c’)-6;

t=timer();




titre=’Simulation via les douze uniformes (N=’+string(N)+’) - timer=’+string(t)

xtitle(titre)

subplot(1,2,2);

timer();

u=rand(1,N);v=rand(1,N)

z = sqrt(-2* log(u)) .*cos(2*%pi*v)

t=timer();




titre=’Simulation via Box-Muller (N=’+string(N)+’) - timer=’+string(t)

xtitle(titre)

10/43


Le resultat complet etant que Y =√−2 lnU sin(2πV ) suit egalement la loi normale centree reduite et

que de plus, X et Y sont independantes, on peut s’en inspirer pour alleger le code en ne simulant queN uniformes au lieu de 2N :

Code Scilab :

clf ;clc ;

N=10000;

x = [-5 : 0.1 : 5];

y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );

subplot(1,2,1);

timer();


z=sum(U,’c’)-6;

t=timer();




titre=’Simulation via les douze uniformes (N=’+string(N)+’) - timer=’+string(t)

xtitle(titre)

subplot(1,2,2);

timer();

u=rand(1,N/2);v=rand(1,N/2)

z = [sqrt(-2* log(u)) .*cos(2*%pi*v),sqrt(-2* log(u)) .*sin(2*%pi*v)]

t=timer();




titre=’Simulation via Box-Muller (N=’+string(N)+’) - timer=’+string(t)

xtitle(titre)

Les deux methodes semblent assez equivalentes en termes de temps de calcul et de resultats !

11/43


4) Loi binomiale

a) Simulation :Les boucles for peuvent presenter un certain interet lors de l’apprentissage de Scilab en premiereannee ; petit a petit, le 〈〈 jeu 〉〉 consistera a apprendre a s’en passer a chaque fois qu’il y aura plussimple...

−→ Premiere version, encore tres impregnee de Turbo-Pascal :

Code Scilab :

clc ;clf;

n=10; N=100; p=0.7

// Simulation via Bernoulli

subplot(1,3,1) ;

function y=Bin(n,p)// Fonction simulant une loi binomiale (n,p)

y=0;

for i=1:n

if grand(1,1,"bin",1,p)==1

y=y+1;// Ou bien : if rand()<p

end

end

endfunction

for i=1:N ; x(i)=Bin(n,p); end

z=tabul(x,"i")

bar(z(:,1),z(:,2)/N, width =0.2,color="b")

xtitle("", "Classes", "Effectifs par classe normalises")

legend(’Simulation via Bernoulli’)

a = get("current_axes");

a.data_bounds([3 4]) = [0 0.4];

// Simulation via grand

subplot(1,3,2) ;

x = grand(1,N,"bin", n, p);

z=tabul(x,"i")

bar(z(:,1),z(:,2)/N,width=0.2,color="r")

titre =’Loi binomiale de parametres (n=’+ string(n)+’, p=’+string(p)+’)-Echantillon de..

taille N=’+ string(N);

xtitle(titre, "Classes", "Effectifs par classe normalises")

legend(’Simulation via grand’)

a = get("current_axes");

a.data_bounds([3 4]) = [0 0.4];

// Distribution theorique

subplot(1,3,3) ; a=get("current_axes"); a.font_size=1; a.x_location="bottom";

function t = triangle_de_Pascal(n)

tableau = [ones(n,1), eye( n, n)];

for p=2:n

for k=2:p tableau(p,k) = tableau(p-1,k) + tableau(p-1, k-1); end

end

t = tableau(n,:) // : signifie "toutes les colonnes"

endfunction // "k parmi n"" est donne par t(k+1)

c = triangle_de_Pascal(n);// Calcul des coefficients binomiaux

x=0:n; y=zeros(n)

for k=x

y(k+1) = c(k+1) * (p^k) * (1-p)^(n-k);

end

plot2d3(x, y, rect=[-0.5,0,11,0.4],style=1);

xtitle("", "Valeurs de k", "P(X=k)")

legend(’Distribution theorique’)

12/43


• Attention a l’ordre des instructions dans bar (width avant color).• Comme on ne peut pas regler la fenetre avec bar de la meme maniere qu’avec plot2d3, il est possiblede redefinir apres coup les axes avec a = get("current axes"); a.data bounds([3 4]) = [0 0.4]; - pour queles y aillent de 0 a 0.4 ; si on veut redefinir l’echelle des x, il faut prendre

a = get("current axes"); a.data bounds([1 2]) = [... ...];

et pour redefinir l’ensemble : a = get("current axes"); a.data bounds= [... ... ... ...];

• Variante pour Bernoulli : on peut remplacer if grand(1,1,"bin",1,p)==1; y(k)=y(k)+1; end par

y(k)=y(k)+(rand()<p); (puisque rand()<p est un booleen valant 1 s’il est realise...)

•Mieux encore : on peut remplacer toute la fonction Bin par l’unique instruction sum(rand(n,N) < p, ’r’) !

• Variante pour les coefficients binomiaux, beaucoup plus rapide et astucieuse (idee de Lionel Dorat, ECS2

a Valence) : c = [1 cumprod((n:-1:1)./(1:n))]; .

(n

k

)est alors donne par c(k+1) (les vecteurs commencant

toujours a 1). C’est cette ecriture, qui tient en une ligne, que nous utiliserons par la suite.

• Il est egalement possible de se passer de la boucle for pour la distribution theorique :

−→ Seconde version (〈〈methode Scilabique 〉〉) :

Code Scilab :

clc ;clf;

n=10; N=1000; p=0.7;

titre = ’Loi binomiale de parametres (n=’+ string(n)+’, p=’+string(p)+’) - ..

Echantillon de taille N=’ + string(N);

// Simulation via Bernoulli

subplot(1,3,1) ;

x=sum(rand(n,N) < p, ’r’)

y=tabul(x,"i")

bar(y(:,1),y(:,2)/N,width=0.2,color="b")

a = get("current_axes"); a.data_bounds([3 4]) = [0 0.4];

legend("Simulation via Bernoulli")

// Simulation via grand

subplot(1,3,2) ; a=get("current_axes"); a.font_size=1; a.x_location="bottom";

x = grand(1,N,"bin", n, p);

y=tabul(x,"i")

bar(y(:,1),y(:,2)/N,width=0.2,color="r")

a = get("current_axes"); a.data_bounds([3 4]) = [0 0.4];

legend("Simulation via grand")

xtitle(titre)


subplot(1,3,3) ;

c = [1 cumprod((n:-1:1)./(1:n))];

x=0:n

y=c .*p^x .*(1-p)^(n-x)





13/43


b) Illustration du Theoreme Limite Central :

Code Scilab :

clf;clc;

N=100000; n=[10,50,100] ; p=0.5

x = [-5 : 0.1 : 5];

y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );

for i=1:3

z = (grand(1,N,"bin", n(i), p)-n(i)*p)/sqrt(n(i)*p*(1-p));

L=([-1:n(i)]-n(i)*p+1/2)/sqrt(n(i)*p*(1-p));

subplot(1,3,i);

plot2d(x, y,style=1)

histplot(L, z, rect=[-5,0,5,0.45],style=5)

leg=’n=’+string(n(i))+’ et p=’+string(p)

legend(leg)

if i==2;

xtitle("Illustration du Theoreme Limite Central");

end


end

14/43


4) Loi de Poisson via grand

a) Simulation :

Code Scilab :

clc; clf;

N = 10000;

lambda = 3;

titre=’Loi de Poisson de parametre lambda=’+string(lambda)+’ par grand - N=’+string(N)

x = grand(1,N,"poi", lambda);

y=tabul(x,"i")

subplot(1,2,1)


plot2d3(y(:,1), y(:,2)/N, rect=[-0.5,0,10,0.3],style=2)


subplot(1,2,2)

x=0:10

y=exp(-lambda)*lambda^x ./factorial(x)



xtitle("Distribution theorique", "Valeurs de k", "P(X=k)")

15/43


b) Illustration du Theoreme Limite Central :

Code Scilab :

clf;clc;

x = [-5 : 0.1 : 5];

y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );

titre=’Illustration du Theoreme Limite Central - N=’+string(N)

N=10000;lambda=[5,50,100]

for i=1:3

z = (grand(1,N,"poi", lambda(i))-lambda(i))/sqrt(lambda(i));

L=([-1:lambda(i)+3*sqrt(lambda(i))]-lambda(i)+1/2)/sqrt(lambda(i));

subplot(1,3,i);


histplot(L, z,rect=[-5,0,5,0.8], style=2*i-1)

leg=’lambda=’+string(lambda(i))

legend(leg)

if i==2

xtitle(titre);

end


end

16/43


5) Loi geometrique

Code Scilab :

clf;clc;

p = 0.2; N=10000;

titre=’Loi geometrique de parametre p=’+string(p)+’ - N=’+string(N)

// Simulation de la loi geometrique a partir d’une loi de Bernoulli

subplot(1,3,1) ;

timer();

x=ones(1,N)

for i = 1:N

while (rand() > p) // Autre possibilite : while grand(1,1,"bin",1,p)==0

x(i) = x(i)+ 1;

end

end

t=timer();

y=tabul(x,"i")

plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=2);

xtitle("", "Classes","Effectifs par classe normalises")

leg=’A partir d’’une loi de Bernoulli - timer=’+string(t); legend(leg)

// Simulation de la loi geometrique avec grand

subplot(1,3,2) ;

timer();

x = grand(1,N,"geom", p);

t=timer();

y=tabul(x,"i")


xtitle(titre,"Classes", "Effectifs par classe normalises")

leg=’Avec grand - timer=’+string(t) ; legend(leg)

// Loi geometrique theorique

x=1:20

y = (1-p)^(x-1) * p;

subplot(1,3,3); a=get("current_axes"); a.font_size=1; a.x_location="bottom";

plot2d3(x, y, rect=[-0.5,0,21,p],style=1);

xtitle("", "Valeurs de k", "P(X=k)"); legend("Distribution theorique")

On constate que la seconde methode est nettement plus rapide...

17/43


5) Loi binomiale negative

Code Scilab :

clf;clc;

p = 0.2; r=4 ;

N=10000;

titre=’Loi binomiale negative de parametres (r=’+string(r)+’, p=’+string(p)+’) - N=’+string(N)

// Simulation de la loi binomiale negative a partir d’une loi de Bernoulli

subplot(1,2,1) ;

x=ones(1:N)

for i = 1:N

s=0;

while(s<r)

s=s+1;

while (rand() > p) // Autre possibilite : while grand(1,1,"bin",1,p)==0

x(i) = x(i) + 1;

end

end

end

y=tabul(x,"i")


xtitle(titre, "Classes","Effectifs par classe normalises")

legend("A partir d’’une loi de Bernoulli")


// Simulation de la loi binomiale negative avec grand

subplot(1,2,2) ;

x = grand(1,N,"nbn", r,p);

y=tabul(x,"i")


xtitle("","Classes", "Effectifs par classe normalises")

legend("Avec grand")


18/43


II - LA METHODE D’INVERSION

A. Variables discretes

1) Variables aleatoires finies

Principe : Soit X une variable aleatoire prenant un nombre fini de valeurs x0, ..., xn (n ∈ N).

On note pour tout k ∈ [[0, n]], Fk =

k∑i=0

P (X = xi) et F−1 = 0.

On definit pour tout u ∈ [0, 1], H(u) =n∑i=0

xi I1[Fi−1<u≤Fi].

Si U suit la loi uniforme sur [0, 1], H(U) suit la meme loi que X.

a) Loi de Bernoulli de parametre p ∈]0, 1[ :

Ici, x0 = 0, x1 = 1, F0 = 1− p, F1 = 1.

if rand()<= 1-p then X=0; else X=1; end ou de maniere equivalente : if 1-rand()<p then X=1; else X=0; end

ou encore, puisque 1 − U suit la loi uniforme sur [0, 1] : if rand()<p then X=1; else X=0; end (choix

generalement retenu pour coder une Bernoulli)... et comme un booleen, lorsqu’il est vrai, vaut 1 en Scilab,on peut meme se passer du if...then : rand()<p simule ainsi la loi de Bernoulli.

b) Loi binomiale de parametres (n, p), p ∈]0, 1[ et n ∈ N :

Code Scilab :

clf;clc;

n=10 ; p=0.5 ;

titre=’Loi binomiale de parametres (n=’+string(n)+’, p=’+string(p)+’)’

c=[1 cumprod((n:-1:1) ./(1:n))]

k=0:n

z=c .* (p^k) .* (1-p)^(n-k)

//Simulation via Inversion

F=cumsum(z);

N=1000

u=rand(1,N)

[x,b]=dsearch(u,F)

y=tabul(x,"i")

subplot(1,2,1) ;

plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,11,0.3],style=2)


legend(’Simulation via Inversion’)



subplot(1,2,2) ;

plot2d3(0:n, z, rect=[-0.5,0,11,0.3],style=5);




19/43


Note sur la commande dsearch : [x,b]=dsearch(u,F) cree un vecteur x tel que pour tout i ∈ [[1, N ]], x(i)est egal a l’entier k tel que u(i) appartienne a l’intervalle ]F (k), F (k+1)] et vaut 0 s’il n’appartient a aucunde ces intervalles. b(k) compte le nombre de composantes de x appartenant a l’intervalle ]F (k), F (k + 1)]et est inutile ici - quoique indispensable en entree dans la commande de dsearch. Cette commande estcitee dans le theme 1 (statistiques descriptives univariees) des nouveaux programmes de seconde annee.On peut aussi la remplacer par les lignes de code suivantes :

Code Scilab :

x=zeros(1,N)

for i=1:N

while (u(i)> F(x(i)+1))

x(i)=x(i)+1 ;

end;

end

(Comme F(n+1)=1, il est certain que pour tout i ∈ [[1, N ]], la boucle while s’arrete au bout d’au plusn+ 1 tests - et n incrementations de x(i)).

20/43


c) Comparaison en termes de temps de calcul avec l’algorithme ESSEC 2006 E3 :

Dans le cas d’une variable aleatoire X suivant une loi binomiale de parametres (2n, 1/2), on peut effectuerle reagencement suivant : pour tout k ∈ [[0, 2n]], si k est pair, on pose p′k = P (X = n + k/2) et si k estimpair, p′k = P (X = n− (k + 1)/2).

Alors p′0 ≥ p′1 ≥ ... ≥ p′2n et on effectue l’algorithme de la methode d’inversion avec les effectifs cumulesdes nombres p′i, i ∈ [[0, 2n]] - qui correspondent aux valeurs X = [x′0...x

′2n] ou pour tout k ∈ [[0, 2n]], si k

est pair, x′k = n+ k/2 et si k est impair, x′k = n− (k + 1)/2.

L’etude theorique conclut a un nombre moyen de passages dans la boucle while de l’ordre de√n - contre

un nombre moyen de n pour l’algorithme 〈〈brut 〉〉.

21/43


Code Scilab :

clf;clc;

n=200 ; p=0.5 ; N=10000

nu=2*n

titre=’Loi binomiale (2n,1/2) avec n=’+string(n)+’ et N=’+string(N)

c=[1 cumprod((nu:-1:1) ./(1:nu))]

k=0:nu

z=c .* (p^k) .* (1-p)^(nu-k)

subplot(1,2,1)

F=cumsum(z);

x=zeros(1:N)

timer();

for i=1:N;

u=rand();

while (F(x(i)+1)<u )

x(i)=x(i)+1 ;

end

end

t=timer();

y=tabul(x,"i")

plot2d3(y(:,1), y(:,2)/N, rect=[n/2,0,n*3/2,0.06],style=2)


leg=+’via inversion simple - timer=’+string(t)

legend(leg)


xtitle(titre)

subplot(1,2,2)

for k=0:nu

if modulo(k,2)==0 ;

w(k+1) = z(n+1+k/2);

else

w(k+1) = z(n+1-(k+1)/2);

end

end

F=cumsum(w);

timer();

for i=1:N;

u=rand(); k=0;

while (F(k+1)<u )

k=k+1 ;

end

if modulo(k,2)==0

x(i)=n+k/2;

else

x(i)=n-(k+1)/2;

end

end

t=timer();

y=tabul(x,"i")

plot2d3(y(:,1), y(:,2)/N, rect=[n/2,0,n*3/2,0.06],style=5)


leg=’via methode ESSEC 2006 E3 - timer=’+string(t)

legend(leg)


Le timer indique effectivement des temps de calcul moins longs pour n grand pour la seconde methode.

22/43


2) Variables aleatoires discretes infinies

Principe : Soit X une variable aleatoire d’ensemble image denombrable X(Ω) = xi, i ∈ N.

On note pour tout k ∈ N, Fk =

k∑i=0

P (X = xi) et F−1 = 0.

On definit pour tout u ∈ [0, 1], H(u) =

+∞∑i=0

xi I1[Fi−1<u≤Fi].

Si U suit la loi uniforme sur [0, 1], H(U) suit la meme loi que X.

a) Loi geometrique :

Code Scilab :

clf;clc;

p=0.3; n=20; N=10000

titre=’Loi geometrique de parametre p=’+string(p)

z=p*(1-p)^([0:n-1]);

F=cumsum(z)

u=rand(1,N)

[x,b]=dsearch(u,F)

y=tabul(x,"i")

subplot(1,2,1) ;





subplot(1,2,2); // Distribution theorique

plot2d3(1:n, z, rect=[-0.5,0,20,0.4],style=5);




23/43


e) Loi de Poisson :

Code Scilab :

clf;clc;

lambda=5; N=1000;

titre=’Loi de Poisson de parametre lambda=’+string(lambda)+’- N=’+string(N)

n=20;

z=exp(-lambda)*lambda^([0:n]) ./factorial([0:n]);

// On peut aussi remplacer factorial par cumprod([1 1:n])...

F=cumsum(z);

u=rand(1,N)

[x,b]=dsearch(u,F)

y=tabul(x,"i")

subplot(1,2,1) ;





subplot(1,2,2) ; // Distribution theorique

plot2d3(0:n, z, rect=[-0.5,0,n+1,0.3],style=5);




24/43


B. Variables a densite

Principe : si X est une variable aleatoire a densite dont la fonction de repartition F definit une bijectionde ]a, b[ (−∞ ≤ a < b ≤ +∞) sur ]0, 1[ et si U suit la loi uniforme sur ]0, 1[ alors F−1(U) suit la memeloi que X.

1) Loi exponentielle de parametre λ

a) Simulation :

Code Scilab :

clf;clc;

N=10000;lambda=0.5

titre=’Loi exponentielle de parametre lambda=’+string(lambda)+’ - N=’+string(N)

x=0:0.1:10

y=lambda*exp(-lambda*x)

subplot(1,2,1);

z=-1/lambda*log(rand(1,N));




plot2d(x,y,rect=[0,0,8,lambda+0.1],style=1)


subplot(1,2,2); // Simulation via grand

t=grand(N,1,"exp",1/lambda)

histplot(x, t, style=5);


legend(’Simulation via grand’)

plot2d(x,y,rect=[0,0,8,lambda+0.1],style=1)


25/43


b) Application a la simulation d’une loi geometrique :

L’instruction floor(log(1-rand())/log(1-p))+1 ou floor(log(rand())/log(1-p))+1 permet de simuler une loigeometrique de parametre p.

Code Scilab :

clf;clc;

p = 0.2; N=10000;

titre=’Loi geometrique de parametre p=’+string(p)+’ - N=’+string(N)

// Simulation de la loi geometrique avec la methode d’inversion/loi exponentielle

subplot(1,3,1) ;

timer();

x = floor(log(rand(1,N))/log(1-p))+1;

t=timer();

y=tabul(x,"i")


xtitle("", "Classes","Effectifs par classe normalises")

leg=’Avec une loi exponentielle:inversion - timer=’+string(t); legend(leg)

// Simulation de la loi geometrique avec grand

subplot(1,3,2) ;

timer();

x = grand(1,N,"geom", p);

t=timer();

y=tabul(x,"i")


xtitle(titre,"Classes", "Effectifs par classe normalises")

leg=’Avec grand - timer=’+string(t) ; legend(leg)

// Loi geometrique theorique

x=1:20

y = (1-p)^(x-1) * p;

subplot(1,3,3); a=get("current_axes"); a.font_size=1; a.x_location="bottom";

plot2d3(x, y, rect=[-0.5,0,21,p],style=1);

xtitle("", "Valeurs de k", "P(X=k)"); legend("Distribution theorique")

26/43


c) Application a la simulation d’une loi de Poisson :

Un resultat classique (voir par exemple Oral ESCP 2008 ex. 3.5) et base la methode d’inver-sion appliquee aux lois exponentielles montre que si (Un)n∈N∗ est une suite de variables aleatoiresmutuellement independantes suivant toutes la loi uniforme sur ]0, 1] alors la variable aleatoire Xdefinie pour tout ω ∈ Ω par

X(ω) =

0 si U1(ω) < e−λ

minn ∈ N∗ : U1(ω)...Un+1(ω) < e−λ sinon

suit une loi de Poisson de parametre λ.

D’ou le code suivant pour simuler une variable aleatoire suivant une loi de Poisson de parametre λ (oncompare en termes de temps a la methode d’inversion 〈〈directe 〉〉) :

Code Scilab :

clf;clc;

lambda=7; n=20; N=1000

titre=’Loi de Poisson de parametre lambda=’+string(lambda)

subplot(1,2,1) ;

z=exp(-lambda)*lambda^([0:n]) ./factorial([0:n])

F=cumsum(z); u=rand(1,N)

[x,b]=dsearch(u,F)

y=tabul(x,"i")





subplot(1,2,2) ;

for i=1:N

u=rand(); x(i)=0;

while (u>=exp(-lambda)) u=u*rand() ; x(i)=x(i)+1;end

end

y=tabul(x,"i")



legend(’Simulation via Exponentielle’)


27/43


2) Loi de Laplace (standard)

Code Scilab :

clf;clc;

x=-10:0.1:10

y=exp(-abs(x))/2;

N=10000;

u=rand(1,N);

z=log(2*u) .*(u<1/2)-log(2*(1-u)) .*(u>=1/2)

subplot(1,2,1);



leg=’Laplace via Inversion - N=’+string(N)

legend(leg)

plot2d(x,y,rect=[-8,0,8,0.6],style=1)


// Simulation via la difference de deux exponentielles de parametre 1 independantes

subplot(1,2,2);

t=grand(N,1,"exp",1)-grand(N,1,"exp",1)

histplot(x, t,style=5);


leg=’Laplace via X-Y - N=’+string(N)

legend(leg)



28/43


3) Loi logistique (standard)

Code Scilab :

clf;clc

x=-10:0.1:10

y=1 ./((exp(x/2)+exp(-x/2))^2);

N=10000;

u=rand(1,N);

z=log(u ./(1-u))

histplot(x, z, style=2)

xtitle("Loi logistique via Inversion", "Classes", "Effectifs par classe normalises")



29/43


4) Loi de Pareto (generale)

X suit une loi de Pareto de parametres (α, a, x0) ∈ (R∗+)2 × R si X admet comme densite

f : x 7−→ α

a

(a

x− x0

)α+1

I1[x0+a,+∞[.

X admet alors comme fonction de repartition F : x 7−→[1−

(a

x− x0

)α]I1[x0+a,+∞[, d’ou le code :

Code Scilab :

clf;clc

alpha=3

a=2

x0=1

titre=’Simulation de la loi de Pareto de parametres (alpha=’+string(alpha)+’, a=’+string(a)..

+’,x0=’+string(x0)+’) via inversion’

x=2.5:0.1:12

y=alpha*a^alpha ./(x-x0)^(alpha+1);

N=10000;

u=rand(1,N);

z=a*(1-u)^(-1/alpha)+x0



plot2d(x,y,rect=[2.5,0,12,1],style=5)


30/43


5) Loi de Cauchy (standard)

a) Simulation :

Code Scilab :

clf;clc

x=-10:0.1:10

y=1/%pi ./(1+x^2)

N=10000;

z=tan(%pi*(rand(1,N)-1/2))



xtitle("Cauchy via Inversion", "Classes", "Effectifs par classe normalises")


legend("Courbe theorique")

b) Mise en evidence de la non existence de l’esperance :On peut par exemple proposer le code suivant :

Code Scilab :

clc;clf;

N=100;n=20

z=tan(%pi*(rand(n,N)-1/2))

disp(mean(z,’c’))

y=tabul(mean(z,’c’),’i’)

bar(y(:,1),y(:,2)/n,color="r")

31/43


III - LA METHODE DU REJET

A. Introduction : simulation d’une loi uniforme sur le disque unite

Le resultat theorique a la base de la methode du rejet est que si (Wn)n∈N∗ est une suite de variablesaleatoires mutuellement independantes suivant une loi uniforme sur une partie A de R2 d’aire finie nonnulle et que B ⊂ A (B egalement d’aire non nulle), alors en definissant N = infn ∈ N∗ : Wn ∈ B,WN suit une loi uniforme sur B.On remarque que la generation de WN necessite un nombre d’iterations suivant une loi geometrique.

Ainsi, pour simuler une variable suivant une loi uniforme sur le disque unite :

Code Scilab :

clf;clc;

i=1

for n=[500,800,1000]

subplot(1,3,i)

titre=’Uniforme sur disque via rejet, n=’+string(n)+’ tirages’

u=ones(1,n);v=ones(1,n)

for k=1:n

while (u(k)^2+v(k)^2>1)

u(k)=2*rand()-1;

v(k)=2*rand()-1;

end

end

plot(u,v,"d")

xtitle(titre)

a = gca();

a.isoview = "on";

i=i+1

end

32/43


Remarque : on pourrait etre tente, pour simuler une loi uniforme sur le disque, de tirer au hasard un angleentre 0 et 2π : angle=2%pi*rand() et un rayon egalement uniformement entre 0 et 1 : rayon=rand() maison constate alors que le centre est nettement favorise !

C’est normal : il faut en fait prendre r =√U ou U → [0, 1]...

D’ou le code suivant :

Code Scilab :

clf;clc;

n=800

subplot(1,2,1)

rayon=rand(1,n);angle=2*%pi*rand(1,n);

x=rayon .*cos(angle);

y=rayon .*sin(angle);

plot(x,y,"d")

legend(’Uniforme sur disque tentative 1 (la mauvaise)’)

a = gca();

a.isoview = "on";

subplot(1,2,2)

rayon=sqrt(rand(1,n));angle=2*%pi*rand(1,n);

x=rayon .*cos(angle);

y=rayon .*sin(angle);

plot(x,y,"d")

legend(’Uniforme sur disque tentative 2 (la bonne)’)

a = gca();

a.isoview = "on";

33/43


B. Cas d’une densite a support compact et majoree

Hypotheses : Soit X une variable aleatoire reelle admettant une densite f telle que :

• f est nulle est dehors d’un segment [c, d], c < d

• ∃M ∈ R+ : ∀x ∈ [c, d], f(x) ≤M .

Le rectangle A delimite par les points (c, 0), (d, 0), (d,M) et (c,M) est d’aire M(d − c). La partie Bcorrespondant a la zone sous la courbe de f entre les points d’abscisses c et d est d’aire 1.Pour tout x ∈ [c, d], P (X ≤ x) est donnee par l’aire de la partie Cx correspondant a la zone sous la courbede f entre les points d’abscisses c et x.

Soit alors une suite de variables (Wn)n∈N∗ = (Un, Vn)n∈N∗ suivant une loi uniforme sur ce rectangle : ilsuffit de prendre pour tout n ∈ N∗,

Un=c+(d-c)*rand(); et Vn=M*rand(); .

Si on pose N = infn ∈ N∗ : Wn ∈ B = infn ∈ N∗ : Vn ≤ f(Un), alors UN suit la loi de X.

En effet : (UN , VN ) suivant une loi uniforme sur B, pour tout x ∈ [c, d],

P (UN ≤ x) = P ((UN , VN ) ∈ Cx) =Aire de CxAire de B

=P (X ≤ x)

1= P (X ≤ x).

Un peu plus generalement : on peut considerer que f est non exactement une densite, mais de la forme Kgou g est une densite de probabilite et K une constante strictement positive (cela peut s’averer pratiquepour certaines lois...). La partie B est alors d’aire K et Cx d’aire KP (X ≤ x) : le resultat demeure donc,la constante disparaissant par quotient...

::::::::::Remarque : En pratique, mieux vaut evidemment prendre M le plus petit possible !

1) Exemple : loi beta de parametres (a, b) ∈ [1,+∞[2 via la methode du rejet

Une densite pour cette loi est x 7−→ 1

β(a, b)xa−1(1− x)b−1 I1]0,1[ ou β(a, b) =

∫ 1

0xa−1(1− x)b−1dx .

Le calcul de β(a, b) n’est pas necessaire, puisqu’il va disparaıtre par quotient : il suffit donc d’effectuerla methode du rejet avec f : x 7−→ xa−1(1− x)b−1 et [c, d] = [0, 1].

Avec les notations precedentes, l’aire de la partie B est alors β(a, b) et celle de la partie Cx est β(a, b)P (X ≤ x).

Lorsque (a, b) ∈ [1,+∞[2, f est majoree sur [0, 1] et une simple etude de fonction montre que f atteint

son maximum en x =a− 1

a+ b− 2. On peut alors prendre M = f

(a− 1

a+ b− 2

).

::::::::::Remarque : lorsque a et b sont entiers, il est possible de prendre directement f : x 7−→ 1

β(a, b)xa−1(1− x)b−1

puisqu’on a alors1

β(a, b)=

(a+ b− 1)!

(a− 1)!(b− 1)!= a

a∏k=1

a+ b− kk

, ce que l’on peut facilement implementer

en Scilab via le code (inspire de l’idee de L.Dorat pour la binomiale [p13])

Code Scilab :

deff(’y=f(x,a,b)’,’y=x^(a-1) .*(1-x)^(b-1)*a*prod((a+b-[1:a]) ./[1:a])’)

34/43


Code Scilab :

clf;clc;

a=1.7;b=2.5;

deff(’y=f(x,a,b)’,’y=x^(a-1) .*(1-x)^(b-1)’)

x=0:0.01:1

M=f((a-1)/(a+b-2),a,b)

titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’)’

N=[1000,50000]

T=[1 2;3 4]

for i=1:2//Taille N

for j = 1:2 // methode de simulation

if j==1

u=ones(1,N(i));v=ones(1,N(i));

timer();

for k=1:N(i)

while (v(k)>f(u(k),a,b)) u(k)=rand(); v(k)=M*rand(); end

end

t=timer();

leg=’via rejet - N=’+string(N(i))+’ - timer=’+string(t)

c=2

else

timer();

u=grand(1,N(i),"bet",a,b)

t=timer();

leg=’via grand - N=’+string(N(i))+’ - timer=’+string(t)

c=5

end

subplot(2,2,T(i,j))

histplot(x,u,style=c,rect=[0,0,1,2.5])

legend(leg)

if i*j==1; xtitle(titre); end

end

end

35/43


2) Quelques autres methodes de simulation de la loi beta

a) Via l’algorithme de Jonk :

Principe : soit (Un)n∈N∗ et (Vn)n∈N∗ deux suites de variables aleatoires mutuellement independantes

et suivant toutes la loi uniforme sur ]0, 1]. On note N = infn ∈ N∗ : U1/an + V

1/bn ≤ 1.

AlorsU

1/aN

U1/aN + V

1/bN

suit une loi beta de parametres (a, b).

Avantage : marche dans le cas ou les densites n’admettent pas de majorant (a ∈]0, 1[ ou b ∈]0, 1[).

Code Scilab :

clf;clc;

a=0.7; b=0.4;

N=10000

x=0:0.01:1

subplot(1,2,1)

timer();

for i=1:N

u=rand();v=rand();

while (u^(1/a)+v^(1/b)>1) u=rand(); v=rand(); end

y(i)=u^(1/a)/(u^(1/a)+v^(1/b))

end

t=timer();

histplot(x,y,rect=[0,0,1,4],style=2)

titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’) via Jonk - N=’+string(N)+’..

- timer=’+string(t)

xtitle(titre)

subplot(1,2,2)

timer();

s=grand(1,N,"bet",a,b)

t=timer();

histplot(x,s,rect=[0,0,1,4],style=5)

titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N)+’..

- timer=’+string(t)

xtitle(titre)

36/43


b) Via les statistiques d’ordre :

Un resultat classique montre que si U1, ..., Un sont n variables aleatoires mutuellement independantes sui-vant toutes la loi uniforme sur [0, 1] alors en notant (X1, ..., Xn) la statistique d’ordre associee a (U1, ..., Un),pour tout k ∈ [[1, n]], Xk suit la loi beta de parametres (k, n− k + 1). D’ou le code (pour simuler une loibeta de parametres entiers strictements positifs ; on compare a grand et a la courbe theorique, facile atracer dans ce cas) :

Code Scilab :

clf;clc;

a=2//(=k)

b=5//(=n-k+1)

N=10000;


x=0:0.01:1

y=f(x,a,b)

subplot(1,2,1)

u=rand(b+a-1,N)

z=gsort(u,’r’,’i’)

plot2d(x,y,rect=[0,0,1,M+0.2])

histplot(x,z(a,:),style=2)

titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’) via stats d’’ordre ..

- N=’+string(N)

xtitle(titre)

subplot(1,2,2)


plot2d(x,y,rect=[0,0,1,M+0.2])

histplot(x,s,style=5)

titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N)

xtitle(titre)

37/43


c) Via un resultat de convergence - ESSEC 2004 E3 :

Principe : SoitN+1 urnes U0, ..., UN telles que pour tout k ∈ [[0, N ]], l’urne Uk contient une proportion

dek

Nboules rouges. On choisit une urne au hasard et on y effectue n tirages successifs avec remise.

On note R le nombre de boules rouges obtenues au cours des n tirages. et YN la proportion de boulesrouges dans l’urne qui a ete choisie. Alors la loi conditionnelle de la suite de variables aleatoires(YN )N∈N∗ sachant [R = r] converge vers la loi beta de parametres (r + 1, n− r + 1).

Code Scilab :

clf;clc;

a=3//(=r+1) d’ou r=a-1

b=5//(=n-r+1) d’ou n=b+a-2


x=0:0.01:1

y=f(x,a,b)

M=f((a-1)/(a+b-2),a,b)

N=10000; z=zeros(1,N); nb_urnes=100

for i=1:N

R=0

while (R<>a-1)

z(i)=grand(1,1,"uin",0,nb_urnes)/nb_urnes;

R=sum(rand(1,b+a-2)<z(i),’c’);

end

end

subplot(1,2,1)

histplot(x,z,style=2)

leg=’Via ESSEC 2004 E3 - ’+string(nb_urnes)+’ urnes’

legend(leg)

plot2d(x,y,rect=[0,0,1,M+0.2],style=1)

titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’) - N=’+string(N)

xtitle(titre)

subplot(1,2,2)



legend(’Via grand’)

plot2d(x,y,rect=[0,0,1,M+0.2],style=1)

38/43


C. Extension aux densites a support non compact

Principe : Pour simuler une variable aleatoire X de densite f , on cherche a ∈ [1,+∞[ et une densiteg telles que f ≤ ag sur R. Alors si (Un)n∈N∗ est une suite de variables aleatoires independantesde densite g, (Vn)n∈N∗ une suite de variables aleatoires telle que pour tout n ∈ N∗, Vn suit une loiuniforme sur [0, ag(Un)], et N est definie par N = infn ∈ N∗ : Vn ≤ f(Un), UN suit la loi de X.

1) Application a la simulation de la loi normale via la loi de Laplace

Pour tout x ∈ R, ϕ(x) =1√2πe−x

2/2 ≤√

2e

π× g(x) ou g est la densite usuelle de la loi de Laplace standard.

Code Scilab :

clc ;clf;funcprot(0);

deff(’y=f(x)’,’y= exp(-(x^2)/2) / sqrt(2*%pi)’);

deff(’y=g(x)’,’y=exp(-abs(x))/2’)

x = [-5 : 0.1 : 5];

y = f(x)

N=10000;

subplot(1,2,1);

u=zeros(1,N); v=ones(1,N)

for i=1:N

while v(i)>f(u(i))

a=rand()

u(i)=log(2*a) .*(a<1/2)-log(2*(1-a)) .*(a>=1/2)

v(i)=g(u(i))*rand()*sqrt(2*%e*%pi)

end

end

histplot(x, u,rect=[-5,0,5,0.45],style=2)

legend(’Via la methode du rejet’)

titre=’Simulation de loi normale - N=’+string(N)

xtitle(titre)


subplot(1,2,2);

z = grand(1,N,"nor", 0, 1);

histplot(x, z,rect=[-5,0,5,0.45],style=5)

legend(’Via grand’)


39/43


2) Application a la simulation des lois Gamma

Principe : Si on sait simuler une variable aleatoire X suivant la loi Gamma de parametres (1, ν), ν > 0alors pour tout b > 0, bX suit la loi Gamma de parametres (b, ν) : il suffit donc de savoir simuler les loisGamma de parametres (1, ν), ν > 0.

De plus, si on sait simuler les lois Gamma de parametres (1, a), a ∈]0, 1[ alors pour tout ν > 0, a =ν

bνc+ 1est dans ]0, 1[ et si X1, ..., Xbνc+1 sont des variables mutuellement independantes suivant toutes la loiGamma de parametres (1, a), alors leur somme suit la loi Gamma de parametres (1, (bνc+ 1)a = ν) : ilsuffit donc de savoir simuler les lois Gamma de parametres (1, a), a ∈]0, 1[.

Soit a ∈]0, 1[ et soit f : x 7−→ xa−1e−x

Γ(a)I1]0,+∞[(x) une densite de la loi Gamma de parametres (1, a),

alors en posant b =e

a+ e, g : x 7−→ ab

(xa−1I1]0,1[(x) + e−xI1[1,+∞[(x)

)est une densite de probabilite

telle que, sur R, f ≤ g

abΓ(a).

Soit G : x 7−→∫ x

−∞g la fonction de repartition liee a g.

G definit une bijection de R∗+ sur ]0, 1[ et pour tout x ∈ R, G(x) = bxaI1]0,1[(x) + (1− abe−x)I1[1,+∞[(x)d’ou pour tout u ∈]0, 1[,

G−1(u) =(ub

)1/aI1]0,b[(u)− ln

(1− uab

)I1[b,1[(u).

Soit alors pour tout x > 0, q(x) =abΓ(a)f(x)

g(x)= e−xI1]0,1[(x) + xa−1I1[1,+∞[(x).

Si (Un)n∈N∗ et (Vn)n∈N∗ sont deux suites de variables aleatoires mutuellement independantes suivanttoutes la loi uniforme sur ]0, 1[, on definit N = infn ∈ N∗ : Vn ≤ q(G−1(Un)).Alors X = G−1(UN ) suit la loi Gamma de parametres (1, a).

Code Scilab :

clf;clc;

a=0.7 ; b=%e/(a+%e);N=10000

x=0:0.1:5

deff(’y=q(x,a)’,’y=exp(-x)*(x<1)+x^(a-1)*(x>=1)’)

deff(’y=H(u,a,b)’,’y=(u/b)^(1/a) .*(u<b)-log((1-u)/a/b) .*(u>=b)’)

subplot(1,2,1)

v=2*ones(1,N); z=ones(1,N)

for i=1:N

while(v(i)>q(z(i),a))

z(i)=H(rand(),a,b);

v(i)=rand();

end

end

histplot(x,z,style=2)

titre=’Loi gamma de parametres (1,a=’+string(a)+’) via rejet - N=’+string(N)

xtitle(titre)

subplot(1,2,2)

s=grand(1,N,"gam",a,1)


titre=’Loi gamma de parametres (1,a=’+string(a)+’) via grand - N=’+string(N)

xtitle(titre)

40/43


3) Application : loi du χ2 a n degres de liberte via differentes methodes

(Comparaison avec la simulation via grand)

a) Par la methode du rejet :

Pour simuler une variable suivant la loi du χ2 a n ∈ N∗ degres de liberte, il faut simuler la loi Gammade parametres (2, n/2) : c’est la somme de n variables aleatoires independantes suivant la loi Gamma deparametres (2, 1/2).

b) Par la loi normale :

Classiquement, la somme de n carres de variables independantes suivant toutes la loi normale centreereduite suit une loi du χ2 a n ∈ N∗ degres de liberte.

c) Par un resultat de convergence :

(Voir par exemple HEC 1999, voies E et S).

On decompose l’intervalle [0, 1[ en p ∈ N∗ intervalles Ij =

[j − 1

p,j

p

[(j ∈ [[1, p]]). Soit alors (U1, ..., Uk)

k ∈ N∗ variables aleatoires independantes et suivant la loi uniforme sur [0, 1[. Pour tout j ∈ [[1, p]] et tout

ω ∈ Ω, on note νj(ω) = card i ∈ [[1, k]] : Ui(ω) ∈ Ij et on pose Zk =

p∑j=1

(νj − k

p

)2kp

.

L’etude theorique montre que la suite (Zk)k∈N∗ converge en loi vers la loi du χ2 a p− 1 degres de liberte.

41/43


Code Scilab :

clf;clc;

a=0.5 ; b=%e/(a+%e);

n=30; r=n/2; N=5000

titre=’chi-2 a n=’+string(n)+’ degres de liberte - N=’+string(N)

deff(’y=q(x,a)’,’y=exp(-x)*(x<1)+x^(a-1)*(x>=1)’)

deff(’y=H(u,a,b)’,’y=(u/b)^(1/a) .*(u<b)-log((1-u)/a/b) .*(u>=b)’)

x=0:0.5:80

deff(’y=f(x,r)’, ’y=1/factorial(14)*(1/2)^(r)*x^(r-1) .*exp(-x/2)’)

chi2=f(x,r)

subplot(2,2,1)

timer();

v=2*ones(n,N); y=ones(n,N)

for i=1:n

for j=1:N

while(v(i,j)>q(y(i,j),a)) y(i,j)=H(rand(),a,b);v(i,j)=rand(); end

end

end

z=2*sum(y,’r’)

t=timer();

histplot(x,z,style=2,rect=[0,0,80,0.07])

leg=’via rejet - timer=’+string(t)

legend(leg)

plot2d(x,chi2,style=1)

xtitle(titre)

subplot(2,2,2)

timer();

s=grand(n,N,"nor",0,1)

z=sum(s .^2,’r’)

t=timer();

histplot(x,z,style=5,rect=[0,0,80,0.07])

leg=’via somme de carres de normales (0,1) - timer=’+string(t)

legend(leg)


subplot(2,2,3)

k=10000; p=n+1; q=k/p ;

I=linspace(0,1,p+1)

timer();

for i=1:N

u=rand(1,k)

[a,nu]=dsearch(u,I)

z(i)=sum((nu-q)^2/q)

end

t=timer();

histplot(x,z, style=3,rect=[0,0,80,0.07]);

leg=’via convergence - timer=’+string(t)

legend(leg)


subplot(2,2,4)

timer();

s=grand(1,N,"chi",n)

t=timer();

histplot(x,s,style=1,rect=[0,0,80,0.07])

leg=’via grand - timer=’+string(t)

legend(leg)


42/43


43/43

simulation de lois - webhost.hec.frwebhost.hec.fr/stoltz/seances/f3/f3-polycopie.pdf · christine...

Documents