SIMULATION DE LOIS

(1)

Formation en ligne à Scilab - Séance enregistrée le 11 mars 2014 à HEC Paris

SIMULATION DE LOIS

- SOMMAIRE -

PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPR ´ESENTATIONS SCILAB

1 Quelques remarques g´ en´ erales 1

rand . . . . 1

grand . . . . 2

Quelques remarques sur la d´ efinition des fonctions . . . . 2

Quelques remarques sur la d´ efinition des vecteurs . . . . 3

tabul, bar, plot2d3 . . . . 3

histplot . . . . 3

Trac´ e des fonctions de r´ epartition empiriques . . . . 4

Exemple 1 : loi binomiale

. . . . 4

Exemple 2 : loi normale centr´ee r´eduite

. . . . 5

Simulations classiques 6 Loi uniforme discr` ete sur [[n1, n2]] . . . . 6

Avec plot2d3

. . . . 6

Avec bar

. . . . 7

Loi uniforme sur [a, b[ . . . . 8

Application aux

^hh

douze uniformes

ⁱⁱ

. . . . 9

Principe et code associ´e - comparaison avec grand

. . . . 9

Comparaison avec Box-M¨uller

. . . . 10

Loi binomiale . . . . 12

Simulation

. . . . 12

Illustration du Th´eor`eme Limite Central

. . . . 14

Loi de Poisson via grand . . . . 15

Simulation

. . . . 15

Illustration du Th´eor`eme Limite Central

. . . . 16

Loi g´ eom´ etrique . . . . 17

Loi binomiale n´ egative . . . . 18

LA M ´ETHODE D’INVERSION

19 Variables discr` etes 19 Variables al´ eatoires finies . . . . 19

