Vous êtes sur la page 1sur 45

Christine HEINEMANN

ECE 2 - Lycée Henri IV - Paris

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

SIMULATION DE LOIS


- SOMMAIRE -

PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPRÉSENTATIONS SCILAB 1

Quelques remarques générales 1


rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Quelques remarques sur la définition des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 2
Quelques remarques sur la définition des vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . 3
tabul, bar, plot2d3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
histplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Tracé des fonctions de répartition empiriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Exemple 1 : loi binomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Exemple 2 : loi normale centrée réduite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Simulations classiques 6
Loi uniforme discrète sur [[n1, n2]] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Avec plot2d3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Avec bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Loi uniforme sur [a, b[ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Application aux hh douze uniformes ii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Principe et code associé - comparaison avec grand . . . . . . . . . . . . . . . . . . . . . . . . . 9
Comparaison avec Box-Müller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Loi binomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Illustration du Théorème Limite Central . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Loi de Poisson via grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Illustration du Théorème Limite Central . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Loi géométrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Loi binomiale négative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

LA MÉTHODE D’INVERSION 19

Variables discrètes 19
Variables aléatoires finies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Loi de Bernoulli de paramètre p ∈]0, 1[ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Loi binomiale de paramètres (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éatoires discrètes infinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Loi géométrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Loi de Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Variables à densité 25
Loi exponentielle de paramètre λ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Application à la simulation d’une loi géométrique . . . . . . . . . . . . . . . . . . . . . . . . . 26
Application à la simulation d’une loi de Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Loi de Laplace (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Loi logistique (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Loi de Pareto (générale) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Loi de Cauchy (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Mise en évidence de la non existence de l’espérance . . . . . . . . . . . . . . . . . . . . . . . . 31

LA MÉTHODE DU REJET 32

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

Cas d’une densité à support compact et majorée 34


Exemple : loi beta de paramètres (a, b) ∈ [1, +∞[2 via la méthode du rejet . . . . . . . . . . . . 34
Quelques autres méthodes de simulation de la loi beta . . . . . . . . . . . . . . . . . . . . . . . 36
Via l’algorithme de Jönk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Via les statistiques d’ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Via un résultat de convergence - ESSEC 2004 E3 . . . . . . . . . . . . . . . . . . . . . . . . . 38

Extension aux densités à support non compact 39


Application à la simulation de la loi normale via la loi de Laplace . . . . . . . . . . . . . . . . . 39
Application à la simulation des lois Gamma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Application : loi du χ2 à n degrés de liberté via différentes méthodes . . . . . . . . . . . . . . . 41
Par la méthode du rejet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Par la loi normale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Par un résultat de convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Formation en ligne à Scilab - HEC Paris 11 mars 2014

SIMULATION DE LOIS

I - PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPRÉSENTATIONS SCILAB

A. Quelques remarques générales

1) rand
rand() est l’équivalent de random en Turbo-Pascal.
Il est possible de réinitialiser l’état interne du générateur aléatoire (spécifié par un entier de l’intervalle
[0, 231 − 1])) ; s=rand("seed") renvoie la valeur courante de la graine.
À graine fixée, rand() fournira toujours la même série 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 être utile dans le but de pouvoir obtenir des simulations reproductibles (par défaut la graine
est initialisée à s=0 au premier appel, la séquence sera toujours la même d’une session à l’autre)
Si l’on souhaite des séquences moins prévisibles, on peut initialiser la graine avec getdate, qui renvoie
la date en secondes écoulées 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ès 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éatoire de dimensions n1 × n2 × ... × nk. En particulier,


r=rand(n1,n2) renvoie une matrice aléatoire de dimensions n1 × n2. Pour un vecteur, il faut spécifier
ligne ou colonne : r=rand(1,n2) ou r=rand(n1,1) ( r=rand(A) renvoie une matrice aléatoire de même taille
que la matrice A donc si on entre r=rand(n1) on obtient exactement le même résultat que r=rand() ...)
rand("uniform") : la loi par défaut est la loi uniforme sur [0, 1].
rand("normal") : la loi par défaut est la loi normale centrée réduite.

1/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

Le générateur de nombres aléatoires hh uniform ii est de type Urand (Universal Random


 Number Generator).
 a = 843314861

C’est un générateur linéaire à congruence de la forme x = (ax + c) mod M avec c = 453816693 .

M = 231

Le générateur de nombres aléatoires hh normal ii est obtenu par la méthode de Box-Müller (la source de
nombres uniformes étant toujours Urand).

2) grand
La fonction grand dispose de générateurs aléatoires produisant des séquences de nombres qui possèdent
de meilleures qualités statistiques que rand. Par conséquent, dans les situations où la qualité statistique
des séquences de nombres aléatoires est importante, il vaut mieux utiliser la fonction grand. Cette
fonction dispose par ailleurs de fonctionnalités très variées 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éatoire suivant la loi uniforme sur [[n1, n2]] ;
X=grand(N,M,"bin",n,p) simule une variable aléatoire suivant la binomiale de paramètres (n, p) ;
X=grand(N,M,"nbn",r,p) simule une variable aléatoire suivant la binomiale négative de paramètres (r, p) ;
X=grand(N,M,"geom",p) simule une variable aléatoire suivant la loi géométrique de paramètre p ;
X=grand(N,M,"poi",lambda) simule une variable aléatoire suivant la loi Poisson de paramètre λ ;
X=grand(N,M,"def") simule une variable aléatoire suivant la loi uniforme sur [0, 1[ ;
X=grand(N,M,"unf",a,b) simule une variable aléatoire suivant la loi uniforme sur [a, b[ ;
X=grand(N,M,"exp",1/lambda) simule une variable aléatoire suivant la exponentielle de paramètre λ ;
X=grand(N,M,"gam",nu,1/b) simule une variable aléatoire suivant la loi gamma de paramètres (b, ν) ;
X=grand(N,M,"bet",a,b) simule une variable aléatoire suivant la loi beta de paramètres (a, b) ;
X=grand(N,M,"nor",m,sigma) simule une variable aléatoire suivant la loi normale de paramètres (m, σ 2 ).
X=grand(N,M,"chi",n) simule une variable aléatoire suivant la loi du chi-2 à n degrés de liberté ;

• Pour initialiser la graine avec getdate :

Code Scilab :
s=getdate("s");
grand("setsd",s)

• À noter aussi : X=grand(n,"prm",U) génère n permutations aléatoires d’un vecteur colonne U . Exemple :

Code Scilab :
U=[1:10]’
X=grand(5,"prm",U)
disp(X)

3) Quelques remarques sur la définition des fonctions


On utilisera ici soit deff(’...’,’...’) soit function... endfunction, avec des opérations pointées.
Pour plus d’options, voir le document pdf d’Hervé Chabert (séance E2) p9.

2/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

4) Quelques remarques sur la définition des vecteurs


• Pour des vecteurs espacés régulièrement : x=1:n ou x=[1:n] (avec n ∈ N∗ ) crée le vecteur ligne
(1, 2, ..., n) (c’est ce dont on se sert dans les boucles for). Pour un vecteur colonne, il faudra écrire
x=[1:n]’. Remarque : si a est un réel, x=1:a sort le vecteur ligne (1, ..., bac) si a ≥ 1 (et le vecteur ligne
hh vide ii si a < 1). Si on souhaite des espacements non entiers : x=1:eps:n où eps désigne le pas (il n’est

pas nécessaire que cela hh tombe juste ii : par exemple, x=1:0.3:2 donnera le vecteur (1, 1.3, 1.6, 1.9). Cela
peut aussi servir à obtenir des vecteurs à composantes décroissantes : 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éfaut, le nombre de valeurs est 100. Par exemple, x=linspace(1,1.99)
créera un vecteur x de composantes 1, 1.01, 1.02,...,1.99. Sinon, on peut préciser (en dernier argument) le
nombre de composantes de x : par exemple, x=linspace(1,2,5) créera le vecteur (1, 1.25, 1.5, 1.75, 2).
Pour obtenir des vecteurs colonnes, il suffit de rajouter un hh prime ii derrière la parenthèse. Cela marche
aussi pour des décomposantes décroissantes : x=linspace(1,-1,3) créera le vecteur (1, 0, −1).
• La première méthode crée ainsi des vecteurs correspondant à des classes de largeur fixée ; leur nombre
dépendra 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éthode crée des vecteurs à nombre de classes
fixé. Ces classes seront toutes d’une même largeur, déterminée par les valeurs minimale et maximale du
vecteur, qui correspondront respectivement à la première et à la dernière composante du vecteur.
5) tabul, bar, plot2d3
• si x est un vecteur ou une matrice, tabul(x) est une matrice à deux colonnes, la première contenant les
valeurs prises par les composantes de x rangées dans l’ordre décroissant (ordre par défaut) et la seconde
colonne contenant le nombre d’occurrences de chaque valeur ; tabul(x, "i") est construit sur le même
principe, mais avec les valeurs rangées dans l’ordre croissant (i pour increase).
• Pour obtenir un diagramme en bâtons, il suffit d’écrire le code y = tabul(x,"i"); puis bar(y(:,1), y(:,2)/N);
ou plot2d3(y(:,1), y(:,2)/N); (où N est le nombre de composantes de x : N=length(x) ).
→ bar trace un diagramme en bâtons de largeur par défaut 0, 8 (1 étant la hh largeur maximale autorisée ii,
i.e. la distance minimale entre deux valeurs reportées dans l’histogramme). On peut changer cette largeur
en rajoutant width=.... On peut également changer la couleur (avec color et non style ici).
→ plot2d3 fonctionne comme plot2d (mêmes possibilités d’options) mais trace les courbes avec des
barres verticales.
6) histplot
On suppose les données regroupées 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éfinissant les classes.
histplot(n,y) : n désigne le nombre de classes. Les classes sont équiréparties entre a = min(y) et
b = max(y), ce qui reviendrait à écrire histplot(x,y)
  avec x le vecteur à n + 1 composantes défini par
b−a
pour tout k ∈ [[1, n + 1]], x(k) = a + (k − 1) (les vecteurs et matrices en Scilab commencent
n
toujours à 1). La première 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é, normalisation, etc. (les mêmes que pour plot2d).
Par exemple, histplot(x,y,style=5,rect=[-1,0,1,2],normalization=%f) renverra un histogramme tracé en
rouge (style 5), la zone de tracé étant le rectangle [−1, 1] × [0, 2], et les valeurs étant non normalisées.
• Par défaut, les histogrammes sont normalisés (inutile, donc, d’écrire normalization=%t), c’est-à-dire, si
N est le nombre de composantes de y (i.e. le nombre total de données), n est le nombre de classes, et pour
tout i ∈ [[1, n]], Ni est le nombre de données appartenant à la classe Ci , la valeur de l’ordonnée correspon-
Ni
dant à la classe Ci sera , de manière à ce que l’aire de l’histogramme correspondant
N (x(i + 1) − x(i))
Ni
à Ci soit égale à , et donc que l’aire totale soit égale à 1.
N

3/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

7) Tracé des fonctions de répartition empiriques


Voici un code simple permettant de tracer la fonction de répartition empirique correspondant à un
échantillon u de données :

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 ii de u, c’est-à-dire son nombre de composantes.


gsort avec l’option ’i’ (il est alors obligatoire de préciser aussi en seconde position l’option ’g’ qui est
sinon par défaut) trie les valeurs de u (via l’algorithme hh quick sort ii) 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);

function Fr_empirique(u)
L = length(u)
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égler les options des axes
a.font_size=1; //taille de la légende sur les axes
a.x_location="bottom"; //position de l’axe des abscisses
a.y_location="origin";//position de l’axe des ordonnées

4/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

b) Exemple 2 : loi normale centrée réduite :

Code Scilab :
clc;clf;

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

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

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
Formation en ligne à Scilab - HEC Paris 11 mars 2014

B. Simulations classiques

1) Loi uniforme discrète 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ète 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
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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 discrète 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ète à partir de rand() et floor en remplaçant
la ligne U =grand(1,N,"uin",n1,n2); par U =n1+floor((n2-n1+1)*rand(1,N)); .

7/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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 échantillon de loi uniforme sur [0, 1[ : U=grand(1,N,"def"); .


::::::::::

8/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

3) Application aux hh douze uniformes ii

a) Principe et code associé - comparaison avec grand :


12 12
1 X X
La variable centrée-réduite associée à Ui est Ui − 6, donc particulièrement simple à écrire, et
12
i=1 i=1
de plus, fournit déjà une bonne approximation de la loi normale centrée réduite.

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ée réduite avec grand (N=’+string(N)+’)’
xtitle(titre)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

9/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

b) Comparaison avec Box-Müller :

Principe √
: Si U et V sont deux variables aléatoires indépendantes suivant la loi uniforme sur ]0, 1]
alors X = −2 ln U cos(2πV ) suit la loi normale centrée réduite.

