SCILAB TD N°1 – Simulation de Lois

Programme officiel ECE : dans toutes les simulations on pourra comparer les échantillons obtenus avec les distributions théoriques en utilisant des diagrammes en bâtons et des histogrammes et on pourra aussi tracer la fonction de répartition empirique et la comparer à la fonction de répartition théorique.

Les simulations à effectuer sont :

- Simulation de la loi uniforme sur [0,1] et sur [a,b] avec le générateur grand- Méthode d’inversion de la fonction de répartition (application à l’exponentielle)- Simulation d’une loi géométrique (Bernouilli + while ou exponentielle + floor)- Simulation d’une loi normale par utilisation du Théorème Central Limite et la méthode des 12

uniformes

I Aspects théoriques

1) Inversion de la fonction de répartition

Théorème : soit X une variable aléatoire réelle telle que sa fonction de répartition FX soit inversible.

Soit U la variable aléatoire FX(X), alors U suit une loi uniforme U(]0,1[).

Démonstration : ∀ u∈¿0,1¿ P(U≤u) = P(FX(X) ≤u) = P(X≤ FX-1(u) )= FX(FX

-1(u))= u

Donc ∀u∈¿0,1 ¿ P(U≤u) = u et U suit bien une loi uniforme U(]0,1[)

Rappel : FX est croissante donc FX-1 aussi d’où P(FX(X) ≤u) = P(X≤ FX

-1(u) )

Ce théorème permet de générer la loi de n’importe quelle variable aléatoire X dont la fonction de répartition est inversible à partir d’une loi uniforme U(]0,1[) car en remontant le raisonnement de la démonstration précédente on montre que (FX

-1(U)) suit la loi de X. En termes d’application pratique, il faut bien entendu que FX

-1 soit facile à exprimer. Le générateur aléatoire de base de Scilab étant rand() qui suit une loi uniforme U(]0,1[), on voit tout l’intérêt de ce théorème.

2) Simulation d’une loi géométrique

Une loi géométrique de paramètre p (0<p<1) est la variable indicatrice du rang du premier succès lors d’une répartition d’épreuves de Bernoulli de paramètre p indépendantes. On peut la voir (donc la simuler) sous forme d’une répétition d’expériences de Bernoulli jusqu’à obtention d’un succès.

Sous Scilab, on va générer successivement des expériences de Bernoulli de même paramètre p et compter le nombre le nombre de tirages qu’il faut effectuer pour obtenir un succès.

1

3) Théorème Central Limite

4) Fonction de répartition empirique

Soit X un n-échantillon ou série statistique (X1, ….,Xn). La fonction de répartition empirique est donnée par :

I(Xi≤x) est l’indicatrice de l’ensemble {Xi ≤ x}.

II Fonctions Scilab utilisées dans ce TD

1) Générateurs de nombre aléatoires

L’instruction rand() génère un nombre aléatoire suivant une loi uniforme U(]0,1[).

L’instruction grand(nombre_lignes, nombre_colonnes, nom_loi, paramètres_loi) génère une matrice de taille (nombre_lignes, nombre_colonnes) de nombres aléatoires suivant une loi « nom_loi » de paramètre « paramètres_loi » avec les syntaxes suivantes :

Loi CommandeN([[a,b]]) (discrète) grand(i,j,’uin’,a,b)

N([a,b]) (continue) grand(i,j,’unf’,a,b)

B(n,p) grand(i,j,’bin’,n,p)

G(p) grand(i,j,’geom’,p)

P(l) grand(i,j,’poi’,l)

E(a) grand(i,j,’exp’,1/a) - WARNING

N(m,s²) grand(i,j,’nor’,m,s) - WARNING

Lorsqu’on doit générer de longues séquences de nombres suivant une même loi, il faut privilégier grand car les qualités statistiques sont supérieures à celles de rand.

2

2) Définition de fonctions

Conformément au programme, il faut privilégier la syntaxe suivante à l’utilisation de l’instruction deff :

function y=f(x)

y = …..

endfunction

y peut être absolument n’importe quoi mais doit être impérativement instancié par un calcul dans l’algorithme définissant la fonction.

Si vous créez une fonction f de la manière suivante :

function y=f(x)

disp(x^2)

endfunction

et qu’ensuite vous appelez cette fonction, par exemple en tapant f(4) puis enter, Scilab renvoie un message d’erreur car y n’est pas définie.

y peut être un nombre, un vecteur, un mélange entre nombres et vecteurs … Dans ces cas, il est préférable de différentier chaque composante et au lieu d’écrire y=f(x), d’écrire par exemple [a,b,M,V]=f(x) si on veut que la fonction renvoie 2 nombres, une matrice et un vecteur.

3) Diagramme en bâtons et histogrammes

Soit X un vecteur ou une matrice représentant une série statistique (séquence de nombres aléatoires par exemple).