Loi de Bernoulli de param`etrep∈]0,1[

. . . . 19

Loi binomiale de param`etres(n, p),p∈]0,1[et n∈N

. . . . 19

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

. . . . 21

Variables al´ eatoires discr` etes infinies . . . . 23

(2)

Loi de Poisson

. . . . 24

Variables ` a densit´ e 25 Loi exponentielle de param` etre λ . . . . 25

Simulation

. . . . 25

Application à la simulation d’une loi géométrique

. . . . 26

Application `a la simulation d’une loi de Poisson

. . . . 27

Loi de Laplace (standard) . . . . 28

Loi logistique (standard) . . . . 29

Loi de Pareto (g´ en´ erale) . . . . 30

Loi de Cauchy (standard) . . . . 31

Simulation

. . . . 31

Mise en ´evidence de la non existence de l’esp´erance

. . . . 31

LA M ´ETHODE DU REJET

32 Introduction : simulation d’une loi uniforme sur le disque unit´ e 32 Cas d’une densit´ e ` a support compact et major´ ee 34 Exemple : loi beta de param` etres (a, b) ∈ [1, +∞[

²

via la m´ ethode du rejet . . . . 34

Quelques autres m´ ethodes de simulation de la loi beta . . . . 36

Via l’algorithme de J¨onk

. . . . 36

Via les statistiques d’ordre

. . . . 37

Via un r´esultat de convergence - ESSEC 2004 E3

. . . . 38

Extension aux densit´ es ` a support non compact 39 Application ` a la simulation de la loi normale via la loi de Laplace . . . . 39

Application ` a la simulation des lois Gamma . . . . 40

Application : loi du χ

²

` a n degr´ es de libert´ e via diff´ erentes m´ ethodes . . . . 41

Par la m´ethode du rejet

. . . . 41

Par la loi normale

. . . . 41

Par un r´esultat de convergence

. . . . 41

(3)

SIMULATION DE LOIS

I - PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPR ´ ESENTATIONS SCILAB A. Quelques remarques g´ en´ erales

1) rand

rand()

est l’´ equivalent de random en Turbo-Pascal.

Il est possible de r´ einitialiser l’´ etat interne du g´ en´ erateur al´ eatoire (sp´ ecifi´ e par un entier de l’intervalle [0, 2

³¹

− 1])) ;

s=rand("seed")

renvoie la valeur courante de la graine.

A graine fix´ ` ee, rand() fournira toujours la mˆ eme s´ erie 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 d´ efaut la graine est initialis´ ee ` a s=0 au premier appel, la s´ equence sera toujours la mˆ eme d’une session ` a l’autre)

Si l’on souhaite des s´ equences moins pr´ evisibles, on peut initialiser la graine avec getdate, qui renvoie la date en secondes ´ ecoul´ ees 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 tr` es 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 al´ eatoire de dimensions n1 × n2 × ... × nk. En particulier,

r=rand(n1,n2)

renvoie une matrice al´ eatoire de dimensions n1 × n2. Pour un vecteur, il faut sp´ ecifier ligne ou colonne :

r=rand(1,n2)

ou

r=rand(n1,1)

(

r=rand(A)

renvoie une matrice al´ eatoire de mˆ eme taille que la matrice A donc si on entre

r=rand(n1)

on obtient exactement le mˆ eme r´ esultat que

r=rand()

...)

rand("uniform")

: la loi par d´ efaut est la loi uniforme sur [0, 1].

rand("normal")

: la loi par d´ efaut est la loi normale centr´ ee r´ eduite.

(4)

Le g´ en´ erateur de nombres al´ eatoires

^hh

uniform

ⁱⁱ

est de type Urand (Universal Random Number Generator).

C’est un g´ en´ erateur lin´ eaire ` a congruence de la forme x = (ax + c) mod M avec



 

 

a = 843314861 c = 453816693 M = 2

³¹

. Le g´ en´ erateur de nombres al´ eatoires

^hh

normal

ⁱⁱ

est obtenu par la m´ ethode de Box-M¨ uller (la source de nombres uniformes ´ etant toujours Urand).

2) grand

La fonction grand dispose de g´ en´ erateurs al´ eatoires produisant des s´ equences de nombres qui poss` edent de meilleures qualit´ es statistiques que rand. Par cons´ equent, dans les situations o` u la qualit´ e statistique des s´ equences de nombres al´ eatoires est importante, il vaut mieux utiliser la fonction grand. Cette fonction dispose par ailleurs de fonctionnalit´ es tr` es vari´ ees dont voici les plus classiques (les instructions ci-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 al´ eatoire suivant la loi uniforme sur [[n1, n2]] ;

X=grand(N,M,"bin",n,p)

simule une variable al´ eatoire suivant la binomiale de param` etres (n, p) ;

X=grand(N,M,"nbn",r,p)

simule une variable al´ eatoire suivant la binomiale n´ egative de param` etres (r, p) ;

X=grand(N,M,"geom",p)

simule une variable al´ eatoire suivant la loi g´ eom´ etrique de param` etre p ;

X=grand(N,M,"poi",lambda)

simule une variable al´ eatoire suivant la loi Poisson de param` etre λ ;

X=grand(N,M,"def")

simule une variable al´ eatoire suivant la loi uniforme sur [0, 1[ ;

X=grand(N,M,"unf",a,b)

simule une variable al´ eatoire suivant la loi uniforme sur [a, b[ ;

X=grand(N,M,"exp",1/lambda)

simule une variable al´ eatoire suivant la exponentielle de param` etre λ ;

X=grand(N,M,"gam",nu,1/b)

simule une variable al´ eatoire suivant la loi gamma de param` etres (b, ν) ;

X=grand(N,M,"bet",a,b)

simule une variable al´ eatoire suivant la loi beta de param` etres (a, b) ;

X=grand(N,M,"nor",m,sigma)

simule une variable al´ eatoire suivant la loi normale de param` etres (m, σ

²

).

X=grand(N,M,"chi",n)

simule une variable al´ eatoire suivant la loi du chi-2 ` a n degr´ es de libert´ e ;

• Pour initialiser la graine avec getdate :

Code Scilab : s=getdate("s");

grand("setsd",s)

• A noter aussi : `

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

g´ en` ere n permutations al´ eatoires d’un vecteur colonne U . Exemple :

Code Scilab : U=[1:10]’

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

3) Quelques remarques sur la d´ efinition des fonctions

On utilisera ici soit deff(’...’,’...’) soit function... endfunction, avec des op´ erations point´ ees.

Pour plus d’options, voir le document pdf d’Herv´ e Chabert (s´ eance E2) p9.

(5)

4) Quelques remarques sur la d´ efinition des vecteurs

• Pour des vecteurs espac´ es r´ eguli` erement : x=1:n ou x=[1:n] (avec n ∈ N

^∗

) cr´ ee le vecteur ligne (1, 2, ..., n) (c’est ce dont on se sert dans les boucles for). Pour un vecteur colonne, il faudra ´ ecrire x=[1:n]’. Remarque : si a est un r´ eel, x=1:a sort le vecteur ligne (1, ..., bac) si a ≥ 1 (et le vecteur ligne

hh

vide

ⁱⁱ

si a < 1). Si on souhaite des espacements non entiers : x=1:eps:n o` u eps d´ esigne le pas (il n’est pas n´ ecessaire que cela

^hh

tombe juste

ⁱⁱ

: par exemple, x=1:0.3:2 donnera le vecteur (1, 1.3, 1.6, 1.9). Cela peut aussi servir ` a obtenir des vecteurs ` a composantes d´ ecroissantes : par exemple, x=n:-1:1 donnera le vecteur (n, n − 1, ..., 1) et x=1:-0.25:0 le vecteur (1, 0.75, 0.5, 0.25, 0)...

• Autre option : linspace. Par d´ efaut, le nombre de valeurs est 100. Par exemple, x=linspace(1,1.99) cr´ eera un vecteur x de composantes 1, 1.01, 1.02,...,1.99. Sinon, on peut pr´ eciser (en dernier argument) le nombre de composantes de x : par exemple, x=linspace(1,2,5) cr´ eera le vecteur (1, 1.25, 1.5, 1.75, 2).

Pour obtenir des vecteurs colonnes, il suffit de rajouter un

^hh

prime

ⁱⁱ

derri` ere la parenth` ese. Cela marche aussi pour des d´ ecomposantes d´ ecroissantes : x=linspace(1,-1,3) cr´ eera le vecteur (1, 0, −1).

• La premi` ere m´ ethode cr´ ee ainsi des vecteurs correspondant ` a des classes de largeur fix´ ee ; leur nombre d´ ependra des valeurs minimale et maximale du vecteur, et il est possible que la valeur maximale ne soit pas atteinte (si cela ne tombe pas juste). La seconde m´ ethode cr´ ee des vecteurs ` a nombre de classes fix´ e. Ces classes seront toutes d’une mˆ eme largeur, d´ etermin´ ee par les valeurs minimale et maximale du vecteur, qui correspondront respectivement ` a la premi` ere et ` a la derni` ere composante du vecteur.

5) tabul, bar, plot2d3

• si x est un vecteur ou une matrice, tabul(x) est une matrice ` a deux colonnes, la premi` ere contenant les valeurs prises par les composantes de x rang´ ees dans l’ordre d´ ecroissant (ordre par d´ efaut) et la seconde colonne contenant le nombre d’occurrences de chaque valeur ; tabul(x, "i") est construit sur le mˆ eme principe, mais avec les valeurs rang´ ees dans l’ordre croissant (i pour increase).

• Pour obtenir un diagramme en bˆ atons, il suffit d’´ ecrire le code

y = tabul(x,"i");

puis

bar(y(:,1), y(:,2)/N);

ou

plot2d3(y(:,1), y(:,2)/N);

(o` u N est le nombre de composantes de x :

N=length(x)

).

→ bar trace un diagramme en bˆ atons de largeur par d´ efaut 0, 8 (1 ´ etant la

^hh

largeur maximale autoris´ ee

ⁱⁱ

, i.e. la distance minimale entre deux valeurs report´ ees dans l’histogramme). On peut changer cette largeur en rajoutant width=.... On peut ´ egalement changer la couleur (avec color et non style ici).

→ plot2d3 fonctionne comme plot2d (mˆ emes possibilit´ es d’options) mais trace les courbes avec des barres verticales.

6) histplot

On suppose les donn´ ees regroup´ ees 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 d´ efinissant les classes.

histplot(n,y) : n d´ esigne le nombre de classes. Les classes sont ´ equir´ eparties entre a = min(y) et b = max(y), ce qui reviendrait ` a ´ ecrire histplot(x,y) avec x le vecteur ` a n + 1 composantes d´ efini par pour tout k ∈ [[1, n + 1]], x(k) = a + (k − 1)

b − a n

(les vecteurs et matrices en Scilab commencent toujours ` a 1). La premi` ere 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, trac´ e, normalisation, etc. (les mˆ emes que pour plot2d).

Par exemple,

histplot(x,y,style=5,rect=[-1,0,1,2],normalization=%f)

renverra un histogramme trac´ e en rouge (style 5), la zone de trac´ e ´ etant le rectangle [−1, 1] × [0, 2], et les valeurs ´ etant non normalis´ ees.

• Par d´ efaut, les histogrammes sont normalis´ es (inutile, donc, d’´ ecrire normalization=%t), c’est-` a-dire, si N est le nombre de composantes de y (i.e. le nombre total de donn´ ees), n est le nombre de classes, et pour tout i ∈ [[1, n]], N

i

est le nombre de donn´ ees appartenant ` a la classe C

i

, la valeur de l’ordonn´ ee correspon- dant ` a la classe C

i

sera N

i

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

`

a C

i

soit ´ egale ` a N

i

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

(6)

7) Trac´ e des fonctions de r´ epartition empiriques

Voici un code simple permettant de tracer la fonction de r´ epartition empirique correspondant ` a un

´ echantillon u de donn´ ees :

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

^hh

longueur

ⁱⁱ

de u, c’est-` a-dire son nombre de composantes.

gsort avec l’option ’i’ (il est alors obligatoire de pr´ eciser aussi en seconde position l’option ’g’ qui est sinon par d´ efaut) trie les valeurs de u (via l’algorithme

^hh

quick sort

ⁱⁱ

) par ordre croissant.

a) Exemple 1 : loi binomiale :

Code Scilab :

clf;//pour "nettoyer" la fen^etre des figures clc;//pour "nettoyer" la console Scilab N = 10000; n=10,p=0.2

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

x = gsort(u,’g’,’i’) 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 r´egler les options des axes a.font_size=1; //taille de la l´egende sur les axes

a.x_location="bottom"; //position de l’axe des abscisses a.y_location="origin";//position de l’axe des ordonn´ees

(7)

b) Exemple 2 : loi normale centr´ ee r´ eduite :

Code Scilab : clc;clf;

N = 100;

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

x = gsort(u,’g’,’i’) 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";

(8)

B. Simulations classiques

1) Loi uniforme discr` ete 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 discr`ete 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";

(9)

b) Avec bar :

