simulation de lois
TRANSCRIPT
Christine HEINEMANNECE 2 - Lycee Henri IV - Paris
Formation en ligne a Scilab - Seance enregistree le 11 mars 2014 a HEC Paris
SIMULATION DE LOIS
- SOMMAIRE -
PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPRESENTATIONS SCILAB 1
Quelques remarques generales 1rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2Quelques remarques sur la definition des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 2Quelques remarques sur la definition des vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . 3tabul, bar, plot2d3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3histplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3Trace des fonctions de repartition empiriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Exemple 1 : loi binomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4Exemple 2 : loi normale centree reduite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Simulations classiques 6Loi uniforme discrete sur [[n1, n2]] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Avec plot2d3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Avec bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Loi uniforme sur [a, b[ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Application aux 〈〈douze uniformes 〉〉 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Principe et code associe - comparaison avec grand . . . . . . . . . . . . . . . . . . . . . . . . . 9Comparaison avec Box-Muller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Loi binomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12Illustration du Theoreme Limite Central . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Loi de Poisson via grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Illustration du Theoreme Limite Central . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Loi geometrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Loi binomiale negative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
LA METHODE D’INVERSION 19
Variables discretes 19Variables aleatoires finies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Loi de Bernoulli de parametre p ∈]0, 1[ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Loi binomiale de parametres (n, p), p ∈]0, 1[ et n ∈ N . . . . . . . . . . . . . . . . . . . . . . . 19Comparaison en termes de temps de calcul avec l’algorithme ESSEC 2006 E3 . . . . . . . . . . . 21
Variables aleatoires discretes infinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Loi geometrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23Loi de Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Variables a densite 25Loi exponentielle de parametre λ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Application a la simulation d’une loi geometrique . . . . . . . . . . . . . . . . . . . . . . . . . 26Application a la simulation d’une loi de Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Loi de Laplace (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Loi logistique (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Loi de Pareto (generale) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Loi de Cauchy (standard) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Mise en evidence de la non existence de l’esperance . . . . . . . . . . . . . . . . . . . . . . . . 31
LA METHODE DU REJET 32
Introduction : simulation d’une loi uniforme sur le disque unite 32
Cas d’une densite a support compact et majoree 34Exemple : loi beta de parametres (a, b) ∈ [1,+∞[2 via la methode du rejet . . . . . . . . . . . . 34Quelques autres methodes de simulation de la loi beta . . . . . . . . . . . . . . . . . . . . . . . 36
Via l’algorithme de Jonk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36Via les statistiques d’ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37Via un resultat de convergence - ESSEC 2004 E3 . . . . . . . . . . . . . . . . . . . . . . . . . 38
Extension aux densites a support non compact 39Application a la simulation de la loi normale via la loi de Laplace . . . . . . . . . . . . . . . . . 39Application a la simulation des lois Gamma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Application : loi du χ2 a n degres de liberte via differentes methodes . . . . . . . . . . . . . . . 41
Par la methode du rejet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Par la loi normale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Par un resultat de convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Formation en ligne a Scilab - HEC Paris 11 mars 2014
SIMULATION DE LOIS
I - PREMIERS PAS : SIMULATIONS CLASSIQUES ET REPRESENTATIONS SCILAB
A. Quelques remarques generales
1) rand
rand() est l’equivalent de random en Turbo-Pascal.Il est possible de reinitialiser l’etat interne du generateur aleatoire (specifie par un entier de l’intervalle[0, 231 − 1])) ; s=rand("seed") renvoie la valeur courante de la graine.
A graine fixee, rand() fournira toujours la meme serie de valeurs : essayer par exemple avec
Code Scilab :
N=20
A=zeros(N,5)
rand("seed",0)
for i=1:N A(i,:)=rand(5); end
disp(A)
Cela peut etre utile dans le but de pouvoir obtenir des simulations reproductibles (par defaut la graineest initialisee a s=0 au premier appel, la sequence sera toujours la meme d’une session a l’autre)Si l’on souhaite des sequences moins previsibles, on peut initialiser la graine avec getdate, qui renvoiela date en secondes ecoulees depuis le 1er Janvier 1970 - et change donc toutes les secondes
Code Scilab :
s=getdate("s")
rand("seed",s)
disp(rand())
(on constate que si on va tres vite, les valeurs de rand() ne changent pas...)
Code Scilab :
for i=1:5
s=getdate("s")
rand("seed",s)
disp(rand())
end
:::::::::Quelques
::::::::options :
r=rand(n1,n2,..,nk) renvoie une matrice aleatoire de dimensions n1 × n2 × ... × nk. En particulier,
r=rand(n1,n2) renvoie une matrice aleatoire de dimensions n1 × n2. Pour un vecteur, il faut specifier
ligne ou colonne : r=rand(1,n2) ou r=rand(n1,1) ( r=rand(A) renvoie une matrice aleatoire de meme taille
que la matrice A donc si on entre r=rand(n1) on obtient exactement le meme resultat que r=rand() ...)
rand("uniform") : la loi par defaut est la loi uniforme sur [0, 1].
rand("normal") : la loi par defaut est la loi normale centree reduite.
1/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
Le generateur de nombres aleatoires 〈〈uniform 〉〉 est de type Urand (Universal Random Number Generator).
C’est un generateur lineaire a congruence de la forme x = (ax+ c) mod M avec
a = 843314861
c = 453816693
M = 231.
Le generateur de nombres aleatoires 〈〈normal 〉〉 est obtenu par la methode de Box-Muller (la source denombres uniformes etant toujours Urand).
2) grand
La fonction grand dispose de generateurs aleatoires produisant des sequences de nombres qui possedentde meilleures qualites statistiques que rand. Par consequent, dans les situations ou la qualite statistiquedes sequences de nombres aleatoires est importante, il vaut mieux utiliser la fonction grand. Cettefonction dispose par ailleurs de fonctionnalites tres variees dont voici les plus classiques (les instructionsci-dessous renvoient une matrice de taille N ×M de valeurs obtenues selon la loi choisie) :
X=grand(N,M,"uin",n1,n2) simule une variable aleatoire suivant la loi uniforme sur [[n1, n2]] ;
X=grand(N,M,"bin",n,p) simule une variable aleatoire suivant la binomiale de parametres (n, p) ;
X=grand(N,M,"nbn",r,p) simule une variable aleatoire suivant la binomiale negative de parametres (r, p) ;
X=grand(N,M,"geom",p) simule une variable aleatoire suivant la loi geometrique de parametre p ;
X=grand(N,M,"poi",lambda) simule une variable aleatoire suivant la loi Poisson de parametre λ ;
X=grand(N,M,"def") simule une variable aleatoire suivant la loi uniforme sur [0, 1[ ;
X=grand(N,M,"unf",a,b) simule une variable aleatoire suivant la loi uniforme sur [a, b[ ;
X=grand(N,M,"exp",1/lambda) simule une variable aleatoire suivant la exponentielle de parametre λ ;
X=grand(N,M,"gam",nu,1/b) simule une variable aleatoire suivant la loi gamma de parametres (b, ν) ;
X=grand(N,M,"bet",a,b) simule une variable aleatoire suivant la loi beta de parametres (a, b) ;
X=grand(N,M,"nor",m,sigma) simule une variable aleatoire suivant la loi normale de parametres (m,σ2).
X=grand(N,M,"chi",n) simule une variable aleatoire suivant la loi du chi-2 a n degres de liberte ;
• Pour initialiser la graine avec getdate :
Code Scilab :
s=getdate("s");
grand("setsd",s)
• A noter aussi : X=grand(n,"prm",U) genere n permutations aleatoires d’un vecteur colonne U . Exemple :
Code Scilab :
U=[1:10]’
X=grand(5,"prm",U)
disp(X)
3) Quelques remarques sur la definition des fonctions
On utilisera ici soit deff(’...’,’...’) soit function... endfunction, avec des operations pointees.Pour plus d’options, voir le document pdf d’Herve Chabert (seance E2) p9.
2/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
4) Quelques remarques sur la definition des vecteurs
• Pour des vecteurs espaces regulierement : x=1:n ou x=[1:n] (avec n ∈ N∗) cree le vecteur ligne(1, 2, ..., n) (c’est ce dont on se sert dans les boucles for). Pour un vecteur colonne, il faudra ecrirex=[1:n]’. Remarque : si a est un reel, x=1:a sort le vecteur ligne (1, ..., bac) si a ≥ 1 (et le vecteur ligne〈〈vide 〉〉 si a < 1). Si on souhaite des espacements non entiers : x=1:eps:n ou eps designe le pas (il n’estpas necessaire que cela 〈〈 tombe juste 〉〉 : par exemple, x=1:0.3:2 donnera le vecteur (1, 1.3, 1.6, 1.9). Celapeut aussi servir a obtenir des vecteurs a composantes decroissantes : par exemple, x=n:-1:1 donnera levecteur (n, n− 1, ..., 1) et x=1:-0.25:0 le vecteur (1, 0.75, 0.5, 0.25, 0)...
• Autre option : linspace. Par defaut, le nombre de valeurs est 100. Par exemple, x=linspace(1,1.99)creera un vecteur x de composantes 1, 1.01, 1.02,...,1.99. Sinon, on peut preciser (en dernier argument) lenombre de composantes de x : par exemple, x=linspace(1,2,5) creera le vecteur (1, 1.25, 1.5, 1.75, 2).Pour obtenir des vecteurs colonnes, il suffit de rajouter un 〈〈prime 〉〉 derriere la parenthese. Cela marcheaussi pour des decomposantes decroissantes : x=linspace(1,-1,3) creera le vecteur (1, 0,−1).
• La premiere methode cree ainsi des vecteurs correspondant a des classes de largeur fixee ; leur nombredependra des valeurs minimale et maximale du vecteur, et il est possible que la valeur maximale ne soitpas atteinte (si cela ne tombe pas juste). La seconde methode cree des vecteurs a nombre de classesfixe. Ces classes seront toutes d’une meme largeur, determinee par les valeurs minimale et maximale duvecteur, qui correspondront respectivement a la premiere et a la derniere composante du vecteur.
5) tabul, bar, plot2d3
• si x est un vecteur ou une matrice, tabul(x) est une matrice a deux colonnes, la premiere contenant lesvaleurs prises par les composantes de x rangees dans l’ordre decroissant (ordre par defaut) et la secondecolonne contenant le nombre d’occurrences de chaque valeur ; tabul(x, "i") est construit sur le memeprincipe, mais avec les valeurs rangees dans l’ordre croissant (i pour increase).
• Pour obtenir un diagramme en batons, il suffit d’ecrire le code y = tabul(x,"i"); puis bar(y(:,1), y(:,2)/N);
ou plot2d3(y(:,1), y(:,2)/N); (ou N est le nombre de composantes de x : N=length(x) ).
→ bar trace un diagramme en batons de largeur par defaut 0, 8 (1 etant la 〈〈 largeur maximale autorisee 〉〉,i.e. la distance minimale entre deux valeurs reportees dans l’histogramme). On peut changer cette largeuren rajoutant width=.... On peut egalement changer la couleur (avec color et non style ici).
→ plot2d3 fonctionne comme plot2d (memes possibilites d’options) mais trace les courbes avec desbarres verticales.
6) histplot
On suppose les donnees regroupees dans un vecteur (ou une matrice) y.
• Deux options principales : histplot(x,y) et histplot(n,y) (n ∈ N∗).histplot(x,y) : x est un vecteur aux composantes strictement croissantes definissant les classes.
histplot(n,y) : n designe le nombre de classes. Les classes sont equireparties entre a = min(y) etb = max(y), ce qui reviendrait a ecrire histplot(x,y) avec x le vecteur a n+ 1 composantes defini par
pour tout k ∈ [[1, n + 1]], x(k) = a + (k − 1)
(b− an
)(les vecteurs et matrices en Scilab commencent
toujours a 1). La premiere classe est alors [x(1), x(2)] et les suivantes ]x(i), x(i+ 1)] (i ∈ [[2, n]]).
• On peut rajouter des options de couleur, trace, normalisation, etc. (les memes que pour plot2d).Par exemple, histplot(x,y,style=5,rect=[-1,0,1,2],normalization=%f) renverra un histogramme trace en
rouge (style 5), la zone de trace etant le rectangle [−1, 1]× [0, 2], et les valeurs etant non normalisees.
• Par defaut, les histogrammes sont normalises (inutile, donc, d’ecrire normalization=%t), c’est-a-dire, siN est le nombre de composantes de y (i.e. le nombre total de donnees), n est le nombre de classes, et pourtout i ∈ [[1, n]], Ni est le nombre de donnees appartenant a la classe Ci, la valeur de l’ordonnee correspon-
dant a la classe Ci seraNi
N(x(i+ 1)− x(i)), de maniere a ce que l’aire de l’histogramme correspondant
a Ci soit egale aNi
N, et donc que l’aire totale soit egale a 1.
3/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
7) Trace des fonctions de repartition empiriques
Voici un code simple permettant de tracer la fonction de repartition empirique correspondant a unechantillon u de donnees :
Code Scilab :
function Fr_empirique(u)
L = length(u)
x = gsort(u,’g’,’i’)
y = (1:L) /L
plot2d2(x, y,style=5, leg="Fonction de repartition empirique")
endfunction
length(u) donne la 〈〈 longueur 〉〉 de u, c’est-a-dire son nombre de composantes.
gsort avec l’option ’i’ (il est alors obligatoire de preciser aussi en seconde position l’option ’g’ qui estsinon par defaut) trie les valeurs de u (via l’algorithme 〈〈quick sort 〉〉) par ordre croissant.
a) Exemple 1 : loi binomiale :
Code Scilab :
clf;//pour "nettoyer" la fenetre des figures
clc;//pour "nettoyer" la console Scilab
N = 10000; n=10,p=0.2
u = grand(N,1,"bin",n,p);
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 regler les options des axes
a.font_size=1; //taille de la legende sur les axes
a.x_location="bottom"; //position de l’axe des abscisses
a.y_location="origin";//position de l’axe des ordonnees
4/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
b) Exemple 2 : loi normale centree reduite :
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 a Scilab - HEC Paris 11 mars 2014
B. Simulations classiques
1) Loi uniforme discrete sur [[n1, n2]]
a) Avec plot2d3 :
Code Scilab :
clf;clc;
n1=-2;n2=11;
N=10000;
U =grand(1,N,"uin",n1,n2);
X = tabul(U,"i");
plot2d3(X(:,1), X(:,2)/N,rect= [-3,0,12,.09],style=2)
titre=’Loi uniforme discrete sur l’’intervalle d’’entiers [n1=’+string(n1)+’,n2=’+string(n2)+’]..
- N=’+string(N)
xtitle(titre)
a=get("current_axes") ;
a.font_size=1;
a.x_location="bottom";
a.y_location="left";
6/43
Formation en ligne a 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 discrete sur l’’intervalle d’’entiers [n1=’+string(n1)+’,n2=’+string(n2)+’]..
- N=’+string(N)
xtitle(titre)
a=get("current_axes") ; a.font_size=1; a.x_location="bottom"; a.y_location="left";
::::::::::Remarque : il est aussi possible de simuler une uniforme discrete a partir de rand() et floor en remplacantla ligne U =grand(1,N,"uin",n1,n2); par U =n1+floor((n2-n1+1)*rand(1,N)); .
7/43
Formation en ligne a 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 echantillon de loi uniforme sur [0, 1[ : U=grand(1,N,"def"); .
8/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
3) Application aux 〈〈douze uniformes 〉〉
a) Principe et code associe - comparaison avec grand :
La variable centree-reduite associee a1
12
12∑i=1
Ui est12∑i=1
Ui − 6, donc particulierement simple a ecrire, et
de plus, fournit deja une bonne approximation de la loi normale centree reduite.
Code Scilab :
clf; clc ;
N=10000;
x = [-5 : 0.1 : 5];
y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi )
subplot(1,2,1);
U=grand(N,12,"def");
z=sum(U,’c’)-6;
plot2d(x, y,rect=[-5,0,5,0.45],style=1)
histplot(x, z,style=2)
titre=’Simulation de loi normale via les douze uniformes (N=’+string(N)+’)’
xtitle(titre)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
subplot(1,2,2);
z = grand(1,N,"nor", 0, 1);
plot2d(x, y,rect=[-5,0,5,0.45])
histplot(x, z,style=5)
titre=’Simulation de loi de la loi normale centree reduite avec grand (N=’+string(N)+’)’
xtitle(titre)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
9/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
b) Comparaison avec Box-Muller :
Principe : Si U et V sont deux variables aleatoires independantes suivant la loi uniforme sur ]0, 1]alors X =
√−2 lnU cos(2πV ) suit la loi normale centree reduite.
Code Scilab :
clf ;clc ;
N=10000;
x = [-5 : 0.1 : 5];
y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );
subplot(1,2,1);
timer();
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-Muller (N=’+string(N)+’) - timer=’+string(t)
xtitle(titre)
10/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
Le resultat complet etant que Y =√−2 lnU sin(2πV ) suit egalement la loi normale centree reduite et
que de plus, X et Y sont independantes, on peut s’en inspirer pour alleger le code en ne simulant queN uniformes au lieu de 2N :
Code Scilab :
clf ;clc ;
N=10000;
x = [-5 : 0.1 : 5];
y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );
subplot(1,2,1);
timer();
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-Muller (N=’+string(N)+’) - timer=’+string(t)
xtitle(titre)
Les deux methodes semblent assez equivalentes en termes de temps de calcul et de resultats !
11/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
4) Loi binomiale
a) Simulation :Les boucles for peuvent presenter un certain interet lors de l’apprentissage de Scilab en premiereannee ; petit a petit, le 〈〈 jeu 〉〉 consistera a apprendre a s’en passer a chaque fois qu’il y aura plussimple...
−→ Premiere version, encore tres impregnee de Turbo-Pascal :
Code Scilab :
clc ;clf;
n=10; N=100; p=0.7
// Simulation via Bernoulli
subplot(1,3,1) ;
function y=Bin(n,p)// Fonction simulant une loi binomiale (n,p)
y=0;
for i=1:n
if grand(1,1,"bin",1,p)==1
y=y+1;// Ou bien : if rand()<p
end
end
endfunction
for i=1:N ; x(i)=Bin(n,p); end
z=tabul(x,"i")
bar(z(:,1),z(:,2)/N, width =0.2,color="b")
xtitle("", "Classes", "Effectifs par classe normalises")
legend(’Simulation via Bernoulli’)
a = get("current_axes");
a.data_bounds([3 4]) = [0 0.4];
// Simulation via grand
subplot(1,3,2) ;
x = grand(1,N,"bin", n, p);
z=tabul(x,"i")
bar(z(:,1),z(:,2)/N,width=0.2,color="r")
titre =’Loi binomiale de parametres (n=’+ string(n)+’, p=’+string(p)+’)-Echantillon de..
taille N=’+ string(N);
xtitle(titre, "Classes", "Effectifs par classe normalises")
legend(’Simulation via grand’)
a = get("current_axes");
a.data_bounds([3 4]) = [0 0.4];
// Distribution theorique
subplot(1,3,3) ; a=get("current_axes"); a.font_size=1; a.x_location="bottom";
function t = triangle_de_Pascal(n)
tableau = [ones(n,1), eye( n, n)];
for p=2:n
for k=2:p tableau(p,k) = tableau(p-1,k) + tableau(p-1, k-1); end
end
t = tableau(n,:) // : signifie "toutes les colonnes"
endfunction // "k parmi n"" est donne par t(k+1)
c = triangle_de_Pascal(n);// Calcul des coefficients binomiaux
x=0:n; y=zeros(n)
for k=x
y(k+1) = c(k+1) * (p^k) * (1-p)^(n-k);
end
plot2d3(x, y, rect=[-0.5,0,11,0.4],style=1);
xtitle("", "Valeurs de k", "P(X=k)")
legend(’Distribution theorique’)
12/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
• Attention a l’ordre des instructions dans bar (width avant color).• Comme on ne peut pas regler la fenetre avec bar de la meme maniere qu’avec plot2d3, il est possiblede redefinir apres coup les axes avec a = get("current axes"); a.data bounds([3 4]) = [0 0.4]; - pour queles y aillent de 0 a 0.4 ; si on veut redefinir l’echelle des x, il faut prendre
a = get("current axes"); a.data bounds([1 2]) = [... ...];
et pour redefinir l’ensemble : a = get("current axes"); a.data bounds= [... ... ... ...];
• Variante pour Bernoulli : on peut remplacer if grand(1,1,"bin",1,p)==1; y(k)=y(k)+1; end par
y(k)=y(k)+(rand()<p); (puisque rand()<p est un booleen valant 1 s’il est realise...)
•Mieux encore : on peut remplacer toute la fonction Bin par l’unique instruction sum(rand(n,N) < p, ’r’) !
• Variante pour les coefficients binomiaux, beaucoup plus rapide et astucieuse (idee de Lionel Dorat, ECS2
a Valence) : c = [1 cumprod((n:-1:1)./(1:n))]; .
(n
k
)est alors donne par c(k+1) (les vecteurs commencant
toujours a 1). C’est cette ecriture, qui tient en une ligne, que nous utiliserons par la suite.
• Il est egalement possible de se passer de la boucle for pour la distribution theorique :
−→ Seconde version (〈〈methode Scilabique 〉〉) :
Code Scilab :
clc ;clf;
n=10; N=1000; p=0.7;
titre = ’Loi binomiale de parametres (n=’+ string(n)+’, p=’+string(p)+’) - ..
Echantillon de taille N=’ + string(N);
// Simulation via Bernoulli
subplot(1,3,1) ;
x=sum(rand(n,N) < p, ’r’)
y=tabul(x,"i")
bar(y(:,1),y(:,2)/N,width=0.2,color="b")
a = get("current_axes"); a.data_bounds([3 4]) = [0 0.4];
legend("Simulation via Bernoulli")
// Simulation via grand
subplot(1,3,2) ; a=get("current_axes"); a.font_size=1; a.x_location="bottom";
x = grand(1,N,"bin", n, p);
y=tabul(x,"i")
bar(y(:,1),y(:,2)/N,width=0.2,color="r")
a = get("current_axes"); a.data_bounds([3 4]) = [0 0.4];
legend("Simulation via grand")
xtitle(titre)
// Distribution theorique
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 theorique’)
13/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
b) Illustration du Theoreme Limite Central :
Code Scilab :
clf;clc;
N=100000; n=[10,50,100] ; p=0.5
x = [-5 : 0.1 : 5];
y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );
for i=1:3
z = (grand(1,N,"bin", n(i), p)-n(i)*p)/sqrt(n(i)*p*(1-p));
L=([-1:n(i)]-n(i)*p+1/2)/sqrt(n(i)*p*(1-p));
subplot(1,3,i);
plot2d(x, y,style=1)
histplot(L, z, rect=[-5,0,5,0.45],style=5)
leg=’n=’+string(n(i))+’ et p=’+string(p)
legend(leg)
if i==2;
xtitle("Illustration du Theoreme Limite Central");
end
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
end
14/43
Formation en ligne a 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 parametre 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 normalises")
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 theorique", "Valeurs de k", "P(X=k)")
15/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
b) Illustration du Theoreme Limite Central :
Code Scilab :
clf;clc;
x = [-5 : 0.1 : 5];
y=exp(- (x^2) / 2) ./ sqrt( 2 * %pi );
titre=’Illustration du Theoreme Limite Central - N=’+string(N)
N=10000;lambda=[5,50,100]
for i=1:3
z = (grand(1,N,"poi", lambda(i))-lambda(i))/sqrt(lambda(i));
L=([-1:lambda(i)+3*sqrt(lambda(i))]-lambda(i)+1/2)/sqrt(lambda(i));
subplot(1,3,i);
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 a Scilab - HEC Paris 11 mars 2014
5) Loi geometrique
Code Scilab :
clf;clc;
p = 0.2; N=10000;
titre=’Loi geometrique de parametre p=’+string(p)+’ - N=’+string(N)
// Simulation de la loi geometrique a partir d’une loi de Bernoulli
subplot(1,3,1) ;
timer();
x=ones(1,N)
for i = 1:N
while (rand() > p) // Autre possibilite : while grand(1,1,"bin",1,p)==0
x(i) = x(i)+ 1;
end
end
t=timer();
y=tabul(x,"i")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=2);
xtitle("", "Classes","Effectifs par classe normalises")
leg=’A partir d’’une loi de Bernoulli - timer=’+string(t); legend(leg)
// Simulation de la loi geometrique avec grand
subplot(1,3,2) ;
timer();
x = grand(1,N,"geom", p);
t=timer();
y=tabul(x,"i")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=5);
xtitle(titre,"Classes", "Effectifs par classe normalises")
leg=’Avec grand - timer=’+string(t) ; legend(leg)
// Loi geometrique theorique
x=1:20
y = (1-p)^(x-1) * p;
subplot(1,3,3); a=get("current_axes"); a.font_size=1; a.x_location="bottom";
plot2d3(x, y, rect=[-0.5,0,21,p],style=1);
xtitle("", "Valeurs de k", "P(X=k)"); legend("Distribution theorique")
On constate que la seconde methode est nettement plus rapide...
17/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
5) Loi binomiale negative
Code Scilab :
clf;clc;
p = 0.2; r=4 ;
N=10000;
titre=’Loi binomiale negative de parametres (r=’+string(r)+’, p=’+string(p)+’) - N=’+string(N)
// Simulation de la loi binomiale negative a partir d’une loi de Bernoulli
subplot(1,2,1) ;
x=ones(1:N)
for i = 1:N
s=0;
while(s<r)
s=s+1;
while (rand() > p) // Autre possibilite : while grand(1,1,"bin",1,p)==0
x(i) = x(i) + 1;
end
end
end
y=tabul(x,"i")
plot2d3(y(:,1), y(:,2)/N, rect=[-0.5,0,51,0.08],style=2)
xtitle(titre, "Classes","Effectifs par classe normalises")
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 negative 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 normalises")
legend("Avec grand")
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
18/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
II - LA METHODE D’INVERSION
A. Variables discretes
1) Variables aleatoires finies
Principe : Soit X une variable aleatoire prenant un nombre fini de valeurs x0, ..., xn (n ∈ N).
On note pour tout k ∈ [[0, n]], Fk =
k∑i=0
P (X = xi) et F−1 = 0.
On definit pour tout u ∈ [0, 1], H(u) =n∑i=0
xi I1[Fi−1<u≤Fi].
Si U suit la loi uniforme sur [0, 1], H(U) suit la meme loi que X.
a) Loi de Bernoulli de parametre p ∈]0, 1[ :
Ici, x0 = 0, x1 = 1, F0 = 1− p, F1 = 1.
if rand()<= 1-p then X=0; else X=1; end ou de maniere equivalente : if 1-rand()<p then X=1; else X=0; end
ou encore, puisque 1 − U suit la loi uniforme sur [0, 1] : if rand()<p then X=1; else X=0; end (choix
generalement retenu pour coder une Bernoulli)... et comme un booleen, lorsqu’il est vrai, vaut 1 en Scilab,on peut meme se passer du if...then : rand()<p simule ainsi la loi de Bernoulli.
b) Loi binomiale de parametres (n, p), p ∈]0, 1[ et n ∈ N :
Code Scilab :
clf;clc;
n=10 ; p=0.5 ;
titre=’Loi binomiale de parametres (n=’+string(n)+’, p=’+string(p)+’)’
c=[1 cumprod((n:-1:1) ./(1:n))]
k=0:n
z=c .* (p^k) .* (1-p)^(n-k)
//Simulation via Inversion
F=cumsum(z);
N=1000
u=rand(1,N)
[x,b]=dsearch(u,F)
y=tabul(x,"i")
subplot(1,2,1) ;
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,11,0.3],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalises")
legend(’Simulation via Inversion’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
// Distribution theorique
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 theorique’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
19/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
Note sur la commande dsearch : [x,b]=dsearch(u,F) cree un vecteur x tel que pour tout i ∈ [[1, N ]], x(i)est egal a l’entier k tel que u(i) appartienne a l’intervalle ]F (k), F (k+1)] et vaut 0 s’il n’appartient a aucunde ces intervalles. b(k) compte le nombre de composantes de x appartenant a l’intervalle ]F (k), F (k + 1)]et est inutile ici - quoique indispensable en entree dans la commande de dsearch. Cette commande estcitee dans le theme 1 (statistiques descriptives univariees) des nouveaux programmes de seconde annee.On peut aussi la remplacer par les lignes de code suivantes :
Code Scilab :
x=zeros(1,N)
for i=1:N
while (u(i)> F(x(i)+1))
x(i)=x(i)+1 ;
end;
end
(Comme F(n+1)=1, il est certain que pour tout i ∈ [[1, N ]], la boucle while s’arrete au bout d’au plusn+ 1 tests - et n incrementations de x(i)).
20/43
Formation en ligne a 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 aleatoire X suivant une loi binomiale de parametres (2n, 1/2), on peut effectuerle reagencement suivant : pour tout k ∈ [[0, 2n]], si k est pair, on pose p′k = P (X = n + k/2) et si k estimpair, p′k = P (X = n− (k + 1)/2).
Alors p′0 ≥ p′1 ≥ ... ≥ p′2n et on effectue l’algorithme de la methode d’inversion avec les effectifs cumulesdes nombres p′i, i ∈ [[0, 2n]] - qui correspondent aux valeurs X = [x′0...x
′2n] ou pour tout k ∈ [[0, 2n]], si k
est pair, x′k = n+ k/2 et si k est impair, x′k = n− (k + 1)/2.
L’etude theorique conclut a un nombre moyen de passages dans la boucle while de l’ordre de√n - contre
un nombre moyen de n pour l’algorithme 〈〈brut 〉〉.
21/43
Formation en ligne a 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 normalises")
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 normalises")
leg=’via methode 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 methode.
22/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
2) Variables aleatoires discretes infinies
Principe : Soit X une variable aleatoire d’ensemble image denombrable X(Ω) = xi, i ∈ N.
On note pour tout k ∈ N, Fk =
k∑i=0
P (X = xi) et F−1 = 0.
On definit pour tout u ∈ [0, 1], H(u) =
+∞∑i=0
xi I1[Fi−1<u≤Fi].
Si U suit la loi uniforme sur [0, 1], H(U) suit la meme loi que X.
a) Loi geometrique :
Code Scilab :
clf;clc;
p=0.3; n=20; N=10000
titre=’Loi geometrique de parametre p=’+string(p)
z=p*(1-p)^([0:n-1]);
F=cumsum(z)
u=rand(1,N)
[x,b]=dsearch(u,F)
y=tabul(x,"i")
subplot(1,2,1) ;
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,20,0.4],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalises")
legend(’Simulation via Inversion’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
subplot(1,2,2); // Distribution theorique
plot2d3(1:n, z, rect=[-0.5,0,20,0.4],style=5);
xtitle("", "Valeurs de k", "P(X=k)")
legend(’Distribution theorique’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
23/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
e) Loi de Poisson :
Code Scilab :
clf;clc;
lambda=5; N=1000;
titre=’Loi de Poisson de parametre lambda=’+string(lambda)+’- N=’+string(N)
n=20;
z=exp(-lambda)*lambda^([0:n]) ./factorial([0:n]);
// On peut aussi remplacer factorial par cumprod([1 1:n])...
F=cumsum(z);
u=rand(1,N)
[x,b]=dsearch(u,F)
y=tabul(x,"i")
subplot(1,2,1) ;
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,20,0.3],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalises")
legend(’Simulation via Inversion’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
subplot(1,2,2) ; // Distribution theorique
plot2d3(0:n, z, rect=[-0.5,0,n+1,0.3],style=5);
xtitle("", "Valeurs de k", "P(X=k)")
legend(’Distribution theorique’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
24/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
B. Variables a densite
Principe : si X est une variable aleatoire a densite dont la fonction de repartition F definit une bijectionde ]a, b[ (−∞ ≤ a < b ≤ +∞) sur ]0, 1[ et si U suit la loi uniforme sur ]0, 1[ alors F−1(U) suit la memeloi que X.
1) Loi exponentielle de parametre λ
a) Simulation :
Code Scilab :
clf;clc;
N=10000;lambda=0.5
titre=’Loi exponentielle de parametre lambda=’+string(lambda)+’ - N=’+string(N)
x=0:0.1:10
y=lambda*exp(-lambda*x)
subplot(1,2,1);
z=-1/lambda*log(rand(1,N));
histplot(x, z,style=2)
xtitle(titre, "Classes", "Effectifs par classe normalises")
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 normalises")
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 a Scilab - HEC Paris 11 mars 2014
b) Application a la simulation d’une loi geometrique :
L’instruction floor(log(1-rand())/log(1-p))+1 ou floor(log(rand())/log(1-p))+1 permet de simuler une loigeometrique de parametre p.
Code Scilab :
clf;clc;
p = 0.2; N=10000;
titre=’Loi geometrique de parametre p=’+string(p)+’ - N=’+string(N)
// Simulation de la loi geometrique avec la methode d’inversion/loi exponentielle
subplot(1,3,1) ;
timer();
x = floor(log(rand(1,N))/log(1-p))+1;
t=timer();
y=tabul(x,"i")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=2);
xtitle("", "Classes","Effectifs par classe normalises")
leg=’Avec une loi exponentielle:inversion - timer=’+string(t); legend(leg)
// Simulation de la loi geometrique avec grand
subplot(1,3,2) ;
timer();
x = grand(1,N,"geom", p);
t=timer();
y=tabul(x,"i")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,21,p],style=5);
xtitle(titre,"Classes", "Effectifs par classe normalises")
leg=’Avec grand - timer=’+string(t) ; legend(leg)
// Loi geometrique theorique
x=1:20
y = (1-p)^(x-1) * p;
subplot(1,3,3); a=get("current_axes"); a.font_size=1; a.x_location="bottom";
plot2d3(x, y, rect=[-0.5,0,21,p],style=1);
xtitle("", "Valeurs de k", "P(X=k)"); legend("Distribution theorique")
26/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
c) Application a la simulation d’une loi de Poisson :
Un resultat classique (voir par exemple Oral ESCP 2008 ex. 3.5) et base la methode d’inver-sion appliquee aux lois exponentielles montre que si (Un)n∈N∗ est une suite de variables aleatoiresmutuellement independantes suivant toutes la loi uniforme sur ]0, 1] alors la variable aleatoire Xdefinie pour tout ω ∈ Ω par
X(ω) =
0 si U1(ω) < e−λ
minn ∈ N∗ : U1(ω)...Un+1(ω) < e−λ sinon
suit une loi de Poisson de parametre λ.
D’ou le code suivant pour simuler une variable aleatoire suivant une loi de Poisson de parametre λ (oncompare en termes de temps a la methode d’inversion 〈〈directe 〉〉) :
Code Scilab :
clf;clc;
lambda=7; n=20; N=1000
titre=’Loi de Poisson de parametre lambda=’+string(lambda)
subplot(1,2,1) ;
z=exp(-lambda)*lambda^([0:n]) ./factorial([0:n])
F=cumsum(z); u=rand(1,N)
[x,b]=dsearch(u,F)
y=tabul(x,"i")
plot2d3(y(:,1),y(:,2)/N, rect=[-0.5,0,20,0.3],style=2)
xtitle(titre, "Classes", "Effectifs par classe normalises")
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 normalises")
legend(’Simulation via Exponentielle’)
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
27/43
Formation en ligne a 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 normalises")
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 difference de deux exponentielles de parametre 1 independantes
subplot(1,2,2);
t=grand(N,1,"exp",1)-grand(N,1,"exp",1)
histplot(x, t,style=5);
xtitle("", "Classes", "Effectifs par classe normalises")
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 a 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 normalises")
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 a Scilab - HEC Paris 11 mars 2014
4) Loi de Pareto (generale)
X suit une loi de Pareto de parametres (α, a, x0) ∈ (R∗+)2 × R si X admet comme densite
f : x 7−→ α
a
(a
x− x0
)α+1
I1[x0+a,+∞[.
X admet alors comme fonction de repartition F : x 7−→[1−
(a
x− x0
)α]I1[x0+a,+∞[, d’ou le code :
Code Scilab :
clf;clc
alpha=3
a=2
x0=1
titre=’Simulation de la loi de Pareto de parametres (alpha=’+string(alpha)+’, a=’+string(a)..
+’,x0=’+string(x0)+’) via inversion’
x=2.5:0.1:12
y=alpha*a^alpha ./(x-x0)^(alpha+1);
N=10000;
u=rand(1,N);
z=a*(1-u)^(-1/alpha)+x0
histplot(x, z, style=2)
xtitle(titre, "Classes", "Effectifs par classe normalises")
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 a 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 normalises")
a=get("current_axes"); a.font_size=1; a.x_location="bottom";
legend("Courbe theorique")
b) Mise en evidence de la non existence de l’esperance :On peut par exemple proposer le code suivant :
Code Scilab :
clc;clf;
N=100;n=20
z=tan(%pi*(rand(n,N)-1/2))
disp(mean(z,’c’))
y=tabul(mean(z,’c’),’i’)
bar(y(:,1),y(:,2)/n,color="r")
31/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
III - LA METHODE DU REJET
A. Introduction : simulation d’une loi uniforme sur le disque unite
Le resultat theorique a la base de la methode du rejet est que si (Wn)n∈N∗ est une suite de variablesaleatoires mutuellement independantes suivant une loi uniforme sur une partie A de R2 d’aire finie nonnulle et que B ⊂ A (B egalement d’aire non nulle), alors en definissant N = infn ∈ N∗ : Wn ∈ B,WN suit une loi uniforme sur B.On remarque que la generation de WN necessite un nombre d’iterations suivant une loi geometrique.
Ainsi, pour simuler une variable suivant une loi uniforme sur le disque unite :
Code Scilab :
clf;clc;
i=1
for n=[500,800,1000]
subplot(1,3,i)
titre=’Uniforme sur disque via rejet, n=’+string(n)+’ tirages’
u=ones(1,n);v=ones(1,n)
for k=1:n
while (u(k)^2+v(k)^2>1)
u(k)=2*rand()-1;
v(k)=2*rand()-1;
end
end
plot(u,v,"d")
xtitle(titre)
a = gca();
a.isoview = "on";
i=i+1
end
32/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
Remarque : on pourrait etre tente, pour simuler une loi uniforme sur le disque, de tirer au hasard un angleentre 0 et 2π : angle=2%pi*rand() et un rayon egalement uniformement entre 0 et 1 : rayon=rand() maison constate alors que le centre est nettement favorise !
C’est normal : il faut en fait prendre r =√U ou U → [0, 1]...
D’ou le code suivant :
Code Scilab :
clf;clc;
n=800
subplot(1,2,1)
rayon=rand(1,n);angle=2*%pi*rand(1,n);
x=rayon .*cos(angle);
y=rayon .*sin(angle);
plot(x,y,"d")
legend(’Uniforme sur disque tentative 1 (la mauvaise)’)
a = gca();
a.isoview = "on";
subplot(1,2,2)
rayon=sqrt(rand(1,n));angle=2*%pi*rand(1,n);
x=rayon .*cos(angle);
y=rayon .*sin(angle);
plot(x,y,"d")
legend(’Uniforme sur disque tentative 2 (la bonne)’)
a = gca();
a.isoview = "on";
33/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
B. Cas d’une densite a support compact et majoree
Hypotheses : Soit X une variable aleatoire reelle admettant une densite f telle que :
• f est nulle est dehors d’un segment [c, d], c < d
• ∃M ∈ R+ : ∀x ∈ [c, d], f(x) ≤M .
Le rectangle A delimite par les points (c, 0), (d, 0), (d,M) et (c,M) est d’aire M(d − c). La partie Bcorrespondant a la zone sous la courbe de f entre les points d’abscisses c et d est d’aire 1.Pour tout x ∈ [c, d], P (X ≤ x) est donnee par l’aire de la partie Cx correspondant a la zone sous la courbede f entre les points d’abscisses c et x.
Soit alors une suite de variables (Wn)n∈N∗ = (Un, Vn)n∈N∗ suivant une loi uniforme sur ce rectangle : ilsuffit de prendre pour tout n ∈ N∗,
Un=c+(d-c)*rand(); et Vn=M*rand(); .
Si on pose N = infn ∈ N∗ : Wn ∈ B = infn ∈ N∗ : Vn ≤ f(Un), alors UN suit la loi de X.
En effet : (UN , VN ) suivant une loi uniforme sur B, pour tout x ∈ [c, d],
P (UN ≤ x) = P ((UN , VN ) ∈ Cx) =Aire de CxAire de B
=P (X ≤ x)
1= P (X ≤ x).
Un peu plus generalement : on peut considerer que f est non exactement une densite, mais de la forme Kgou g est une densite de probabilite et K une constante strictement positive (cela peut s’averer pratiquepour certaines lois...). La partie B est alors d’aire K et Cx d’aire KP (X ≤ x) : le resultat demeure donc,la constante disparaissant par quotient...
::::::::::Remarque : En pratique, mieux vaut evidemment prendre M le plus petit possible !
1) Exemple : loi beta de parametres (a, b) ∈ [1,+∞[2 via la methode du rejet
Une densite pour cette loi est x 7−→ 1
β(a, b)xa−1(1− x)b−1 I1]0,1[ ou β(a, b) =
∫ 1
0xa−1(1− x)b−1dx .
Le calcul de β(a, b) n’est pas necessaire, puisqu’il va disparaıtre par quotient : il suffit donc d’effectuerla methode du rejet avec f : x 7−→ xa−1(1− x)b−1 et [c, d] = [0, 1].
Avec les notations precedentes, l’aire de la partie B est alors β(a, b) et celle de la partie Cx est β(a, b)P (X ≤ x).
Lorsque (a, b) ∈ [1,+∞[2, f est majoree sur [0, 1] et une simple etude de fonction montre que f atteint
son maximum en x =a− 1
a+ b− 2. On peut alors prendre M = f
(a− 1
a+ b− 2
).
::::::::::Remarque : lorsque a et b sont entiers, il est possible de prendre directement f : x 7−→ 1
β(a, b)xa−1(1− x)b−1
puisqu’on a alors1
β(a, b)=
(a+ b− 1)!
(a− 1)!(b− 1)!= a
a∏k=1
a+ b− kk
, ce que l’on peut facilement implementer
en Scilab via le code (inspire de l’idee de L.Dorat pour la binomiale [p13])
Code Scilab :
deff(’y=f(x,a,b)’,’y=x^(a-1) .*(1-x)^(b-1)*a*prod((a+b-[1:a]) ./[1:a])’)
34/43
Formation en ligne a 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 parametres (a=’+string(a)+’,b=’+string(b)+’)’
N=[1000,50000]
T=[1 2;3 4]
for i=1:2//Taille N
for j = 1:2 // methode de simulation
if j==1
u=ones(1,N(i));v=ones(1,N(i));
timer();
for k=1:N(i)
while (v(k)>f(u(k),a,b)) u(k)=rand(); v(k)=M*rand(); end
end
t=timer();
leg=’via rejet - N=’+string(N(i))+’ - timer=’+string(t)
c=2
else
timer();
u=grand(1,N(i),"bet",a,b)
t=timer();
leg=’via grand - N=’+string(N(i))+’ - timer=’+string(t)
c=5
end
subplot(2,2,T(i,j))
histplot(x,u,style=c,rect=[0,0,1,2.5])
legend(leg)
if i*j==1; xtitle(titre); end
end
end
35/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
2) Quelques autres methodes de simulation de la loi beta
a) Via l’algorithme de Jonk :
Principe : soit (Un)n∈N∗ et (Vn)n∈N∗ deux suites de variables aleatoires mutuellement independantes
et suivant toutes la loi uniforme sur ]0, 1]. On note N = infn ∈ N∗ : U1/an + V
1/bn ≤ 1.
AlorsU
1/aN
U1/aN + V
1/bN
suit une loi beta de parametres (a, b).
Avantage : marche dans le cas ou les densites n’admettent pas de majorant (a ∈]0, 1[ ou b ∈]0, 1[).
Code Scilab :
clf;clc;
a=0.7; b=0.4;
N=10000
x=0:0.01:1
subplot(1,2,1)
timer();
for i=1:N
u=rand();v=rand();
while (u^(1/a)+v^(1/b)>1) u=rand(); v=rand(); end
y(i)=u^(1/a)/(u^(1/a)+v^(1/b))
end
t=timer();
histplot(x,y,rect=[0,0,1,4],style=2)
titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’) via Jonk - N=’+string(N)+’..
- timer=’+string(t)
xtitle(titre)
subplot(1,2,2)
timer();
s=grand(1,N,"bet",a,b)
t=timer();
histplot(x,s,rect=[0,0,1,4],style=5)
titre=’Loi beta de parametres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N)+’..
- timer=’+string(t)
xtitle(titre)
36/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
b) Via les statistiques d’ordre :
Un resultat classique montre que si U1, ..., Un sont n variables aleatoires mutuellement independantes sui-vant toutes la loi uniforme sur [0, 1] alors en notant (X1, ..., Xn) la statistique d’ordre associee a (U1, ..., Un),pour tout k ∈ [[1, n]], Xk suit la loi beta de parametres (k, n− k + 1). D’ou le code (pour simuler une loibeta de parametres entiers strictements positifs ; on compare a grand et a la courbe theorique, facile atracer dans ce cas) :
Code Scilab :
clf;clc;
a=2//(=k)
b=5//(=n-k+1)
N=10000;
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 parametres (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 parametres (a=’+string(a)+’,b=’+string(b)+’) via grand - N=’+string(N)
xtitle(titre)
37/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
c) Via un resultat de convergence - ESSEC 2004 E3 :
Principe : SoitN+1 urnes U0, ..., UN telles que pour tout k ∈ [[0, N ]], l’urne Uk contient une proportion
dek
Nboules rouges. On choisit une urne au hasard et on y effectue n tirages successifs avec remise.
On note R le nombre de boules rouges obtenues au cours des n tirages. et YN la proportion de boulesrouges dans l’urne qui a ete choisie. Alors la loi conditionnelle de la suite de variables aleatoires(YN )N∈N∗ sachant [R = r] converge vers la loi beta de parametres (r + 1, n− r + 1).
Code Scilab :
clf;clc;
a=3//(=r+1) d’ou r=a-1
b=5//(=n-r+1) d’ou n=b+a-2
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 parametres (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 a Scilab - HEC Paris 11 mars 2014
C. Extension aux densites a support non compact
Principe : Pour simuler une variable aleatoire X de densite f , on cherche a ∈ [1,+∞[ et une densiteg telles que f ≤ ag sur R. Alors si (Un)n∈N∗ est une suite de variables aleatoires independantesde densite g, (Vn)n∈N∗ une suite de variables aleatoires telle que pour tout n ∈ N∗, Vn suit une loiuniforme sur [0, ag(Un)], et N est definie par N = infn ∈ N∗ : Vn ≤ f(Un), UN suit la loi de X.
1) Application a la simulation de la loi normale via la loi de Laplace
Pour tout x ∈ R, ϕ(x) =1√2πe−x
2/2 ≤√
2e
π× g(x) ou g est la densite usuelle de la loi de Laplace standard.
Code Scilab :
clc ;clf;funcprot(0);
deff(’y=f(x)’,’y= exp(-(x^2)/2) / sqrt(2*%pi)’);
deff(’y=g(x)’,’y=exp(-abs(x))/2’)
x = [-5 : 0.1 : 5];
y = f(x)
N=10000;
subplot(1,2,1);
u=zeros(1,N); v=ones(1,N)
for i=1:N
while v(i)>f(u(i))
a=rand()
u(i)=log(2*a) .*(a<1/2)-log(2*(1-a)) .*(a>=1/2)
v(i)=g(u(i))*rand()*sqrt(2*%e*%pi)
end
end
histplot(x, u,rect=[-5,0,5,0.45],style=2)
legend(’Via la methode du rejet’)
titre=’Simulation de loi normale - N=’+string(N)
xtitle(titre)
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 a Scilab - HEC Paris 11 mars 2014
2) Application a la simulation des lois Gamma
Principe : Si on sait simuler une variable aleatoire X suivant la loi Gamma de parametres (1, ν), ν > 0alors pour tout b > 0, bX suit la loi Gamma de parametres (b, ν) : il suffit donc de savoir simuler les loisGamma de parametres (1, ν), ν > 0.
De plus, si on sait simuler les lois Gamma de parametres (1, a), a ∈]0, 1[ alors pour tout ν > 0, a =ν
bνc+ 1est dans ]0, 1[ et si X1, ..., Xbνc+1 sont des variables mutuellement independantes suivant toutes la loiGamma de parametres (1, a), alors leur somme suit la loi Gamma de parametres (1, (bνc+ 1)a = ν) : ilsuffit donc de savoir simuler les lois Gamma de parametres (1, a), a ∈]0, 1[.
Soit a ∈]0, 1[ et soit f : x 7−→ xa−1e−x
Γ(a)I1]0,+∞[(x) une densite de la loi Gamma de parametres (1, a),
alors en posant b =e
a+ e, g : x 7−→ ab
(xa−1I1]0,1[(x) + e−xI1[1,+∞[(x)
)est une densite de probabilite
telle que, sur R, f ≤ g
abΓ(a).
Soit G : x 7−→∫ x
−∞g la fonction de repartition liee a g.
G definit une bijection de R∗+ sur ]0, 1[ et pour tout x ∈ R, G(x) = bxaI1]0,1[(x) + (1− abe−x)I1[1,+∞[(x)d’ou pour tout u ∈]0, 1[,
G−1(u) =(ub
)1/aI1]0,b[(u)− ln
(1− uab
)I1[b,1[(u).
Soit alors pour tout x > 0, q(x) =abΓ(a)f(x)
g(x)= e−xI1]0,1[(x) + xa−1I1[1,+∞[(x).
Si (Un)n∈N∗ et (Vn)n∈N∗ sont deux suites de variables aleatoires mutuellement independantes suivanttoutes la loi uniforme sur ]0, 1[, on definit N = infn ∈ N∗ : Vn ≤ q(G−1(Un)).Alors X = G−1(UN ) suit la loi Gamma de parametres (1, a).
Code Scilab :
clf;clc;
a=0.7 ; b=%e/(a+%e);N=10000
x=0:0.1:5
deff(’y=q(x,a)’,’y=exp(-x)*(x<1)+x^(a-1)*(x>=1)’)
deff(’y=H(u,a,b)’,’y=(u/b)^(1/a) .*(u<b)-log((1-u)/a/b) .*(u>=b)’)
subplot(1,2,1)
v=2*ones(1,N); z=ones(1,N)
for i=1:N
while(v(i)>q(z(i),a))
z(i)=H(rand(),a,b);
v(i)=rand();
end
end
histplot(x,z,style=2)
titre=’Loi gamma de parametres (1,a=’+string(a)+’) via rejet - N=’+string(N)
xtitle(titre)
subplot(1,2,2)
s=grand(1,N,"gam",a,1)
histplot(x,s,style=5)
titre=’Loi gamma de parametres (1,a=’+string(a)+’) via grand - N=’+string(N)
xtitle(titre)
40/43
Formation en ligne a Scilab - HEC Paris 11 mars 2014
3) Application : loi du χ2 a n degres de liberte via differentes methodes
(Comparaison avec la simulation via grand)
a) Par la methode du rejet :
Pour simuler une variable suivant la loi du χ2 a n ∈ N∗ degres de liberte, il faut simuler la loi Gammade parametres (2, n/2) : c’est la somme de n variables aleatoires independantes suivant la loi Gamma deparametres (2, 1/2).
b) Par la loi normale :
Classiquement, la somme de n carres de variables independantes suivant toutes la loi normale centreereduite suit une loi du χ2 a n ∈ N∗ degres de liberte.
c) Par un resultat de convergence :
(Voir par exemple HEC 1999, voies E et S).
On decompose l’intervalle [0, 1[ en p ∈ N∗ intervalles Ij =
[j − 1
p,j
p
[(j ∈ [[1, p]]). Soit alors (U1, ..., Uk)
k ∈ N∗ variables aleatoires independantes et suivant la loi uniforme sur [0, 1[. Pour tout j ∈ [[1, p]] et tout
ω ∈ Ω, on note νj(ω) = card i ∈ [[1, k]] : Ui(ω) ∈ Ij et on pose Zk =
p∑j=1
(νj − k
p
)2kp
.
L’etude theorique montre que la suite (Zk)k∈N∗ converge en loi vers la loi du χ2 a p− 1 degres de liberte.
41/43
Formation en ligne a 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 a n=’+string(n)+’ degres de liberte - N=’+string(N)
deff(’y=q(x,a)’,’y=exp(-x)*(x<1)+x^(a-1)*(x>=1)’)
deff(’y=H(u,a,b)’,’y=(u/b)^(1/a) .*(u<b)-log((1-u)/a/b) .*(u>=b)’)
x=0:0.5:80
deff(’y=f(x,r)’, ’y=1/factorial(14)*(1/2)^(r)*x^(r-1) .*exp(-x/2)’)
chi2=f(x,r)
subplot(2,2,1)
timer();
v=2*ones(n,N); y=ones(n,N)
for i=1:n
for j=1:N
while(v(i,j)>q(y(i,j),a)) y(i,j)=H(rand(),a,b);v(i,j)=rand(); end
end
end
z=2*sum(y,’r’)
t=timer();
histplot(x,z,style=2,rect=[0,0,80,0.07])
leg=’via rejet - timer=’+string(t)
legend(leg)
plot2d(x,chi2,style=1)
xtitle(titre)
subplot(2,2,2)
timer();
s=grand(n,N,"nor",0,1)
z=sum(s .^2,’r’)
t=timer();
histplot(x,z,style=5,rect=[0,0,80,0.07])
leg=’via somme de carres de normales (0,1) - timer=’+string(t)
legend(leg)
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