SIMULATION DE LOIS - SOMMAIRE -

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 douze uniformes.................................. 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

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, 2 31 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 N=20 A=zeros(N,5) rand("seed",0) for i=1:n A(i,:)=rand(5); 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 s=getdate("s") rand("seed",s) disp(rand()) (on constate que si on va très vite, les valeurs de rand() ne changent pas...) for i=1:5 s=getdate("s") rand("seed",s) disp(rand()) 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

Le générateur de nombres aléatoires uniform 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 = 2 31 Le générateur de nombres aléatoires normal 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 : 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 : 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... function, avec des opérations pointées. Pour plus d options, voir le document pdf d Hervé Chabert (séance E2) p9. 2/43

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,..., a ) si a 1 (et le vecteur ligne vide 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 tombe juste : 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 prime 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épra 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 largeur maximale autorisée, 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 revirait à é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], N i est le nombre de données appartenant à la classe C i, la valeur de l ordonnée correspondant à la classe C i sera, de manière à ce que l aire de l histogramme correspondant N i N(x(i + 1) x(i)) à C i soit égale à N i, et donc que l aire totale soit égale à 1. N 3/43

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 : 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") function length(u) donne la longueur 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 quick sort ) par ordre croissant. a) Exemple 1 : loi binomiale : 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") function Fr_empirique(u); a=get("current_axes") ; //pour régler les options des axes a.font_size=1; //taille de la lége 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

b) Exemple 2 : loi normale centrée réduite : 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") function Fr_empirique(u); x = -5:0.1:5 y = cdfnor("pq", x, zeros(x), ones(x)); z=ones(x) plot2d(x, z, style=1) plot2d(x, y, style=1,rect=[-5,0,5,1.2]) a=get("current_axes") ; a.font_size=1; a.x_location="bottom"; a.y_location="middle"; 5/43

B. Simulations classiques 1) Loi uniforme discrète sur [n1, n2] a) Avec plot2d3 : 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

b) Avec bar : 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

2) Loi uniforme sur [a, b[ a=-2;b=5; N=100000; U=grand(1,N,"unf",a,b);// Autre option : U=(b-a)*rand(1,N)+a; titre= Simulation de loi uniforme continue sur [ +string(a)+, +string(b)+ ] - N= +string(n); histplot(a:0.1:b, U,style=2,rect=[-3,0,6,0.2]) xtitle(titre) a=get("current_axes") ; a.font_size=1; a.x_location="bottom"; a.y_location="left"; Remarque : alternative pour un échantillon de loi uniforme sur [0, 1[ : U=grand(1,N,"def");. 8/43

3) Application aux douze uniformes a) Principe et code associé - comparaison avec grand : La variable centrée-réduite associée à 1 12 12 U i est U i 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. 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) 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) 9/43

b) Comparaison avec Box-Müller : Principe : Si U et V sont deux variables aléatoires indépantes suivant la loi uniforme sur ]0, 1] alors X = 2 ln U cos(2πv ) suit la loi normale centrée réduite. 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) 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) titre= Simulation via Box-Müller (N= +string(n)+ ) - timer= +string(t) xtitle(titre) 10/43

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épantes, on peut s en inspirer pour alléger le code en ne simulant que N uniformes au lieu de 2N : 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) 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) 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

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 jeu consistera à apprre à s en passer à chaque fois qu il y aura plus simple... Première version, encore très imprégnée de Turbo-Pascal : 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 function for i=1:n ; x(i)=bin(n,p); z=tabul(x,"i") bar(z(:,1),z(:,2)/n, width =0.2,color="b") xtitle("", "Classes", "Effectifs par classe normalisés") leg( 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") leg( Simulation via grand ) a = get("current_axes"); a.data_bounds([3 4]) = [0 0.4]; // Distribution théorique subplot(1,3,3) ; 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); t = tableau(n,:) // : signifie "toutes les colonnes" function // "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); plot2d3(x, y, rect=[-0.5,0,11,0.4],style=1); xtitle("", "Valeurs de k", "P(X=k)") leg( Distribution théorique ) 12/43

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 prre 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; y(k)=y(k)+(rand()<p); (puisque rand()<p est un booléen valant 1 s il est réalisé...) par 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 ( méthode Scilabique ) : 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]; leg("simulation via Bernoulli") // Simulation via grand subplot(1,3,2) ; 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]; leg("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); xtitle("", "Valeurs de k", "P(X=k)") leg( Distribution théorique ) 13/43