n1=-2; n2=11;

N=10000;

X = tabul(U,"i");

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

titre=’Loi uniforme discr`ete 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 discr` ete ` a partir de rand() et floor en rempla¸cant

la ligne

par

U =n1+floor((n2-n1+1)*rand(1,N));

.

(10)

2) Loi uniforme sur [a, b[

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");

.

(11)

3) Application aux

^hh

douze uniformes

ⁱⁱ

a) Principe et code associ´ e - comparaison avec grand : La variable centr´ ee-r´ eduite associ´ ee ` a 1

12

X

i=1

U

_i

est

12

X

i=1

U

_i

− 6, donc particuli` erement simple ` a ´ ecrire, et de plus, fournit d´ ej` a une bonne approximation de la loi normale centr´ ee r´ eduite.

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]) histplot(x, z,style=5)

titre=’Simulation de loi de la loi normale centr´ee r´eduite avec grand (N=’+string(N)+’)’

xtitle(titre)

(12)

b) Comparaison avec Box-M¨ uller :

Principe : Si U et V sont deux variables al´ eatoires ind´ ependantes suivant la loi uniforme sur ]0, 1]

alors X = √

−2 ln U cos(2πV ) suit la loi normale centr´ ee r´ eduite.

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-M¨uller (N=’+string(N)+’) - timer=’+string(t) xtitle(titre)

(13)

Le r´ esultat complet ´ etant que Y = √

−2 ln U sin(2πV ) suit ´ egalement la loi normale centr´ ee r´ eduite et que de plus, X et Y sont ind´ ependantes, on peut s’en inspirer pour all´ eger le code en ne simulant que N 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-M¨uller (N=’+string(N)+’) - timer=’+string(t) xtitle(titre)

Les deux m´ ethodes semblent assez ´ equivalentes en termes de temps de calcul et de r´ esultats !

(14)

4) Loi binomiale a) Simulation :

Les boucles for peuvent pr´ esenter un certain int´ erˆ et lors de l’apprentissage de Scilab en premi` ere ann´ ee ; petit ` a petit, le

^hh

jeu

ⁱⁱ

consistera ` a apprendre ` a s’en passer ` a chaque fois qu’il y aura plus simple...