Code Scilab :
clf ;clc ;

N=10000;

x = [-5 : 0.1 : 5];


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

subplot(1,2,1);
timer();
U=grand(N,12,"def");
z=sum(U,’c’)-6;
t=timer();
plot2d(x, y,rect=[-5,0,5,0.45],style=1)
histplot(x, z,style=2)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
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();
plot2d(x, y,rect=[-5,0,5,0.45],style=1)
histplot(x, z,style=5)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
titre=’Simulation via Box-Müller (N=’+string(N)+’) - timer=’+string(t)
xtitle(titre)

10/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014


Le résultat complet étant que Y = −2 ln U sin(2πV ) suit également la loi normale centrée réduite et
que de plus, X et Y sont indépendantes, on peut s’en inspirer pour alléger 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();
U=grand(N,12,"def");
z=sum(U,’c’)-6;
t=timer();
plot2d(x, y,rect=[-5,0,5,0.45],style=1)
histplot(x, z,style=2)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
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();
plot2d(x, y,rect=[-5,0,5,0.45],style=1)
histplot(x, z,style=5)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
titre=’Simulation via Box-Müller (N=’+string(N)+’) - timer=’+string(t)
xtitle(titre)

Les deux méthodes semblent assez équivalentes en termes de temps de calcul et de résultats !