b) Illustration du Théorème Limite Central : N=100000; n=[10,50,100] ; p=0.5 x = [-5 : 0.1 : 5]; y=exp(- (x^2) / 2)./ sqrt( 2 * %pi ); for i=1:3 z = (grand(1,n,"bin", n(i), p)-n(i)*p)/sqrt(n(i)*p*(1-p)); L=([-1:n(i)]-n(i)*p+1/2)/sqrt(n(i)*p*(1-p)); subplot(1,3,i); plot2d(x, y,style=1) histplot(l, z, rect=[-5,0,5,0.45],style=5) leg= n= +string(n(i))+ et p= +string(p) leg(leg) if i==2; xtitle("illustration du Théorème Limite Central"); 14/43

4) Loi de Poisson via grand a) Simulation : 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) 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) plot2d3(x, y, rect=[-0.5,0,10,0.3],style=5); xtitle("distribution théorique", "Valeurs de k", "P(X=k)") 15/43

b) Illustration du Théorème Limite Central : 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)) leg(leg) if i==2 xtitle(titre); 16/43

5) Loi géométrique 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; 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); leg(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) ; leg(leg) // Loi géométrique théorique x=1:20 y = (1-p)^(x-1) * p; subplot(1,3,3); plot2d3(x, y, rect=[-0.5,0,21,p],style=1); xtitle("", "Valeurs de k", "P(X=k)"); leg("distribution théorique") On constate que la seconde méthode est nettement plus rapide... 17/43

5) Loi binomiale négative 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; 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") leg("a partir d une loi de Bernoulli") // 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") leg("avec grand") 18/43

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 {x 0,..., x n } (n N). k On note pour tout k [0, n], F k = P (X = x i ) et F 1 = 0. i=0 On définit pour tout u [0, 1], H(u) = n x i I1 [Fi 1 <u F i ]. Si U suit la loi uniforme sur [0, 1], H(U) suit la même loi que X. i=0 a) Loi de Bernoulli de paramètre p ]0, 1[ : Ici, x 0 = 0, x 1 = 1, F 0 = 1 p, F 1 = 1. if rand()<= 1-p then X=0; else X=1; ou de manière équivalente : if 1-rand()<p then X=1; else X=0; ou encore, puisque 1 U suit la loi uniforme sur [0, 1] : if rand()<p then X=1; else X=0; (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 : 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") leg( Simulation via Inversion ) // 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)") leg( Distribution théorique ) 19/43

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 : x=zeros(1,n) for i=1:n while (u(i)> F(x(i)+1)) x(i)=x(i)+1 ; ; (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

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 p k = P (X = n + k/2) et si k est impair, p k = P (X = n (k + 1)/2). Alors p 0 p 1... p 2n et on effectue l algorithme de la méthode d inversion avec les effectifs cumulés des nombres p i, i [0, 2n] - qui correspondent aux valeurs X = [x 0...x 2n ] où 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 é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 brut. 21/43

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 ; 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) leg(leg) xtitle(titre) subplot(1,2,2) for k=0:nu if modulo(k,2)==0 ; w(k+1) = z(n+1+k/2); else w(k+1) = z(n+1-(k+1)/2); F=cumsum(w); timer(); for i=1:n; u=rand(); k=0; while (F(k+1)<u ) k=k+1 ; if modulo(k,2)==0 x(i)=n+k/2; else x(i)=n-(k+1)/2; 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) leg(leg) Le timer indique effectivement des temps de calcul moins longs pour n grand pour la seconde méthode. 22/43