−→ Premi` ere version, encore tr` es impr´ egn´ ee 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 normalis´es") 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 param`etres (n=’+ string(n)+’, p=’+string(p)+’)-Echantillon de..

taille N=’+ string(N);

xtitle(titre, "Classes", "Effectifs par classe normalis´es") legend(’Simulation via grand’)

a = get("current_axes");

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

// Distribution th´eorique

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 donn´e 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 th´eorique’)

(15)

• Attention ` a l’ordre des instructions dans bar (width avant color).

• Comme on ne peut pas r´ egler la fenˆ etre avec bar de la mˆ eme mani` ere qu’avec plot2d3, il est possible de red´ efinir apr` es coup les axes avec

a = get("current axes"); a.data bounds([3 4]) = [0 0.4];

- pour que les y aillent de 0 ` a 0.4 ; si on veut red´ efinir l’´ echelle des x, il faut prendre

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

et pour red´ efinir 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 bool´ een valant 1 s’il est r´ ealis´ e...)

• 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 (id´ ee de Lionel Dorat, ECS2

`

a Valence) :

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

. n

k

est alors donn´ e par c(k +1) (les vecteurs commen¸ cant 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 th´ eorique :

−→ Seconde version (

^hh

m´ ethode Scilabique

ⁱⁱ

) :

Code Scilab : clc ;clf;

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

titre = ’Loi binomiale de param`etres (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)

// Distribution th´eorique subplot(1,3,3) ;

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

x=0:n

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

(16)

b) Illustration du Th´ eor` eme Limite Central :

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 Th´eor`eme Limite Central");

end

(17)

4) Loi de Poisson via grand a) Simulation :

Code Scilab : clc; clf;

N = 10000;

lambda = 3;

titre=’Loi de Poisson de param`etre 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) xtitle(titre, "Classes", "Effectifs par classe normalis´es") subplot(1,2,2)

x=0:10

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

xtitle("Distribution th´eorique", "Valeurs de k", "P(X=k)")

(18)

b) Illustration du Th´ eor` eme Limite Central :

x = [-5 : 0.1 : 5];

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

titre=’Illustration du Th´eor`eme 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

(19)

5) Loi g´ eom´ etrique

p = 0.2; N=10000;

titre=’Loi géométrique de paramètre p=’+string(p)+’ - N=’+string(N) // Simulation de la loi géometrique à partir d’une loi de Bernoulli subplot(1,3,1) ;

timer();

x=ones(1,N) for i = 1:N

while (rand() > p) // Autre possibilit´e : 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 normalis´es")

leg=’A partir d’’une loi de Bernoulli - timer=’+string(t); legend(leg) // Simulation de la loi g´eometrique 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 normalis´es") leg=’Avec grand - timer=’+string(t) ; legend(leg)

// Loi géométrique théorique 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 th´eorique")

On constate que la seconde m´ ethode est nettement plus rapide...

(20)

5) Loi binomiale n´ egative

p = 0.2; r=4 ; N=10000;

titre=’Loi binomiale négative de paramètres (r=’+string(r)+’, p=’+string(p)+’) - N=’+string(N) // Simulation de la loi binomiale négative à 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 possibilit´e : while grand(1,1,"bin",1,p)==0 x(i) = x(i) + 1;

end end end

y=tabul(x,"i")

plot2d3(y(:,1), y(:,2)/N, rect=[-0.5,0,51,0.08],style=2) xtitle(titre, "Classes","Effectifs par classe normalis´es") legend("A partir d’’une loi de Bernoulli")

// Simulation de la loi binomiale n´egative avec grand subplot(1,2,2) ;

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

y=tabul(x,"i")

plot2d3(y(:,1), y(:,2)/N, rect=[-0.5,0,51,0.08],style=5) xtitle("","Classes", "Effectifs par classe normalis´es") legend("Avec grand")

(21)

II - LA M ´ ETHODE D’INVERSION A. Variables discr` etes