L’instruction tabul(X) génère une matrice à deux colonnes, la première contenant les valeurs prises par X rangées par ordre décroissant, la seconde, le nombre d’occurrences de chaque valeur. Si on veut un rangement par ordre croissant, il faut utiliser tabul(X, ‘’i’’)

Pour générer un diagramme en bâtons d’une série statistique donnée dont on connaît le nombre de termes N, il suffit de taper la séquence suivante :

Y = tabul(X,"i")

bar(Y(:,1), Y(:,2)/N)

Exemple :

3

Affiche

On peut affiner la taille des bâtons avec l’instruction bar(Y(:,1), Y(:,2)/N, a) avec a (largeur = width) prenant des valeurs strictement comprises entre 0 et 1

Pour le même exemple avec width=0.1, on obtient :

Tout ceci est évidemment parfait quand on a des séries statistiques entières. Avec des séquences de réels, bar n’est pas très adaptée et devient carrément illisible. Il faut alors privilégier histplot qui va tracer un histogramme de répartition suivant un nombre de classes défini par l’utilisateur.

L’instruction histplot admet deux syntaxes :

a) histplot(nombre_de_classes,X) où un nombre de classes est défini par l’utilisateur. C’est pratique lorsqu’on sait que la série prend des valeurs comprises entre des valeurs extrêmes identifiées.

b) histplot(V,X) où V est un vecteur de réels strictement croissants définissant les bornes successives des classes.

La valeur des ordonnées correspondant à une classe est Nombre d’éléments dans la classe i/ (Nombre de classes*(longueur de la classe i)). La somme des aires de toutes les barres est égale à 1.

Exemples :

4

Produit l’histogramme (10 classes)

Mais si on ne s’intéresse qu’aux classes [0,0.5], [0.5,1], [1,1.5], [1.5,2], on définit V=[0 0.5 1 1.5 2] (ou en utilisant linspace) puis histplot(V,X) ce qui donne :

4) Fonction de répartition

Soit X une séquence aléatoire de réels résultats d’une expérience statistique. Pour tracer la fonction de répartition empirique de X, il suffit de mettre en place l’algorithme suivant :

Cet algorithme génère le résultat graphique suivant (pour X=grand(1,500,'exp',1/0.2)) (500 réalisations d’une exponentielle)

5

Ou alors pour une normale centrée réduite (X=grand(1,10000,’nor’,0,1))

Concrètement que fait cet algorithme ? Prenons l’exemple simple du n-échantillon

X= (-1 2 0 -1 -1 1 2 0 1 0 2 1 0 1 -1)

On pose l=nombre de termes (length(X))

Ensuite, on ordonne X avec gsort, ce qui donne : (- 1 - 1 - 1 - 1 0 0 0 0 1 1 1 1 2 2 2).

On crée le vecteur Y= (0.06 0.13 0.2 0.267 0.33 0.4 0.47 0.53 0.6 0.67 0.73 0.8 0.87 0.93 1)

Ensuite, plot commence à placer (-1, 0.06) puis il continue et tombe encore sur X=-1 donc il place (-1, 0.13) en supprimant la valeur précédente et ainsi de suite jusqu’à la 4 e valeur donnant -1. On a bien P(X≤-1)=4/15 ce qui donne la valeur 0,267 (arrondie). Ensuite, on passe à (0, 0.33) et au bout de quatre lectures de 0 on obtient en affiche le couple (0, 0.53). On a alors bien P(X≤0)=8/15 etc …

Autre algorithme possible pour la fonction de répartition empirique :

tabul(X,’’i’’) est une matrice à 2 colonnes, la première contenant les valeurs différentes que prend X classées par ordre croissant, la seconde, leur nombre d’occurrences. Pour calculer la fonction de répartition empirique, il suffit donc de calculer les sommes cumulées des valeurs de la 2 e colonne et de les associer aux valeurs différentes de X, puis de les diviser par le nombre total de valeurs de X et d’afficher le graphique correspondant.

Exemple : X=[0 1 0 2 1 2 1 0 1 1 1 2] tabul(X,’’i’’) renvoie la matrice suivante :

0 31 6

6

2 3

On applique cumsum à la deuxième colonne, ce qui renvoie la matrice :

0 31 92 12

On divise ensuite dans l’instruction plot la deuxième colonne par 12 pour avoir :

0 ¼ 1 ¾2 1

Et on obtient la fonction de répartition empirique (sa valeur en 0, 1 et 2)

Cet algorithme fournit, pour X=grand(1,500,'exp',1/0.2) (500 réalisations d’une exponentielle) le graphe suivant :

7

III Aspects algorithmiques

1) Simulation de la loi uniforme

a) Proposer un algorithme permettant de simuler une loi uniforme discrète sur un intervalle [n1,n2] (n1 et n2 étant des entiers tels que n1<n2)

Ainsi pour n1=-1, n2=6 et N=10000 simulations, on obtient :