11/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

4) Loi binomiale

a) Simulation :
Les boucles for peuvent présenter un certain intérêt lors de l’apprentissage de Scilab en première
année ; petit à petit, le hh jeu ii consistera à apprendre à s’en passer à chaque fois qu’il y aura plus
simple...
−→ Première version, encore très imprégnée 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és")
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ètres (n=’+ string(n)+’, p=’+string(p)+’)-Echantillon de..
taille N=’+ string(N);
xtitle(titre, "Classes", "Effectifs par classe normalisés")
legend(’Simulation via grand’)
a = get("current_axes");
a.data_bounds([3 4]) = [0 0.4];

// Distribution théorique
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é 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éorique’)

12/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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


• Comme on ne peut pas régler la fenêtre avec bar de la même manière qu’avec plot2d3, il est possible
de redéfinir après coup les axes avec a = get("current axes"); a.data bounds([3 4]) = [0 0.4]; - pour que
les y aillent de 0 à 0.4 ; si on veut redéfinir l’échelle des x, il faut prendre
a = get("current axes"); a.data bounds([1 2]) = [... ...];

et pour redéfinir 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éen valant 1 s’il est réalisé...)

• 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ée de Lionel Dorat, ECS2
n
à Valence) : c = [1 cumprod((n:-1:1)./(1:n))]; . est alors donné par c(k+1) (les vecteurs commençant
k
toujours à 1). C’est cette écriture, qui tient en une ligne, que nous utiliserons par la suite.