1) Variables al´ eatoires finies

Principe : Soit X une variable al´ eatoire prenant un nombre fini de valeurs {x

₀

, ..., x

_n

} (n ∈ N ).

On note pour tout k ∈ [[0, n]], F

_k

=

k

X

i=0

P (X = x

_i

) et F

−1

= 0.

On d´ efinit pour tout u ∈ [0, 1], H(u) =

n

X

i=0

x

_i

I1

_[F_i−1_<u≤F_i_]

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

a) Loi de Bernoulli de param` etre p ∈]0, 1[ : Ici, x

₀

= 0, x

₁

= 1, F

₀

= 1 − p, F

₁

= 1.

if rand()<= 1-p then X=0; else X=1; end

ou de mani` ere ´ 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 g´ en´ eralement retenu pour coder une Bernoulli)... et comme un bool´ een, lorsqu’il est vrai, vaut 1 en Scilab, on peut mˆ eme se passer du if...then :

rand()<p

simule ainsi la loi de Bernoulli.

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

n=10 ; p=0.5 ;

titre=’Loi binomiale de param`etres (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) xtitle(titre, "Classes", "Effectifs par classe normalis´es") legend(’Simulation via Inversion’)

// Distribution th´eorique subplot(1,2,2) ;

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

(22)

Note sur la commande dsearch :

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

cr´ ee 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 aucun de 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 entr´ ee dans la commande de dsearch. Cette commande est cit´ ee dans le th` eme 1 (statistiques descriptives univari´ ees) des nouveaux programmes de seconde ann´ ee.

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’arrˆ ete au bout d’au plus

n + 1 tests - et n incr´ ementations de x(i)).

(23)

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

Dans le cas d’une variable al´ eatoire X suivant une loi binomiale de param` etres (2n, 1/2), on peut effectuer le r´ eagencement suivant : pour tout k ∈ [[0, 2n]], si k est pair, on pose p

⁰_k

= P (X = n + k/2) et si k est impair, p

⁰_k

= P (X = n − (k + 1)/2).

Alors p

⁰₀

≥ p

⁰₁

≥ ... ≥ p

⁰_2n

et on effectue l’algorithme de la m´ ethode d’inversion avec les effectifs cumul´ es des nombres p

⁰_i

, i ∈ [[0, 2n]] - qui correspondent aux valeurs X = [x

⁰₀

...x

⁰_2n

] o` u 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 th´ eorique 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

^hh

brut

ⁱⁱ

.

(24)

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) xtitle("", "Classes", "Effectifs par classe normalis´es") 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) xtitle("", "Classes", "Effectifs par classe normalis´es") leg=’via m´ethode ESSEC 2006 E3 - timer=’+string(t) legend(leg)

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

(25)

2) Variables al´ eatoires discr` etes infinies

Principe : Soit X une variable al´ eatoire d’ensemble image d´ enombrable X(Ω) = {x

_i

, i ∈ N }.

On note pour tout k ∈ N , F

_k

=

k

X

i=0

P (X = x

_i

) et F

−1

= 0.

On d´ efinit pour tout u ∈ [0, 1], H(u) =

+∞

X

i=0

x

_i

I1

_[F_i−1_<u≤F_i_]

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

a) Loi g´ eom´ etrique :

p=0.3; n=20; N=10000

titre=’Loi géométrique de paramètre 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 th´eorique plot2d3(1:n, z, rect=[-0.5,0,20,0.4],style=5);

(26)

e) Loi de Poisson :

lambda=5; N=1000;

titre=’Loi de Poisson de param`etre 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 th´eorique plot2d3(0:n, z, rect=[-0.5,0,n+1,0.3],style=5);

(27)

B. Variables ` a densit´ e

Principe : si X est une variable al´ eatoire ` a densit´ e dont la fonction de r´ epartition F d´ efinit une bijection de ]a, b[ (−∞ ≤ a < b ≤ +∞) sur ]0, 1[ et si U suit la loi uniforme sur ]0, 1[ alors F

⁻¹

(U ) suit la mˆ eme loi que X.

1) Loi exponentielle de param` etre λ a) Simulation :

N=10000;lambda=0.5

titre=’Loi exponentielle de param`etre 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));

histplot(x, z,style=2)

xtitle(titre, "Classes", "Effectifs par classe normalis´es") legend(’Simulation via Inversion’)

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);

xtitle("", "Classes", "Effectifs par classe normalis´es") legend(’Simulation via grand’)

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

(28)

b) Application ` a la simulation d’une loi g´ eom´ etrique :

L’instruction

floor(log(1-rand())/log(1-p))+1

ou

floor(log(rand())/log(1-p))+1

permet de simuler une loi g´ eom´ etrique de param` etre p.

p = 0.2; N=10000;

titre=’Loi géométrique de paramètre p=’+string(p)+’ - N=’+string(N)

// Simulation de la loi g´eometrique avec la m´ethode 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 normalis´es")

leg=’Avec une loi exponentielle:inversion - timer=’+string(t); legend(leg) // Simulation de la loi g´eometrique 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 normalis´es") leg=’Avec grand - timer=’+string(t) ; legend(leg)