8

b) Proposer un algorithme permettant de simuler une loi uniforme discrète à partir du générateur aléatoire rand() donc d’une loi uniforme continue sur [0,1]

Que fait l’instruction X=n1+floor((n2-n1+1)*rand(1,N)) ?

Elle génère d’abord un vecteur de N nombres aléatoires suivant une loi uniforme continue sur ]0,1[ puis multiplie chacun par n2-n1+1 de sorte que ces nombres soient alors aléatoirement compris strictement entre 0 et n2-n1+1 de manière uniforme. On prend pour chacun la partie entière qui est alors comprise au sens large entre 0 et n2-n1 et on l’ajoute à n1 pour avoir un nombre aléatoire discret compris entre n1 et n2.

Graphiquement, on obtient pour une simulation donnée :

9

c) Proposer un algorithme permettant de simuler une loi uniforme continue sur un intervalle [a,b] entré par l’utilisateur

Corps de l’algorithme : X=grand(1,N,"unf",a,b) ou X =(b-a)*rand(1,N)+aOn utilise alors histplot à la place de bar car on a des valeurs réelles et surtout avec un nombre de classes raisonnable histplot([a :longueur_classe :b],X)

Ainsi pour a=-1.5, b=2, N=10000, L=0.2 on obtient :

On constate que le choix de la longueur de classe n’était pas pertinent car il exclut du diagramme les valeurs comprises entre 1.9 et 2. Il faut donc être vigilant sur ce point.

2) Inversion de la fonction de répartition

a) Proposer un algorithme simulant une loi exponentielle à partir d’une loi uniforme continue sur ]0,1[ (i.e. : le générateur rand)

10

Dans l’algorithme suivant, on va comparer cette simulation (via affichage d’un histogramme par classes) à la simulation obtenue via l’instruction grand(i,j,’exp’,1/λ) en se limitant à l’intervalle [0,10].

Pour lambda=0.2, N=10000 et une longueur de classe d’histogramme de 0.25, on obtient (en rouge : la simu avec rand, en bleu la simu avec grand) une « superposition » à peu près cohérente.

3) Simulations d’une loi géométrique

a) Proposer un algorithme simulant une loi géométrique à partir de la répétition d’épreuves de Bernoulli de paramètre p

Une épreuve de Bernoulli X sous Scilab se simule via une loi uniforme sur ]0,1[ en comparant la valeur obtenue avec rand() au paramètre p. Si cette valeur est inférieure à p, on obtient un succès X=1. Si cette valeur est supérieure à p on obtient un échec X=0. Donc pour la géométrique, on va générer des épreuves de Bernoulli suivant ce modèle et les compter via un compteur (boucle while) jusqu’à obtenir un succès (une valeur de rand() inférieure à p).

11

b) Proposer un algorithme simulant une loi géométrique à partir d’une loi exponentielle

On sait que si X suit une loi exponentielle de paramètre 1 et si Y=partie entière(aX)+1 alors Y suit une loi géométrique de paramètre p=1-exp(-1/a)

Démonstration :

On peut donc utiliser la méthode d’inversion : X=floor(log(1-rand())/log(1-p))+1

L’instruction (log(1-rand())/log(1-p)) génère (voir III 2) a)) un nombre aléatoire suivant une loi exponentielle de paramètre lambda=ln(1-p) à partir d’une loi uniforme continue sur ]0,1[ (générateur rand()). En prenant la partie entière, on retrouve bien la loi géométrique de paramètre p.

On va comparer ci-dessous ce générateur avec la fonction grand via un diagramme en bâtons (p=0.2, N=10000)

On aurait pu aussi faire plus simple et prendre X=floor(grand(1,N,’exp’,1/a))+1 ce qui évite de « simuler » la géométrique avec rand().

Simu avec exponentielle simu avec grand

12

4) Simulations d’une loi normale

a) La méthode des 12 uniformes …

On considère une famille Ui (i un entier compris entre 1 et 12) de lois uniformes sur ]0,1[ alors la variable centrée réduite associée à elle fournit une approximation de la loi normale centrée réduite.

On va le montrer en comparant les histogrammes sur l’intervalle [-5,5] entre cette simulation et la simulation d’une normale via grand.

b) Illustration du TCL : proposer un algorithme permettant d’approcher une loi normale centrée réduite via une loi binomiale

13

On va utiliser le théorème de Moivre Laplace qui est un corollaire du TCL. Si 0<p<1 et si on a une suite (Sn) de binomiale de paramètres (n,p) indépendantes alors converge en loi vers une normale centrée réduite.

On va utiliser la comparaison des fonctions de répartition pour illustrer cela.

Pour comparer les fonctions de répartition, on utilisera la fonction de répartition empirique donnée par :

L’algorithme est le suivant :

Pour n=60, p=0.2 et N=100000, on obtient :

14