• Il est également possible de se passer de la boucle for pour la distribution théorique :

−→ Seconde version (hh méthode Scilabique ii) :

Code Scilab :
clc ;clf;

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

titre = ’Loi binomiale de paramètres (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éorique
subplot(1,3,3) ;
c = [1 cumprod((n:-1:1)./(1:n))];
x=0:n
y=c .*p^x .*(1-p)^(n-x)
plot2d3(x, y, rect=[-0.5,0,11,0.4],style=1);
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
xtitle("", "Valeurs de k", "P(X=k)")
legend(’Distribution théorique’)

13/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

b) Illustration du Théorème 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 Théorème Limite Central");
end
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
end

14/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

4) Loi de Poisson via grand

a) Simulation :

Code Scilab :
clc; clf;

N = 10000;
lambda = 3;
titre=’Loi de Poisson de paramètre lambda=’+string(lambda)+’ par grand - N=’+string(N)

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

subplot(1,2,1)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
plot2d3(y(:,1), y(:,2)/N, rect=[-0.5,0,10,0.3],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalisés")

subplot(1,2,2)
x=0:10
y=exp(-lambda)*lambda^x ./factorial(x)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
plot2d3(x, y, rect=[-0.5,0,10,0.3],style=5);
xtitle("Distribution théorique", "Valeurs de k", "P(X=k)")

15/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

b) Illustration du Théorème Limite Central :

Code Scilab :
clf;clc;

x = [-5 : 0.1 : 5];


y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );
titre=’Illustration du Théorème 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);
plot2d(x, y,style=2)
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
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
end

16/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

5) Loi géométrique

Code Scilab :
clf;clc;
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é : 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és")
leg=’A partir d’’une loi de Bernoulli - timer=’+string(t); legend(leg)

// Simulation de la loi géometrique avec grand


subplot(1,3,2) ;
timer();
x = grand(1,N,"geom", p);
t=timer();
y=tabul(x,"i")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=5);
xtitle(titre,"Classes", "Effectifs par classe normalisés")
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éorique")

On constate que la seconde méthode est nettement plus rapide...


17/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

5) Loi binomiale négative

Code Scilab :
clf;clc;

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é : 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és")
legend("A partir d’’une loi de Bernoulli")
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

// Simulation de la loi binomiale négative 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és")
legend("Avec grand")
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

18/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

II - LA MÉTHODE D’INVERSION

A. Variables discrètes

1) Variables aléatoires finies

Principe : Soit X une variable aléatoire prenant un nombre fini de valeurs {x0 , ..., xn } (n ∈ N).
k
X
On note pour tout k ∈ [[0, n]], Fk = P (X = xi ) et F−1 = 0.
i=0
n
X
On définit pour tout u ∈ [0, 1], H(u) = xi I1[Fi−1 <u≤Fi ] .
i=0
Si U suit la loi uniforme sur [0, 1], H(U ) suit la même loi que X.