// Loi géométrique théorique 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 th´eorique")

(29)

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

Un r´ esultat classique (voir par exemple Oral ESCP 2008 ex. 3.5) et bas´ e la m´ ethode d’inver- sion appliqu´ ee aux lois exponentielles montre que si (U

n

)

n∈N^∗

est une suite de variables al´ eatoires mutuellement ind´ ependantes suivant toutes la loi uniforme sur ]0, 1] alors la variable al´ eatoire X d´ efinie pour tout ω ∈ Ω par

X(ω) =

( 0 si U

1

(ω) < e

^−λ

min{n ∈ N

^∗

: U

1

(ω)...U

n+1

(ω) < e

^−λ

} sinon suit une loi de Poisson de param` etre λ.

D’o` u le code suivant pour simuler une variable al´ eatoire suivant une loi de Poisson de param` etre λ (on compare en termes de temps ` a la m´ ethode d’inversion

^hh

directe

ⁱⁱ

) :

lambda=7; n=20; N=1000

titre=’Loi de Poisson de param`etre 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")

plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,20,0.3],style=2) xtitle(titre, "Classes", "Effectifs par classe normalis´es") legend(’Simulation via Exponentielle’)

(30)

2) Loi de Laplace (standard)

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);

histplot(x, z,style=2)

xtitle("", "Classes", "Effectifs par classe normalis´es") leg=’Laplace via Inversion - N=’+string(N)

legend(leg)

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

// Simulation via la différence de deux exponentielles de paramètre 1 indépendantes subplot(1,2,2);

t=grand(N,1,"exp",1)-grand(N,1,"exp",1) histplot(x, t,style=5);

xtitle("", "Classes", "Effectifs par classe normalis´es") leg=’Laplace via X-Y - N=’+string(N)

legend(leg)

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

(31)

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 normalis´es") plot2d(x,y,rect=[-11,0,11,0.3],style=5)

(32)

4) Loi de Pareto (g´ en´ erale)

X suit une loi de Pareto de param` etres (α, a, x

0

) ∈ ( R

^∗+

)

²

× R si X admet comme densit´ e f : x 7−→ α

a a

x − x

₀

α+1

I1

_[x₀_+a,+∞[

. X admet alors comme fonction de r´ epartition F : x 7−→

1 −

a x − x

0

α

I1

_[x₀+a,+∞[

, d’o` u le code :

Code Scilab : clf;clc alpha=3 a=2 x0=1

titre=’Simulation de la loi de Pareto de param`etres (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 histplot(x, z, style=2)

xtitle(titre, "Classes", "Effectifs par classe normalis´es") plot2d(x,y,rect=[2.5,0,12,1],style=5)

(33)

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))

plot2d(x,y,rect=[-11,0,11,0.4],style=5) histplot(x, z, style=2)

xtitle("Cauchy via Inversion", "Classes", "Effectifs par classe normalis´es") a=get("current_axes"); a.font_size=1; a.x_location="bottom";

legend("Courbe th´eorique")

b) Mise en ´ evidence de la non existence de l’esp´ erance : 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")

(34)

III - LA M ´ ETHODE DU REJET

A. Introduction : simulation d’une loi uniforme sur le disque unit´ e

Le r´ esultat th´ eorique ` a la base de la m´ ethode du rejet est que si (W

n

)

n∈N^∗

est une suite de variables al´ eatoires mutuellement ind´ ependantes suivant une loi uniforme sur une partie A de R

²

d’aire finie non nulle et que B ⊂ A (B ´ egalement d’aire non nulle), alors en d´ efinissant N = inf{n ∈ N

^∗

: W

_n

∈ B}, W

N

suit une loi uniforme sur B.

On remarque que la g´ en´ eration de W

N

n´ ecessite un nombre d’it´ erations suivant une loi g´ eom´ etrique.

Ainsi, pour simuler une variable suivant une loi uniforme sur le disque unit´ e :

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

(35)

Remarque : on pourrait ˆ etre tent´ e, pour simuler une loi uniforme sur le disque, de tirer au hasard un angle entre 0 et 2π :

angle=2%pi*rand()

et un rayon ´ egalement uniform´ ement entre 0 et 1 :

rayon=rand()

mais on constate alors que le centre est nettement favoris´ e !

C’est normal : il faut en fait prendre r = √

U o` u U , → [0, 1]...

D’o` u le code suivant :

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";

(36)

B. Cas d’une densit´ e ` a support compact et major´ ee

Hypoth` eses : Soit X une variable al´ eatoire r´ eelle admettant une densit´ e 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 d´ elimit´ e par les points (c, 0), (d, 0), (d, M) et (c, M ) est d’aire M (d − c). La partie B correspondant ` 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 donn´ ee par l’aire de la partie C

x

correspondant ` a la zone sous la courbe de f entre les points d’abscisses c et x.

Soit alors une suite de variables (W

_n

)

n∈N^∗

= (U

_n

, V

_n

)

n∈N^∗

suivant une loi uniforme sur ce rectangle : il suffit de prendre pour tout n ∈ N

^∗

,

Un=c+(d-c)*rand();

et

Vn=M*rand();

.

Si on pose N = inf{n ∈ N

^∗

: W

n

∈ B} = inf{n ∈ N

^∗

: V

n

≤ f(U

n

)}, alors U

N

suit la loi de X.

En effet : (U

_N

, V

_N

) suivant une loi uniforme sur B , pour tout x ∈ [c, d], P (U

N

≤ x) = P ((U

N

, V

N

) ∈ C

x

) = Aire de C

x

Aire de B = P (X ≤ x)

1 = P(X ≤ x).

Un peu plus g´ en´ eralement : on peut consid´ erer que f est non exactement une densit´ e, mais de la forme Kg o` u g est une densit´ e de probabilit´ e et K une constante strictement positive (cela peut s’av´ erer pratique pour certaines lois...). La partie B est alors d’aire K et C

x

d’aire KP (X ≤ x) : le r´ esultat demeure donc, la constante disparaissant par quotient...

::::::::::

Remarque : En pratique, mieux vaut ´ evidemment prendre M le plus petit possible ! 1) Exemple : loi beta de param` etres (a, b) ∈ [1, +∞[

²

via la m´ ethode du rejet

Une densit´ e pour cette loi est x 7−→ 1

β(a, b) x

^a−1

(1 − x)

^b−1

I1

_]0,1[

o` u β(a, b) = Z

1

0

x

^a−1

(1 − x)

^b−1

dx . Le calcul de β (a, b) n’est pas n´ ecessaire, puisqu’il va disparaˆıtre par quotient : il suffit donc d’effectuer la m´ ethode du rejet avec f : x 7−→ x

^a−1

(1 − x)

^b−1

et [c, d] = [0, 1].

Avec les notations pr´ ec´ edentes, l’aire de la partie B est alors β (a, b) et celle de la partie C

x

est β(a, b)P (X ≤ x).

Lorsque (a, b) ∈ [1, +∞[

²

, f est major´ ee 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) x

^a−1

(1 − x)

^b−1

puisqu’on a alors 1

β(a, b) = (a + b − 1)!

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

a

Y

k=1

a + b − k

k , ce que l’on peut facilement impl´ ementer en Scilab via le code (inspir´ e de l’id´ ee 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])’)