2) Variables aléatoires discrètes infinies Principe : Soit X une variable aléatoire d ensemble image dénombrable X(Ω) = {x i, i N}. k On note pour tout k N, F k = P (X = x i ) et F 1 = 0. i=0 On définit pour tout u [0, 1], H(u) = + i=0 x i I1 [Fi 1 <u F i ]. Si U suit la loi uniforme sur [0, 1], H(U) suit la même loi que X. a) Loi géométrique : 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") leg( Simulation via Inversion ) 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)") leg( Distribution théorique ) 23/43

e) Loi de Poisson : 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") leg( Simulation via Inversion ) 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)") leg( Distribution théorique ) 24/43

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 : 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") leg( Simulation via Inversion ) plot2d(x,y,rect=[0,0,8,lambda+0.1],style=1) subplot(1,2,2); // Simulation via grand t=grand(n,1,"exp",1/lambda) histplot(x, t, style=5); xtitle("", "Classes", "Effectifs par classe normalisés") leg( Simulation via grand ) plot2d(x,y,rect=[0,0,8,lambda+0.1],style=1) 25/43

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. 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); leg(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) ; leg(leg) // Loi géométrique théorique x=1:20 y = (1-p)^(x-1) * p; subplot(1,3,3); plot2d3(x, y, rect=[-0.5,0,21,p],style=1); xtitle("", "Valeurs de k", "P(X=k)"); leg("distribution théorique") 26/43

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 inversion appliquée aux lois exponentielles montre que si (U n ) n N est une suite de variables aléatoires mutuellement indépantes 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 suit une loi de Poisson de paramètre λ. : U 1 (ω)...u n+1 (ω) < e λ } sinon 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 directe ) : 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") leg( Simulation via Inversion ) 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; 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") leg( Simulation via Exponentielle ) 27/43

2) Loi de Laplace (standard) x=-10:0.1:10 y=exp(-abs(x))/2; N=10000; u=rand(1,n); z=log(2*u).*(u<1/2)-log(2*(1-u)).*(u>=1/2) subplot(1,2,1); histplot(x, z,style=2) xtitle("", "Classes", "Effectifs par classe normalisés") leg= Laplace via Inversion - N= +string(n) leg(leg) plot2d(x,y,rect=[-8,0,8,0.6],style=1) // Simulation via la différence de deux exponentielles de paramètre 1 indépantes 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) leg(leg) plot2d(x,y,rect=[-8,0,8,0.6],style=1) 28/43

3) Loi logistique (standard) 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) 29/43