a) Loi de Bernoulli de paramètre 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 manière équivalente : 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énéralement retenu pour coder une Bernoulli)... et comme un booléen, lorsqu’il est vrai, vaut 1 en Scilab,
on peut même se passer du if...then : rand()<p simule ainsi la loi de Bernoulli.

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

Code Scilab :
clf;clc;

n=10 ; p=0.5 ;
titre=’Loi binomiale de paramètres (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és")
legend(’Simulation via Inversion’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

// Distribution théorique
subplot(1,2,2) ;
plot2d3(0:n, z, rect=[-0.5,0,11,0.3],style=5);
xtitle("", "Valeurs de k", "P(X=k)")
legend(’Distribution théorique’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

19/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

Note sur la commande dsearch : [x,b]=dsearch(u,F) crée un vecteur x tel que pour tout i ∈ [[1, N ]], x(i)
est égal à l’entier k tel que u(i) appartienne à l’intervalle ]F (k), F (k+1)] et vaut 0 s’il n’appartient à aucun
de ces intervalles. b(k) compte le nombre de composantes de x appartenant à l’intervalle ]F (k), F (k + 1)]
et est inutile ici - quoique indispensable en entrée dans la commande de dsearch. Cette commande est
citée dans le thème 1 (statistiques descriptives univariées) des nouveaux programmes de seconde année.
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ête au bout d’au plus
n + 1 tests - et n incrémentations de x(i)).

20/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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

Dans le cas d’une variable aléatoire X suivant une loi binomiale de paramètres (2n, 1/2), on peut effectuer
le réagencement suivant : pour tout k ∈ [[0, 2n]], si k est pair, on pose p0k = P (X = n + k/2) et si k est
impair, p0k = P (X = n − (k + 1)/2).
Alors p00 ≥ p01 ≥ ... ≥ p02n et on effectue l’algorithme de la méthode d’inversion avec les effectifs cumulés
des nombres p0i , i ∈ [[0, 2n]] - qui correspondent aux valeurs X = [x00 ...x02n ] où pour tout k ∈ [[0, 2n]], si k
est pair, x0k = n + k/2 et si k est impair, x0k = n − (k + 1)/2.

L’étude théorique conclut à 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 ii.

21/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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)
xtitle("", "Classes", "Effectifs par classe normalisés")
leg=+’via inversion simple - timer=’+string(t)
legend(leg)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
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és")
leg=’via méthode ESSEC 2006 E3 - timer=’+string(t)
legend(leg)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

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

22/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

2) Variables aléatoires discrètes infinies

Principe : Soit X une variable aléatoire d’ensemble image dénombrable X(Ω) = {xi , i ∈ N}.
X k
On note pour tout k ∈ N, Fk = P (X = xi ) et F−1 = 0.
i=0
+∞
X
On définit pour tout u ∈ [0, 1], H(u) = xi I1[Fi−1 <u≤Fi ] .
i=0
Si U suit la loi uniforme sur [0, 1], H(U ) suit la même loi que X.

a) Loi géométrique :

Code Scilab :
clf;clc;

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) ;
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,20,0.4],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalisés")
legend(’Simulation via Inversion’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

subplot(1,2,2); // Distribution théorique


plot2d3(1:n, z, rect=[-0.5,0,20,0.4],style=5);
xtitle("", "Valeurs de k", "P(X=k)")
legend(’Distribution théorique’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

23/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

e) Loi de Poisson :

Code Scilab :
clf;clc;

lambda=5; N=1000;
titre=’Loi de Poisson de paramètre 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) ;
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,20,0.3],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalisés")
legend(’Simulation via Inversion’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

subplot(1,2,2) ; // Distribution théorique


plot2d3(0:n, z, rect=[-0.5,0,n+1,0.3],style=5);
xtitle("", "Valeurs de k", "P(X=k)")
legend(’Distribution théorique’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

24/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

B. Variables à densité

Principe : si X est une variable aléatoire à densité dont la fonction de répartition F définit une bijection
de ]a, b[ (−∞ ≤ a < b ≤ +∞) sur ]0, 1[ et si U suit la loi uniforme sur ]0, 1[ alors F −1 (U ) suit la même
loi que X.

1) Loi exponentielle de paramètre λ

a) Simulation :

Code Scilab :
clf;clc;

N=10000;lambda=0.5
titre=’Loi exponentielle de paramètre 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és")
legend(’Simulation via Inversion’)
plot2d(x,y,rect=[0,0,8,lambda+0.1],style=1)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

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és")
legend(’Simulation via grand’)
plot2d(x,y,rect=[0,0,8,lambda+0.1],style=1)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