(37)

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 param`etres (a=’+string(a)+’,b=’+string(b)+’)’

N=[1000,50000]

T=[1 2;3 4]

for i=1:2//Taille N

for j = 1:2 // m´ethode 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

(38)

2) Quelques autres m´ ethodes de simulation de la loi beta a) Via l’algorithme de J¨ onk :

Principe : soit (U

_n

)

n∈N^∗

et (V

_n

)

n∈N^∗

deux suites de variables al´ eatoires mutuellement ind´ ependantes et suivant toutes la loi uniforme sur ]0, 1]. On note N = inf {n ∈ N

^∗

: U

_n^1/a

+ V

_n^1/b

≤ 1}.

Alors U

_N^1/a

U

_N^1/a

+ V

_N^1/b

suit une loi beta de param` etres (a, b).

Avantage : marche dans le cas o` u les densit´ es n’admettent pas de majorant (a ∈]0, 1[ ou b ∈]0, 1[).

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 param`etres (a=’+string(a)+’,b=’+string(b)+’) via J¨onk - 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 param`etres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N)+’..

- timer=’+string(t) xtitle(titre)

(39)

b) Via les statistiques d’ordre :

Un r´ esultat classique montre que si U

1

, ..., U

n

sont n variables al´ eatoires mutuellement ind´ ependantes sui- vant toutes la loi uniforme sur [0, 1] alors en notant (X

₁

, ..., X

_n

) la statistique d’ordre associ´ ee ` a (U

₁

, ..., U

_n

), pour tout k ∈ [[1, n]], X

k

suit la loi beta de param` etres (k, n − k + 1). D’o` u le code (pour simuler une loi beta de param` etres entiers strictements positifs ; on compare ` a grand et ` a la courbe th´ eorique, facile ` a tracer dans ce cas) :

a=2//(=k) b=5//(=n-k+1) N=10000;

deff(’y=f(x,a,b)’,’y=x^(a-1) .*(1-x)^(b-1)*a*prod((a+b-[1:a]) ./[1:a])’) 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 param`etres (a=’+string(a)+’,b=’+string(b)+’) via stats d’’ordre ..

- N=’+string(N) xtitle(titre) subplot(1,2,2)

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

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

titre=’Loi beta de param`etres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N) xtitle(titre)

(40)

c) Via un r´ esultat de convergence - ESSEC 2004 E3 :

Principe : Soit N +1 urnes U

0

, ..., U

N

telles que pour tout k ∈ [[0, N ]], l’urne U

k

contient une proportion de k

N boules 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 Y

N

la proportion de boules rouges dans l’urne qui a ´ et´ e choisie. Alors la loi conditionnelle de la suite de variables al´ eatoires (Y

_N

)

N∈N^∗

sachant [R = r] converge vers la loi beta de param` etres (r + 1, n − r + 1).

a=3//(=r+1) d’o`u r=a-1 b=5//(=n-r+1) d’o`u n=b+a-2

deff(’y=f(x,a,b)’,’y=x^(a-1) .*(1-x)^(b-1)*a*prod((a+b-[1:a]) ./[1:a])’) 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 param`etres (a=’+string(a)+’,b=’+string(b)+’) - N=’+string(N) xtitle(titre)

subplot(1,2,2)

s=grand(1,N,"bet",a,b) histplot(x,s,style=5) legend(’Via grand’)

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

(41)

C. Extension aux densit´ es ` a support non compact