4) Loi de Pareto (générale) X suit une loi de Pareto de paramètres (α, a, x 0 ) (R +) 2 R si X admet comme densité f : x α ( ) a α+1 I1 a x x [x0+a,+ [. 0 [ ( ) a α ] X admet alors comme fonction de répartition F : x 1 I1 x x [x0 +a,+ [, d où le code : 0 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) 30/43

5) Loi de Cauchy (standard) a) Simulation : 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") leg("courbe théorique") b) Mise en évidence de la non existence de l espérance : On peut par exemple proposer le code suivant : clc;clf; N=100;n=20 z=tan(%pi*(rand(n,n)-1/2)) disp(mean(z, c )) y=tabul(mean(z, c ), i ) bar(y(:,1),y(:,2)/n,color="r") 31/43

III - LA 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 (W n ) n N est une suite de variables aléatoires mutuellement indépantes suivant une loi uniforme sur une partie A de R 2 d aire finie non nulle et que B A (B également d aire non nulle), alors en définissant N = inf{n N : W n B}, W N suit une loi uniforme sur B. On remarque que la génération de W N 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é : 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; plot(u,v,"d") xtitle(titre) a = gca(); a.isoview = "on"; i=i+1 32/43

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 prre r = U où U [0, 1]... D où le code suivant : n=800 subplot(1,2,1) rayon=rand(1,n);angle=2*%pi*rand(1,n); x=rayon.*cos(angle); y=rayon.*sin(angle); plot(x,y,"d") leg( 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") leg( Uniforme sur disque tentative 2 (la bonne) ) a = gca(); a.isoview = "on"; 33/43

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 C x correspondant à la zone sous la courbe de f entre les points d abscisses c et x. Soit alors une suite de variables (W n ) n N = (U n, V n ) n N suivant une loi uniforme sur ce rectangle : il suffit de prre pour tout n N, Un=c+(d-c)*rand(); et Vn=M*rand();. Si on pose N = inf{n N : W n B} = inf{n N : V n f(u n )}, alors U N suit la loi de X. En effet : (U N, V N ) suivant une loi uniforme sur B, pour tout x [c, d], P (U N x) = P ((U N, V N ) C x ) = Aire de C x P (X x) = = 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 C x d aire KP (X x) : le résultat demeure donc, la constante disparaissant par quotient... Remarque : En pratique, mieux vaut évidemment prre M le plus petit possible! 1) Exemple : loi beta de paramètres (a, b) [1, + [ 2 via la méthode du rejet Une densité pour cette loi est x 1 β(a, b) xa 1 (1 x) b 1 I1 ]0,1[ où β(a, b) = 1 0 x a 1 (1 x) b 1 dx. 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 x a 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 C x 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 son maximum en x = a 1 ( ) a 1. On peut alors prre M = f. a + b 2 a + b 2 Remarque : lorsque a et b sont entiers, il est possible de prre directement f : x 1 β(a, b) xa 1 (1 x) b 1 puisqu on a alors 1 β(a, b) = (a + b 1)! (a 1)!(b 1)! = a a en Scilab via le code (inspiré de l idée de L.Dorat pour la binomiale [p13]) k=1 a + b k, ce que l on peut facilement implémenter k deff( y=f(x,a,b), y=x^(a-1).*(1-x)^(b-1)*a*prod((a+b-[1:a])./[1:a]) ) 34/43

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(); 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 subplot(2,2,t(i,j)) histplot(x,u,style=c,rect=[0,0,1,2.5]) leg(leg) if i*j==1; xtitle(titre); 35/43

2) Quelques autres méthodes de simulation de la loi beta a) Via l algorithme de Jönk : Principe : soit (U n ) n N et (V n ) n N deux suites de variables aléatoires mutuellement indépantes et suivant toutes la loi uniforme sur ]0, 1]. On note N = inf{n N : Un 1/a + Vn 1/b 1}. U 1/a N Alors U 1/a N + V 1/b suit une loi beta de paramètres (a, b). N Avantage : marche dans le cas où les densités n admettent pas de majorant (a ]0, 1[ ou b ]0, 1[). a=0.7; b=0.4; N=10000 x=0:0.01:1 subplot(1,2,1) timer(); for i=1:n u=rand();v=rand(); while (u^(1/a)+v^(1/b)>1) u=rand(); v=rand(); y(i)=u^(1/a)/(u^(1/a)+v^(1/b)) 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

b) Via les statistiques d ordre : Un résultat classique montre que si U 1,..., U n sont n variables aléatoires mutuellement indépantes suivant toutes la loi uniforme sur [0, 1] alors en notant (X 1,..., X n ) la statistique d ordre associée à (U 1,..., U n ), pour tout k [1, n], X k 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) : 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