25/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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


L’instruction floor(log(1-rand())/log(1-p))+1 ou floor(log(rand())/log(1-p))+1 permet de simuler une loi
géométrique de paramètre p.

Code Scilab :
clf;clc;

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 avec la méthode 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")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=2);
xtitle("", "Classes","Effectifs par classe normalisés")
leg=’Avec une loi exponentielle:inversion - timer=’+string(t); legend(leg)

// Simulation de la loi géometrique avec grand


subplot(1,3,2) ;
timer();
x = grand(1,N,"geom", p);
t=timer();
y=tabul(x,"i")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=5);
xtitle(titre,"Classes", "Effectifs par classe normalisés")
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éorique")

26/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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


Un résultat classique (voir par exemple Oral ESCP 2008 ex. 3.5) et basé la méthode d’inver-
sion appliquée aux lois exponentielles montre que si (Un )n∈N∗ est une suite de variables aléatoires
mutuellement indépendantes suivant toutes la loi uniforme sur ]0, 1] alors la variable aléatoire X
définie pour tout ω ∈ Ω par
0 si U1 (ω) < e−λ
(
X(ω) =
min{n ∈ N∗ : U1 (ω)...Un+1 (ω) < e−λ } sinon
suit une loi de Poisson de paramètre λ.
D’où le code suivant pour simuler une variable aléatoire suivant une loi de Poisson de paramètre λ (on
compare en termes de temps à la méthode d’inversion hh directe ii) :

Code Scilab :
clf;clc;

lambda=7; n=20; N=1000


titre=’Loi de Poisson de paramètre 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")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,20,0.3],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalisés")
legend(’Simulation via Inversion’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

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és")
legend(’Simulation via Exponentielle’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

27/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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);
histplot(x, z,style=2)
xtitle("", "Classes", "Effectifs par classe normalisés")
leg=’Laplace via Inversion - N=’+string(N)
legend(leg)
plot2d(x,y,rect=[-8,0,8,0.6],style=1)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

// 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és")
leg=’Laplace via X-Y - N=’+string(N)
legend(leg)
plot2d(x,y,rect=[-8,0,8,0.6],style=1)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

28/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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és")
plot2d(x,y,rect=[-11,0,11,0.3],style=5)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

29/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

4) Loi de Pareto (générale)

X suit une loi de Pareto de paramètres (α, a, x0 ) ∈ (R∗+ )2 × R si X admet comme densité
 α+1