Principe : Pour simuler une variable al´ eatoire X de densit´ e f, on cherche a ∈ [1, +∞[ et une densit´ e g telles que f ≤ ag sur R. Alors si (U

n

)

n∈N^∗

est une suite de variables al´ eatoires ind´ ependantes de densit´ e g, (V

_n

)

n∈N^∗

une suite de variables al´ eatoires telle que pour tout n ∈ N

^∗

, V

_n

suit une loi uniforme sur [0, ag(U

_n

)], et N est d´ efinie par N = inf{n ∈ N

^∗

: V

_n

≤ f (U

_n

)}, U

_N

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

≤ r 2e

π × g(x) o` u g est la densit´ e 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 m´ethode du rejet’)

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

plot2d(x, y,style=1) 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’)

(42)

2) Application ` a la simulation des lois Gamma

Principe : Si on sait simuler une variable al´ eatoire X suivant la loi Gamma de param` etres (1, ν ), ν > 0 alors pour tout b > 0, bX suit la loi Gamma de param` etres (b, ν) : il suffit donc de savoir simuler les lois Gamma de param` etres (1, ν), ν > 0.

De plus, si on sait simuler les lois Gamma de param` etres (1, a), a ∈]0, 1[ alors pour tout ν > 0, a = ν bνc + 1 est dans ]0, 1[ et si X

₁

, ..., X

_bνc+1

sont des variables mutuellement ind´ ependantes suivant toutes la loi Gamma de param` etres (1, a), alors leur somme suit la loi Gamma de param` etres (1, (bνc + 1)a = ν) : il suffit donc de savoir simuler les lois Gamma de param` etres (1, a), a ∈]0, 1[.

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

^a−1

e

^−x

Γ(a) I1

_]0,+∞[

(x) une densit´ e de la loi Gamma de param` etres (1, a), alors en posant b = e

a + e , g : x 7−→ ab x

^a−1

I1

_]0,1[

(x) + e

^−x

I1

_[1,+∞[

(x)

est une densit´ e de probabilit´ e telle que, sur R , f ≤ g

abΓ(a) . Soit G : x 7−→

Z

x

−∞

g la fonction de r´ epartition li´ ee ` a g.

G d´ efinit une bijection de R

^∗+

sur ]0, 1[ et pour tout x ∈ R , G(x) = bx

^a

I1

_]0,1[

(x) + (1 − abe

^−x

)I1

_[1,+∞[

(x) d’o` u pour tout u ∈]0, 1[,

G

⁻¹

(u) = u

b

1/a

I1

_]0,b[

(u) − ln

1 − u ab

I1

_[b,1[

(u).

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

g(x) = e

^−x

I1

_]0,1[

(x) + x

^a−1

I1

_[1,+∞[

(x).

Si (U

n

)

n∈N^∗

et (V

n

)

n∈N^∗

sont deux suites de variables al´ eatoires mutuellement ind´ ependantes suivant toutes la loi uniforme sur ]0, 1[, on d´ efinit N = inf{n ∈ N

^∗

: V

_n

≤ q(G

⁻¹

(U

_n

))}.

Alors X = G

⁻¹

(U

N

) suit la loi Gamma de param` etres (1, a).

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 param`etres (1,a=’+string(a)+’) via rejet - N=’+string(N) xtitle(titre)

subplot(1,2,2)

s=grand(1,N,"gam",a,1) histplot(x,s,style=5)

titre=’Loi gamma de param`etres (1,a=’+string(a)+’) via grand - N=’+string(N) xtitle(titre)

(43)

3) Application : loi du χ

²

` a n degr´ es de libert´ e via diff´ erentes m´ ethodes (Comparaison avec la simulation via grand)

a) Par la m´ ethode du rejet :

Pour simuler une variable suivant la loi du χ

²

` a n ∈ N

^∗

degr´ es de libert´ e, il faut simuler la loi Gamma de param` etres (2, n/2) : c’est la somme de n variables al´ eatoires ind´ ependantes suivant la loi Gamma de param` etres (2, 1/2).

b) Par la loi normale :

Classiquement, la somme de n carr´ es de variables ind´ ependantes suivant toutes la loi normale centr´ ee r´ eduite suit une loi du χ

²

` a n ∈ N

^∗

degr´ es de libert´ e.

c) Par un r´ esultat de convergence : (Voir par exemple HEC 1999, voies E et S).

On d´ ecompose l’intervalle [0, 1[ en p ∈ N

^∗

intervalles I

j

=

j − 1 p , j

p

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

1

, ..., U

_k

) k ∈ N

^∗

variables al´ eatoires ind´ ependantes et suivant la loi uniforme sur [0, 1[. Pour tout j ∈ [[1, p]] et tout ω ∈ Ω, on note ν

j

(ω) = card {i ∈ [[1, k]] : U

i

(ω) ∈ I

j

} et on pose Z

k

=

p

X

j=1

ν

j

−

^k_p

2 k p

.

L’´ etude th´ eorique montre que la suite (Z

_k

)

k∈N^∗

converge en loi vers la loi du χ

²