c) Via un résultat de convergence - ESSEC 2004 E3 : Principe : Soit N+1 urnes U 0,..., U N telles que pour tout k [0, N ], l urne U k contient une proportion de k 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 Y N la proportion de boules rouges dans l urne qui a été choisie. Alors la loi conditionnelle de la suite de variables aléatoires (Y N ) N N sachant [R = r] converge vers la loi beta de paramètres (r + 1, n r + 1). 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 ); subplot(1,2,1) histplot(x,z,style=2) leg= Via ESSEC 2004 E3 - +string(nb_urnes)+ urnes leg(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) leg( Via grand ) plot2d(x,y,rect=[0,0,1,m+0.2],style=1) 38/43

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 (U n ) n N est une suite de variables aléatoires indépantes de densité g, (V n ) n N une suite de variables aléatoires telle que pour tout n N, V n suit une loi uniforme sur [0, ag(u n )], et N est définie par N = inf{n N : V n f(u n )}, U N suit la loi de X. 1) Application à la simulation de la loi normale via la loi de Laplace Pour tout x R, ϕ(x) = 1 2e e x2 /2 g(x) où g est la densité usuelle de la loi de Laplace standard. 2π π 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) histplot(x, u,rect=[-5,0,5,0.45],style=2) leg( 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) leg( Via grand ) plot2d(x, y,style=1) 39/43

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 = ν + 1 est dans ]0, 1[ et si X 1,..., X ν +1 sont des variables mutuellement indépantes suivant toutes la loi Gamma de paramètres (1, a), alors leur somme suit la loi Gamma de paramètres (1, ( ν + 1)a = ν) : il suffit donc de savoir simuler les lois Gamma de paramètres (1, a), a ]0, 1[. Soit a ]0, 1[ et soit f alors en posant b = e a + e, telle que, sur R, f Soit G : x x : x xa 1 e x I1 Γ(a) ]0,+ [ (x) une densité de la loi Gamma de paramètres (1, a), g abγ(a). g : x ab ( x a 1 I1 ]0,1[ (x) + e x I1 [1,+ [ (x) ) est une densité de probabilité 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) = bx a I1 ]0,1[ (x) + (1 abe x )I1 [1,+ [ (x) d où pour tout u ]0, 1[, ( u ) ( ) 1/a 1 u G 1 (u) = I1]0,b[ (u) ln I1 b ab [b,1[ (u). Soit alors pour tout x > 0, q(x) = abγ(a)f(x) = e x I1 g(x) ]0,1[ (x) + x a 1 I1 [1,+ [ (x). Si (U n ) n N et (V n ) n N sont deux suites de variables aléatoires mutuellement indépantes suivant toutes la loi uniforme sur ]0, 1[, on définit N = inf{n N : V n q(g 1 (U n ))}. Alors X = G 1 (U N ) suit la loi Gamma de paramètres (1, a). a=0.7 ; b=%e/(a+%e);n=10000 x=0:0.1:5 deff( y=q(x,a), y=exp(-x)*(x<1)+x^(a-1)*(x>=1) ) deff( y=h(u,a,b), y=(u/b)^(1/a).*(u<b)-log((1-u)/a/b).*(u>=b) ) subplot(1,2,1) v=2*ones(1,n); z=ones(1,n) for i=1:n while(v(i)>q(z(i),a)) z(i)=h(rand(),a,b); v(i)=rand(); 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

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épantes 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épantes 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 On décompose l intervalle [0, 1[ en p N intervalles I j = p, j [ (j [1, p]). Soit alors (U 1,..., U k ) p k N variables aléatoires indépantes et suivant la loi uniforme sur [0, 1[. Pour tout j [1, p] et tout ( ) 2 p ν j k p ω Ω, on note ν j (ω) = card {i [1, k ] : U i (ω) I j } et on pose Z k =. L étude théorique montre que la suite (Z k ) k N j=1 converge en loi vers la loi du χ 2 à p 1 degrés de liberté. k p 41/43

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(); z=2*sum(y, r ) t=timer(); histplot(x,z,style=2,rect=[0,0,80,0.07]) leg= via rejet - timer= +string(t) leg(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) leg(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) t=timer(); histplot(x,z, style=3,rect=[0,0,80,0.07]); leg= via convergence - timer= +string(t) leg(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) leg(leg) plot2d(x,chi2,style=1) 42/43

43/43