α a
f : x 7−→ I1[x0 +a,+∞[ .
a x − x0
  α 
a
X admet alors comme fonction de répartition F : x 7−→ 1 − I1[x0 +a,+∞[ , d’où le code :
x − x0

Code Scilab :
clf;clc

alpha=3
a=2
x0=1
titre=’Simulation de la loi de Pareto de paramètres (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és")
plot2d(x,y,rect=[2.5,0,12,1],style=5)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";

30/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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és")
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
legend("Courbe théorique")

b) Mise en évidence de la non existence de l’espérance :


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
Formation en ligne à Scilab - HEC Paris 11 mars 2014

III - LA MÉTHODE DU REJET

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

Le résultat théorique à la base de la méthode du rejet est que si (Wn )n∈N∗ est une suite de variables
aléatoires mutuellement indépendantes suivant une loi uniforme sur une partie A de R2 d’aire finie non
nulle et que B ⊂ A (B également d’aire non nulle), alors en définissant N = inf{n ∈ N∗ : Wn ∈ B},
WN suit une loi uniforme sur B.
On remarque que la génération de WN nécessite un nombre d’itérations suivant une loi géométrique.
Ainsi, pour simuler une variable suivant une loi uniforme sur le disque unité :

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
Formation en ligne à Scilab - HEC Paris 11 mars 2014

Remarque : on pourrait être tenté, 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 également uniformément entre 0 et 1 : rayon=rand() mais
on constate alors que le centre est nettement favorisé !

C’est normal : il faut en fait prendre r = U où U ,→ [0, 1]...
D’où 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
Formation en ligne à Scilab - HEC Paris 11 mars 2014

B. Cas d’une densité à support compact et majorée

Hypothèses : Soit X une variable aléatoire réelle admettant une densité 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élimité par les points (c, 0), (d, 0), (d, M ) et (c, M ) est d’aire M (d − c). La partie B
correspondant à 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ée par l’aire de la partie Cx correspondant à la zone sous la courbe
de 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 : il
suffit de prendre pour tout n ∈ N∗ ,
Un=c+(d-c)*rand(); et Vn=M*rand(); .
Si on pose N = inf{n ∈ N∗ : Wn ∈ B} = inf{n ∈ 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],
Aire de Cx P (X ≤ x)
P (UN ≤ x) = P ((UN , VN ) ∈ Cx ) = = = P (X ≤ x).
Aire de B 1
Un peu plus généralement : on peut considérer que f est non exactement une densité, mais de la forme Kg
où g est une densité de probabilité et K une constante strictement positive (cela peut s’avérer pratique
pour certaines lois...). La partie B est alors d’aire K et Cx d’aire KP (X ≤ x) : le résultat demeure donc,
la constante disparaissant par quotient...
Remarque
::::::::::
: En pratique, mieux vaut évidemment prendre M le plus petit possible !

1) Exemple : loi beta de paramètres (a, b) ∈ [1, +∞[2 via la méthode du rejet
Z 1
1 a−1 b−1
Une densité pour cette loi est x 7−→ x (1 − x) I1]0,1[ où β(a, b) = xa−1 (1 − x)b−1 dx .
β(a, b) 0
Le calcul de β(a, b) n’est pas nécessaire, puisqu’il va disparaı̂tre par quotient : il suffit donc d’effectuer
la méthode du rejet avec f : x 7−→ xa−1 (1 − x)b−1 et [c, d] = [0, 1].
Avec les notations précédentes, 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 majorée sur [0, 1] et une simpleétude de fonction
 montre que f atteint
a−1 a−1
son maximum en x = . On peut alors prendre M = f .
a+b−2 a+b−2
1
Remarque : lorsque a et b sont entiers, il est possible de prendre directement f : x 7−→
::::::::::
xa−1 (1 − x)b−1
β(a, b)
a
1 (a + b − 1)! Y a+b−k
puisqu’on a alors = =a , ce que l’on peut facilement implémenter
β(a, b) (a − 1)!(b − 1)! k
k=1
en Scilab via le code (inspiré de l’idée 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
Formation en ligne à Scilab - HEC Paris 11 mars 2014

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 paramètres (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éthode 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
Formation en ligne à Scilab - HEC Paris 11 mars 2014

2) Quelques autres méthodes de simulation de la loi beta

a) Via l’algorithme de Jönk :


Principe : soit (Un )n∈N∗ et (Vn )n∈N∗ deux suites de variables aléatoires mutuellement indépendantes
1/a 1/b
et suivant toutes la loi uniforme sur ]0, 1]. On note N = inf{n ∈ N∗ : Un + Vn ≤ 1}.
1/a
U
Alors 1/a N 1/b suit une loi beta de paramètres (a, b).
UN + VN

Avantage : marche dans le cas où les densités 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 paramètres (a=’+string(a)+’,b=’+string(b)+’) via Jönk - 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ètres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N)+’..
- timer=’+string(t)
xtitle(titre)

36/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

b) Via les statistiques d’ordre :


Un résultat classique montre que si U1 , ..., Un sont n variables aléatoires mutuellement indépendantes sui-
vant toutes la loi uniforme sur [0, 1] alors en notant (X1 , ..., Xn ) la statistique d’ordre associée à (U1 , ..., Un ),
pour tout k ∈ [[1, n]], Xk suit la loi beta de paramètres (k, n − k + 1). D’où le code (pour simuler une loi
beta de paramètres entiers strictements positifs ; on compare à grand et à la courbe théorique, facile à
tracer dans ce cas) :

Code Scilab :
clf;clc;

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ètres (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ètres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N)
xtitle(titre)

37/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

c) Via un résultat de convergence - ESSEC 2004 E3 :


Principe : Soit N +1 urnes U0 , ..., UN telles que pour tout k ∈ [[0, N ]], l’urne Uk contient une proportion
k
de boules rouges. On choisit une urne au hasard et on y effectue n tirages successifs avec remise.
N
On note R le nombre de boules rouges obtenues au cours des n tirages. et YN la proportion de boules
rouges dans l’urne qui a été choisie. Alors la loi conditionnelle de la suite de variables aléatoires
(YN )N ∈N∗ sachant [R = r] converge vers la loi beta de paramètres (r + 1, n − r + 1).

Code Scilab :
clf;clc;
a=3//(=r+1) d’où r=a-1
b=5//(=n-r+1) d’où 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ètres (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)

38/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

C. Extension aux densités à support non compact

Principe : Pour simuler une variable aléatoire X de densité f , on cherche a ∈ [1, +∞[ et une densité
g telles que f ≤ ag sur R. Alors si (Un )n∈N∗ est une suite de variables aléatoires indépendantes
de densité g, (Vn )n∈N∗ une suite de variables aléatoires telle que pour tout n ∈ N∗ , Vn suit une loi
uniforme sur [0, ag(Un )], et N est définie par N = inf{n ∈ N∗ : Vn ≤ f (Un )}, UN suit la loi de X.

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


r
1 −x2 /2 2e
Pour tout x ∈ R, ϕ(x) = √ e ≤ × g(x) où g est la densité usuelle de la loi de Laplace standard.
2π π

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

39/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

2) Application à la simulation des lois Gamma

Principe : Si on sait simuler une variable aléatoire X suivant la loi Gamma de paramètres (1, ν), ν > 0
alors pour tout b > 0, bX suit la loi Gamma de paramètres (b, ν) : il suffit donc de savoir simuler les lois
Gamma de paramètres (1, ν), ν > 0.
ν
De plus, si on sait simuler les lois Gamma de paramètres (1, a), a ∈]0, 1[ alors pour tout ν > 0, a =
bνc + 1
est dans ]0, 1[ et si X1 , ..., Xbνc+1 sont des variables mutuellement indépendantes suivant toutes la loi
Gamma de paramètres (1, a), alors leur somme suit la loi Gamma de paramètres (1, (bνc + 1)a = ν) : il
suffit donc de savoir simuler les lois Gamma de paramètres (1, a), a ∈]0, 1[.
xa−1 e−x
Soit a ∈]0, 1[ et soit f : x 7−→ I1 (x) une densité de la loi Gamma de paramètres (1, a),
Γ(a) ]0,+∞[
e
, g : x 7−→ ab xa−1 I1]0,1[ (x) + e−x I1[1,+∞[ (x) est une densité de probabilité

alors en posant b =
a+e
g
telle que, sur R, f ≤ .
Z x abΓ(a)
Soit G : x 7−→ g la fonction de répartition liée à g.
−∞
G définit une bijection de R∗+ sur ]0, 1[ et pour tout x ∈ R, G(x) = bxa I1]0,1[ (x) + (1 − abe−x )I1[1,+∞[ (x)
d’où pour tout u ∈]0, 1[,  
−1
 u 1/a 1−u
G (u) = I1]0,b[ (u) − ln I1[b,1[ (u).
b ab
abΓ(a)f (x)
Soit alors pour tout x > 0, q(x) = = e−x I1]0,1[ (x) + xa−1 I1[1,+∞[ (x).
g(x)
Si (Un )n∈N∗ et (Vn )n∈N∗ sont deux suites de variables aléatoires mutuellement indépendantes suivant
toutes la loi uniforme sur ]0, 1[, on définit N = inf{n ∈ N∗ : Vn ≤ q(G−1 (Un ))}.
Alors X = G−1 (UN ) suit la loi Gamma de paramètres (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 paramètres (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ètres (1,a=’+string(a)+’) via grand - N=’+string(N)
xtitle(titre)

40/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

3) Application : loi du χ2 à n degrés de liberté via différentes méthodes

(Comparaison avec la simulation via grand)

a) Par la méthode du rejet :


Pour simuler une variable suivant la loi du χ2 à n ∈ N∗ degrés de liberté, il faut simuler la loi Gamma
de paramètres (2, n/2) : c’est la somme de n variables aléatoires indépendantes suivant la loi Gamma de
paramètres (2, 1/2).

b) Par la loi normale :


Classiquement, la somme de n carrés de variables indépendantes suivant toutes la loi normale centrée
réduite suit une loi du χ2 à n ∈ N∗ degrés de liberté.

c) Par un résultat de convergence :


(Voir par exemple HEC 1999, voies E et S).
 
j−1 j
On décompose l’intervalle [0, 1[ en p ∈ N∗
intervalles Ij = , (j ∈ [[1, p]]). Soit alors (U1 , ..., Uk )
p p

k ∈ N variables aléatoires indépendantes et suivant la loi uniforme sur [0, 1[. Pour tout j ∈ [[1, p]] et tout
 2
X p νj − kp
ω ∈ Ω, on note νj (ω) = card {i ∈ [[1, k]] : Ui (ω) ∈ Ij } et on pose Zk = k
.
j=1 p
L’étude théorique montre que la suite (Zk )k∈N∗ converge en loi vers la loi du χ2 à p − 1 degrés de liberté.

41/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

Code Scilab :
clf;clc;

a=0.5 ; b=%e/(a+%e);
n=30; r=n/2; N=5000

titre=’chi-2 à n=’+string(n)+’ degrés de liberté - 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 carrés de normales (0,1) - timer=’+string(t)
legend(leg)
plot2d(x,chi2,style=1)

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

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

42/43
Formation en ligne à Scilab - HEC Paris 11 mars 2014

43/43

Vous aimerez peut-être aussi