Probabilités et statistiques avec Scilab

Université Joseph Fourier (Grenoble I)
Préparation à l’agrégation de mathématiques
Année 2010-2011
Épreuve de modélisation
Probabilités et statistiques
avec Scilab
version du 6 septembre 2013
Table des matières
1 Introduction à Scilab
1.1 Un premier contact . . . . . . . . . . . . . . . . . . .
1.2 Algèbre élémentaire . . . . . . . . . . . . . . . . . . .
1.2.1 Vecteurs et matrices . . . . . . . . . . . . . .
1.2.2 Extraction . . . . . . . . . . . . . . . . . . . .
1.2.3 Modification, insertion, suppression . . . . . .
1.3 Opérations matricielles . . . . . . . . . . . . . . . . .
1.4 Programmation . . . . . . . . . . . . . . . . . . . . .
1.4.1 Utilisation des fichiers . . . . . . . . . . . . .
1.4.2 Fonctions . . . . . . . . . . . . . . . . . . . .
1.4.3 Opérateurs logiques . . . . . . . . . . . . . .
1.4.4 Boucle for . . . . . . . . . . . . . . . . . . .
1.4.5 Boucle while . . . . . . . . . . . . . . . . . .
1.4.6 Instructions conditionnelles . . . . . . . . . .
1.5 Compléments . . . . . . . . . . . . . . . . . . . . . .
1.5.1 Systèmes linéaires . . . . . . . . . . . . . . .
1.5.2 Résolution d’équations non linéaires . . . . .
1.5.3 Équations différentielles . . . . . . . . . . . .
1.5.4 Polynômes . . . . . . . . . . . . . . . . . . . .
1.6 Commandes graphiques de base . . . . . . . . . . . .
1.6.1 Courbes planes et nuages de points . . . . . .
1.6.2 Courbes paramétrées et surfaces en dimension
1.6.3 Fenêtres et sous-fenêtres graphiques . . . . .
1.7 Quelques conseils . . . . . . . . . . . . . . . . . . . .
1.8 Exercices . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
3
3
5
6
6
9
9
9
12
12
12
13
13
13
14
14
14
15
15
16
16
17
17
2 Fonctions de base pour les probabilités et les statistiques
2.1 Générateurs aléatoires . . . . . . . . . . . . . . . . . . . . . .
2.1.1 Le générateur rand . . . . . . . . . . . . . . . . . . . .
2.1.2 La fonction grand . . . . . . . . . . . . . . . . . . . .
2.1.3 Simulation de lois quelconques . . . . . . . . . . . . .
2.2 Représentation de lois . . . . . . . . . . . . . . . . . . . . . .
2.2.1 Représentation de lois discrètes . . . . . . . . . . . . .
2.2.2 Représentation de lois à densité . . . . . . . . . . . . .
2.2.3 Quantiles . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Echantillons . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1 Moyenne, variance, covariance empiriques . . . . . . .
2.3.2 Répartition en classes : les fonctions dsearch et tabul
2.3.3 Représentations graphiques . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
19
19
20
23
23
23
25
25
25
25
26
i
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2.4
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30
3 Loi des grands nombres, méthode de Monte-Carlo
3.1 Loi des grands nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1 Vérification graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.2 Vitesse de convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.3 Comparaison des bornes dans l’inégalité de Bienaymé-Tchebychev et dans
l’approximation normale . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Convergence des histogrammes et des fonctions de répartition empiriques . . . . .
3.2.1 Théorème de Glivenko-Cantelli . . . . . . . . . . . . . . . . . . . . . . . .
3.2.2 Convergence des histogrammes . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.1 L’aiguille de Buffon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.2 Calcul d’intégrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
35
35
36
4 Variables aléatoires gaussiennes, théorème limite central
4.1 Loi multinormale . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Échantillons gaussiens, loi du χ2 et lois associées . . . . . .
4.2.1 Loi du χ2 . . . . . . . . . . . . . . . . . . . . . . . .
4.2.2 Loi de Student . . . . . . . . . . . . . . . . . . . . .
4.2.3 Loi de Fisher-Snedecor . . . . . . . . . . . . . . . . .
4.2.4 Échantillons gaussiens . . . . . . . . . . . . . . . . .
4.3 Théorème limite central . . . . . . . . . . . . . . . . . . . .
4.3.1 Le cas unidimensionnel . . . . . . . . . . . . . . . . .
4.3.2 Le cas multidimensionnel . . . . . . . . . . . . . . .
4.3.3 Application à la loi multinomiale . . . . . . . . . . .
4.4 Mouvement brownien . . . . . . . . . . . . . . . . . . . . . .
4.4.1 Mouvement brownien standard . . . . . . . . . . . .
4.4.2 Mouvement brownien dans Rd . . . . . . . . . . . . .
4.4.3 Pont brownien . . . . . . . . . . . . . . . . . . . . .
4.5 Processus gaussiens stationnaires . . . . . . . . . . . . . . .
4.5.1 Un peu de terminologie . . . . . . . . . . . . . . . .
4.5.2 Moyennes mobiles . . . . . . . . . . . . . . . . . . .
4.5.3 Processus auto-régressifs . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
45
45
47
47
48
48
49
50
50
51
51
52
52
53
54
55
55
55
58
5 Chaînes de Markov à temps discret
5.1 Simulation de chaînes de Markov . . . . . . . . .
5.1.1 Commandes de base . . . . . . . . . . . .
5.1.2 Chaînes absorbantes . . . . . . . . . . . .
5.1.3 Estimation de la probabilité de transition
5.2 Exemples . . . . . . . . . . . . . . . . . . . . . .
5.2.1 Le modèle d’urne d’Ehrenfest . . . . . . .
5.2.2 Le modèle de Wright-Fisher . . . . . . . .
5.2.3 Le processus de Galton-Watson . . . . . .
5.2.4 L’urne de Polya . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
61
61
61
62
63
64
64
67
69
71
ii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
36
37
37
39
39
39
40
42
6 Processus à temps continu
6.1 Le processus de Poisson . . . . . . . . . . . . . . . . .
6.1.1 Âge et durée de vie résiduelle . . . . . . . . . .
6.1.2 Loi conditionnelle des instants d’arrivées . . . .
6.1.3 Superposition et décomposition de processus de
6.1.4 Processus de Poisson composé . . . . . . . . . .
6.1.5 Processus de Poisson non homogène . . . . . .
6.1.6 Processus de Poisson dans le plan : . . . . . . .
6.2 Processus markoviens de sauts . . . . . . . . . . . . . .
6.2.1 Définition et propriétés . . . . . . . . . . . . . .
6.2.2 Lois stationnaires . . . . . . . . . . . . . . . . .
6.2.3 Simulation par variables exponentielles . . . . .
6.2.4 Simulation par la chaîne incluse . . . . . . . . .
6.2.5 Simulation par la chaîne harmonisée . . . . . .
6.3 Files d’attente . . . . . . . . . . . . . . . . . . . . . . .
6.3.1 La file d’attente G/G/1 . . . . . . . . . . . . .
6.3.2 Le cas markovien . . . . . . . . . . . . . . . . .
6.3.3 Files d’attente à plusieurs serveurs . . . . . . .
6.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . .
. . . . .
. . . . .
Poisson
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
73
73
74
74
75
75
75
76
77
77
77
78
78
79
80
80
81
82
83
7 Statistique
7.1 Régions et intervalles de confiance . . . . . . . . . . . . . . .
7.1.1 Régions et intervalles de confiance exacts . . . . . . .
7.1.2 Régions et intervalles de confiance approchés . . . . .
7.2 Tests d’adéquation . . . . . . . . . . . . . . . . . . . . . . . .
7.2.1 Test du χ2 . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.2 Test de Kolmogorov-Smirnov . . . . . . . . . . . . . .
7.3 Comparaison de deux échantillons . . . . . . . . . . . . . . . .
7.3.1 Test de Wilcoxon-Mann-Whitney . . . . . . . . . . . .
7.3.2 Test de Smirnov . . . . . . . . . . . . . . . . . . . . .
7.4 Régression . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4.1 Ajustement affine par la méthode des moindres carrés
7.4.2 Régression linéaire simple . . . . . . . . . . . . . . . .
7.4.3 Le modèle linéaire . . . . . . . . . . . . . . . . . . . .
7.4.4 Régression linéaire multiple . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
85
85
85
86
88
88
91
91
91
91
92
92
94
94
95
8 Indications de solutions
8.1 Chapitre 1 . . . . . . .
8.2 Chapitre 2 . . . . . . .
8.3 Chapitre 3 . . . . . . .
8.4 Chapitre 4 . . . . . . .
8.5 Chapitre 5 . . . . . . .
8.6 Chapitre 6 . . . . . . .
8.7 Chapitre 7 . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
97
97
99
104
106
108
111
119
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
iii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
iv
Chapitre 1
Introduction à Scilab
Scilab est un logiciel de calcul numérique développé par l’INRIA et l’ENPC. Sa syntaxe et ses
possibilités sont très proches de celles du logiciel commercial Matlab, mais contrairement à celuici, il est distribué gratuitement, avec ses sources, sur le site
http://www.scilab.org
Scilab n’est pas un logiciel de calcul formel : il ne fait pas de calcul exact (à de rares exceptions
près), mais permet de faire très rapidement des calculs numériques approchés et dispose de
nombreuses fonctionnalités graphiques.
1.1
Un premier contact
Lorsque Scilab est lancé, une fenêtre de commande s’ouvre et une invite de commande -->
indique que le logiciel attend vos instructions. Cette fenêtre peut être utilisée comme une supercalculatrice : vous entrez un calcul, vous tapez sur la touche « Entrée » et Scilab vous donne le
résultat.
Mais dès que vous aurez à écrire des programmes un peu plus développés, vous aurez besoin de
deux fenêtres supplémentaires : la fenêtre de l’éditeur, accessible par le menu « Editeur », qui vous
permettra d’écrire, de sauvegarder, de modifier et d’exécuter ces programmes, et la fenêtre de
l’aide en ligne, indispensable pour retrouver rapidement la syntaxe précise des fonctions dont vous
ne vous servez pas tous les jours. On accède à l’aide en tapant help mot-clé — en anglais ! — ou
par le menu « ? » et le sous-menu « Aide de Scilab » (ou « Help browser », suivant la version et le
système d’exploitation que vous utilisez). On peut aussi utiliser la commande apropos mot-clé.
Tapez :
--> x=1
les lignes suivantes s’affichent :
x
=
1.
-->
Par contre, si vous tapez y=1;, la valeur 1 est bien affectée à y (vérifiez en tapant y), mais le
résultat de l’affectation ne s’affiche pas (ce qui est particulièrement utile si y est une matrice
100 × 100 !).
Si on tape simplement 3*5 sans affecter le résultat à une variable nommée, il est automatiquement
affecté à une variable nommée ans (pour answer ). La valeur de cette variable est conservée
jusqu’au premier calcul non affecté.
1
Dans les noms de variables, les majuscules sont distinctes des minuscules. Toutes les variables
d’une session sont globales et conservées en mémoire. Des erreurs proviennent souvent de confusions avec des noms de variables déjà affectés. Il faut penser à ne pas toujours utiliser les mêmes
noms ou à libérer les variables par clear. Vos variables sont listées par who_user.
a=[1,2]; A=[1,2;3,4];
1+1
who_user
clear a
who_user
clear
who_user
// affecte a et A
// affecte ans
// vos variables
// a disparait
// a, A et ans disparaissent
On peut, dans la fenêtre de Scilab copier et coller des lignes à l’aide de la souris (y compris les
exemples donnés par l’aide) ; on peut aussi naviguer dans l’historique des commandes au moyen
des flèches ↑ ou ↓.
Chaque instruction doit être tapée sur une ligne. Si une instruction est trop longue, on peut la
continuer sur la ligne suivante en terminant la première ligne par deux points (ou plus) :
-->a=..
-->7
a =
7.
Les constantes e, π et i sont prédéfinies ; elles sont notées %e, %pi et %i respectivement.
Scilab est un logiciel de calcul numérique et non de calcul formel : il effectue des calculs numériques approchés et non des calculs exacts. On peut le constater en calculant eiπ :
-->%e^(%i*%pi)
ans =
- 1. + 1.225D-16i
Par défaut les réels sont affichés avec 7 décimales. On peut cependant, si besoin est, changer cet
affichage par défaut en utilisant la commande format (cette commande ne change que l’affichage,
et non la valeur des variables en mémoire) :
-->%pi
%pi =
3.1415927
-->format(20);%pi
%pi =
3.14159265358979312
En fait, les réels sont codés dans Scilab sur 64 bits : un bit pour le signe, 11 bits pour l’exposant
et 52 bits pour la mantisse, ce qui permet de coder des réels entre environ 2.10−308 et 2.10308
avec une précision de l’ordre de 2.10−16 . Cette valeur est celle de la variable prédéfinie %eps :
-->%eps
%eps =
2.220D-16
Le nombre de mots en mémoire (un mot=un réel en double précision) peut être très grand (de
l’ordre de 5000000 par défaut). Si l’espace alloué n’est pas suffisant, on peut l’augmenter en
utilisant la commande stacksize(k), où k est le nombre de mots disponibles souhaité. Il n’est
naturellement pas extensible à l’infini :
2
-->stacksize(1e10)
!--error 1504
Out of bounds value for stacksize argument
La commande who liste les variables utilisées. Un éditeur de variables, accessible par le menu,
permet également de visualiser et de modifier ces variables.
Chaque variable a un type. Les principaux types qui nous intéresseront sont :
– les constantes (matrices réelles ou complexes) ;
– les booléens (vrai : %t ou faux : %f) ;
– les chaînes de caractères (’x’ ou "x", qui représentent le même objet).
Il en existe d’autres (polynômes, fonctions, listes, . . .). On obtient le type d’une variable x en
tapant typeof(x).
Des fonctions permettent de convertir certains types entre eux (string(7) équivaut à ’7’
(string=chaîne de caractères), evstr(’7’) à 7 (evstr=evaluate string), bool2s(%t) donne 1
(bool2s=boolean-to-scalar), . . .). Certaines conversions entre booléens et réels sont effectuées automatiquement par le logiciel.
Les types des variables ne doivent pas être déclarés et ils peuvent changer à tout instant : on
peut toujours affecter à une variable déjà existante une valeur d’un autre type.
1.2
Algèbre élémentaire
Pour Scilab, tout (ou presque) est matrice : un réel est simplement une matrice 1×1. Les matrices
peuvent avoir des coefficients réels, complexes, booléens, chaînes de caractères, polynômes . . ..
Les coefficients d’une matrice doivent cependant tous être de même type.
Il faut, chaque fois qu’on le peut, utiliser les opérations matricielles prédéfinies. Le gain de temps,
par rapport à l’utilisation de boucles, peut être considérable :
-->timer();
-->for j=1:100
-->for i=1:100
-->B(i,j)=rand(1,1,’n’);
-->end
-->end
-->timer()
ans =
1.3
1.2.1
-->timer();
-->C=rand(100,100,’n’);
-->timer()
ans =
0.02
Vecteurs et matrices
En petite dimension, la façon la plus simple de définir une matrice n × m est d’en écrire entre
crochets les éléments séparés par des virgules, les lignes étant séparées par des points-virgules :
x=[a11, ... , a1m ; ... ;an1, ... ,anm].
-->A=[1,1,1;3,0,0;2,0,1]
A =
!
1.
1.
1. !
!
3.
0.
0. !
!
2.
0.
1. !
3
On peut aussi séparer les colonnes par des espaces au lieu de virgules : ainsi [1 -2,2] et [1,-2,2]
définissent le même objet (la deuxième écriture est cependant fortement conseillée).
De nombreuses matrices sont prédéfinies : matrice nulle, matrice unité, matrices aléatoires, intervalles.
zeros (n,m)
ones(n,m)
eye(n,m)
rand(n,m)
diag(A,k)
triu(A)
tril(A)
toeplitz
linspace(a,b,k+1)
logspace(a,b,k+1)
matrice n × m nulle
matrice n × m telle que ai,j = 1 pour tout i, j
matrice n × m ayant des 1 sur la diagonale
principale et des zéros ailleurs
les coefficients sont des réalisations de variables aléatoires indépendantes de loi uniforme sur ]0, 1[
extrait la k-ième diagonale de la matrice A
annule les coefficients au-dessous de la diagonale
annule les coefficients au-dessus de la diagonale
matrices à diagonales constantes
vecteur (matrice 1 × (k + 1)) de coordonnées
a + j(b − a)/k avec 0 ≤ j ≤ k.
analogue au précédent en échelle logarithmique (xi+1 = Cxi entre 10a et 10b (sauf si
b = π !)
Matrices : construction
Si une matrice A est déjà définie, la commande rand(A) (resp. zeros(A). . .) définit une matrice
aléatoire (resp. nulle, . . .) ayant la même taille que A. Ainsi la commande rand(7) ne produit
pas un vecteur aléatoire à 7 éléments, mais une matrice aléatoire de même taille que la matrice
[7], i.e. un seul nombre.
Si x est un vecteur, la commande diag(x) construit la matrice diagonale de diagonale x. Par
contre, si A est une matrice, cette commande renvoie le vecteur formé par la diagonale de A.
Ainsi, la commande diag(diag(A)) renvoie la matrice diagonale dont la diagonale est celle de
A.
Il existe deux façons de définir une suite de points régulièrement espacés : la commande
linspace(a,b,k+1) renvoie un vecteur ligne de k + 1 points régulièrements espacés (par défaut k + 1 = 100), le premier étant égal à a et le dernier à b ; la commande a:h:b renvoie
sous forme de vecteur ligne la progression arithmétique de premier terme a et de raison h, le
dernier terme étant le plus grand élément de cette progression ≤ b (si h > 0). Les commandes
linspace(0,1,11) et 0:0.1:1 sont donc équivalentes. Par défaut, h est égal à 1 : les commandes
a:1:b et a:b sont équivalentes.
0:%pi
ans =
0.
1.
2.
3.
La raison h peut également être négative :
10:-1:%pi
ans =
10.
9.
8.
7.
6.
5.
4.
4
1.2.2
Extraction
Pour accéder à l’élément ai,j d’une matrice A, on tape A(i,j). Plus généralement, si A est une
matrice n × m et v = (v1 , v2 , . . . , vk ), w = (w1 , . . . , wp ) deux vecteurs d’indices (non nécessairement distincts) vérifiant :
a) 1 ≤ vi ≤ n pour tout i ∈ {1, . . . , k}
b) 1 ≤ wi ≤ m pour tout i ∈ {1, . . . , p}
alors B=A(v,w) est la sous-matrice de A formée des éléments ai,j pour i parcourant v1 , . . . , vk et
j parcourant w1 , . . . , wp .
-->A=(1:6)’*(2:7)
A =
!
2.
3.
!
4.
6.
!
6.
9.
!
8.
12.
!
10.
15.
!
12.
18.
-->v=1:2:6
v =
!
1.
3.
4.
8.
12.
16.
20.
24.
5.
10.
15.
20.
25.
30.
6.
12.
18.
24.
30.
36.
7.
14.
21.
28.
35.
42.
!
!
!
!
!
!
5. !
-->A(v,v)
ans =
//extraction par copie: A n’est pas modifiée
!
!
!
4.
12.
20.
2.
6.
10.
6. !
18. !
30. !
-->A(2*ones(1,3),:)
ans =
4.
4.
4.
6.
6.
6.
8.
8.
8.
10.
10.
10.
12.
12.
12.
14.
14.
14.
Le symbole : représente le vecteur de tous les indices lignes ou colonnes. Si A est une matrice,
A(:) est le vecteur colonne obtenu en concaténant toutes les colonnes de A.
Pour un vecteur (ligne ou colonne), on peut se contenter de n’indiquer qu’un indice :
-->v=5:-1:1;v([3:$])
ans =
3.
2.
1.
Le symbole $ représente le dernier indice (de ligne ou de colonne).
La commande size(A) renvoie la taille de la matrice A sous forme d’un vecteur ligne à deux
éléments (voir aussi size(A,1), size(A,"c") et size(A,"*")). La longueur d’un vecteur v (ligne
ou colonne) est obtenue par la commande length(v).
La commande matrix permet de remodeler une matrice :
-->matrix(1:6,2,3)
5
ans =
1.
2.
1.2.3
3.
4.
5.
6.
Modification, insertion, suppression
La commande a(i,j)=x, où a est une matrice scalaire déjà définie et x un scalaire, affecte la
valeur x au coefficient a(i,j). On peut de même modifer une sous-matrice de a en remplaçant
les indices i et j par des vecteurs d’indices.
Si l’un des indices i et j est supérieur au nombre de lignes ou de colonnes de a, la matrice a est
automatiquement complétée par des 0 :
-->a=diag(1:2);a(3,1)=5
a =
1.
0.
0.
2.
5.
0.
On peut supprimer des lignes ou des colonnes d’une matrice en leur affectant comme valeur la
matrice vide [ ] :
-->a(2,:)=[ ]
a =
1.
0.
5.
0.
1.3
Opérations matricielles
Les opérations ont en général deux versions : l’une correspond à l’opération usuelle sur les
matrices, l’autre à l’opération effectuée élément par élément. Ainsi, les opérations .∗, .^, ./
sont les versions élément par élément alors que les opérations *, ^, / représentent les opérations
usuelles sur les matrices (produit, puissance, division) lorsque ces opérations ont un sens.
Une fonction usuelle f (sin, cos, exp, abs, int, floor. . .) appliquée à la matrice A = (ai,j )
donne la matrice (f (ai,j )). Par exemple, si A = (ai,j ), exp(A) = (exp(ai,j )). Par contre, si A est
+∞ n
X
A
une matrice carrée, l’exponentielle matricielle
s’obtient par la commande expm(A). On
n!
n=0
trouve de même les fonctions cosm, sinm, etc . . .
Exemple :
-->x=rand(2,2)
x =
!
0.2113249
!
0.7560439
-->U=bool2s(x>0.1)
U =
!
1.
O !
!
1.
1. !
0.0002211 !
0.3303271 !
Les commandes min et max retournent respectivement le plus petit et le plus grand élément de
A si elles sont employées avec un seul argument A (matrice ou vecteur) ; si elles sont employées
avec plusieurs arguments A1 , . . . , An (matrices ou vecteurs de même taille), elles s’interprètent
coefficient par coefficient ; on peut également obtenir les plus petits (ou plus grands) éléments de
chaque ligne (ou colonne) :
6
+
*
.*
/
./
^
.^
\
addition usuelle des matrices
soustraction usuelle des matrices
multiplication usuelle des matrices
multiplication élément par élément des matrices
division à droite
division élément par élément
fonction puissance
puissance élément par élément
division à gauche
Matrices : opérations binaires
bool2s(A)
A’
A.’
sum(A,’c’)
sum(A,’r’)
cumsum(A,’c’)
cumsum(A,’r’)
cumprod(A,’c’)
cumprod(A,’r’)
matrice de même taille que la matrice booléenne A dont les éléments sont 1 pour %t et
0 pour %f.
matrice adjointe de A (conjuguée de la transposée)
matrice transposée de A
P
vecteur colonne : xi = j ai,j
P
vecteur ligne : xj = i ai,j
Pj
matrice : xi,j = k=1 ai,k
P
matrice : xi,j = ik=1 ak,j
Q
matrice : xi,j = jk=1 ai,k
Q
matrice : xi,j = ik=1 ak,j
Opérations sur les matrices
-->x=rand(2,3)
x =
0.7783129
0.2119030
-->min(x)
ans =
0.1121355
-->min(x,’c’)
ans =
0.1121355
0.2119030
-->y=rand(x)
y =
0.8415518
0.4062025
-->min(x,y)
ans =
0.7783129
0.2119030
0.1121355
0.6856896
0.1531217
0.6970851
0.4094825
0.8784126
0.1138360
0.1998338
0.1121355
0.6856896
0.1138360
0.1998338
7
L’addition d’un scalaire à une matrice s’interprète comme l’addition à chaque coefficient. De
même la multiplication, la division par un scalaire, l’élévation à une puissance :
-->2^(0:6)
ans =
1.
2.
4.
-->eye(2,3)-1
ans =
0. - 1. - 1.
- 1.
0. - 1.
8.
16.
32.
64.
Notez cependant que A^2 renvoie le vecteur des carrés de A si A est un vecteur, mais le carré matriciel de A si A est une matrice carrée (et un message d’erreur si A est une matrice rectangulaire).
Attention : la commande 1./ ne donne pas le résultat escompté :
-->1./(1:3)
ans =
0.0714286
0.1428571
0.2142857
En effet Scilab l’interprète comme (1.)/ et non comme 1 ./ et résout un système linéaire au
sens des moindres carrés.
Le rang d’une matrice A, le déterminant et le spectre d’une matrice carrée A, l’inverse d’une
matrice carrée inversible A, sont donnés par les commandes rank(A), det(A), spec(A), inv(A)
(ou A^(-1)). La diagonalisation (quand elle est possible) s’obtient par la commande bdiag(A).
De nombreuses autres fonctions ou décompositions matricielles sont implémentées (voir la
rubrique d’aide Algèbre linéaire).
La commande find
La fonction find permet de trouver, et donc d’extraire etc..., les éléments d’un vecteur (ou d’une
matrice) vérifiant une propriété donnée.
-->a=rand(2,3)
a =
0.2113249
0.0002211
0.7560439
0.3303271
-->find(a<0.5)
ans =
1.
3.
4.
-->x=a(find(a<0.5))
x =
0.2113249
0.0002211
0.3303271
0.6653811
0.6283918
On peut remplacer la commande a(find(a<0.5)) par la commande a(a<0.5) :
-->a(a<0.5)=0
a =
0.
0.7560439
0.
0.
0.6653811
0.6283918
8
De même si b est une matrice booléenne de la même taille que a, a(b) équivaut à a(find(b)).
Tri
La fonction gsort permet de trier les éléments d’un vecteur ou d’une matrice, soit dans leur
ensemble, soit ligne par ligne ou colonne par colonne ; l’ordre peut être croissant ou décroissant
(pour les divers arguments de cette commande, voir la rubrique d’aide). Par exemple, pour trier
chaque colonne par ordre croissant, on utilise gsort(A,’r’,’i’) (’r’ pour ’row’ : on trie sur
les lignes) :
---->A=rand(3,2)
A =
!
0.4368588
0.4051954 !
!
0.2693125
0.9184708 !
!
0.6325745
0.0437334 !
1.4
1.4.1
-->gsort(A,’c’,’i’)
ans =
!
0.4051954
0.4368588 !
!
0.2693125
0.9184708 !
!
0.0437334
0.6325745 !
Programmation
Utilisation des fichiers
En règle générale, dès qu’un programme sort du cadre de l’utilisation d’une "supercalculatrice",
on utilise un éditeur de texte (à bien distinguer d’un traitement de texte), le plus souvent l’éditeur
intégré dans Scilab, accessible par un des menus de la fenêtre de commande. On enregistre le
fichier obtenu avec le suffixe .sce (même si ce n’est pas obligatoire) puis on exécute le fichier
dans Scilab au moyen du menu File operations ou par la commande exec(’fichier.sce’)
où ’fichier.sce’ est le nom du fichier.
Lors de l’oral vous devez utiliser de tels fichiers. Pour faciliter la mise au point et la relecture du
programme par vous-même et sa compréhension par le jury, vous devez également le commenter.
Une ligne de commentaires commence par //. Plus généralement, l’interpréteur ignore tout ce qui,
sur une ligne, suit //. L’éditeur de Scilab permet de commenter et de décommenter simplement
des blocs de texte, ce qui est particulièrement utile si vous voulez n’exécuter qu’une partie de
votre programme.
1.4.2
Fonctions
Pour définir une fonction, on utilise la syntaxe function y=nomdefonction(x), où y est la
valeur retournée par la fonction, nomdefonction le nom de la fonction que l’on veut définir et x
l’argument d’entrée. La définition de la fonction se termine par le mot-clé endfunction :
-->function y=sq(x)
-->y=x.^2
-->endfunction;
-->sq(1:4)
ans =
1.
4.
9.
16.
Pour des fonctions très courtes, on peut aussi utiliser la syntaxe deff(’y=sq(x)’,’y=x.^2’) en
n’oubliant pas les guillemets (mais function y=sq(x),y=x.^2,endfunction tient aussi sur une
ligne).
Une fonction peut avoir plusieurs arguments tant en entrée qu’en sortie. Par exemple la fonction
9
prédéfinie max peut renvoyer à la fois le maximum des coefficients d’un vecteur (ou d’une matrice)
de scalaires et le premier indice où ce maximum est atteint. Si on appelle cette fonction seule,
elle ne renvoie que le maximum :
-->x=floor(3*rand(1,10))
x =
2.
2.
1.
1.
-->max(x)
ans =
2.
1.
2.
2.
1.
1.
2.
Si on veut obtenir aussi l’indice, on appelle la fonction en explicitant deux valeurs en sortie :
-->[y,k]=max(x)
k =
1.
y =
2.
La même remarque vaut pour la fonction de tri gsort qui permet de récupérer le rang de chacun
des éléments d’un vecteur :
-->x=rand(1,7)
x =
0.26395
0.41481
0.28064
0.12800
-->[y,ind]=gsort(x,’g’,’i’)
ind =
7.
4.
6.
1.
3.
2.
5.
y =
0.11213
0.12800
0.21190
0.26395
0.77831
0.21190
0.11213
0.28064
0.41481
0.77831
De manière générale, si une fonction retourne plusieurs valeurs, il faut lui demander explicitement
de retourner ces valeurs en les nommant sous forme d’un vecteur si on veut toutes les obtenir ;
sinon seul le premier argument de sortie (en général le plus important) est retourné.
Une fonction peut être récursive (s’appeler elle-même au cours de son exécution). Ainsi pour
calculer la factorielle d’un entier naturel, on pourrait définir la fonction :
function x=fact(n)
if n<=1 then x=1;else x=n*fact(n-1);end;
endfunction;
(mais la fonction prédéfinie factorial donne directement le résultat et accepte un vecteur ou
une matrice en argument :
-->factorial(0:5)
ans =
1.
1.
2.
6.
24.
120.
de même que la fonction gamma qui permet d’obtenir le même résultat).
10
1.4.2.1
Variables locales et variables globales
Une fonction peut très bien ne pas renvoyer de valeur, mais effectuer une action (par exemple
dessiner une figure ou afficher un message). La fonction dessinercercle(x,y,r) définie par
function dessinercercle(x,y,r)
square(x-r,y-r,x+r,y+r);
xarc(x-r,y+r,2*r,2*r,0,64*360)
endfunction;
dessine le cercle de centre (x,y) et de rayon r. De même la fonction affichercarre(x) définie
par :
-->function affichercarre(x)
-->disp(x^2);
-->endfunction;
-->affichercarre(5)
25.
affiche à l’écran le carré de son argument, mais ne renvoie aucune valeur. Les résultats des calculs
intermédiaires effectués lors de l’exécution d’une fonction ne s’affichent jamais à l’écran, si bien
qu’il est indifférent de terminer les instructions à l’intérieur d’une fonction par un point-virgule
ou un passage à la ligne. La commande disp permet d’afficher la valeur d’une variable ; on peut y
ajouter un texte sous forme de chaîne de caractères, comme disp(’Valeur de x: ’+string(x)).
Une fonction peut accéder en lecture à toutes les variables déjà définies, mais ne peut pas modifier
en cours d’exécution une variable existante, sauf si celle-ci a été déclarée globale. Par exemple la
fonction double() définie par :
function double()
a=2*a;
endfunction;
ne modifie pas la variable a dans le script suivant :
-->a=2;double();a
a =
2.
Pour qu’elle modifie a, il faudrait déclarer cette variable globale :
-->global a;
-->function double()
-->global a;
-->a=2*a;
-->endfunction;
-->a=3;double();a
a =
6.
Le plus simple est naturellement de définir la fonction autrement :
-->function y=double(x)
-->y=2*x;
-->endfunction;
-->a=3;a=double(a)
a =
6.
et d’éviter ainsi l’utilisation de variables globales.
11
1.4.3
Opérateurs logiques
==
<
>
<=
>=
∼= ou <>
∼
& ou and
| ou or
égal à
inférieur à
supérieur à
inférieur ou égal à
supérieur ou égal à
différent de
négation
et logique
ou logique (non exclusif)
Ces opérateurs s’appliquent coefficient par coefficient sur des matrices de même taille :
-->a=rand(2,3),b=rand(a),b<a,or(b<a)
a =
0.2113249
0.0002211
0.6653811
0.7560439
0.3303271
0.6283918
b =
0.8497452
0.8782165
0.5608486
0.6857310
0.0683740
0.6623569
ans =
F F T
T T F
ans =
T
1.4.4
Boucle for
La boucle for itère sur les composantes d’un vecteur ligne. Elle s’écrit :
for variable=indices, instruction(s), end
(ne pas oublier le end).
-->v=zeros(1,4);for i=1:2:5, v(i)=i^2;end;v
v =
1.
0.
9.
0.
25.
1.4.5
Boucle while
Elle permet de répéter une instruction tant qu’une condition est vraie. Sa syntaxe est :
while condition, instruction(s); end
Ne pas oublier le end et se méfier des boucles sans fin du type :
-->while 1
-->i=i+1;
-->end
(Scilab transforme la constante non nulle 1 en le booléen %t). On peut dans ce cas arrêter
l’exécution du programme au moyen de la commande stop du menu control de la barre de
menu.
La commande break interrompt l’exécution d’une boucle :
-->for k=1:100, if k^2>50 then break;end;end;k
k =
8.
12
1.4.6
1.4.6.1
Instructions conditionnelles
if then else
Elle s’écrit :
if condition(s) then instruction(s), else instructions, end
.
L’alternative else n’est pas obligatoire. Si elle est suivie d’un if, on peut contracter les deux
mots-clés en elseif.
Attention : le mot-clé then doit être situé sur la même ligne que if ou elseif ; il peut être
remplacé par un passage à la ligne ou une virgule.
1.4.6.2
select case
Elle s’écrit :
select n,case n1 instruction,case n2 instruction,...else instruction,end
Un exemple suffira à l’illustrer :
-->nom=’jean’;select nom, case ’pierre’ y=1, case ’jean’ y=2,else y=3,end
y =
2.
1.5
1.5.1
Compléments
Systèmes linéaires
Pour résoudre un système de Cramer Ax = b, où A est une matrice carrée inversible, on peut
soit exprimer la solution sous la forme x = A−1 b, soit utiliser la division matricielle à gauche
x=A\b :
-->A=rand(3,3);b=rand(3,1);x1=A\b;x2=inv(A)*b;norm(A*x1-b),norm(A*x2-b)
ans =
1.241D-16
ans =
2.719D-16
On peut ainsi résoudre simultanément plusieurs équations ayant le même premier membre, mais
des seconds membres différents, en remplaçant le vecteur b par la matrice rectangulaire obtenue
en concaténant les seconds membres.
Si la matrice A n’est pas inversible (ou est numériquement proche d’une matrice non inversible),
ou si A a le même nombre de lignes que la matrice b, mais n’est pas carrée, Scilab envoie un
message d’avertissement et résoud le système au sens des moindres carrés :
-->A=ones(3,3);b=rand(3,2);x1=A\b
warning
matrix is close to singular or badly scaled. rcond =
computing least squares solution. (see lsq)
x1 =
0.5119654
0.5524123
0.
0.
0.
0.
13
0.0000D+00
1.5.2
Résolution d’équations non linéaires
La résolution d’équations non linéaires se fait par la commande fsolve. La fonction dont on
cherche les zéros est d’abord définie comme fonction Scilab (par function ou deff). Le premier
argument de fsolve est la valeur initiale destinée à initialiser l’algorithme de résolution, le second
la fonction :
-->function y=f(x),y=x-cos(x),endfunction;x=fsolve(0,f)
x =
0.7390851
-->cos(x)-x
ans =
0.
1.5.3
Équations différentielles
La résolution d’équations différentielles ordinaires se fait par la fonction ode (Ordinary Differential Equation). La commande de base pour résoudre l’équation différentielle y ′ = f (t, y) est
de la forme y=ode(y0,t0,t,f), où y0 est la donnée initiale, t0 l’instant initial, t le vecteur des
instants auxquels on veut obtenir la solution et f la fonction Scilab définissant le second membre
(attention : f doit nécessairement être définie comme fonction de t et y, même si l’équation est
de la forme y ′ = g(y)). Pour résoudre numériquement l’équation y ′′ + y = 0, avec y(0) = 1,
y ′ (0) = 0, on peut donc écrire :
function y1=f(t,y),y1=[0 -1;1 0]*y,endfunction;
t=linspace(0,2*%pi);y=ode([1;0],0,t,f);
//vérification:
norm(y(1,:)-cos(t))
ans =
0.0000009
1.5.4
Polynômes
Scilab possède un type polynôme. On définit un polynôme soit par ses racines (comportement par
défaut), soit par ses coefficients. L’indéterminée est entrée sous forme de chaîne de caractères.
Ainsi les deux commandes P=poly([1 2],’s’) et Q=poly([2 -3 1],’s’,’c’) définissent le
même polynôme (s − 1)(s − 2) = s2 − 3s + 2.
La variable prédéfinie %s représente le polynôme élémentaire s :
poly(0,’s’)==%s
ans =
T
Les racines s’obtiennent par la fonction roots, les coefficients par coeff.
L’addition, la multiplication, la multiplication par un scalaire utilisent les symboles ordinaires.
L’évaluation en un point ou la composition se font par la fonction horner. Si A est une matrice,
poly(A,’t’) est le polynôme caractéristique de A.
Le script suivant représente sur un même graphique la première bissectrice, le graphe sur
l’intervalle [0, 1] de la fonction génératrice g d’une loi discrète sur {0, 1, 2, 3} ainsi que celui de
ses itérées successives, et résoud l’équation g(s) = s sur ce même intervalle, d’abord en utilisant
la commande fsolve, puis en entrant la fonction génératrice sous forme d’un polynôme (pour
l’interprétation d’un tel programme, voir la section 5.2.3) :
14
loi=[0.2 0.4 0.2 0.2];
function y=g(t)
y=loi*t^(0:length(loi)-1)’;
endfunction;
t=linspace(0,1);
y=t;
for k=1:10
plot2d(t,y,style=k);
y=feval(y,g);
end;
function y=gg(t)
y=g(t)-t;
endfunction;
q=fsolve(0,gg)
1.0
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
pg=poly(loi,’s’,’c’);fg=poly(0,’s’);
qq=roots(fg-pg);
for k=1:10
plot2d(t,horner(fg,t),style=k);
fg=horner(pg,fg);
end;
disp(qq);
1.6
Commandes graphiques de base
Les possibilités graphiques de Scilab sont importantes. Nous n’indiquerons ici que quelques commandes de base. Pour les autres, se reporter à l’aide en ligne, rubrique Graphics.
1.6.1
Courbes planes et nuages de points
La commande de base pour tracer des courbes planes est plot2d. Les variantes plot2d2 et
plot2d3 permettent de tracer des courbes en escalier ou des diagrammes en bâtons.
Cette commande prend en arguments les vecteurs des abscisses et des ordonnées d’une suite de
points et représente la ligne brisée joignant ces points. Si le nombre de points est suffisant, on
peut ainsi représenter le graphe d’une fonction :
x=linspace(0,%pi);plot2d(x,sin(x));
De nombreux arguments facultatifs permettent de règler l’affichage (couleur, échelle, axes . . .),
d’ajouter un titre (xtitle) ou des légendes (legends) : consulter à ce propos l’aide en ligne.
La commande square permet d’obtenir directement une échelle isométrique (par défaut, Scilab
représente un cercle comme une ellipse : t=linspace(0,2*%pi);plot2d(cos(t),sin(t));).
Si on veut représenter plusieurs courbes sur le même graphique, on donne en arguments de
plot2d deux matrices x et y à n lignes et nc colonnes, où n est le nombre de points de chaque
courbe et nc le nombre de courbes :
x=linspace(0,%pi);plot2d([x’,x’],[sin(x’),cos(x’)])
Pour représenter un nuage de points (ou une courbe dont les points ne sont pas reliés entre eux),
il faut donner un paramètre style=-n, où n est un entier entre 1 et 10, qui représente la marque
utilisée pour représenter chaque point.
Il existe aussi une commande plot, dont la syntaxe est plus souple. Elle permet de représenter
directement le graphe d’une fonction en donnant son nom, ou de choisir style et couleur de
représentation par des paramètres simples. Par exemple :
15
xy=[3 -1;-1 2]*rand(2,100,’n’);
plot(xy(1,:),xy(2,:),’or’)
représente le nuage de points dont les coordonnées sont données dans la matrice xy, chaque point
étant représenté par un petit cercle (’o’) de couleur rouge (’r’).
1.6.2
Courbes paramétrées et surfaces en dimension 3
La commande de base pour représenter une surface est plot3d. Dans sa version la plus simple,
la surface d’équation z = f (x, y) est obtenue en entrant les intervalles de définition discrétisés
de x et y, de longueurs respectives n et m, et une matrice z à n lignes et m colonnes donnant
les valeurs de la fonction en les points de la grille ainsi définie :
x=linspace(-%pi,%pi,40);
y=linspace(-%pi/2,%pi/2,20);
z=cos(x)’*sin(y);
plot3d(x,y,z);
Pour représenter une courbe paramétrée dans l’espace, il faut utiliser la commande param3d ou
param3d1.
En particulier, pour représenter un nuage de points dans R3 , on utilise la commande param3d1
avec un argument de couleur négatif :
n=1000;
xyz=[2 1 0;1 3 0;0 0 1]*rand(3,n,’n’);
param3d1(xyz(1,:),xyz(2,:),list(xyz(3,:),-ones(1,n)));
1.6.3
Fenêtres et sous-fenêtres graphiques
On efface le contenu d’une fenêtre graphique par la commande clf(). Cela évite de superposer
un graphique à un graphique déjà existant (par défaut, Scilab superpose le nouveau graphique
au précédent, en réajustant éventuellement l’échelle). La commande show_window() force la
fenêtre à apparaître au premier plan.
On peut créer une nouvelle fenêtre graphique par la commande xset(’window’,n), où n est le
numéro de la fenêtre que l’on veut créer. Si la fenêtre numérotée n existe déjà, elle devient la
fenêtre graphique courante.
La commande la plus simple pour diviser une fenêtre graphique en plusieurs sous-fenêtres est
subplot. La commande subplot(mnp) (ou subplot(m,n,p)), où m, n et p sont trois entiers
(p ≤ mn) divise la fenêtre graphique en mn sous-fenêtres de même taille (m lignes et n colonnes)
et situe le dessin courant dans la p-ième de ces fenêtres (numérotées par ligne, puis colonne).
La commande xsetech permet plus de souplesse, mais a une syntaxe un peu plus compliquée.
1.7
Quelques conseils
– Nommez systématiquement vos variables en utilisant des noms facilement identifiables (pour
vous d’abord, et pour ceux qui liront vos programmes ensuite). Il est bien plus facile (et
beaucoup plus sûr) de modifier un paramètre (par exemple le nombre de simulations) qui a
reçu un nom que de modifier dans tout le programme la valeur de ce paramètre à chacune de
ses occurences.
– Initialisez toujours les vecteurs et les matrices : la commande :
16
n=100000;
x=zeros(1,n);
timer();for i=1:n,x(i)=i;end;timer()
ans =
0.421875
s’exécute beaucoup plus rapidement que la commande :
n=100000;
timer();for i=1:n,y(i)=i;end;timer()
ans =
68.828125
et donne le même résultat (naturellement aucune de ces commandes n’est ici à recommander :
trouvez la bonne. . .). Ensuite, la première permet de contrôler la taille du résultat (un vecteur
ligne, alors que la seconde fournit un vecteur colonne). Enfin, et surtout, si le vecteur x est
déjà défini et de longueur supérieure à n, la commande
for i=1:n x(i)=i;end;
ne modifie que les n premières composantes de x, et laisse les suivantes en place, ce qui constitue
une source fréquente d’erreur.
– Indentez le contenu des boucles si elles contiennent plusieurs instructions imbriquées, ce qui
rend la structure du programme plus lisible.
1.8
Exercices
Exercice 1.1. Ecrire un vecteur aléatoire de 10 réels. Réécrire ce vecteur dans l’ordre inverse.
Exercice 1.2. Ecrire un vecteur ligne à 10 éléments dont les éléments sont successivement +1 et -1.
Ecrire un vecteur ligne aléatoire à 10 éléments, dont les éléments sont indépendamment +1 et -1 avec
équiprobabilité.
Exercice 1.3. Ecrire une matrice aléatoire 4 × 4, puis la matrice obtenue en remplaçant la première
ligne par la dernière.
Exercice 1.4. Ecrire une matrice carrée aléatoire d’ordre 5 à coefficients ±1, puis la matrice obtenue en
remplaçant les éléments diagonaux de cette matrice par des zéros.
Exercice 1.5. Soit a le vecteur ligne a = (1, 2, 3, 4) et b le vecteur ligne b = (1, 3, 5, 7). Ecrire la
matrice de terme général ai bj .
Plus généralement, étant donné un vecteur ligne et un entier n, écrire la matrice à n lignes toutes égales
au vecteur donné. Idem en remplaçant ligne par colonne.
Exercice 1.6. Ecrire une matrice aléatoire A à 3 lignes et 5 colonnes, puis les matrices tAA et A tA.
Comparer les spectres de ces deux matrices.
Exercice 1.7. Soit A une matrice 5 × 5. Multiplier les colonnes de A respectivement par 1, 2, 3, 4,
5. Proposer plusieurs solutions. Idem pour les lignes. Remplacer la deuxième ligne par la somme de la
première et de la dernière. Calculer le déterminant, puis le rang de la matrice obtenue.
Exercice 1.8. Écrire une fonction dif réciproque de la fonction cumsum agissant sur les vecteurs.
√
nn e−n 2πn
Exercice 1.9. Écrire la suite des quotients qn =
de l’approximation de n! par la forn!
mule de Stirling
par
la
vraie
valeur
n!
pour
n
=
1,
.
.
.
,
1000.
Idem
avec l’approximation de n! par
√
1
.
nn e−n 2πn 1 +
12 n
Exercice 1.10.
Écrire des fonctions calculant les nombres d’arrangements A(n, p) et les nombres de
n
combinaisons
de p objets parmi n :
p
– en utilisant la fonction factorial ;
– en utilisant la fonction gamma ;
17
– en utilisant la fonction gammaln (logarithme de la fonction gamma).
Discuter les avantages et les inconvénients de ces méthodes. Ces fonctions peuvent-elles prendre comme
arguments des vecteurs ?
Exercice 1.11. Écrire une fonction renvoyant les n+1 premières lignes du triangle de Pascal (complétées
par des 0 pour apparaître sous forme de matrice carrée).
Exercice 1.12. Écrire une fonction renvoyant la liste de tous les nombres premiers inférieurs ou égaux
à son argument en utilisant la méthode du crible d’Eratosthène.
π(x) ln(x)
Représenter graphiquement la fonction x 7→
, où π(x) est le nombre de nombres premiers
x
inférieurs ou égaux à x.
18
Chapitre 2
Fonctions de base pour les probabilités
et les statistiques
2.1
Générateurs aléatoires
Scilab dispose de deux générateurs de nombres pseudo-aléatoires : un générateur de base rand
et un générateur plus sophistiqué grand.
2.1.1
Le générateur rand
La commande x=rand(n,m) renvoie une matrice n × m dont les coefficients sont des nombres
pseudo-aléatoires indépendants uniformément distribués sur l’intervalle [0, 1]. Si A est une matrice
n × m, rand(A) équivaut à rand(n,m). On peut également obtenir des nombres suivant la loi
normale réduite par la commande x=rand(n,m,’n’). On peut, par la commande rand(’n’),
modifier le comportement par défaut de manière à obtenir systématiquement des nombres suivant
cette loi normale ; on revient au comportement par défaut par la commande rand(’u’). L’état
de ce paramètre est obtenu par la commande rand(’info’).
Le générateur rand est un générateur congruentiel linéaire de paramètres a = 843314861, c =
453816693, m = 231 , ce qui signifie que la suite xn des nombres renvoyés par la commande
rand est de la forme xn = un /m, où la suite un d’entiers satisfait à la relation de récurrence
un+1 ≡ aun + c (mod m), la valeur initiale (la « graine ») u0 étant 0 au démarrage de Scilab. On
peut obtenir la valeur courante un de la graine par la commande rand(’seed’) et changer la
valeur de cette graine par la commande rand(’seed’,k). Cette commande est utile pour répéter
à l’identique un tirage aléatoire et pouvoir ainsi contrôler ses résultats.
2.1.2
La fonction grand
La commande grand permet de simuler directement la plupart des lois usuelles. Elle fait appel
à un générateur beaucoup plus sophistiqué (en fait, elle permet même d’utiliser différents générateurs très performants), ce qui constitue une raison supplémentaire de l’utiliser. On peut ainsi
simuler des lois uniformes, des lois normales uni ou multidimensionnelles, des lois géométriques,
des lois exponentielles, des lois gamma, des lois bêta, des lois du χ2 , des lois uniformes sur un
intervalle de réels ou d’entiers, . . . Elle permet également de simuler l’évolution de chaînes de
Markov à espace d’états fini, ainsi que de générer des permutations aléatoires.
Pour plus de détails et pour les différents paramètres permettant d’obtenir ces lois, consulter
l’aide de la rubrique grand, dans le chapitre Fonctions de distributions statistiques.
Elle ne permet pas de simuler directement une loi arbitraire sur un ensemble fini (on peut
cependant simuler une chaîne de Markov dont la matrice de transition a toutes ses lignes égales,
19
ou utiliser une loi multinomiale). Pour simuler une telle loi p = (p1 , . . . , pr ) sur l’ensemble
{1, . . . , r}, où r est un entier et (p1 , . . . , pr ) une famille de réels positifs de somme 1, on peut
définir sa propre fonction. Par exemple :
function x=drand(m,n,p)
//matrice mxn de nombres pseudo-aléatoires de loi p sur [1,...,length(p)]
cp=cumsum(p);
y=rand(m,n);// ou : y=grand(m,n,’def’)
x=ones(y);
for k=1:length(p)-1,
ind=find(y>cp(k));
x(ind)=x(ind)+1;
end;
endfunction;
Si p est une loi sur un ensemble fini {x1 , . . . , xr } et non pas sur {1, . . . , r}, on en obtient un
échantillon de taille n en écrivant x(drand(1,n,p)), où x est le vecteur x1 , . . . , xr .
2.1.3
2.1.3.1
Simulation de lois quelconques
Inversion de la fonction de répartition
On sait que si F est une fonction de répartition sur R et G la fonction (appelée pseudo-inverse
de F ) de ]0,1[ dans R définie par :
G(x) = sup{y ∈ R | F (y) < x} = inf{y ∈ R | F (y) ≥ x} ,
la variable aléatoire G(U ), où U est une variable aléatoire de loi uniforme sur [0, 1], admet pour
fonction de répartition F .
On peut donc ainsi simuler une variable aléatoire de fonction de répartition F quelconque, à
condition toutefois que la fonction G ne soit pas trop difficile à implémenter. C’est en fait cette
méthode qui a permis de simuler une variable aléatoire discrète à valeurs dans {1, . . . , r} (la
fonction de répartition F était dans ce cas en escalier, ainsi que G).
En particulier, si F est une bijection d’un intervalle I de R sur ]0, 1[, la fonction G n’est autre
que la bijection réciproque de F . C’est le cas dans les exemples qui suivent :
Exemple : loi exponentielle Une variable aléatoire réelle suit la loi exponentielle de paramètre λ > 0 si elle admet la densité λe−λx sur ]0, +∞[. Sa fonction de répartition F (x) = 1−e−λx
1
définit une bijection de ]0, +∞[ sur ]0, 1[ dont la bijection réciproque est G(y) = − ln(1 − y).
λ
1
1
La variable aléatoire − ln(1 − U ) (ou encore − ln(U ), puisque U et 1 − U ont même loi), où
λ
λ
U suit la loi uniforme sur ]0, 1[, suit donc la loi exponentielle de paramètre λ. Pour simuler un
échantillon de cette loi, on peut donc utiliser indifféremment les commandes :
lambda=2;n=1;m=1000;
x=-log(grand(n,m,’def’))/lambda;
ou
x=grand(n,m,’exp’,1/lambda)
cette loi étant déjà préprogrammée dans Scilab (attention : le paramètre à entrer est la
1
moyenne de la loi, i.e. , et non λ).
λ
20
Exemple : loi de Cauchy Une variable aléatoire réelle suit la loi de Cauchy de paramètre c >0
1
x
c
1 1
si elle admet la densité
sur R. Sa fonction de répartition est F (x) = + arctan
.
2
2
π c + x
2 π
c
1
La variable aléatoire c tan π(U − ) (ou, plus simplement, c tan(πU )), où U suit la loi uni2
forme sur ]0, 1[, suit donc la loi de Cauchy de paramètre c.
La loi de Cauchy de paramètre 1 est aussi la loi du quotient de deux variables aléatoires gaussiennes réduites indépendantes, ce qui fournit une autre façon de simuler cette loi. Les deux
commandes
n=10000;x=tan(%pi*rand(1,n));
et
n=10000;x=rand(1,n,’n’)./rand(1,n,’n’);
fournissent donc toutes deux un échantillon de cette loi.
2.1.3.2
La méthode de rejet
Soit f une densité de probabilité bornée et à support borné : f est nulle en-dehors d’un intervalle
[a, b] et majorée par un réel M . Soit (Yn )n≥1 une suite indépendante de variables aléatoires de
loi uniforme sur [a, b] et (Un )n≥1 une suite indépendante (et indépendante de la précédente) de
variables aléatoires de loi uniforme sur [0,1]. On montre alors que la variable aléatoire T à valeurs
dans N ∪ {+∞} définie par
f (Yn )
T = inf{n ≥ 1 | Un ≤
}
M
est presque sûrement finie et suit une loi géométrique et que la variable aléatoire réelle X = YT
suit la loi de densité f et est indépendante de T . La loi de X est la loi conditionnelle de Y
f (Y )
sachant U ≤
.
M
Ce résultat permet de simuler une variable aléatoire admettant la densité f : on tire Y suivant
la loi uniforme sur [a, b], U suivant la loi uniforme sur [0, 1], on accepte Y comme valeur de X si
1
f (Y )
, sinon on rejette Y et on recommence. La probabilité d’accepter Y est α =
.
U≤
M
M (b − a)
On a donc intérêt à prendre M le plus petit possible.
En pratique, si on veut obtenir un échantillon de grande taille n de la loi de densité f , on génère
un échantillon y1 , . . . , ym de taille m = kn de la loi uniforme sur [a, b], un échantillon u1 , . . . , um
de même taille de la loi uniforme sur [0, 1], avec k un peu supérieur à 1/α, et on conserve les n
f (yk )
premières valeurs yk vérifiant uk ≤
.
M
Plus généralement, si f et g sont deux densités de probabilité sur R, M un réel positif vérifiant
f ≤ M g, (Yn )n≥1 une suite indépendante de variables aléatoires de loi de densité g et (Un )n≥1
une suite indépendante (et indépendante de la précédente) de variables aléatoires de loi uniforme
sur [0,1], la variable aléatoire T définie par
f (Yn )
T = inf n ≥ 1 | Un ≤
M g(Yn )
est presque sûrement finie et X = YT suit la loi de densité f . On peut ainsi simuler une variable
aléatoire de densité f si l’on sait simuler une variable aléatoire de densité g. On remarque que
M ≥ 1 et qu’on a ici encore intérêt à prendre M le plus petit possible.
Le résultat est encore valable si f et g sont des densités de probabilité sur Rd . En particulier,
pour simuler une variable aléatoire de loi uniforme sur un domaine compact A de Rd , il suffit de
simuler une variable aléatoire Y de loi uniforme sur un pavé contenant A. On accepte Y comme
valeur si Y appartient à A et on la rejette sinon.
21
Simulation de lois conditionnelles Plus généralement, si A est un événement de probabilité
P(A) > 0 lié à une certaine expérience aléatoire et si on veut simuler sous la probabilité conditionnelle P( · | A) une variable aléatoire dépendant de cette expérience, on effectue une suite de
tirages successifs sous la probabilité P et on conserve les tirages pour lesquels l’événement A est
réalisé.
Exemple : une propriété de la loi de Pareto Soit X une variable aléatoire réelle admettant
2
1
la densité 3 sur [1, +∞[. La fonction de répartition FX (x) = 1 − 2 de X s’inverse aisément. Il
x
x
1
1
√
√
en résulte que X a même loi que
, ou encore que
, où U suit la loi uniforme sur [0, 1].
1−U
U
Une propriété remarquable d’une telle variable est que, pour tout réel b ≥ 1, E(X | X ≥ b) = 2b,
ou encore E(X − b | X ≥ b) = b. On peut vérifier cette propriété en simulant un échantillon de
grande taille de cette loi et en ne conservant que les valeurs supérieures à b :
n=1000000;x=1 ./sqrt(rand(1,n));mean(x),mean(x(x>2))
ans =
1.9996072
ans =
4.0023543
2.1.3.3
Mélange de lois
Les mélanges de lois apparaissent de façon assez naturelle. Considérons par exemple un système
constitué de r serveurs en parallèle ; on se connecte sur le k-ième serveur avec une probabilité pk
r
X
pk = 1) et le temps de service sur ce serveur suit une loi exponentielle de paramètre λk (et
(
1
donc d’espérance µk = 1/λk ). On se propose de déterminer la loi du temps de service.
Pour modéliser cette situation avec r = 2, on peut utiliser le script suivant :
//melange de lois
N=5000;
p=0.7;
X=grand(1,N,’bin’,1,p);
//muk: esperance de Yk
mu1=3;
mu2=1;
Y1=grand(1,N,’exp’,mu1);
Y2=grand(1,N,’exp’,mu2);
Z=X.*Y1 +(1-X).*Y2;
Si on ne s’intéresse qu’à l’échantillon dans son ensemble, et non pas à l’ordre d’apparition des
individus, on pourrait tirer d’abord le nombre d’individus de chaque espèce en utilisant une loi
multinomiale, puis réunir les échantillons obtenus :
y=grand(1,’mul’,nb,p(1:$-1)’)
//nb est la taille de l’échantillon
//p la loi de probabilité des types (vecteur ligne)
x=[];
for k=1:size(y,’r’)
x=[x,grand(1,y(k),’exp’,mu(k))];
//mu vecteur des espérances des lois de Poisson
end;
Si on veut un vrai échantillon, on peut écrire :
22
y=grand(nb,’mul’,1,p(1:$-1)’);
for i=1:size(y,’r’)
y(i,:)=y(i,:).*grand(1,nb,’exp’,mu(i));
end;
x=sum(y,’r’);
2.2
2.2.1
Représentation de lois
Représentation de lois discrètes
Une loi discrète sur une partie finie de R peut se représenter par un diagramme en bâtons ou par
un diagramme en barres. On dispose pour cela des commande plot2d3 et bar :
x=binomial(0.6,20);
subplot(121);
plot2d3(0:20,x);
subplot(122);
bar(0:20,x)
2.2.2
Représentation de lois à densité
Pour représenter graphiquement la densité d’une loi à densité sur R, il suffit d’utiliser la
commande plot2d.
On peut ainsi vérifier que la loi binomiale de paramètres n et p est proche de la loi normale de
mêmes moyenne et variance si n est grand et p et 1 − p pas trop petits :
x=binomial(0.6,20);
plot2d3(0:20,x,style=5);
x1=linspace(0,20);m=12;v=4.8;
plot2d(x1,exp(-(x1-m).^2/2/v)/sqrt(2*%pi*v),style=2);
23
0.20
0.18
0.16
0.14
0.12
0.10
0.08
0.06
0.04
0.02
0.00
0
2
4
6
8
10
12
14
16
18
20
Pour représenter la fonction de répartition d’une loi à densité, on peut intégrer numériquement
cette densité. Mais la plupart des fonctions de répartition classiques sont préprogrammées (voir
la rubrique Fonctions de distributions statistiques de l’aide). Les commandes associées
commencent toutes par cdf (Cumulative Distribution Function) : cdfbet (lois bêta), cdfnor (lois
normales),. . . Le premier argument en entrée est la chaîne de caractères ’PQ’ si on veut évaluer
la fonction de répartition elle-même. On peut ainsi tracer le graphe de la fonction de répartition
de la loi normale réduite :
x=linspace(-3,3);
y=cdfnor(’PQ’,x,zeros(x),ones(x));
plot2d(x,y)
ou de la loi bêta de paramètres 1 et 3 :
x=linspace(-3,3);
y=cdfbet(’PQ’,x,1-x,ones(x),3*ones(x));
plot2d(x,y)
1.0
1.0
0.9
0.9
0.8
0.8
0.7
0.7
0.6
0.6
0.5
0.5
0.4
0.4
0.3
0.3
0.2
0.2
0.1
0.1
0.0
0.0
−3
−2
−1
0
1
2
3
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
On peut aussi, à partir de la fonction de répartition, reconstituer numériquement la densité si
celle-ci est suffisamment régulière :
x=-3:0.01:3;
y=cdfnor(’PQ’,x,zeros(x),ones(x));
dy=100*(y(2:$)-y(1:$-1));
plot2d(x,y);
24
2.2.3
Quantiles
Les commandes cdf* permettent également d’inverser les fonctions de répartition et ainsi de
déterminer les quantiles des lois usuelles. Il faut pour cela donner comme premier argument en
entrée la chaîne de caractères ’X’. Par exemple, pour déterminer le réel x tel que P(|X| > x) = α,
i.e. tel que P(|X| ≤ x) = 1 − α, pour une variable aléatoire réelle X normale réduite, il suffit
d’écrire :
-->alpha=0.05;x=cdfnor(’X’,0,1,1-alpha/2,alpha/2)
x =
1.959964
Ces quantiles seront particulièrement utiles dans la recherche d’intervalles de confiance.
2.3
Echantillons
Un échantillon de taille n d’une variable aléatoire X (ou d’une loi PX ) est une suite X1 , . . . , Xn
de n variables aléatoires indépendantes de même loi que X (ou de loi PX ). On aura souvent
tendance par la suite à appeler également échantillon de cette variable aléatoire (ou de cette loi)
la suite x1 = X1 (ω), . . . , xn = Xn (ω) des valeurs prises par cette suite de variables aléatoires.
2.3.1
Moyenne, variance, covariance empiriques
n
1X
xi d’un échantillon (x1 , . . . , xn ) est donnée par la fonction
n
i=1
mean : mean(x) donne le même résultat que sum(x)/length(x).
n
1 X
(xi − x̄)2 de cet échantillon est donnée par variance(x) (AttenLa variance empirique
n−1
i=1
tion : il s’agit de l’estimateur sans biais de la variance, d’où le facteur n − 1 et non n).
La covariance empirique d’une série statistique à deux variables (xi , yi )i=1,...,n est donnée par
corr(x,y,1). On peut vérifier que variance(x)=n*corr(x,x,1)/(n-1) :
La moyenne empirique x̄ =
-->n=5;x=rand(1,n,’n’);y=rand(x,’n’);
-->corr(x,x,1),variance(x)
ans =
0.6437903
ans =
0.8047378
2.3.2
Répartition en classes : les fonctions dsearch et tabul
Pour analyser et visualiser rapidement les propriétés d’un échantillon d’une variable aléatoire
réelle (discrète ou continue), on est souvent amené à regrouper ses valeurs par classes. La fonction
dsearch (dichotomic search) est là pour cela. La fonction tabul remplit le même rôle dans le
cas d’un échantillon d’une loi discrète : elle donne les valeurs distinctes prises par la variable et
les fréquences d’apparition de ces valeurs.
-->x=floor(5*rand(1,10))
x =
2.
3.
3.
0.
2.
-->[ind,occ]=dsearch(x,0:2:4)
occ =
6.
4.
1.
1.
25
1.
4.
3.
ind =
1.
2.
2.
1.
1.
1.
-->[ind,occ]=dsearch(x,0:2:4,’d’)
occ =
1.
2.
1.
ind =
2.
0.
0.
1.
2.
0.
-->tabul(x)
ans =
4.
1.
3.
3.
2.
2.
1.
3.
0.
1.
2.3.3
1.
1.
2.
2.
0.
0.
3.
0.
Représentations graphiques
Pour visualiser les propriétés d’un échantillon d’une loi réelle et tenter d’identifier cette loi, on
dispose de plusieurs possibilités : l’histogramme de l’échantillon est analogue au diagramme en
bâtons de la loi si cette loi est discrète et permet d’approcher la densité si cette loi en admet
une ; le graphe de la fonction de répartition empirique permet dans tous les cas d’approcher la
fonction de répartition de la loi théorique.
2.3.3.1
Histogrammes
L’histogramme d’un échantillon est un diagramme constitué de barres verticales juxtaposées,
chacune de ces barres représentant le nombre de termes de l’échantillon appartenant à une classe
donnée. Pour représenter un histogramme d’un échantillon d’une loi réelle, on commence donc par
répartir cet échantillon en classes, chacune de ces classes correspondant aux valeurs appartenant
à un certain intervalle de R, et on représente cette classe par un rectangle vertical dont l’aire est
proportionnelle à l’effectif de la classe. On normalise souvent ces aires de façon à ce que l’aire
totale soit égale à 1 (comme l’aire sous la courbe représentative d’une densité de probabilité).
La commande histplot permet de tracer directement un tel histogramme. Son premier argument
est soit un entier (nombre de classes) soit un vecteur dont les composantes donnent les limites
des classes. Son second argument est le vecteur x = (x1 , . . . , xn ) des données ; on peut aussi
ajouter des arguments de style comme dans plot2d.
// melange de lois normales
N=5000;
p=0.7;
X=grand(1,N,’bin’,1,p);
//faire varier les paramètres
Y1=grand(1,N,’nor’,0,1);
Y2=grand(1,N,’nor’,4,1);
Z=X.*Y1 +(1-X).*Y2;
histplot(100,Z);
function y=f(x) // la densité du mélange
y=(p/sqrt(2*%pi))*exp(-x.^2/2)+((1-p)/sqrt(2*%pi))*exp(-(x-4).^2/2);
endfunction;
26
u=linspace(min(Z),max(Z),200);
plot2d(u,f(u),5,"000");
legends([’histogramme’;’densite théorique’],[1,5],2);
xtitle(’mélange de deux gaussiennes’);
mélange de deux gaussiennes
0.35
histogramme
densite théorique
0.30
0.25
0.20
0.15
0.10
0.05
0.00
−4
−2
0
2
4
6
8
Si le premier argument est un entier (nombre de classes), les classes sont de longueurs égales, la
limite inférieure de la première classe est le minimum min(x) des données et la limite supérieure
de la dernière le maximum max(x) des données. La commande histplot(p,x) équivaut donc à
histplot(linspace(min(x),max(x),p+1),x).
Si le premier argument est un vecteur (a1 , a2 , . . . , ap+1 ), l’histogramme est obtenu en déterminant le nombre de données dans chaque classe Ci (i = 1, . . . , p), où la première classe C1 est
égale à l’intervalle fermé [a1 , a2 ] et les classes suivantes Ci aux intervalles semi-ouverts ]ai , ai+1 ].
Ni
Les rectangles de base [ai , ai+1 ] (i = 0, . . . , p) et de hauteur
, où Ni est le nombre
N (ai+1 − ai )
de données xk appartenant à la classe Ci et N le nombre total de données (N=length(x)), sont
alors dessinés. L’histogramme est ainsi normalisé : si a1 ≤ min(x) ≤ max(x) ≤ ap+1 , la somme
des aires des rectangles représentés est égale à 1. On peut changer ce comportement par défaut
en ajoutant l’argument normalization=%f.
Si on veut représenter l’histogramme d’un échantillon de valeurs entières, on a donc intérêt à
préciser les limites (entières) de chaque classe : par exemple, si x est un échantillon d’une loi
portée par {0, 1, 2}, la commande histplot(4,x) divisera l’intervalle [0, 2] en quatre intervalles
de même longueur (si les valeurs 0 et 2 sont prises par l’échantillon), soit [0, 1/2], ]1/2, 1],
]1, 3/2], ]3/2, 2] et la troisième classe sera toujours vide. Il faut faire attention également à
ce que la première classe est fermée : ainsi si x est à valeurs dans {0, . . . , m}, la commande
histplot(0:m,x) mettra les valeurs 0 et 1 dans la même classe. Pour remédier à ce problème,
il suffit par exemple d’entrer histplot((-0.5:m+0.5,x) (les rectangles dessinés seront alors
centrés en les valeurs prises).
Si on représente ainsi un échantillon x = (x1 , . . . , xN ) de grande taille d’une loi admettant
N
1
1 X
une densité continue f , la valeur
1{ai <xk ≤ai+1 } de l’histogramme sur l’intervalle
ai+1 − ai N
k=1
27
Z ai+1
1
f (t) dt
ai+1 − ai ai
de f sur cet intervalle. Si N et le nombre p de classes sont suffisamment grands, l’histogramme
sera donc proche du graphe de f .
Vérifions le pour un échantillon d’une loi beta, obtenu par quotient à partir de deux lois gamma :
[ai , ai+1 ] sera proche, d’après la loi des grands nombres, de la valeur moyenne
N=10000;p=50;
x1=grand(1,N,’gam’,2,1);
x2=grand(1,N,’gam’,3,1);
x=x1 ./(x1+x2);
histplot(p,x,style=2);
t=linspace(0,1);
plot2d(t,t.*(1-t).^2/beta(2,3),style=5);
2.0
1.8
1.6
1.4
1.2
1.0
0.8
0.6
0.4
0.2
0.0
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Pour représenter la densité, on a entré ici la vraie valeur de f . Si cette densité a une expression
compliquée, on peut aussi utiliser la dérivée numérique approchée de la fonction de répartition
pour la dessiner. Par exemple ici :
t=linspace(0,1);
y=cdfbet(’PQ’,t,1-t,2*ones(t),3*ones(t));
plot2d((t(1:$-1)+t(2:$))/2,(y(2:$)-y(1:$-1))/(t(2)-t(1)),style=3);
donne un tracé de la densité indiscernable du précédent.
2.3.3.2
Fonction de répartition empirique
La fonction de répartition empirique d’un échantillon x = (x1 , . . . , xn ) est la fonction de réparn
1X
tition de la loi empirique
δxi de cet échantillon, i.e. la fonction Fn de R dans [0, 1] définie
n
i=1
par
n
1X
1{xi ≤y} .
Fn (y) =
n
i=1
Si on dispose d’un échantillon de taille n d’une loi inconnue, on peut tracer le graphe de la
fonction de répartition empirique de cet échantillon en ordonnant cet échantillon et en utilisant
la fonction plot2d2. L’exemple suivant tire un échantillon de taille 100 d’une loi normale réduite,
trace le graphe de sa fonction de répartition empirique et la compare à la fonction de répartition
de la loi normale :
28
1.0
0.9
n=100;
x=rand(1,n,’n’);
xx=gsort(x,’g’,’i’);
plot2d2(xx,(1:n)/n);
y=cdfnor(’PQ’,xx,zeros(xx),ones(xx));
plot2d(xx,y,style=3)
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
−3
−2
−1
0
1
2
3
Pour obtenir la valeur en u de la fonction de répartition empirique, il suffit d’écrire
sum(x<=u)/length(x) ou length(find(x<=u))/length(x), où x est l’échantillon.
2.3.3.3
Quantiles empiriques
Si on veut construire la pseudo-inverse de la fonction de répartition empirique, et ainsi déterminer
les quantiles empiriques, on peut définir la fonction suivante :
function y=Q(p,x)
//x est l’échantillon
//p le vecteur des points de ]0,1] où l’on veut calculer la fr empirique
n=length(x);
x=gsort(x,’g’,’i’);
//on ordonne l’échantillon
y=x(n*p);
endfunction;
x=rand(1,1000,’n’);p=0.01:0.01:1;plot2d(Q(p,x),p)
On utilise ici le fait que Scilab remplace automatiquement les indices n ∗ p par leur partie entière
(il faut cependant que cette partie entière appartienne à [1, n], où n est la taille de l’échantillon,
sinon on obtient un message d’erreur).
La boîte à outils Stixbox possède une fonction quantile qui évite d’avoir à définir sa propre
fonction.
Application : QQ-plot. On peut tester graphiquement si un échantillon provient d’une loi
donnée en comparant les quantiles empiriques de cet échantillon avec les quantiles de la loi
théorique. On trace la courbe passant les points d’abscisses les quantiles théoriques et d’ordonnées
les quantiles empiriques. Cette courbe devrait être une droite si l’adéquation était totale. On peut
tracer sur la même figure la droite passant par les quartiles pour vérifier.
n=1000;
r=rand(1,n,’n’);
p=0.05:0.05:0.95;
x=quantile(r,p);
y=cdfnor(’X’,zeros(p),ones(p),p,1-p);
plot2d(x,y,style=-1);
a=(y(15)-y(5))/(x(15)-x(5));b=y(5)-a*x(5);//droite y=ax+b
plot2d(x([1,$]),a*x([1,$])+b,style=2);
29
2.0
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
−2.0
−2.0
−1.5
−1.0
−0.5
0.0
0.5
1.0
1.5
2.0
La boîte à outils Stixbox possède une fonction qqplot (quantile to quantile plot) qui compare
ainsi graphiquement les quantiles empiriques de deux échantillons de même taille.
2.4
Exercices
Exercice 2.1. On considère le générateur congruentiel de nombres pseudo-aléatoires suivant. On part
d’une graine u0 , on définit une suite uk à valeurs dans {0, . . . , 2047} par la relation de récurrence :
uk+1 ≡ 1365uk + 1
(mod 2048)
uk
et on pose xk =
.
2048
Montrer que la suite xk est périodique de période 2048. Représenter graphiquement les 200 premiers
termes de cette suite (xk en fonction de k). Etudier la moyenne et la variance empirique d’un échantillon
de longueur 200 de cette loi. Représenter graphiquement xk+1 en fonction de xk pour k variant de 1 à
200. Que pensez-vous d’un tel générateur ?
Exercice 2.2. Générer un échantillon X de taille n d’une loi diffuse classique sur R (normale, exponentielle,. . .) de fonction de répartition F , puis l’échantillon F (X). Représenter graphiquement la fonction
de répartition empirique de cet échantillon. Que constate-t-on ?
Exercice 2.3. Déterminer les valeurs de x telles que P(|X| > x) = α pour α = 0.01, 0.05, 0.1, où X est
une variable aléatoire réelle normale réduite.
Exercice 2.4. Simuler par la méthode de rejet un échantillon de la loi triangulaire sur [−a, a] de densité
+
1
|x|
1−
. Représenter sur une même figure l’histogramme de cet échantillon et la densité de cette
a
a
loi. Indiquer une autre méthode de générer un tel échantillon.
Exercice 2.5. Loi de Pareto : Simuler un échantillon de la loi de Pareto de paramètres α > 0 et a > 0,
αaα
de densité 1+α 1[a,+∞[ (x). Estimer, pour différentes valeurs des paramètres, l’espérance et la variance
x
de cette loi (on pourra, soit étudier la loi de ln(X) pour X suivant cette loi, soit expliciter l’inverse
de sa fonction de répartition)). Représenter sur un même graphique l’histogramme de cet échantillon
et la densité de sa loi. Vérifier la propriété suivante de la loi de Pareto : si X suit la loi de Pareto
αb
, ce qui s’écrit encore
de paramètres α > 1 et a > 0, alors pour tout b ≥ a, E(X | X ≥ b) =
α−1
b
E(X − b | X ≥ b) =
.
α−1
Exercice 2.6. Loi de Weibull : Une variable aléatoire réelle positive X suit la loi de Weibull de paramètre
d’échelle λ > 0 et de paramètre de forme a > 0 si sa fonction de répartition F vaut
a
F (x) = 1 − exp [− (λx) ]
30
pour x ≥ 0 .
Montrer qu’une variable aléatoire suivant une loi de Weibull admet une densité dont on donnera l’expression. Représenter graphiquement cette densité pour diverses valeurs du paramètre a. Calculer l’espérance
d’une variable aléatoire suivant une loi de Weibull. Que peut-on dire d’une loi de Weibull de paramètre
de forme a = 1 ? Pourquoi le paramètre λ est-il appelé paramètre d’échelle ?
Montrer que si une variable aléatoire U suit la loi uniforme sur [0, 1], alors la variable aléatoire X =
1
1/a
[− ln(U )]
suit la loi de Weibull de paramètres λ et a. Utiliser cette propriété pour simuler un
λ
échantillon de grande taille de la loi de Weibull et représenter un histogramme de cet échantillon.
Les lois de Weibull sont souvent utilisées en fiabilité pour modéliser la durée de vie de certains composants.
Elles interviennent également dans la loi des valeurs extrêmes.
Exercice 2.7. La loi de Fréchet de paramètres a > 0 et α > 0 est la loi sur [0, +∞[ de fonction de
répartition exp(−(a/x)α ). Simuler par inversion un échantillon de grande taille de cette loi. Représenter
sur un même graphique la fonction de répartition empirique de cet échantillon et la fonction de répartition
théorique de la loi.
Exercice 2.8. On rappelle que la distance en variation totale de deux lois de probabilité µ et ν sur un
ensemble fini ou dénombrable E est définie par :
dV T (µ, ν) =
1X
|µ({x}) − ν({x})| .
2
x∈E
Evaluez numériquement la distance en variation totale entre la loi de Poisson de paramètre λ et la loi
binomiale de paramètres n et λ/n pour différentes valeurs de n et λ. Représentez graphiquement ces deux
lois sur une même figure, puis sur deux figures juxtaposées.
Exercice 2.9. Loi de Dirichlet
On veut tirer au hasard une loi de probabilité sur un ensemble fini à n éléments. On considère pour
cela une famille indépendante Y1 , . . . , Yn de n variables aléatoires suivant des lois gamma de paramètres
respectifs α1 , . . . αn . Montrer que la somme Y = Y1 + · · · + Yn de ces variables aléatoires suit la loi gamma
Y1
Yn
de paramètre α1 + · · · + αn et que la famille
,...,
suit la loi de Dirichlet de densité
Y
Y
Γ(α1 + · · · + αn ) α1 −1
n −1
p
. . . pα
1∆n (p1 , . . . , pn )
n
Γ(α1 ) + · · · + Γ(αn ) 1
sur le simplexe ∆n = {(p1 , . . . , pn ) | p1 ≥ 0, . . . , pn ≥ 0, p1 + · · · + pn = 1}.
Simuler cette loi dans le cas où tous les αi sont égaux : α1 = · · · = αn = α > 0. Dans ce cas les pi ont,
1
par symétrie, tous la même espérance , mais leur répartition diffère suivant la valeur de α : pour α = 1,
n
on obtient la loi uniforme sur ∆n ; pour α grand, la loi se concentre autour de sa valeur moyenne, tandis
que pour α proche de 0, cette loi se concentre vers le bord du simplexe (typiquement, un petit nombre
des pi sont grands et les autres très petits). Vérifier cette propriété dans le cas n = 3 en représentant
dans le plan le nuage des points (p1 , p2 ) correspondant à un échantillon de taille 1000.
Exercice 2.10. Soit X une variable aléatoire réelle à valeurs dans un intervalle I de R, et F sa fonction
de répartition. On suppose que F réalise une bijection de l’intérieur de I sur l’intervalle ]0, 1[ et on note
F −1 la bijection réciproque. On souhaite simuler une variable aléatoire suivant la loi conditionnelle de X
sachant que X appartient à un sous-intervalle J de I.
1) Proposer une méthode de rejet. La mettre en œuvre dans le cas où X suit la loi normale N (0, 1) et
J =]m, +∞[ pour un réel donné m (on prendra successivement m = 1, m = 3, m = 5 et on évaluera la
probabilité de rejet).
2) On suppose ici J = [m, +∞[ pour un réel donné m ∈ I. Montrer que la variable aléatoire Z =
F −1 (F (m)+(1−F (m))U ), où U est une variable aléatoire de loi uniforme sur ]0, 1[ suit la loi conditionnelle
de X sachant X > m. Expliciter cette variable aléatoire dans le cas où X suit la loi exponentielle de
paramètre λ > 0.
3) Généraliser la méthode précédente au cas où J =]a, b].
4) Proposer une méthode de rejet utilisant une loi exponentielle pour simuler une variable aléatoire réelle
suivant la loi conditionnelle de X sachant X > m, où X est une variable aléatoire de loi N (0, 1) (on
1
2
cherchera deux réels λ et M strictement positifs tels que √ e−x /2 ≤ M λe−λ(x−m) pour tout x > m).
2π
31
Exercice 2.11. Estimer par simulation la probabilité p(n) que le déterminant d’une matrice aléatoire A
d’ordre n dont les coefficients sont des variables aléatoires i.i.d. de loi uniforme sur {−1, 1} soit nul. On
estimera p(n) pour n = 2, . . . , 20 et on tracera la courbe représentative de p(n) en fonction de n.
Estimer par simulation l’espérance de (det A)2 pour n = 2, . . . , 5. Énoncer, puis démontrer une conjecture
sur l’espérance de ce déterminant.
Exercice 2.12. Temps de retour en 0 de la marche aléatoire symétrique simple
Pnsur Z
Soit (Sn )n≥0 la marche aléatoire symétrique simple sur Z issue de 0 : Sn = k=1 Xk , où (Xk )k≥1 est
une suite i.i.d. de variables aléatoires de loi P(Xk = 1) = P(Xk = −1) = 0.5. On montre que√le temps de
2
retour T = inf{n ≥ 1 | Sn = 0} de cette marche en 0 a pour
r fonction génératrice gT (s) = 1 − 1 − s . On
2
de la queue de T quand t tend vers l’infini.
en déduit la loi de T , ainsi que l’équivalent P(T > t) ∼
πt
Illustrer la loi de T par simulation et comparer la valeur exacte de la queue de cette loi à son équivalent.
Exercice 2.13. On désire simuler la marche
Pnaléatoire simple symétrique sur Z conditionnée à revenir en
0 à un instant déterminé. On a donc Sn = k=1 Xk , où (Xk )k≥1 est une suite i.i.d. de variables aléatoires
de loi P(Xk = 1) = P(Xk = −1) = 0.5, et on veut simuler des trajectoires (Sk )0≤k≤2n jusqu’à l’instant
2n sous la probabilité conditionnelle P(· | S2n = 0).
a) Que peut-on penser de la méthode de rejet ? Donner en particulier un équivalent de la proportion de
trajectoires conservées en appliquant cette méthode quand n est grand.
b) Proposer une autre méthode.
c) Traiter le même problème pour une marche aléatoire simple non symétrique (i.e. pour P(Xk = 1) = p,
P(Xk = −1) = 1 − p avec p quelconque dans ]0, 1[).
Exercice 2.14. Mots
Soit (Xn )1≤n≤N une suite aléatoire de 0 et de 1. On cherche à déterminer, pour toute suite finie s de 0
et de 1, la fréquence d’apparition de cette suite dans la suite (Xn )1≤n≤N . Ainsi la suite s = 00 apparaît
trois fois dans la suite 010001100.
1) Ecrire une fonction [n,t]=nbappar(x,s) calculant le nombre n d’apparitions du vecteur s dans le
vecteur x ainsi que l’indice t de la première apparition de s.
2) Ecrire une version vectorialisée de cette fonction permettant de rechercher les apparitions d’une même
suite s dans chaque ligne d’une matrice x de 0 et de 1.
3) Déterminer le nombre moyen d’apparitions de la suite 00, puis de la suite 01 dans une longue suite
aléatoire de 0 et de 1. Simuler ensuite le temps d’attente moyen de la première apparition pour chacune
de ces suites. Que constate-t-on ?
Exercice 2.15. Permutations aléatoires
Le générateur grand permet de simuler des permutations aléatoires par la commande
x=grand(n,’prm’,v) où n est le nombre de permutations souhaité et v le vecteur colonne à permuter ; le résultat x est alors une matrice à n colonnes, chaque colonne représentant une permutation
aléatoire du vecteur v.
Montrer que l’algorithme suivant génère une permutation aléatoire uniformément répartie du vecteur v
de longueur m et écrire une fonction implémentant cet algorithme : pour i = 1, . . . , m − 1, on choisit
aléatoirement un entier r dans [i, . . . , m] et on permute vi et vr .
Tester cette fonction, par exemple en évaluant la moyenne et la variance du nombre de points fixes de la
permutation engendrée.
Exercice 2.16. Parties aléatoires
a) Simuler un tirage uniforme d’une partie à n élements d’un ensemble E à N éléments (1 ≤ n ≤ N étant
des entiers fixés) en utilisant la fonction grand. On supposera ici que l’entier N n’est pas trop grand.
b) Adapter l’algorithme étudié à l’exercice précédent à la simulation d’un tel tirage.
c) Proposer un algorithme basé sur une méthode de rejet dans le cas où N est très grand et n petit par
rapport à N (on pourra par exemple simuler un tirage uniforme de 1000 individus dans une population
de 50 millions d’habitants).
Exercice 2.17. Echantillons ordonnés, statistique de Wilcoxon
Soient x et y deux familles finies de réels supposés tous distincts représentées par des matrices de tailles
quelconques. Expliquez pourquoi la fonction suivante compte le nombre de couples (xi , yj ) vérifiant yj <
xi :
function r=nb(x,y);
n=size(x,’*’);
32
m=size(y,’*’);
[z,k]=gsort([x(:);y(:)],’g’,’i’);
ind=1:n+m;
r=sum(ind(k<=n))-n*(n+1)/2;
endfunction;
On montre que si X = (X1 , . . . , Xn ) et Y = (Y1 , . . . , Ym ) sont deux échantillons d’une même loi continue
sur R, alors la variable aléatoire U comptant le couple d’indices (i, j) tels que Yj < Xi a pour espérance
mn
mn(n + m + 1)
U − E(U )
2
E(U ) =
et pour variance σU
=
et que la loi de
converge vers la loi normale
2
12
σU
N (0, 1) quand n et m tendent vers l’infini. Vérifier cette propriété sur un échantillon d’une loi uniforme
sur [0, 1].
Exercice 2.18. Loi uniforme sur les sphères
a) Proposer diverses méthodes pour tirer un point au hasard uniformément sur la sphère unité S 1 de R2 .
On pourra en particulier tester les méthodes suivantes :
– tirer uniformément sur [0, 2π[ l’angle polaire du point ;
– tirer un point uniformément dans le disque unité en utilisant une méthode de rejet et diviser le vecteur
obtenu par sa norme ;
– tirer un point dans le plan selon la loi de Gauss standard (i.e. centrée et de matrice de covariance I2 )
et diviser le vecteur obtenu par sa norme.
Étudier en utilisant ces méthodes la loi de l’angle géométrique (compris entre 0 et π) de deux vecteurs
unitaires aléatoires indépendants de R2 .
b) Tirer de même des points aléatoires sur la sphère unité S 2 de R3 . Représenter graphiquement un nuage
de 1000 points aléatoires sur cette sphère. Étudier la loi de l’angle géométrique de deux vecteurs unitaires
aléatoires indépendants.
c) Proposer diverses méthodes pour tirer un point uniformément sur la sphère unité de Rd pour d quelconque. Comparer l’efficacité de ces méthodes.
Exercice 2.19. Tri par insertion Le but de cet exercice est d’implémenter un algorithme de tri très
intuitif, mais pas très efficace (le tri par insertion) et d’en étudier la complexité, mesurée par le nombre
moyen de comparaisons effectuées lors du tri d’un vecteur.
On se propose donc de trier dans l’ordre croissant un vecteur donné x = (x1 , . . . , xn ) de nombres réels. On
supposera, pour simplifier, les xk tous différents et, pour évaluer le nombre de comparaisons à effectuer,
leur ordre initial uniformément réparti parmi les n! ordres possibles.
Le tri par insertion consiste à créer un nouveau vecteur x∗ , initialement vide, et à y insérer successivement
les éléments de x en les ordonnant au fur et à mesure. Le vecteur x∗ est donc initialisé par x∗ = (x1 ),
puis, quand les k − 1 premières composantes de x ont été rangées, on insère xk à sa place dans le vecteur
ordonné x∗ = (x∗1 , . . . , x∗k−1 ). Le nombre total Nk de comparaisons à effectuer pour cette insertion est i
si xk occupe le rang i dans (x1 , . . . , xk ) avec i < k, k − 1 si i = k. L’espérance de ce nombre est donc
k
1X
i − 1, de sorte que le nombre total de comparaisons à effectuer est en moyenne
k i=1
n
X
k+1
k=2
2
−
n
n
X
1
n(n + 3) X 1
=
−
.
k
4
k
k=2
k=1
Ecrire un programme implémentant cet algorithme (on définira une fonction retournant le vecteur trié
et le nombre de comparaisons effectuées). Comparer la moyenne empirique du nombre de comparaisons
avec la valeur théorique. Représenter un histogramme du nombre de comparaisons effectuées.
Remarque : si on a des raisons de penser que le vecteur x initial est déjà plus ou moins ordonné, on a
intérêt à effectuer les comparaisons pour placer les xk de la droite vers la gauche, et non de la gauche vers
la droite. Le nombre de comparaisons dans l’algorithme précédent est en effet maximal quand le vecteur
est déjà ordonné par ordre croissant, et minimal quand il est ordonné par ordre décroissant.
33
34
Chapitre 3
Loi des grands nombres, méthode de
Monte-Carlo
3.1
3.1.1
Loi des grands nombres
Vérification graphique
La loi des grands nombres dit que si (Xn )n≥1 est une suite i.i.d. de variables aléatoires réelles
n
1X
Xk tend presque sûrement vers l’espérance commune E(X1 ) des
intégrables, alors Mn =
n
k=1
Xn .
On peut illustrer graphiquement ce résultat pour des suites de variables aléatoires suivant des
lois usuelles en représentant l’évolution de Mn en fonction de n :
n=1000;nbsimul=5;
subplot(121);
x1=rand(n,nbsimul);
mx1=cumsum(x1,’r’)./((1:n)’*ones(1,nbsimul));
plot2d(mx1);
xtitle(’Loi uniforme sur [0,1]’);
subplot(122);
x2=zeros(n,nbsimul);
x2(rand(x2)<0.5)=1;
mx2=cumsum(x2,’r’)./((1:n)’*ones(1,nbsimul));
plot2d(mx2);
xtitle(’Loi de Bernoulli (p=0.5)’);
Loi uniforme sur [0,1]
Loi de Bernoulli (p=0.5)
0.8
1.0
0.9
0.7
0.8
0.7
0.6
0.6
0.5
0.5
0.4
0.4
0.3
0.2
0.3
0.1
0.2
0.0
0
100 200 300 400 500 600 700 800 900 1000
0
35
100 200 300 400 500 600 700 800 900 1000
Par contre, si (Xn )n≥1 est une suite i.i.d. de variables aléatoires réelles non intégrables (E(|Xn |) =
+∞), alors la suite (Mn )n≥1 diverge presque sûrement. On peut illustrer ce résultat en considérant une suite (Xn )n≥1 de variables aléatoires suivant la loi de Cauchy (cette loi est la loi du
quotient X1 /X2 de deux variables aléatoires normales réduites indépendantes) :
Loi de Cauchy
10
8
//loi de Cauchy
x1=rand(n,nbsimul,’n’);x2=rand(x1,’n’);
x=x1./x2;
mx=cumsum(x,’r’)./((1:n)’*ones(1,nbsimul));
plot2d(mx);
xtitle(’Loi de Cauchy’);
6
4
2
0
−2
−4
−6
0
3.1.2
100
200
300
400
500
600
700
800
900
1000
Vitesse de convergence
Var(X1 )
Si les variables aléatoires Xn sont de carré intégrable, la variance de Mn est égale à
et
n
σX1
son écart-type est √ . On peut vérifier cette propriété en représentant graphiquement l’évolution
n
de la variance empirique de Mn sur un grand échantillon :
n=200;
nb=1000;
x=grand(nb,n,’def’);//loi uniforme sur [0,1]
mx=cumsum(x,’c’)./(ones(nb,1)*(1:n));
sigma=sqrt(variance(mx,’r’));
plot2d(1:n,sigma,style=2);
plot2d(1:n,1 ./sqrt(1:n)/sqrt(12),style=5);
3.1.3
Comparaison des bornes dans l’inégalité de Bienaymé-Tchebychev et
dans l’approximation normale
Il résulte de l’inégalité de Bienaymé-Tchebychev que
P(|Mn − E(X1 )| > ε) ≤
Var(X1 )
nε2
pour tout ε > 0.
Cette inégalité permet de donner un intervalle de confiance pour l’estimation de E(X1 ) si la
variance de X1 est connue, ou si on sait la majorer. Par exemple, dans le cas où les Xn suivent
une loi de Bernoulli de paramètre inconnu p, la variance p(1 − p) de X1 est majorée par 1/4. Il
en résulte que
1
P(Mn − ε ≤ p ≤ Mn + ε) ≥ 1 −
4nε2
pour tout ε > 0.
L’inégalité de Bienaymé-Tchebychev est en fait très mauvaise comme on peut le constater : le
programme suivant tire 1000 fois un échantillon de la loi de Bernoulli de paramètre p = 0.5 et
compte le nombre de fois où l’inégalité |Mn − E(X1 )| > ε est vérifiée pour n = 105 et ε = 0.01. :
36
n=1e5;
nb=1000;
epsilon=0.01;
m=zeros(1,nb);
for k=1:nb
x=grand(1,n,’uin’,0,1);
m(k)=mean(x);
end;
sum(abs(m-0.5)>epsilon)/nb
ans =
0.
On constate que, sur 1000 expériences, la borne n’est jamais dépassée, alors que l’inégalité de
Bienaymé-Tchebychev nous apprend simplement que la probabilité qu’elle le soit est inférieure à
1/40.
Le théorème limite central nous donne en fait une bien meilleure approximation, puisqu’il nous
√
apprend que n(Mn − E(X1)) suit asymptotiquement
la loi normale N (0, σX1 ). Il en résulte que
|Mn − 0.5|
√
≥ 1.96 est de l’ordre de 0.05 :
dans l’exemple précédent P 2
n
sum(abs(m-0.5)>1.96/2/sqrt(n))/nb
ans =
0.054
3.2
3.2.1
Convergence des histogrammes et des fonctions de répartition
empiriques
Théorème de Glivenko-Cantelli
Soit (Xn )n≥1 une suite de variables aléatoires réelles i.i.d. de fonction de répartition F . On rapn
1X
pelle que la loi empirique de l’échantillon X1 (ω), . . . , Xn (ω) est la loi de probabilité
δXk (ω) .
n
k=1
La fonction de répartition Fn (ω, ·) de cette loi est appelée fonction de répartition empirique de
l’échantillon. Elle est définie par :
n
Fn (ω, x) =
1X
1{Xk ≤x} (ω) pour x ∈ R .
n
k=1
Il résulte immédiatement de la loi forte des grands nombres que, pour tout réel x, Fn (·, x) tend
presque sûrement vers F (x) quand n tend vers l’infini.
Le théorème de Glivenko-Cantelli affirme que cette convergence est uniforme sur R :
Théorème : Soit (Xn )n≥1 une suite de variables aléatoires réelles i.i.d. de fonction de répartition F et Fn la fonction de répartition empirique de l’échantillon X1 , . . . , Xn . Alors la variable
aléatoire Dn = sup |Fn (·, x) − F (x)| tend presque sûrement vers 0 quand n tend vers l’infini.
x∈R
√
√
Plus précisément, la variable aléatoire nDn = n sup |Fn (x) − F (x)| converge en loi vers une
x∈R
variable aléatoire W suivant la loi de Kolmogorov-Smirnov de fonction de répartition
K(w) =
+∞
X
k −2k2 w2
(−1) e
k=−∞
+∞
X
2 2
(−1)k e−2k w
=1+2
k=1
37
pour w > 0 .
Cette convergence en loi est à la base d’un important test d’adéquation, le test de KolmogorovSmirnov (voir 7.2.2).
La fonction de répartition de la loi de Kolmogorov-Smirnov n’est pas préprogrammée dans le
noyau de Scilab, mais elle est accessible par la commande pks de la boîte à outils Stixbox :
x=linspace(0,2);y=pks(x);
plot(x,y,’b’);
xtitle(’Fonction de répartition de la loi de Kolmogorov-Smirnov’);
Fonction de répartition de la loi de Kolmogorov−Smirnov
1.0
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0.0
0.2
0.4
0.6
0.8
1.0
1.2
1.4
1.6
1.8
2.0
On montre de plus que la loi de Dn est la même pour toutes les variables aléatoires diffuses :
elle ne dépend donc pas de la fonction de répartition F si celle-ci est continue. Vérifions-le pour
un échantillon de la loi uniforme sur [0, 1] et un échantillon de même taille de la loi de Cauchy :
function d=dks(x,F)
//distance de KS de la loi empirique de l’échantillon x à la fr F
xs=gsort(x(:)’,’g’,’i’);
n=length(xs);
Fxs=F(xs);//F doit s’évaluer sur un vecteur
d=max(abs([Fxs-(1:n)/n,Fxs-(0:n-1)/n]));
endfunction;
function y=F1(x),y=x,endfunction;
function y=F2(x),y=0.5+atan(x)/%pi,endfunction;
n=100;
nbsimul=5000;
d1=zeros(1,nbsimul);d2=zeros(d1);
for k=1:nbsimul
x1=rand(1,n);
d1(k)=dks(x1,F1);
x2=rand(1,n,’n’)./rand(1,n,’n’);
d2(k)=dks(x2,F2);
end;
subplot(121);
histplot(20,d1,style=2);
xtitle(’Loi uniforme sur [0,1]’);
subplot(122);
histplot(20,d2,style=5);
xtitle(’Loi de Cauchy’);
Loi uniforme sur [0,1]
Loi de Cauchy
18
18
16
16
14
14
12
12
10
10
8
8
6
6
4
4
2
2
0
0.02 0.04 0.06 0.08 0.10 0.12 0.14 0.16 0.18 0.20 0.22
0
0.02 0.04 0.06 0.08 0.10 0.12 0.14 0.16 0.18 0.20 0.22
On remarque que pour calculer Dn , il suffit d’évaluer F en les valeurs Xk prises par l’échantillon.
∗ [,
En effet comme F est continue croissante et Fn constante sur chacun des intervalles [Xk∗ , Xk+1
38
où (X1∗ , . . . , Xn∗ ) est l’échantillon (X1 , . . . , Xn ) réordonné par ordre croissant, on a :
Dn = max{ |F (Xk ) − Fn (Xk )|, |F (Xk ) − Fn (Xk −)| | k = 1, . . . , n }
k
k−1
= max{ |F (Xk∗ ) − |, |F (Xk∗ ) −
| | k = 1, . . . , n } .
n
n
3.2.2
Convergence des histogrammes
Si les variables aléatoires Xk admettent une densité continue f , pour tout intervalle [a, b] la pro1[a,b] (X1 ) + · · · + 1[a,b] (Xn )
portion
d’éléments de l’échantillon tombant dans l’intervalle [a, b]
n
Rb
tend vers E(1[a,b] (X1 )) = a f (x) dx. Ce nombre est proche de (b − a)f (x) pour xi n[a, b] si la
longueur de l’intervalle est petite et la densité suffisamment régulière. Il en résulte que l’histogramme normalisé de l’échantillon est proche du graphe de la densité si le nombre de classes est
assez grand.
3.3
Méthode de Monte-Carlo
On appelle méthode de Monte-Carlo toute méthode de calcul numérique consistant à représenter
la valeur qu’on cherche à calculer sous forme d’espérance d’une certaine variable aléatoire et à
estimer cette espérance par simulation. Historiquement, le premier exemple en est attribué à
Buffon, qui a proposé en 1777 une méthode de calcul de π basée sur la simulation d’expériences
répétées (jets d’une aiguille sur des lames de parquet), mais ce n’est qu’avec l’apparition des
ordinateurs que cette méthode a pris son véritable essor.
3.3.1
L’aiguille de Buffon
On lance une aiguille au hasard sur un plan où sont tracées des droites parallèles et équidistantes.
On montre alors facilement que la probabilité pour que l’aiguille rencontre une de ces droites
est p = 2l/πd, où l est la longueur de l’aiguille et d la distance entre les droites, à condition de
supposer l < d, de sorte que l’aiguille ne peut rencontrer au plus qu’une des droites.
En répétant un grand nombre de fois l’expérience, on peut ainsi approcher π par 2lN/nd, où N
est le nombre d’expériences et n le nombre de fois où l’aiguille rencontre une des droites.
Le programme suivant simule cette expérience.
Nombre de lancers: 20 Nombre d’intersections: 13
Approximation de pi: 3.0769231
//une représentation graphique pour vérifier:
39
n=input("Nombre de lancers");
r=rand(3,n);
x=[r(1,:);r(1,:)+cos(2*%pi*r(3,:))];
y=[r(2,:);r(2,:)+sin(2*%pi*r(3,:))];
lx=[-1,-1;2,2];ly=[0,1;0,1];rectangle=[-1,0,2,1];
colors=2*ones(1,n);
cuts=find(((y(2,:)>1)|(y(2,:)<0)));
nbcuts=length(cuts);
colors(cuts)=5*ones(cuts);
xbasc();xselect();
plot2d(lx,ly,strf=’012’,style=[1,1],frameflag=3,axesflag=1,rect=rectangle);
plot2d(x,y,style=colors);
xtitle([" Nombre de lancers: "+string(n)+" Nombre d’’intersections: "+string(nbcuts);
"
Approximation de pi: "+string(2*n/nbcuts)]);
//un calcul plus conséquent:
n=100000;r=rand(3,n);
x=[r(1,:);r(1,:)+cos(2*%pi*r(3,:))];
y=[r(2,:);r(2,:)+sin(2*%pi*r(3,:))];
pi=2*n/(sum((y(2,:)>1)|(y(2,:)<0)));
disp("Approximation de pi pour "+string(n)+" lancers: "+string(pi));
Approximation de pi pour 100000 lancers: 3.1444069
3.3.2
Calcul d’intégrales
Un exemple élémentaire d’application de la méthode de Monte-Carlo consiste à évaluer numériquement une intégrale. L’idée en est
R 1 simple : supposons qu’on cherche à calculer une valeur
numérique approchée de l’intégrale 0 h(x) dx d’une fonction h intégrable sur [0, 1]. On commence par représenter cette intégrale comme l’espérance E(h(U )) d’une fonction d’une variable
aléatoire U de loi uniforme sur [0, 1]. On évalue ensuite cette espérance en simulant un échantillon indépendant de grande taille de la loi de U . La loi des grands nombres nous apprend que
la moyenne des valeurs de h sur cet échantillon converge, quand la taille de l’échantillon tend
vers l’infini, vers la valeur de l’intégrale.
L’avantage de la méthode est qu’elle ne suppose aucune régularité sur la fonction h. Sa converh(X1 ) + · · · + h(Xn )
est de
gence est par contre très lente, puisque l’écart-type de la moyenne
n
1
l’ordre de √ . Il existe bien d’autres méthodes de calcul numérique d’une intégrale ne reposant
n
pas sur l’utilisation du hasard. Ces méthodes convergent beaucoup plus rapidement. On n’utilise donc pas une méthode de Monte-Carlo pour évaluer une intégrale simple. Par contre, si la
dimension de l’espace sur lequel on intègre est grande et la fonction peu régulière, ces méthodes
peuvent se révéler efficaces. En effet, la rapidité de convergence de la méthode ne dépend pas de
la dimension de l’espace sur lequel on intègre.
3.3.2.1
Un exemple en dimension un
R∞
2
On se propose de calculer par une méthode de Monte-Carlo l’intégrale I = 0 e−x | cos(x)| dx.
√
π
X
On remarque que I =
E(| cos( √ )|), où X est une variable aléatoire suivant la loi normale
2
2
N (0, 1), d’où le calcul :
n=100000;//nombre de simulations
40
x=grand(1,n,’nor’,0,1);
y=abs(cos(x/sqrt(2)));
I=sqrt(%pi)*mean(y)/2
Si on veut donner un intervalle de confiance à un niveau de confiance 1 − α donné pour I, il
X
faut connaître ou savoir majorer la variance de Y = | cos( √ )|, puisque l’intervalle de confiance
2
√
√
√
π
[Ȳn − cσY / n, Ȳn + cσY / n], où c est tel que
pour I si on effectue n simulations sera
2
P(Z ∈ [−c, +c]) = 1 − α pour une variable aléatoire Z de loi N (0, 1). On pourrait ici majorer
brutalement σY par 1/4, puisque Y est à valeurs dans [0, 1], mais il est préférable d’estimer la
variance de Y en utilisant l’estimateur sans biais de la variance de l’échantillon et en déduire un
intervalle de confiance :
alpha=0.05;
sigma=sqrt(variance(y))
c=-cdfnor(’X’,0,1,alpha/2,1-alpha/2)
I-sqrt(%pi)*c*sigma/sqrt(n)/2,I+sqrt(%pi)*c*sigma/sqrt(n)/2
sigma =
0.2404235
c =
1.959964
ans =
0.6997564
ans =
0.7023976
L’intégration numérique par Scilab donne :
integrate(’exp(-x^2)*abs(cos(x))’,’x’,0,5)
ans =
0.7011849
3.3.2.2
Réduction de la variance
On voit qu’il importe donc de réduire au maximum la variance des variables aléatoires utilisées
dans la simulation pour réduire l’intervalle de confiance. Diverses techniques existent pour cela :
échantillonnage préférentiel, utilisation de variables négativement corrélées ou de variables de
contrôle, stratification dans l’échantillonnage.
3.3.2.3
Calculs de volumes
La méthode de Monte-Carlo se prête bien au calcul de volumes. Traitons l’exemple suivant : on
tire 5 points au hasard dans le cube unité C = [0, 1]3 de R3 et on se propose de déterminer par
une méthode de Monte-Carlo le volume du complémentaire dans C de la réunion des sphères de
centres ces points et de rayon 1/2.
r=0.5;//rayon des spheres
centres=rand(3,5);//les coordonnees des centres
n=100000;//nombre de points dans la methode de Monte-Carlo
U=rand(3,n);//points aleatoires dans C
X=ones(1,n);//fonction indicatrice du complementaire des spheres
for k=1:5
dist=sum((U-centres(:,k)*ones(1,n)).^2,’r’);
41
X(dist<r^2)=0;
end;
mean(X)
3.4
Exercices
n
Exercice 3.1. Vérifier par simulation que la variance empirique V =
1X
(Xk − X̄)2 (où X̄ =
n
k=1
X1 + · · · + Xn
est la moyenne empirique de l’échantillon) d’un échantillon X1 , . . . , Xn de taille n de
n
n−1
la loi uniforme sur [0, 1] a pour espérance
Var(X1 ). C’est pourquoi il est souvent préférable d’utin
n
1 X
liser la variance empirique modifiée S 2 =
(Xk − X̄)2 qui est un estimateur sans biais de la
n−1
k=1
variance de X1 .
Exercice 3.2. Records : Soient x = (x1 , . . . , xn ) une suite i.i.d. de loi uniforme sur [0,1]. On appelle
record de la suite x tout indice i tel que xi = max(xj | j ≤ i). Compter le nombre de records de la suite x.
n
X
1
.
Evaluer par simulation la moyenne du nombre de records d’une telle suite. Comparer ce nombre à
i
i=1
Démontrer l’égalité.
Exercice 3.3. Représenter sur un même graphique le cercle unité et un nuage de 20 points tirés au
hasard dans [−1, 1]2 . Compter le nombre de points tombant à l’intérieur du cercle. Recommencer avec
100000 points (sans chercher à les représenter graphiquement).
Exercice 3.4. Simuler une marche aléatoire plane
Pn de n pas, tous les pas étant indépendants, de longueur
1 et de direction uniforme sur [0, 2π[ : Sn = k=1 Zk , où Zk = (cos Θk , sin Θk ), les variables aléatoires
Θk étant i.i.d. de loi uniforme sur [0, 2π[. Représenter graphiquement le nuage des points Sn obtenus en
effectuant 500 simulations pour n = 10. Vérifier par la simulation le résultat suivant : la probabilité que
1
Sn appartienne au disque unité est égale à .
n
Exercice 3.5. On se propose de calculer par une méthode de Monte-Carlo l’aire du disque unité D.
Comparer les deux méthodes suivantes :
(i) tirer des points au hasard uniformément dans le carré C = [−1, 1]2 et retenir ceux qui appartiennent
au disque ;
Z 1
√
g(x) dx, où g(x) = 2 1 − x2 pour x ∈ [−1, 1], en estimant par une méthode
(ii) évaluer l’intégrale
−1
de Monte-Carlo l’espérance de la variable aléatoire g(X), où X suit la loi uniforme sur [−1, 1].
On explicitera et on comparera la variance théorique et la variance empirique pour un même entier n
n
4X
des variables aléatoires S1 =
1D (Mk ), où les variables aléatoires M1 , . . . , Mn sont indépendantes
n
k=1
n
2X
et uniformément distribuées sur C, et S2 =
g(Xk ), où les variables aléatoires X1 , . . . , Xn sont
n
k=1
indépendantes et uniformément distribuées sur [−1, 1], et on donnera pour chacune des deux méthodes
un intervalle de confiance pour l’aire du disque.
Exercice 3.6. Un problème de gestion de stock
On considère le problème de gestion de stock suivant. Un magasin vend un produit à l’unité. On note
Xi le stock de ce produit au début du i-ème jour et Di la demande pour ce jour. Les variables aléatoires
Di sont supposées indépendantes équidistribuées de loi la loi de Poisson de paramètre λ. Chaque article
vendu entraîne un bénéfice g et tout invendu en fin de la journée un coût de stockage cs. La politique de
commande est donnée par des seuils s et S : si à la fin de la i-ème journée, le stock restant (Xi − Di )+ est
strictement plus petit que s, une commande est passée pour ramener le stock au niveau S > s. Chaque
commande est honorée le matin suivant et il y a un coût forfaitaire de commande cc si une commande
est passée. On se propose de comparer par la simulation l’espérance du bénéfice total sur une période de
n jours consécutifs de deux politiques correspondant à des seuils (s1 , S1 ) et (s2 , S2 ).
42
Implémenter une méthode de Monte-Carlo pour estimer la différence des espérances de bénéfice entre
ces deux politiques. On donnera un intervalle de confiance pour cette différence et on comparera les
résultats obtenus en utilisant des réalisations différentes des demandes aléatoires Di ou en utilisant les
mêmes réalisations des Di pour les deux politiques. On justifiera le résultat obtenu en remarquant que le
bénéfice est une fonction croissante de la demande.
Exercice 3.7. Loi des grands nombres et théorème limite central
Soit (Xn )n≥1 une suite indépendante de variables aléatoires suivant respectivement la loi uniforme sur
n
1X
α
α
[−n , n ] où α est un réel strictement positif. Étudier la convergence de la suite Mn =
Xk et la
n
k=1
Mn
convergence en loi de
.
σ Mn
Exercice 3.8. Bornes de Chernov
Soit (Xn )n≥1 une suite indépendante de variables aléatoires suivant la même loi de Bernoulli de paramètre
X1 + · · · + Xn
. Alors :
p, q = 1 − p et X̄n =
n
P(X̄n > p + ε) ≤ e−nε
P(X̄n < p − ε) ≤ e−nε
P(|X̄n − p| > ε) ≤ 2e
2
/2q
,
2
/2p
,
−nε2 /2
pour tout ε > 0 (bornes de Chernov).
Comparer graphiquement cette dernière borne à celle obtenue en appliquant l’inégalité de BienayméTchebychev, puis à la borne asymptotique résultant du théorème limite central.
Tester la validité de ces bornes par la simulation.
43
44
Chapitre 4
Variables aléatoires gaussiennes,
théorème limite central
4.1
Loi multinormale
Pour générer un échantillon d’une loi multinormale sur Rd de moyenne m et de matrice de
covariance Γ données, on utilise la fonction grand avec l’option ’mn’. Le script suivant génère
t
2
un échantillon de
taille
100 de la loi de Gauss sur R de moyenne m = (2, 3) et de matrice de
2 1
covariance Γ =
et représente dans le plan le nuage de points associé :
1 3
m=[2;3];Gamma=[2 1;1 3];//moyenne et matrice de covariance
n=100;//nombre de points du nuage
points=grand(n,’mn’,m,Gamma);
xbasc();
plot(points(1,:),points(2,:),’.b’);
On peut également générer un tel échantillon à partir d’un échantillon de la loi normale réduite
(i.e. de moyenne nulle et de matrice de covariance l’identité). En effet si A est une racine carrée
symétrique de Γ et Y une variable aléatoire gaussienne réduite, le vecteur aléatoire X = m + AY
suit la loi normale d’espérance m et de matrice de covariance AId tA = Γ. Le script suivant
génère un échantillon de même taille de la même loi normale et superpose le nuage de points
obtenu au précédent :
A=sqrtm(Gamma);//racine carrée matricielle: A symétrique positive, A*A=Gamma
Y=rand(2,n,’n’);//échantillon de la loi normale réduite
X=m(:,ones(1,n))+A*Y;//échantillon de la loi voulue
plot(X(1,:),X(2,:),’xr’);
9
8
7
6
5
4
3
2
1
0
−1
−3
−2
−1
0
1
2
45
3
4
5
6
Si on veut représenter la densité d’une loi multinormale non dégénérée sur R2 , on peut opter
pour une représentation en 2D ou en 3D. La commande Sfgrayplot permet de représenter cette
densité en niveaux de gris. Il faut d’abord entrer l’expression de la densité sous forme d’une
fonction Scilab. Reprenons l’exemple précédent :
function z=f(x,y)//densité de la loi multinormale
z=exp(-[x-m(1),y-m(2)]*inv(Gamma)*[x-m(1);y-m(2)]/2)/2/%pi/sqrt(det(Gamma));
endfunction;
xset(’colormap’,graycolormap(32));
x=linspace(m(1)-3,m(1)+3);
y=linspace(m(2)-3,m(2)+3);
Sfgrayplot(x,y,f);
La représentation en 3D s’obtient par la fonction fplot3d
fplot3d(x,y,f);//représentation 3D de la densité
8
7
6
0.08
5
0.06
Z
4
0.04
3
0.02
10
2
8
0.00
1
6
−4
0
4
−2
0
−1
2
2
X
−2
−3
−2
−1
0
1
2
3
4
5
6
7
4
Y
0
6
−2
8
On peut également représenter les lignes de niveau de la densité en utilisant la fonction contour2d. Ces lignes de niveau sont aussi celles de la forme quadratique Q(x) =
t
(x − m)Γ−1 (x − m) associée à la matrice inverse de la matrice de covariance, i.e. des ellipses
centrées en m.
Plus précisément, si X suit la loi normale N (m, Γ), la variable aléatoire Q(X) =
t
(X − m)Γ−1 (X − m) suit la loi du χ2 à 2 degrés de liberté. On en déduit que les lignes de
niveau de la densité contenant en leur intérieur 50% et 95% de la masse totale de la loi de X
sont les ellipses d’équations Q(x) = α et Q(x) = β, où α et β sont les quantiles d’ordre 0.5 et
0.95 de cette loi du χ2 . Le script suivant superpose ces lignes de niveau au nuage de points et
vérifie que la proportion de points tombant à l’intérieur de ces lignes est correcte :
function z=Q(x,y)//forme quadratique associée à Gamma^-1
z=[x-m(1),y-m(2)]*inv(Gamma)*[x-m(1);y-m(2)];
endfunction;
xbasc();
plot(points(1,:),points(2,:),’.b’);
x=linspace(min(points(1,:)),max(points(1,:)));
y=linspace(min(points(2,:)),max(points(2,:)));
xset("fpf"," ");//pour ne pas afficher les valeurs sur la figure
cdf=cdfchi(’X’,[2 2],[0.5 0.95],[0.5 0.05]);
//quantiles de la loi du chi-deux
46
contour2d(x,y,Q,cdf,style=5*ones(cdf));//lignes de niveau de Q
//la moitié des points à l’intérieur de la première ellipse
//95% à l’intérieur de la seconde
//vérification
Qp=zeros(1,n);
for k=1:n,Qp(k)=Q(points(1,k),points(2,k));end;
sum(Qp<cdf(1))/n
sum(Qp<cdf(2))/n
Exercice 4.1. Générer un échantillon de taille 500 de la loi normale précédente. Vérifier sur cet échantillon que la loi de 4X1 − 2X2 est gaussienne. Préciser sa moyenne et sa variance.
Exercice 4.2. Représenter
en3D le nuage de points obtenu par la transformation linéaire de R2 dans

2 −1
R3 de matrice B = −2 1  à partir de l’échantillon précédent. La variable aléatoire BX admet-elle
4
2
une densité sur R3 ?
4.2
4.2.1
Échantillons gaussiens, loi du χ2 et lois associées
Loi du χ2
La loi du χ2 à n degrés de liberté est la loi de la somme X12 + · · · + Xn2 des carrés de n variables
aléatoires réelles indépendantes X1 , . . . , Xn suivant toutes la loi normale centrée réduite.
x
n
1
Cette loi admet la densité n n x 2 −1 e− 2 1]0,+∞[ (x). C’est donc une loi gamma de paramètres
2
2 Γ( 2 )
n
1
et . En particulier, pour n = 2, la loi du χ2 à 2 degrés de liberté est une loi exponentielle.
2
2
Densité de quelques lois du chi−deux
0.50
2
0.45
5
10
0.40
0.35
0.30
0.25
0.20
0.15
0.10
0.05
0.00
0
2
4
6
8
10
12
14
16
18
20
On a déjà remarqué que si X suit la loi normale N (m, Γ) sur Rn , où Γ est non dégénérée, alors
t
(X − m)Γ−1 (X − m) suit la loi du χ2 à n degrés de liberté. En effet, (X − m) a même loi que
AY , où A est une racine carrée symétrique positive de Γ et Y une variable aléatoire gaussienne
n
X
Yk2 .
réduite à valeurs dans Rn . Il en résulte que t(X − m)Γ−1 (X − m) a même loi que tY Y =
k=1
t
Exercice 4.3. Vérifier sur l’échantillon obtenu à l’exercice 4.1 que (X − m)Γ
χ2 à 2 degrés de liberté.
47
−1
(X − m) suit la loi du
4.2.2
Loi de Student
X
La loi de Student T (n) à n degrés de liberté est la loi du quotient p
, où X et Y sont deux
Y /n
variables aléatoires réelles indépendantes, X suivant la loi normale réduite N (0, 1) et Y la loi
du χ2 à n degrés de liberté.
Elle admet la densité :
Γ n+1
2
√ f (t) =
Γ n2
πn
1+
t2
n
1
(n+1)/2 .
Une variable aléatoire suivant cette loi est intégrable si n > 1 (son espérance est alors nulle) et
n
de carré intégrable si n > 2 (sa variance est alors égale à
).
n−2
nb=10000;//taille de l’échantillon
n=5;//degrés de liberté
a=5;//borne du graphique
x=grand(1,nb,’nor’,0,1);
y=grand(1,nb,’chi’,n);
z=x ./sqrt(y/n);
histplot(linspace(-a,a,50),z,style=2);
t=linspace(-a,a);
y=cdft(’PQ’,t,5*ones(t));
plot2d((t(1:$-1)+t(2:$))/2,(y(2:$)-y(1:$-1))/(t(2)-t(1)),style=5);
En particulier, pour n = 1, la loi de Student T (1) n’est autre que la loi de Cauchy de densité
1 1
. C’est aussi la loi du quotient de deux variables aléatoires normales réduites indépenπ 1 + t2
dantes, comme le vérifie le script suivant :
t=linspace(-10,10);y=cdft(’PQ’,t,ones(t));
plot((t(1:$-1)+t(2:$))/2,(y(2:$)-y(1:$-1))/(t(2)-t(1)),’+g’)
plot2d(t,1 ./(1+t.^2)/%pi,style=2);
nb=10000;
x=grand(1,nb,’nor’,0,1);
y=grand(1,nb,’nor’,0,1);
z=x ./y;
histplot(-10:0.2:10,z,style=5);
4.2.3
Loi de Fisher-Snedecor
X/n
où X et Y
Y /p
sont des variables aléatoires indépendantes suivant respectivement les lois du χ2 à n et p degrés
de liberté.
Elle admet la densité :
n/2
n
1
t 2 −1
n
f (t) =
(n+p)/2 1[0,+∞[ (t) ,
B( n2 , p2 ) p
1 + nt
p
La loi de Fisher-Snedecor F (n, p) de paramètres n et p est la loi du quotient
où la fonction bêta est définie par B(n, p) =
Γ(n)Γ(p)
pour n > 0, p > 0.
Γ(n + p)
48
nb=10000;//taille de l’échantillon
n=10;//degrés de liberté du numérateur
p=5;//degrés de liberté du dénominateur
x=grand(1,nb,’chi’,n);
y=grand(1,nb,’chi’,p);
z1=(x/n)./(y/p);
histplot(0:0.2:10,z1,rect=[0,0,10,0.7],style=2);
t=linspace(0,10);
yt=cdff(’PQ’,t,10*ones(t),5*ones(t));
plot2d((t(1:$-1)+t(2:$))/2,(yt(2:$)-yt(1:$-1))/(t(2)-t(1)),style=5);
xtitle(’Loi de Fisher F(10,5)’);
Loi de Fisher F(10,5)
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0
4.2.4
1
2
3
4
5
6
7
8
9
10
Échantillons gaussiens
Ces lois interviennent dans l’étude des échantillons des lois normales et jouent un rôle crucial
dans plusieurs problèmes d’estimation ou de tests.
Si X1 , . . . , Xn est un échantillon d’une loi gaussienne N (m, σ 2 ), on sait que la moyenne empirique
X1 + · · · + Xn
X̄ =
de cet échantillon suit la loi de Gauss N (m, σ 2 /n).
n
n
1 X
La variance empirique non biaisée S 2 =
(Xk − X̄)2 est indépendante de X̄ et
n−1
k=1
(n − 1)S 2 /σ 2 suit la loi du χ2 à n − 1 degrés de liberté.
√ X̄ − m
suit la loi de Student à n − 1 degrés de liberté. L’intérêt
Il en résulte que le quotient n
S
de ce résultat est que cette variable aléatoire ne dépend pas de la variance des Xk , qui n’a pas
besoin d’être connue.
Si X = (X1 , . . . , Xn1 ) et Y = (Y1 , . . . , Yn2 ) sont deux échantillons gaussiens de lois respectives
(n1 − 1)S12
N (m1 , σ12 ) et N (m2 , σ22 ) et de variances empiriques respectives S12 et S22 , alors
et
σ12
(n2 − 1)S22
suivent respectivement les lois du χ2 à (n1 − 1) et (n2 − 1) degrés de liberté et sont
σ22
S2
indépendantes. Il en résulte que si σ1 = σ2 , alors F = 12 suit la loi de Fisher F (n1 − 1, n2 − 1).
S2
49
Ce résultat ne dépend pas des espérances m1 et m2 des deux échantillons, qui n’ont pas besoin
d’être connues, pas plus que la valeur commune de la variance des deux échantillons.
4.3
4.3.1
Théorème limite central
Le cas unidimensionnel
Le théorème limite central nous apprend que si (Xn )n≥1 est une suite de variables aléatoires
réelles indépendantes équidistribuéesde carré intégrable
d’espérance m et d’écart-type σ > 0, et
Sn − nm
√
converge en loi vers une variable aléatoire
Sn = X1 + · · · + Xn , alors la suite
σ n
n≥1
Sn − nm
√
réelle gaussienne réduite, i.e. pour tout intervalle [a, b] de R, P a ≤
≤ b tend vers
σ n
Z b
x2
1
√
e− 2 dx.
2π a
Cette convergence permet en particulier d’approcher une loi binomiale de paramètres n grand et
p pas trop proche de 0 ou de 1 par une loi normale. En pratique, on utilise cette approximation
pour np et n(1 − p) tous deux supérieurs à 5.
Historiquement, la première version de ce théorème concernait la convergence de chacun des
coefficients de la loi binomiale renormalisée :
Théorème (de Moivre-Laplace) Si B(n, p, k) désignep
la probabilité qu’une variable
p aléatoire
suivant la loi binomiale B(n, p) prenne la valeur k, alors np(1 − p)B(n, p, [np + x np(1 − p)])
tend vers ϕ(x) quand n tend vers l’infini, où [y] désigne la partie entière de y et ϕ la densité de
la loi normale réduite.
//la loi binomiale réduite et son approximation gaussienne
n=30;p=0.4;q=1-p;
pr=binomial(p,n);//loi binomiale B(n,p)
valeurs=((0:n)-n*p)/sqrt(n*p*q);//valeurs prises par une variable binomiale réduite
plot2d3(valeurs,sqrt(n*p*q)*pr,2);//diagramme en bâtons normalisé
x=linspace(min(valeurs),max(valeurs));
plot2d(x,exp(-x.^2/2)/sqrt(2*%pi),5);//densité de la loi normale N(0,1)
0.40
0.35
0.30
0.25
0.20
0.15
0.10
0.05
0.00
−6
−4
−2
0
2
50
4
6
8
4.3.2
Le cas multidimensionnel
Théorème limite central multidimensionnel : Soit (Xn )n≥1 une suite de variables aléatoires
indépendantes équidistribuées de carré intégrable à valeurs dans Rd , m = E[X1 ]leur espérance,
Sn − nm
√
Γ = ΓX1 leur matrice de covariance, et Sn = X1 + · · · + Xn . Alors la suite
n
n≥1
converge en loi vers une variable aléatoire gaussienne à valeurs dans Rd de loi N (0, Γ).
4.3.3
Application à la loi multinomiale
Soit (Yn )n≥1 une suite de variables aléatoires indépendantes équidistribuées à valeurs dans un
ensemble fini {y1 , . . . , yd } de loi commune p = (p1 , . . . , pd ) : P(Yn = yi ) = pi > 0 pour tout n ≥ 1
et tout i = 1, . . . , d.
Notons, pour tout n, Xn la variable aléatoire à valeurs dans Rd :
Xn = (1Yn =y1 , . . . , 1Yn =yd )
et :
Sn = (Sn(1) , . . . , Sn(d) ) =
n
X
Xj
j=1
le vecteur aléatoire des nombres d’obtention des yi au cours des n premières expériences.
La variable aléatoire Sn suit la loi multinomiale de paramètres n et p1 , . . . , pd . La loi forte des
Sn
tend presque sûrement vers p quand n tend vers l’infini
grands nombres nous apprend que
n
Sn − np
√
converge en loi vers un vecteur gaussien Z de loi
et le théorème central limite que
n
N (0, Γ), où Γ est la matrice de covariance de X1 . Les coefficients Γi,j de cette matrice valent
Γi,j = pi δi,j − pi pj , de sorte qu’on peut écrire Γ = D − tpp, où D est la matrice diagonale de
coefficients diagonaux p1 , . . . , pd . Cette matrice a un déterminant nul (la somme de chacune de ses
d
X
lignes ou de ses colonnes est nulle), ce qui traduit la relation de dépendance affine
Sn (i) = n,
i=1
et la loi normale N (0, Γ) n’admet donc pas de densité par rapport à la mesure de Lebesgue sur
Rd .
(1)
(d−1)
Par contre la loi de la variable aléatoire S̃n = (Sn , . . . , Sn
) converge vers la loi normale
d−1
centrée sur R
de matrice de covariance Γ̃ = (Γi,j )1≤i,j≤d−1 qui est définie positive. Cette loi
normale admet donc une densité.
Vérifions ce résultat en représentant sur un même graphique, pour d = 3, un nuage de points
associé à un échantillon d’une loi multinomiale normalisée (les marqueurs sont des cercles) et le
nuage de points associé à un échantillon de la loi normale N (0, Γ̃) (les marqueurs sont des croix).
nbsimul=100;n=100;p=[0.2;0.5;0.3];
Gammatilde=[p(1)*(1-p(1)),-p(1)*p(2);-p(1)*p(2),p(2)*(1-p(2))];
y=grand(nbsimul,’mul’,n,p(1:$-1));//échantillon de la loi multinomiale
plot((y(1,:)-n*p(1))/sqrt(n),(y(2,:)-n*p(2))/sqrt(n),’ob’);
z=grand(nbsimul,’mn’,zeros(2,1),Gammatilde);//échantillon de la loi normale
plot(z(1,:),z(2,:),’+r’)
51
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
−1.5
−1.0
−0.5
0.0
On montre aussi que la variable aléatoire réelle Dn2 =
0.5
1.0
1.5
d
(i)
X
(Sn − npi )2
i=1
npi
converge en loi vers une
variable aléatoire suivant la loi du χ2 à d − 1 degrés de liberté. Cette loi limite ne dépend donc
pas de la loi p.
Exercice 4.4. Générer un échantillon de la loi multinomiale de paramètres n = 100, p = (0.2, 0.5, 0.3)
en simulant n tirages de la loi p. Déterminer la moyenne et la matrice des covariances empiriques de
3
X
(Ni − npi )2
, où Ni est le nombre
cet échantillon. Comparer aux valeurs théoriques. Évaluer Dn2 =
npi
i=1
d’occurences de i dans l’échantillon. Refaire la même chose en utilisant la fonction grand pour simuler cet
échantillon. Recommencer avec d’autres valeurs de n. Générer un nombre suffisant d’échantillons pour
pouvoir comparer la loi empirique de Dn2 à la loi du χ2 à 2 degrés de liberté.
4.4
4.4.1
Mouvement brownien
Mouvement brownien standard
On appelle mouvement brownien standard tout processus à temps continu (Bt )t≥0 qui vérifie les
propriétés suivantes :
(i) B0 = 0 ;
(ii) pour tout 0 ≤ s < t, Bt − Bs suit la loi normale centrée de variance t − s ;
(iii) pour toute suite 0 < t1 < · · · < tn , les accroissements Bt1 − B0 , Bt2 − Bt1 , . . ., Btn − Btn−1
sont indépendants ;
(iv) presque toutes les trajectoires t 7→ Bt (ω) sont continues.
Il existe plusieurs façons de construire un tel processus ; nous en admettrons ici l’existence.
Son importance vient en particulier de ce qu’il apparaît comme limite de nombreuses familles de
processus.
Pour simuler une trajectoire d’un mouvement brownien, il suffit de simuler des variables gaussiennes indépendantes et d’interpoler les sommes cumulées de ces variables.
dt=0.001;//pas
tmax=1;
nb=5;//nombre de trajectoires
B=[zeros(1:nb);cumsum(grand(tmax/dt,nb,’nor’,0,sqrt(dt)),’r’)];
plot2d((0:dt:tmax)’*ones(1,nb),B);
52
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Exercice 4.5. On peut démontrer que pour tout réel t > 0, la variable aléatoire Bt∗ = max Bs suit la
0≤s≤t
même loi que |Bt |. Vérifier cette propriété en simulant un grand nombre de trajectoires du mouvement
brownien et en représentant les histogrammes de ces deux variables aléatoires.
On montre facilement que, pour tout couple (s, t) de réels positifs, la covariance des variables
aléatoires Bs et Bt est égale à min(s, t). On pourrait utiliser cette propriété pour simuler les trajectoires d’un mouvement brownien. Cette approche est à déconseiller dans le cas du mouvement
brownien, mais elle peut s’avérer utile pour simuler d’autres processus gaussiens.
Exercice 4.6. Simuler une trajectoire d’un mouvement brownien en utilisant une loi multinormale.
4.4.2
Mouvement brownien dans Rd
(1)
(d)
Un processus à temps continu Bt = (Bt , . . . , Bt ) à valeurs dans Rd est un mouvement brow(i)
nien standard si ses composantes Bt (i = 1, . . . , d) sont des mouvements browniens standard
indépendants. Il est facile de simuler une trajectoire d’un tel processus :
dt=0.001;
tmax=1;
B=[zeros(2,1),cumsum(grand(2,tmax/dt,’nor’,0,sqrt(dt)),’c’)];
plot2d(B(1,:),B(2,:),frameflag=4);//échelle isométrique
0.6
0.4
0.2
0.0
−0.2
−0.4
−0.6
−0.8
−1.0
−0.5
0.0
53
0.5
4.4.3
Pont brownien
Le pont brownien standard est le processus (Zt )0≤t≤1 défini par Zt = Bt − tB1 , où (Bt )t≥0 est
un mouvement brownien standard. Il représente le mouvement brownien standard conditionné
à revenir en son point de départ à l’instant 1. C’est un processus gaussien centré de matrice de
covariance Cov(Zs , Zt ) = s(1 − t) pour 0 ≤ s ≤ t ≤ 1.
1.5
1.0
0.5
0.0
−0.5
−1.0
−1.5
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Exercice 4.7. Simuler une trajectoire d’un pont brownien en utilisant cette dernière propriété.
Pont brownien et fonctions de répartition empiriques Soit (Xn )n≥1 une suite indépendante de variables aléatoires suivant toutes la loi uniforme sur [0, 1], et Fn la fonction de
répartition empirique de l’échantillon (X1 , . . . , Xn ) définie par
n
Fn (s) =
1X
1[0,s] (Xk )
n
k=1
pour s ∈ [0, 1] .
Pour tout couple 0 < s < t < 1 de réels, la suite (Yn )n≥1 de variables aléatoires à valeurs dans
R2 définie par
Yn = (1[0,s] (Xn ), 1[0,t] (Xn ))
est indépendante équidistribuée d’espérance (s, t) et de matrice de covariance
s(1 − s) s(1 − t)
Γs,t =
.
s(1 − t) t(1 − t)
√
1
Il en résulte que √ (nFn (s) − ns, nFn (t) − nt) = n(Fn (s) − s, Fn (t) − t) converge en loi vers
n
une variable aléatoire suivant la loi normale N (0, Γs,t ). Cette loi est celle du couple (Zs , Zt ), où
(Z )
est un pont brownien. Plus généralement, pour 0 < s1 < · · · < sr < 1, le r-uplet
√ t 0≤t≤1
n(Fn (s1 ) − s1 , . . . , Fn (sr ) − sr ) converge en loi vers (Zs1 , . . . , Zsr ). Ceci laisse penser (et on
√
peut démontrer) que la variable aléatoire nDn , où Dn = sup |Fn (s) − s|, converge en loi
s∈[0,1]
vers une variable aléatoire suivant la loi de Z ∗ = sup |Zs |. Cette loi n’est autre que la loi de
s∈[0,1]
Kolmogorov-Smirnov vue à la section 3.2.1.
On sait par ailleurs que la loi de Dn = sup |Fn (s) − F (s)|, où Fn est la fonction de répartition
s∈[0,1]
empirique d’un échantillon de taille n d’une loi de fonction de répartition continue F , ne dépend
pas de F . Le résultat précédent s’étend donc à toute suite i.i.d. de variables aléatoires réelles de
loi diffuse.
54
Exercice 4.8. Simuler un grand nombre de trajectoires du pont brownien. Tracer l’histogramme du
maximum des valeurs absolues de ces trajectoires. Représenter sur le même diagramme la densité de la
loi de Kolmogorov-Smirnov.
4.5
4.5.1
Processus gaussiens stationnaires
Un peu de terminologie
Un processus réel indexé par Z est une suite (Xk )k∈Z de variables aléatoires réelles indexée par
Z. En pratique, l’indice k représente souvent le temps, supposé discrétisé.
Le processus (Xk )k∈Z est dit de carré intégrable si toutes les variables aléatoires Xk sont de carré
intégrable. On peut alors définir la moyenne m du processus comme la fonction m : Z → R qui à
tout entier k associe l’espérance m(k) = E(Xk ) de Xk et la fonction de covariance K : Z×Z → R
qui à tout couple (i, j) d’indices associe la covariance de Xi et Xj : K(i, j) = Cov(Xi , Xj ).
Cette fonction de covariance est définie positive, en ce sens que
X
zi z̄j K(ki , kj ) ≥ 0
1≤i,j≤n
pour toute famille (k1 , k2 , . . . , kn ) d’entiers relatifs et toute famille (z1 , z2 , . . . , zn ) de nombres
complexes.
Le processus (Xk )k∈Z est dit gaussien si le vecteur (Xk )k∈I est gaussien pour toute partie finie
I de Z. Un processus gaussien est de carré intégrable et sa loi est entièrement déterminée par sa
moyenne et sa fonction de covariance.
Un processus est dit fortement stationnaire si sa loi est invariante par translation du temps : pour
tout entier j ∈ Z et toute famille (k1 , k2 , . . . , kn ) d’entiers relatifs, les n-uplets (Zk1 , . . . , Zkn ) et
(Zj+k1 , . . . , Zj+kn ) ont même loi.
Un processus de carré intégrable est dit faiblement stationnaire si sa moyenne m et sa fonction
de covariance K sont invariantes par translation du temps, autrement dit si sa moyenne m est
constante et si K(n + i, n + j) = K(i, j) pour tout triplet (i, j, n) d’entiers relatifs. Il existe alors
une fonction paire r : Z → R telle que K(i, j) = r(j − i) pour tout couple (i, j) ∈ Z × Z.
Un processus fortement stationnaire de carré intégrable est faiblement stationnaire, mais la réciproque est en général forte. Elle est vraie si le processus est gaussien : tout processus gaussien
faiblement stationnaire est fortement stationnaire.
On appelle bruit blanc tout processus stationnaire (Wk )k∈Z de carré intégrable de moyenne nulle
tel que Wi et Wj soient non corrélées pour i 6= j, i.e. tel que la fonction de covariance r associée
soit nulle en-dehors de 0. Un bruit blanc (Wk )k∈Z est dit gaussien si le processus (Wk )k∈Z est
gaussien.
4.5.2
Moyennes mobiles
Une série chronologique est simplement une suite de variables aléatoires indexée par le temps,
supposé discrétisé. De telles séries interviennent naturellement en météorologie, en économie et
dans bien d’autres domaines de la vie économique et sociale. L’utilisation de processus gaussiens
pour modéliser de tels phénomènes est justifiée, pour une part par le thérème limite central, mais
surtout par la grande facilité avec laquelle sont effectués les calculs dans de tels modèles.
Dans l’observation de phénomènes chronologiques, on distingue souvent une tendance déterministe globale (augmentation générale des prix en économie) doublée de variations saisonnières
péridodiques, cette évolution déterministe étant perturbée par des variations aléatoires. On modélise souvent ces perturbations par un bruit blanc gaussien.
On peut alors être amené à considérer des moyennes mobiles de la série observée pour éliminer
les variations saisonnières : par exemple, dans le cas d’une étude des prix de produits agricoles,
on fera une moyenne sur les douze mois de l’année.
55
Dans l’exemple suivant, on génère de manière pseudo-aléatoire une série chronologique présentant
une tendance haussière doublée d’une variation saisonnière de période 12, l’unité de temps étant
le mois ; cette évolution déterministe est perturbée par un bruit blanc gaussien. On commence
par estimer la tendance globale, que l’on soustrait à la variation brute ; on estime ensuite les
variations saisonnières, que l’on retranche à leur tour pour faire apparaître la partie aléatoire des
variations, que l’on représente en même temps que le bruit blanc initial qui nous avait servi à
générer l’exemple. On estime ensuite la variance du bruit, ainsi que la corrélation ou l’absence
de corrélation de ce bruit, en utilisant la fonction corr de Silab.
2.5
2.0
1.5
1.0
0.5
0.0
−0.5
0
20
40
60
n=10;//nombre d’annees
a=0.01;//tendance mensuelle
b=0.1;//fluctuations periodiques
c=0.05;//fluctuations aleatoires
t=1:12*n;//temps
e=rand(1,12*n,’n’);//bruit blanc
//les pseudo-donnees:
x=1+a*t+b*sin(2*%pi*t/12)+c*e;
clf
plot2d(t,x)
//moyennes mobiles:
X=zeros(12,12*n-11);
for i=1:12
X(i,:)=x(i:12*n-12+i);
end;
xm=mean(X,’r’);
plot2d(12:12*n,xm,style=5);
//estimation de la tendance:
aest=(x($)-x(12))/(n-1)/12;
y=x-aest*t;
plot2d(t,y,style=3);
//estimation des fluctuations saisonnieres:
my=mean(y);
56
80
100
120
fs=zeros(1,12);
for i=1:12
fs(i)=mean(y(i:12:12*n))-my;
end;
//estimation du bruit
w=zeros(y);
for i=1:n
w(1+12*(i-1):12*i)=y(1+12*(i-1):12*i)-fs-my;
end;
plot2d(t,w,style=2);
plot2d(t,c*e,style=4);
disp(corr(w,10))
column 1 to 6
0.0028704
0.0004340
column 7 to 10
0.0003022
0.0008124
0.0003434
0.0005744
0.0001707
0.0003716
0.0005102
0.0000684
La fonction corr retourne les autocovariances empiriques de la série X1 , . . . , Xn :
n−k
1X
r̂(k) =
(Xi − X̄)(Xi+k − X̄)
n
i=1
où X̄ désigne la moyenne (X1 + · · · + Xn )/n. En particulier, pour k = 0, r̂(0) est la variance
empirique (biaisée). Si le processus est stationnaire, ces autocovariances empiriques convergent
quand n tend vers l’infini vers les covariances théoriques r(k). En particulier, dans le cas d’un
bruit blanc, r̂(k) converge vers la variance du bruit blanc si k = 0 et vers 0 pour k > 0.
Dans le cas d’une moyenne mobile :
Xn =
q
X
bj Wn−j
j=0
les covariances théoriques sont données par :
r(k) =
(
σ2
0
Pq−k
j=0 bj bk+j
si j ≤ q − k
sinon
où σ 2 est la variance du bruit blanc W .
Vérifions le pour une moyenne mobile sur 12 mois (et une très longue durée) :
n=12000;
W=rand(1,n,’n’);
X=W(1:$-11);
for i=1:11
X=X+W(1+i:$-11+i);
end;
X=X/12;
plot(corr(X,20))
57
4.5.3
Processus auto-régressifs
Un processus autorégressif est un processus (Xn )n∈Z vérifiant une relation de récurrence de la
forme
p
X
Xn =
ai Xn−i + Wn
i=1
pour tout n ∈ Z, où p est un entier positif, les ai des scalaires et (Wn )n∈Z un bruit blanc. Si
ap 6= 0, on dit que le processus est autorégressif d’ordre p.
Ces processus sont très utilisés, par exemple en économie pour modéliser l’évolution d’un marché :
les prix dans le futur sont une fonction linéaire des prix des quelques derniers mois perturbée
par une variation aléatoire.
Le cas p = 1
Dans ce cas, l’équation s’écrit :
Xn = aXn−1 + Wn
en notant a = a1 .
Le processus est markovien : son évolution future ne dépend de son passé qu’au travers de son
état présent (ce n’est plus le cas si p > 1).
Si |a| < 1, on peut alors écrire Xn comme somme d’une série :
Xn =
∞
X
ak Wn−k .
k=0
Cette série converge presque sûrement et dans L2 . Le processus X apparaît ainsi comme une
moyenne mobile d’ordre infini et sa variance se calcule facilement :
Var(Xn ) =
∞
X
a2k σ 2 =
k=0
σ2
1 − a2
où σ 2 est la variance du bruit blanc W .
La simulation d’un tel processus est donc simple : on simule X0 suivant la loi normale centrée
de variance σ 2 /(1 − a2 ), puis on génère le bruit blanc W et on en déduit les Xn en utilisant la
relation de récurrence.
Pour calculer la fonction de covariance r, il suffit de remarquer qu’elle vérifie la relation de
récurrence r(k) = ar(k − 1) pour tout k ≥ 1. Cette relation s’obtient en multipliant l’égalité
Xn = aXn−1 + Wn par Xn−k et en prenant l’espérance.
Le cas général
Si un processus stationnaire centré vérifie la relation de récurrence
Xn − a1 Xn−1 − · · · − ap Xn−p = Wn ,
on obtient, en multipliant cette relation par Xn−k (supposé indépendant de Wn ) et en prenant
l’espérance, une relation de récurrence vérifiée par la fonction de covariance r :
r(k) = a1 r(k − 1) + a2 r(k − 2) + · · · + ap r(k − p)
pour k ≥ p.
Si toutes les racines du polynôme q(z) = z p − a1 z p−1 − · · · − ap sont de module strictement
inférieur à 1, ou, ce qui revient au même, si toutes les racines du polynôme 1 − a1 z − · · · − ap z p
sont extérieures au disque unité, r(k) tend 0 quand k tend vers l’infini.
58
Pour simuler une trajectoire du processus, on peut donc partir d’une valeur quelconque de
X0 , . . . , Xp−1 , générer le bruit blanc et utiliser la relation de récurrence pour calculer Xn . La stabilisation autour du processus stationnaire se fera d’autant plus vite que les racines du polynôme
q sont petites en module.
Estimation des coefficients ai et prévision
En statistique, on dispose seulement d’une partie de la série chronologique et le but est de trouver
un modèle le plus simple possible rendant compte au mieux de ces données. Si on pense qu’une
modélisation par un processus autorégressif peut convenir, le premier problème est de déterminer
l’ordre du modèle, i.e. la valeur de l’entier p, puis d’estimer les paramètres ai (1 ≤ i ≤ p) et la
variance du bruit blanc au vu des données.
On commence par estimer la moyenne et la fonction d’autocovariance en utilisant les covariances
empiriques. Si on suppose déterminée la valeur de p, les coefficients ai vérifient les équations de
Yule-Walker, qui peuvent s’écrire sous forme matricielle :


 

r(1)
a(1)
r(0)
r(1)
. . . r(p − 1)

 
 r(1)

r(0)
. . . r(p − 2)
 a(2) = r(2)

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   . . .   . . . 
r(p)
a(p)
r(p − 1) r(p − 2) . . .
r(0)
(ces équations s’obtiennent de même que précédemment en multipliant la relation de récurrence
définissant le processus successivement par Xn−1 , . . . , Xn−p et en prenant l’espérance).
On obtient donc une estimation des ai en résolvant ce système, après avoir remplacé les autocovariances théoriques par leurs estimées.
Si on veut essayer de prévoir le futur du processus au vu de son passé, on utilisera comme
prévision de Xn+1 l’espérance conditionnelle de Xn+1 connaissant la tribu FnX du passé de X
jusqu’à l’instant n : E(Xn+1 | FnX ) = a1 Xn + a2 Xn−1 + · · · + ap Xn−p+1 .
Remarque : ces deux types de processus (autorégressifs et moyennes mobiles) sont en fait des
cas particuliers d’une classe plus large de processus, appelés processus ARMA (Auto Regressive
Moving Average). Un processus ARMA(p, q) vérifie une relation de récurrence du type
p
X
ai Xn−i =
i=0
q
X
bj Wn−j
j=0
pour tout n ∈ Z, où p et q sont deux entiers positifs, les ai et les bj des scalaires et (Wn )n∈Z un
bruit blanc. Les moyennes mobiles correspondent donc à p = 0 et les processus autorégressifs à
q = 0.
Scilab possède une bibliothèque de fonctions arma pour simuler les processus ARMA et estimer
leurs paramètres, mais l’étude se situant ici à un niveau élémentaire, nous nous sommes contentés
d’utiliser les fonctions statistiques usuelles.
59
60
Chapitre 5
Chaînes de Markov à temps discret
5.1
5.1.1
Simulation de chaînes de Markov
Commandes de base
Le générateur grand permet de simuler des trajectoires d’une chaîne de Markov d’espace d’états
fini dont on connaît la matrice de transition. La commande Y=grand(n,’markov’,P,x0) renvoie
une trajectoire de longueur n de la chaîne de Markov d’espace d’états E = {1, . . . , N }, de
matrice de transition P , et d’état initial x0 , où P est une matrice stochastique d’ordre N et x0
un élément de E. On peut simuler simultanément par la même commande m trajectoires de la
chaîne en prenant pour x0 un vecteur de longueur m : Y est alors une matrice à m lignes et
n colonnes, la i-ième ligne de cette matrice représentant une trajectoire de la chaîne issue de x0 (i).
La fonction eigenmarkov(P) renvoie l’unique loi stationnaire d’une chaîne de Markov irréductible de matrice de transition P . Si la chaîne comporte m classes récurrentes, elle renvoie une
matrice à m lignes dont la i-ième ligne est la loi stationnaire correspondant à la i-ième classe
récurrente. Avec deux arguments en sortie, la commande [M,Q]=eigenmarkov(P) renvoie en
outre une matrice Q à m colonnes, où Q(i, j) est la probabilité de terminer dans la j-ième classe,
l’état initial étant i.
La commande genmarkov renvoie une matrice de transition aléatoire. Ses arguments sont
en entrée un vecteur contenant le nombre d’éléments de chacune des classes récurrentes, et
le nombre d’états transients. Ainsi genmarkov([n1,n2,...,np],nt) renvoie la matrice de
transition d’une chaîne de Markov ayant p classes récurrentes, de cardinaux respectifs n1 ,
n2 , . . ., np , et nt états transients communiquant tous entre eux. En particulier, la commande
genmarkov(N,0) renvoie la matrice de transition d’une chaîne irréductible d’espace d’états
{1, . . . , N }. Cette commande peut être utile pour tester certaines propriétés d’une chaîne de
Markov.
La commande [perm,rec,tr,indsRec,indsT]=classmarkov(P) permet de trouver le nombre
d’états transients (tr), les tailles des classes récurrentes (rec), les indices des états récurrents
(indsRec) et transients (indsT) ainsi qu’une permutation (perm) de ces indices permettant de
mettre la matrice de transition P sous forme canonique.
Vérifions pour commencer sur un exemple le théorème ergodique :
N=5;n=10000;//5 états, 10000 pas
P=genmarkov(N,0);//une seule classe récurrente, pas d’états transients
x=grand(n,’markov’,P,1);
t=tabul(x);//fréquences de passage
61
eigenmarkov(P)//loi stationnaire
t($:-1:1,2)’/n
ans =
0.1305591
0.3130950
0.1635297
ans =
0.1301
0.3088
0.1623
0.1997
0.1950212
0.1977949
0.1991
On peut vérifier également que, dans le cas d’une chaîne irréductble apériodique d’espace d’états
fini, la matrice P n tend très vite vers la matrice de rang 1 dont toutes les lignes sont égales à la
probabilité stationnaire :
N=3;P=genmarkov(N,0);P^100,eigenmarkov(P)
ans =
0.3159087
0.2556059
0.4284854
0.3159087
0.2556059
0.4284854
0.3159087
0.2556059
0.4284854
ans =
0.3159087
0.2556059
0.4284854
Exercice 5.1. Générer une matrice de transition aléatoire P pour une chaîne ayant 2 classes récurrentes
de cardinaux 1 et 3 et une classe transiente de cardinal 4. Étudier la convergence de P n quand n tend vers
l’infini et comparer la limite à la matrice QM , où M et Q sont obtenues par la commande eigenmarkov.
Que peut-on dire de la matrice QM ?
5.1.2
Chaînes absorbantes
Si une chaîne de Markov (Xn )n≥0 possède r états absorbants et s états transients, la matrice
de
Ir 0
transition de cette chaîne peut s’écrire, quitte à renuméroter les états, sous la forme P =
R Q
Ir
0
n
n
,
où Q est une matrice sous-stochastique d’ordre s. La matrice P s’écrit alors P =
Rn Q n
où Rn = (Ir + Q + · · · + Qn−1 )R. La matrice Qn tend vers 0 quand n tend vers l’infini, puisque
Qn (i, j) = P(Xn = j | X0 = i) tend vers 0 pour tout état transient j. On en déduit que la
n−1
∞
X
X
Qk = Is − Qn tend
Qk puisque (Is − Q)
matrice Is − Q est inversible d’inverse N =
k=0
k=0
vers Is . La matrice N est parfois appelée matrice fondamentale de la chaîne. Elle permet en
particulier de calculer les temps et les probabilités d’absorption. En effet pour tout couple (i, j)
∞
X
P k (i, j) est l’espérance du nombre total de visites en j pour la chaîne issue
d’états, U (i, j) =
k=0
de i. Ce nombre est fini si j est transient et la somme
r+s
X
U (i, j) de ces espérances sur tous
j=r+1
les états transients représente le temps moyen de séjour dans l’ensemble des états transients, i.e.
l’espérance du temps T d’atteinte de l’ensemble des états absorbants pour la chaîne issue de i.
La matrice N Js , où Js est la matrice colonne d’ordre s dont tous les coefficients valent 1, a donc
pour coefficients ces espérances.
La loi du temps d’absorption s’obtient en remarquant que
Pi (T = n) =
r
X
j=1
(P n (i, j) − P n−1 (i, j)) .
Soit f une fonction définie sur l’ensemble {1, . . . , r} des états absorbants et g la fonction définie
sur l’ensemble des états transients par g(i) = Ei (f (XT )) pour tout i = r + 1, . . . , r + s. La
62
relation g = Rf + Qg s’écrit encore (Is − Q)g = Rf , ou g = N Rf . En particulier si f est la
fonction indicatrice d’un état absorbant particulier j0 , la matrice N Rf a pour coefficients les
probabilités Pi (XT = j0 ), i parcourant l’ensemble des états transients.
La commande genmarkov(ones(1,r),s) fournit une matrice de transition aléatoire pour une
chaîne de Markov comportant r états absorbants et s états transients. Elle permet de tester
facilement les résultats précédents.
r=2;//nombre d’états absorbants
s=3;//nombre d’états transients
P=genmarkov(ones(1,r),s);
Q=P(r+1:r+s,r+1:r+s);
N=inv(eye(Q)-Q);
t=sum(N*ones(s,1),’c’)
R=P(r+1:r+s,1:r);
N*R//espérance du temps d’absorption
nbsimul=10000;
x=grand(50,’markov’,P,(r+s)*ones(1,nbsimul));
//simulation de la chaîne issue de r+s
for k=1:r
p(k)=sum(x(:,$)==k)/nbsimul;
end;
p//fréquences d’absorption
temps=sum(x>r,’c’)+1;
mean(temps)//temps moyen d’absorption en partant de r+s
tmax=max(temps);
histplot(0:tmax,temps)//histogramme du temps d’absorption
tempstheorique=zeros(1,tmax);
M=P-eye(P);
for k=1:tmax
tempstheorique(k)=sum(M(r+s,1:r));
M=P*M;
end;
plot2d2(0:tmax-1,tempstheorique,style=5);
5.1.3
Estimation de la probabilité de transition
Soit (Xn )n≥0 une chaîne de Markov d’espace d’états fini E et de matrice de transition P . Supposons que l’on sache simuler cette chaîne sans connaître la valeur de P . L’estimateur du maximum
de vraisemblance de P est alors donné par :
P̂ (i, j) =
N (i, j)
N (i)
pour tout (i, j) ∈ E × E tel que N (i) > 0 ,
où N (i, j) est le nombre de transitions de i à j observées et N (i) =
X
N (i, j) le nombre de
j∈E
passages en i observés. Cet estimateur est convergent, i.e. P̂ (i, j) converge vers P (i, j) quand le
nombre de pas observés tend vers l’infini.
Exemple Reprenons l’exemple et les notations de la section 5.1.2. Soit j0 un état absorbant,
et h la fonction définie sur l’espace d’états par h(i) = Pi (XT = j0 ). On peut montrer que la
63
chaîne conditionnée à être absorbée en j0 est une chaîne de Markov de probabilité de transition
Ph définie par
P (i, j)h(j)
Ph (i, j) =
h(i)
pour tout état transient i. On souhaite vérifier ce résultat par la simulation.
r=2;//nombre d’états absorbants
s=3;//nombre d’états transients
P=genmarkov(ones(1,r),s);
Q=P(r+1:$,r+1:$);
R=P(r+1:$,1:r);
h=[1;0;(eye(Q)-Q)\(R*[1;0])];
Ph=P;
for i=r+1:r+s
for j=1:r+s
Ph(i,j)=Ph(i,j)*h(j)/h(i);
end;
end;
nbsimul=10000;
x=grand(20,’markov’,P,(r+s)*ones(1,nbsimul));
ind1=find(x(:,$)==1);
x1=x(ind1,:);
i=r+1;
ni=sum(x1(:,1:$-1)==i);
ni1=sum(x1(:,1:$-1)==i&x1(:,2:$)==1);
ni1/ni
Ph(i,1)
Exercice 5.2. Retournement du temps. Générer une matrice de transition aléatoire P pour une chaîne
de Markov Xk irréductible d’espace d’états à 5 éléments. Simuler un nombre n suffisant de pas de cette
chaîne de Markov. Estimer,
P
Pn pour tout couple (i, j) d’états la fréquence Q̃(i, j) = N (i, j)/N (i) (où N (i) =
n
1
,
N
(i,
j)
=
k=2 Xk =i
k=2 1Xk =i,Xk−1 =j ) du nombre de passages de i en j du processus retourné Xn−k
P (j, i)π(i)
, où π
(k = 0, . . . , n − 1). Comparer la matrice Q̃ à la matrice Q de terme général Q(i, j) =
π(j)
est la loi stationnaire de la chaîne initiale. Montrer que Q est la matrice de transition d’une chaîne de
Markov irréductible. Déterminer la loi stationnaire de cette chaîne de Markov.
5.2
Exemples
Dans beaucoup de cas, le mécanisme de transition d’une chaîne de Markov permet de simuler directement cette chaîne sans avoir à expliciter sa matrice de transition, ce qui permet en
particulier de simuler des chaînes d’espace d’états dénombrable.
5.2.1
Le modèle d’urne d’Ehrenfest
Les lois de la mécanique classique sont réversibles : un système confiné finira toujours par revenir
à un état proche de son état initial. Or la thermodynamique des particules semble montrer un
phénomène diamétralement opposé : un système tend toujours de manière irréversible vers un
état d’équilibre. Pour tenter d’expliquer cet apparent paradoxe, les physiciens Paul et Tatiana
Ehrenfest ont introduit un modèle d’urne très simple qui porte leur nom. Le modèle physique
est le suivant : on considère une enceinte confinée séparée en deux compartiments et contenant
N = 2L particules. A l’instant initial, toutes les particules sont dans l’un des compartiments.
64
Elles diffusent ensuite à travers la paroi séparant les compartiments de manière à se répartir
entre les deux. Le modèle d’urne associé consiste en deux urnes contenant N boules. A l’instant
initial, toutes les boules se trouvent dans l’une des urnes. A chaque unité de temps, on tire au
hasard une des N boules et on la change d’urne.
5.2.1.1
Le modèle microscopique
Dans cette description, on considère que toutes les particules (ou les boules) sont discernables.
Le système est alors représenté par l’espace d’états E = (Z/2Z)N , où la k-ième coordonnée
représente la position de la k-ième particule, 0̄ représentant un des compartiments et 1̄ l’autre.
Changer la k-ième particule de compartiment consiste à ajouter à l’état Xn du système à l’instant
n le vecteur (0, . . . , 1̄, . . . , 0), où 1̄ est situé à la k-ième position. Tirer une particule au hasard
avec équiprobabilité et la changer d’urne revient donc à ajouter à Xn une variable aléatoire de
loi uniforme sur l’ensemble E1 des vecteurs ayant exactement une coordonnée non nulle. La suite
(Xn )n∈N n’est autre qu’une marche aléatoire sur E, la loi de chaque pas étant la loi uniforme sur
E1 . On peut aussi représenter les éléments de E comme les sommets d’un graphe, deux points
étant voisins sur ce graphe si et seulement si ils diffèrent en exactement une coordonnée. La
chaîne est alors la marche aléatoire simple sur ce graphe.
5.2.1.2
Le modèle macroscopique
On suppose cette fois les particules indiscernables. L’état du système est alors représenté par le
nombre de particules dans chacun des deux compartiments. On choisit donc cette fois pour E
l’intervalle d’entiers {0, 1, . . . , N }, l’état Yn du système à l’instant n étant le nombre de particules
dans le compartiment initialement vide. La matrice de transition est cette fois donnée par P (i, i−
i
N −i
1) = , P (i, i + 1) =
pour tout i ∈ {0, 1, . . . , N }. Cette chaîne de Markov est récurrente :
N
N
elle revient indéfiniment à son état initial, mais l’espérance du temps de retour est telle que ce
retour est physiquement inobservable. En pratique, le système se rapproche très vite de l’équilibre,
et semble ensuite osciller très peu autour de sa position d’équilibre.
5.2.1.3
Simulations
On commence par représenter graphiquement pour diverses valeurs de N (par exemple N =
20, 50, 1000) une trajectoire du nombre Yn de particules dans le compartiment initialement vide
en utilisant le modèle microscopique.
N=50;n=1000;
x=zeros(1,N);
y=zeros(1,n);
for k=1:n-1
i=ceil(N*rand());
x(i)=1-x(i);
y(k+1)=y(k)+2*x(i)-1;
end;
plot(y)
On constate que le nombre de particules dans le compartiment initialement vide commence par
croître, puis se met à osciller autour de la valeur moyenne N/2.
On peut également utiliser ce modèle pour simuler la loi du temps d’atteinte de cette valeur
moyenne (N/2 particules dans chaque compartiment) et évaluer l’espérance de ce temps :
nbsimul=10000;t=zeros(1,nbsimul);
for j=1:nbsimul,
65
x=zeros(1:N);
k=0;y=0;
while y<N/2
i=ceil(N*rand());
x(i)=1-x(i);
y=y+2*x(i)-1;
k=k+1;
end;
t(j)=k;
end;
histplot(20,t);
mean(t)
On peut en fait donner une formule exacte pour l’espérance de ce temps d’atteinte en utilisant
le modèle macroscopique. Entrons d’abord la matrice de transition de cette chaîne de Markov :
function P=ehrenfest(N)
d1=(N-(0:N-1))/N;
d2=(1:N)/N;
P=diag(d1,1)+diag(d2,-1);
endfunction;
On peut alors utiliser la commande grand pour simuler cette chaîne de Markov et reprendre les
simulations précédentes :
P=ehrenfest(N);
nbsimul=10000;nmax=200;
y=grand(nmax,’markov’,P,ones(1,nbsimul));
t=zeros(nbsimul);
for k=1:nbsimul
t(k)=min(find(y(k,:)==N/2+1));
end;
sum(t==0)//nombre de simulations n’ayant pas atteint N/2
t(t==0)=nmax;
mean(t)
xbasc();histplot(20,t)
On peut aussi déterminer l’espérance du temps d’atteinte de N/2 en utilisant la matrice P (cf
5.1.2) :
Q=P(1:N/2,1:N/2);
temps=sum((eye(Q)-Q)^(-1),’c’);
On vérifie aisément que la loi stationnaire π du processus est la loi binomiale de paramètres N
et 0.5 :
pi1=eigenmarkov(P);
pi2=binomial(0.5,N);
norm(pi1-pi2)
On peut alors vérifier le théorème ergodique pour cette chaîne de Markov :
n
pour tout i = 0, . . . , N,
1X
lim
1i (Yk ) = π(i)
n→∞ n
k=1
66
presque sûrement.
nbpas=1e6;
x=grand(nbpas,’markov’,P,1);
histplot(0.5:N+1.5,x,style=2);
p=binomial(0.5,N);
plot2d3(1:N+1,p,style=5);
Par contre la loi de Yn ne converge pas vers la loi stationnaire : en effet la chaîne est périodique
de période 2 et Yn a toujours la parité de n. Une façon d’éliminer cette périodicité est de
considérer la chaîne Ỹn de matrice de transition Pα = αIN + (1 − α)P , où α ∈]0, 1[. Cette
chaîne a les mêmes transitions que la chaîne initiale, mais à chaque pas elle reste sur place avec
une probabilité α. Elle admet la même loi stationnaire que la chaîne initiale mais n’est plus
périodique. On constate que la loi de Ỹn converge vers la loi stationnaire :
0.12
alpha=0.1;
Palpha=(1-alpha)*P+alpha*eye(P);
nbsimul=10000;n=200;
y1=grand(n,’markov’,Palpha,ones(1,nbsimul));
histplot(-0.5:N+0.5,y1(:,$)-1)
plot2d2(-0.5:N+0.5,[pi2,0],style=5)
0.10
0.08
0.06
0.04
0.02
0.00
0
5
10
15
20
25
30
35
40
45
50
L’espérance du temps de retour Ei (Ri ) en i est l’inverse de π(i). On peut vérifier ce résultat en
prenant N pas trop grand et une situation initiale où toutes les particules sont situées dans un
même compartiment. Dans ce cas E0 (R0 ) = 2N est aussi l’espérance du temps d’atteinte de 0
en partant de 1 augmenté d’une unité :
N=20;
P=ehrenfest(N);
Q=P(2:$,2:$);
Q1=inv(eye(Q)-Q);
t1=1+sum(Q1(1,:))
t2=2^N
5.2.2
Le modèle de Wright-Fisher
Une population de taille constante N évolue sans mutation au cours du temps. Les individus
sont de deux types, A et B. La génération initiale comporte m individus du type A et N − m
individus du type B. Chaque individu de la (n + 1)-ième génération a un parent tiré au sort
avec équiprobabilité parmi les N individus de la génération précédente et hérite du type de
son unique parent. Tous les tirages sont supposés indépendants, de sorte que le nombre Xn
d’individus de type A dans la n-ième génération suit, conditionnellement à Xn−1 , la loi binomiale
de paramètres N et Xn−1 /N . Il en résulte que (Xn )n∈N est une chaîne de Markov d’espace d’états
E = {0, . . . , N }, d’état initial X0 = m et de matrice de transition :
j N
i
N − i N −j
P (i, j) =
j
N
N
pour tout (i, j) ∈ E × E .
Les deux états 0 et N sont absorbants pour cette chaîne de Markov, et les autres états communiquent tous entre eux. Il en résulte que Xn converge presque sûrement vers 0 ou N . Plus
précisément, (Xn )n∈N est une martingale bornée qui converge presque sûrement vers l’un de ces
deux états. Il en résulte que E(XT ) = X0 = m, où T est le temps de fixation de la chaîne, i.e.
T = inf{n ≥ 0 | Xn = 0 ou N }. La probabilité de fixation en N est donc P(XT = N ) = m/N et
67
celle de fixation en 0 est P(XT = 0) = 1 − m/N .
Vérifions-le par simulation. On commence par entrer la matrice de transition :
n=20;N=2*n;
P=zeros(N+1,N+1);
for i=0:N
P(i+1,:)=binomial(i/N,N);
end;
et par représenter graphiquement quelques trajectoires de la chaîne :
nbsimul=6;
genmax=300;
for k=1:nbsimul
x=grand(genmax,’markov’,P,n+1);
ind=min(find(x==1|x==N+1));
plot2d(0:ind,[n,x(1:ind)-1],style=k);
end;
On effectue ensuite un plus grand nombre de simulations pour tester la probabilité de fixation
en l’un ou l’autre des états ainsi que la loi du temps de fixation :
nbsimul=10000;
x=grand(genmax,’markov’,P,(n/2+1)*ones(1,nbsimul));
//initialement 10 individus de type A
temps=sum(x>1&x<N+1,’c’)+1;//temps de fixation empiriques
f0=sum(x(:,$)==1)/nbsimul;//fréquence de fixation en 0
disp(’fréquence de fixation en 0: ’+string(f0));
xbasc();histplot(20,temps);
On peut alors comparer la loi empirique du temps de fixation à sa loi théorique :
Q=P(2:$-1,2:$-1);R=eye(Q)-Q;
tmax=max(temps);
tempsth=zeros(1,tmax);
for k=1:tmax,
tempsth(k)=sum(R(n/2,:));
R=Q*R;
end;
plot2d(1:tmax,tempsth,style=5);
Exercice 5.3. Processus généalogique associé
Déterminer la probabilité que deux individus donnés de la n-ième génération aient un parent commun,
puis la probabilité qu’ils aient un ancêtre commun. Simuler la loi du nombre d’individus de la génération
initiale ayant un descendant à la n-ième génération. Evaluer par simulation le temps d’apparition
dans le passé de l’ancêtre commun le plus récent de la génération actuelle. Représenter graphiquement
l’évolution dans le temps du nombre d’ancêtres de cette génération.
Exercice 5.4. Chaîne conditionnée
On s’intéresse à la chaîne conditionnée à se fixer en 0. On peut montrer que le processus ainsi conditionné
est encore une chaîne de Markov et qu’on peut le décrire de la façon suivante : chaque individu sauf un
choisit son parent de la même manière que précédemment, le dernier parent étant systématiquement de
type B. Vérifier par la simulation que ce modèle équivaut bien à la chaîne conditionnée.
68
5.2.3
Le processus de Galton-Watson
On étudie l’évolution d’une population au cours du temps. On note Zn la taille de cette
population à la n-ième génération et on suppose que la génération initiale comporte un seul
individu, de sorte que Z0 = 0. Tout individu a un nombre aléatoire de descendants, et on
suppose tous ces nombres indépendants et équidistribués. Pour modéliser cette situation, on
(i)
introduit une famille (Xn )n≥0,i≥1 de variables aléatoires indépendantes et équidistribuées à
(i)
valeurs dans N : Xn sera le nombre de descendants du i-ième individu de la n-ième génération,
P n (i)
(i)
si cet individu existe. On a donc : Zn+1 = Z
i=1 Xn . On suppose les variables aléatoires Xn
intégrables, on note m leur espérance et g leur fonction génératrice. On s’intéresse en particulier
à la probabilité d’extinction q de la population, i.e. la probabilité q = P(T < +∞) que l’instant
d’extinction T de la population, défini par T = inf{n ∈ N | Zn = 0}, soit fini.
On remarque d’abord que l’événement {T < +∞} est la réunion croissante de la suite d’événements {Zn = 0}. Il en résulte que q est la limite de la suite croissante P(Zn = 0) = gn (0), où gn
est la fonction génératrice de Zn . On a g0 (s) = s, g1 = g et la relation E(sZn+1 | Zn ) = g(s)Zn
implique gn+1 (s) = gn (g(s)) pour tout n ≥ 0 et tout s ∈ [0, 1], d’où aussi gn+1 (s) = g(gn (s)).
On en déduit que q est la plus petite solution dans [0, 1] de l’équation g(s) = s. Cette solution
vaut 1 si m < 1 (cas sous-critique) ou m = 1 et g(s) 6= s (cas critique). Elle appartient à [0, 1[
sinon (cas surcritique).
Si la population initiale comporte k individus, i.e. Z0 = k, la probabilité d’extinction de la
population est égale à q k .
Le programme ci-dessous représente 10 trajectoires du processus Zn :
loi=[0.5 0.2 0.1 0.2]’;nbsimul=10;nmax=100;
for k=1:nbsimul
z=1;nbgen=0;
while z($)>0&z($)<nmax
z=[z,(0:length(loi)-1)*grand(1,’mul’,z($),loi(1:$-1))];
nbgen=nbgen+1;
end;
plot2d(0:nbgen,z,style=k);
end;
On peut également simuler un grand nombre de réalisations de ce processus pour évaluer empiriquement la probabilité d’extinction, puis calculer la probabilité théorique d’extinction et tracer
le graphe sur [0, 1] de la fonction génératrice :
loi=[0.3 0.2 0.3 0.2]’;nbsimul=10000;nmax=100;
//probabilite d’extinction empirique (cas surcritique)
results=zeros(1,nbsimul);
for k=1:nbsimul
z=1;
while z>0&z<nmax
z=(0:length(loi)-1)*grand(1,’mul’,z,loi(1:$-1));
end;
if z==0 then results(k)=1;end;
end;
disp(’probabilite empirique d’’extinction: ’+..
string(sum(results)/nbsimul));
function y=g(s) //fonction generatrice de la loi de reproduction
69
y=loi’*s.^(0:length(loi)-1)’;
endfunction;
function y=h(s)
y=g(s)-s;
endfunction;
// h(s)=g(s)-s
q=fsolve(0,h);
disp(’probabilite theorique d’’extinction: ’+..
string(q));
t=linspace(0,1);
plot(t,g,’b’);
plot([0 1],[0 1],’r’);
probabilite empirique d’extinction: 0.5014
probabilite theorique d’extinction: 0.5
Zn
On vérifie facilement que la suite Wn = n est une martingale positive. Elle converge donc
m
presque sûrement, ce que l’on peut vérifier graphiquement dans le cas surcritique :
loi=[0.4 0.1 0.5]’;nbsimul=10;nmax=100;
//trajectoires du processus normalisé (cas surcritique)
m=(0:length(loi)-1)*loi;
trajectoires=zeros(nbsimul,nmax);
for k=1:nbsimul
z=1;
for n=1:nmax-1
if z>0 then
z=(0:length(loi)-1)*grand(1,’mul’,z,loi(1:$-1));
trajectoires(k,n+1)=z/m^n;
else break;
end;
end;
end;
plot2d(0:nmax,[zeros(1,nbsimul);trajectoires’])
14
12
10
8
6
4
2
0
0
10
20
30
40
50
60
70
80
90
100
Exercice 5.5. Population totale d’un processus de Galton-Watson.
T
−1
∞
X
X
Zn la population totale d’un processus de Galton-Watson et h sa fonction
Zn =
Soit Y =
n=0
n=0
70
génératrice. La variable aléatoire Y est finie si et seulement si T l’est et son espérance est, si m < 1,
∞
X
1
la somme
E(Zn ). La fonction génératrice h(s) = E(sY ) de Y vérifie, pour tout
de la série
1−m
n=0
s ∈ [0, 1], h(s) = sg(h(s)) (conditionner par rapport à la taille Z1 de la génération à l’instant 1). C’est
s
donc la fonction réciproque de la fonction s →
.
g(s)
1) Expliciter cette solution dans le cas où p0 + p2 = 1. En déduire dans ce cas la loi de Y . Montrer que
cette loi est celle du temps d’atteinte de 1 par la marche aléatoire simple sur Z de paramètre p = p0 .
Vérifier ce résultat par la simulation.
2) Dans le cas où la loi du nombre de descendants est la loi de Poisson de paramètre θ < 1, on montre
k k−1
pour k ≥ 1. Vérifier ce
que la loi de Y est la loi de Borel de paramètre θ sur N∗ : P(Y = k) = e−kθ
k!
résultat par simulation.
3) Dans le cas où le nombre de descendants est borné, déterminer numériquement la loi de la population
totale. Vérifier ce calcul par simulation.
5.2.4
L’urne de Polya
Une urne contient des boules noires et des boules blanches. On effectue une suite de tirages
dans cette urne de la façon suivante : à chaque tirage, on tire une boule avec équiprobabilité, on
regarde sa couleur, on la remet dans l’urne et on y rajoute une boule de la même couleur. On
note Nk (resp. Bk ) le nombre de boules noires (resp. blanches) dans l’urne après k tirages, et
Bk
la proportion de boules blanches après ces k tirages.
Xk =
Bk + N k
La loi conditionnelle de (Bk+1 , Nk+1 ) sachant (Bk , Nk ) est donnée par :
b
b+n
n
.
= Nk + 1 | Bk = b, Nk = n) =
b+n
P(Bk+1 = Bk + 1, Nk+1 = Nk | Bk = b, Nk = n) =
P(Bk+1 = Bk , Nk+1
Il en résulte que (Xk )k∈N est une martingale positive, qui converge donc presque sûrement. La
loi de la limite sous les conditions initiales B0 = i, N0 = j est
la loi bêta B(i, j).
En particulier
1
k+1
pour B0 = N0 = 1, Xk suit pour tout k l’équiprobabilité sur
,...,
; sa limite suit
k+2
k+2
donc la loi uniforme sur [0, 1]. On peut vérifier ces résultats par la simulation. Commençons par
représenter quelques trajectoires :
nbsimul=10;
nbpas=100;
for k=1:nbsimul
b=ones(1,nbpas);
for i=1:nbpas-1
if rand()<b(i)/(i+1) then b(i+1)=b(i)+1;
else b(i+1)=b(i);
end;
end;
plot2d(0:nbpas-1,b./(2:nbpas+1),style=k);
end;
71
Urne de Polya : b0=2, n0=4
1.0
2.5
0.9
2.0
0.8
0.7
1.5
0.6
0.5
1.0
0.4
0.3
0.5
0.2
0.1
0.0
0
10
20
30
40
50
60
70
80
90
100
0.0
0.1
0.2
0.3
0.4
0.5
0.6
Vérifions maintenant que la loi de X1000 approche bien la loi bêta :
nbsimul=10000;
nbpas=1000;
b0=input("Nombre de boules blanches");
n0=input("Nombre de boules noires");
b=b0*ones(nbsimul,1);
for i=1:nbpas
r=rand(nbsimul,1);
ind=find(r<b/(i+n0+b0-1));
b(ind)=b(ind)+1;
end;
xbasc();
histplot(0:0.02:1,b/(b0+n0+nbpas))
t=0:0.005:1;
F=cdfbet(’PQ’,t,1-t,b0*ones(t),n0*ones(t));
f=(F(2:$)-F(1:$-1))/0.005;
plot((t(1:$-1)+t(2:$))/2,f,’r’);
xtitle(’Urne de Polya : b0=’+string(b0)’+’, n0=’+string(n0));
72
0.7
0.8
0.9
1.0
Chapitre 6
Processus à temps continu
6.1
Le processus de Poisson
On appelle processus de Poisson d’intensité λ le processus de comptage associé à la suite
(Sn )n∈N∗ des sommes partielles d’une suite (Xn )n∈N∗ de variables aléatoires indépendantes suivant toutes la même loi exponentielle de paramètre λ > 0 :
Nt =
∞
X
n=1
où Sn =
1Sn ≤t
pour tout t ≥ 0 ,
Pn
k=1 Xk .
Exercice 6.1. Loi de Sn : Montrer que pour tout n ≥ 1, Sn suit la loi gamma de paramètres n et λ,
c’est-à-dire la loi de densité :
e−λs λn sn−1
fSn (s) = 1[0,+∞[ (s)
.
(n − 1)!
On peut commencer par représenter une trajectoire de ce processus :
//processus de Poisson d’intensité lambda
n=10;lambda=2;
S=[0,cumsum(grand(1,n,’exp’,1/lambda))];
plot2d2(S,0:n,style=2)
Le processus de Poisson tire son nom de ce que la loi de Nt est la loi de Poisson de paramètre
λt, ce que l’on vérifie facilement :
nbsimul=10000;
lambda=2;t=10;
S=cumsum(grand(nbsimul,50,’exp’,1/lambda),’c’);
Nt=sum(S<t,’c’);
//vérification que S_50>t pour toutes les simulations
sum(S(:,$)<t)
histplot(-0.5:50.5,Nt,style=2);
y=cdfpoi(’PQ’,0:50,t*lambda*ones(1,51));
plot2d3(0:50,y-[0,y(1:$-1)],style=5)
Exercice 6.2. Effectuer un test du χ2 pour vérifier l’adéquation de la loi empirique de Nt à la loi de
Poisson.
Le processus de Poisson est un processus à accroissements indépendants et stationnaires (ses accroissements sur des intervalles de temps disjoints sont indépendants et leurs lois sont invariantes
par translation du temps). Plus précisément :
73
Théorème : Soient N un processus de Poisson de paramètre λ et 0 = t0 < t1 < t2 < · · · < tp
des réels. Alors les variables aléatoires Nt1 , Nt2 − Nt1 , . . . , Ntp − Ntp−1 sont indépendantes et
suivent des lois de Poisson de paramètres respectifs λt1 , λ(t2 − t1 ), . . . , λ(tp − tp−1 ) :
p
Y
(λ(tk − tk−1 ))nk
e−λ(tk −tk−1 )
P Nt1 = n1 , Nt2 − Nt1 = n2 , . . . , Ntp − Ntp−1 = np =
.
nk !
k=1
Exercice 6.3. Vérifier que les accroissements de Nt sur deux intervalles de temps disjoints ne sont pas
corrélés.
6.1.1
Âge et durée de vie résiduelle
Pour tout réel t, on a SNt ≤ t < SNt +1 . On définit des variables aléatoires réelles positives Ut et
Vt (t ∈ [0, +∞[) par Ut = t − SNt et Vt = SNt +1 − t. Si la suite (Sn )n∈N représente les instants
où l’on change un composant, Ut représente donc l’âge du composant en place à l’instant t et Vt
sa durée de vie résiduelle. On démontre le résultat suivant :
Proposition : Pour tout réel t ≥ 0, les variables aléatoires Ut et Vt sont indépendantes. La loi
de Ut est celle de X1 ∧ t et celle de Vt est égale à celle de X1 (c’est-à-dire la loi exponentielle de
paramètre λ).
2 − e−λt
, qui
En particulier l’espérance de la longueur de l’intervalle [SNt , SNt +1 ] est égale à
λ
2
tend très vite vers , alors que l’espérance de la longueur de chaque intervalle inter-arrivées Xk
λ
1
est (ce qu’on appelle parfois paradoxe de l’inspection).
λ
Exercice 6.4. Vérifier par la simulation cette propriété.
6.1.2
Loi conditionnelle des instants d’arrivées
Une autre modélisation possible du processus de Poisson repose sur la propriété suivante :
Proposition : La variable aléatoire (S1 , . . . , Sn ) des instants successifs d’arrivées a, conditionnellement à Nt = n, la même loi que la statistique d’ordre (U1∗ , . . . , Un∗ ) obtenue en ordonnant
par ordre croissant une suite (Uk )k=1,...,n de variables aléatoires indépendantes équidistribuées
de loi uniforme sur [0, t] :
{U1∗ , . . . , Un∗ } = {U1 , . . . , Un }
et
U1∗ < · · · < Un∗ .
On peut utiliser cette propriété pour simuler une trajectoire du processus de Poisson sur un
intervalle de temps de longueur donnée :
lambda=2;t=10;
nt=grand(1,1,’poi’,t*lambda);
S=gsort(t*rand(1,nt),’g’,’i’);
plot2d2([0,S],0:nt);
Exercice 6.5. Vérifier sur ce modèle le caractère exponentiel des temps inter-arrivées.
74
6.1.3
Superposition et décomposition de processus de Poisson
Proposition : Soient (Mt )t≥0 et (Nt )t≥0 deux processus de Poisson indépendants d’intensités respectives λ et µ. Alors le processus (Mt +Nt )t≥0 est un processus de Poisson d’intensité λ+µ.
Exercice 6.6. Vérifier que les temps inter-arrivées du processus (Mt + Nt )t≥0 sont bien exponentiels de
paramètre λ + µ.
Proposition : Soient (Mt )t≥0 un processus de Poisson d’intensité λ et (Yn )n≥1 une suite i.i.d.
de variables aléatoires à valeurs dans {1, . . . m} de loi commune {p1 , . . . , pm } indépendante du
∞
X
(i)
(i)
1Sn ≤t 1Yn =i , où (Sn )n≥1
processus (Mt )t≥0 . On définit m processus (Mt )t≥0 par Mt =
n=1
(i)
est la suite des temps d’arrivée du processus (Mt )t≥0 . Alors les m processus (Mt )t≥0 sont des
processus de Poisson indépendants d’intensités respectives λpi .
Exercice 6.7. Vérifier ce résultat par la simulation.
6.1.4
Processus de Poisson composé
Soit λ un réel positif et µ une loi de probabilité sur R. On appelle processus de Poisson composé
d’intensité λ et de loi de sauts µ le processus (Zt )t≥0 défini par
Zt =
∞
X
1Sn ≤t Yn
n=1
où (Sn )n≥1 est la suite des temps d’arrivée d’un processus de Poisson (Mt )t≥0 d’intensité λ et
(Yn )n≥1 une suite i.i.d. de variables aléatoires réelles de loi µ indépendante de (Mt )t≥0 .
Les trajectoires d’un tel processus se représentent aisément :
//processus de Poisson composé à loi de sauts gaussienne
n=50;lambda=2;
S=[0,cumsum(grand(1,n,’exp’,1/lambda))];
Z=[0,cumsum(grand(1,n,’nor’,0.5,1))];
plot2d2(S,Z,style=2)
Exercice 6.8. Vérifier par la simulation que l’espérance et la variance de Zt valent respectivement λtm
et λt(σ 2 + m2 ), où m et σ sont l’espérance et l’écart-type des variables aléatoires Yn .
6.1.5
Processus de Poisson non homogène
Soit λ une fonction mesurable positive sur [0, +∞[ intégrable sur tout compact. On appelle
processus de Poisson d’intensité λ tout processus (Nt )Rt≥0 à accroissements indépendants tel que
t
la loi de Nt − Ns soit la loi de Poisson de paramètre s λ(u) du pour tout couple s < t.
Un tel processus peut se simuler par effacement à partir d’un processus de Poisson homogène
(i.e. d’intensité constante). Supposons pour cela λ majorée par une constante Λ. Soit (Mt )t≥0 un
processus de Poisson d’intensité Λ et (Nt )t≥0 le processus obtenu en gardant le n-ième saut de
λ(Sn )
(Mt )t≥0 avec probabilité
, où Sn est l’instant de ce n-ième saut. En formule :
Λ
Nt =
∞
X
1Sn ≤t 1U
n=1
n≤
λ(Sn )
Λ
où (Un )n≥1 est une suite i.i.d. de variables aléatoires uniformes sur [0, 1] indépendante du
processus (Mt )t≥0 . On montre alors que le processus (Nt )t≥0 est un processus de Poisson
75
d’intensité λ.
Exercice 6.9. Simuler par effacement un processus de Poisson (Nt )t≥0 d’intensité λ(t) = 50(1+cos(2πt)).
Vérifier que les accroissements ∆s,t = Nt − Ns de ce processus suivent des lois de Poisson de paramètres
Rt
m(t) − m(s) = s λ(u) du.
6.1.6
Processus de Poisson dans le plan :
Soit D = [a, b] × [c, d] un rectangle, λ > 0 un réel, N une variable aléatoire suivant la loi de
Poisson de paramètre λ(b − a)(d − c) et (Xn )n∈N∗ une suite indépendante équidistribuée de
variables aléatoires de loi uniforme dans D indépendante de N . Pour tout borélien B de D, on
définit une variable aléatoire NB à valeurs entières par :
NB =
N
X
1B (Xk ) .
k=1
On montre alors que pour toute partition D = B1 ∪ B2 ∪ · · · ∪ Bp de D par des boréliens,
les variables aléatoires NB1 , . . . , NBp sont indépendantes et suivent des lois de Poisson de
paramètres λµ(B1 ), . . . , λµ(Bp ), où µ désigne la mesure de Lebesgue sur R2 .
Exercice 6.10. Simuler un processus de Poisson de paramètre λ = 100 dans le carré D = [0, 1] × [0, 1].
Vérifier que les variables aléatoires N1 et N2 égales au nombre de points du processus appartenant aux
domaines D1 et D2 , où D1 est le disque de centre (0.2, 0.6) et de rayon 0.2 et D2 le triangle défini par
y ≤ x, sont non corrélées et suivent les lois de Poisson de paramètres respectifs 4π et 50.
Exercice 6.11. Un modèle écologique
1) On étudie une population de plantes qui évolue d’année en année. On suppose qu’initialement ces
plantes sont distribuées dans le plan suivant un processus de Poisson d’intensité constante λ. À la génération suivante, chacune de ces plantes a un descendant situé à la position x + D(x) si la plante initiale
est située en x ∈ R2 , où les variables aléatoires D(x) (x ∈ R2 ) représentant les déplacements des plantes
relativement à leur parent sont supposées indépendantes équidistribuées et indépendantes du processus
de Poisson initial. Montrer que la distribution des plantes reste constante au fil des années. Tester ce
résultat par la simulation.
2) On suppose maintenant que chaque plante a un nombre aléatoire de descendants suivant une loi de
Poisson de paramètre α, chacun de ces descendants subissant un déplacement lui-même aléatoire. Tous
ces déplacements sont supposés indépendants et indépendants de la position initiale et du nombre de descendants de chaque plante. Montrer que la famille des déplacements des descendants d’une même plante
constitue un processus de Poisson plan dont on précisera l’intensité en fonction de α et de la loi des
déplacements. Tester par la simulation la nature poissonienne du processus des localisations des plantes
de la seconde génération. On pourra supposer les déplacements bornés (par exemple de loi uniforme sur
un disque centré en la position de la plante parente) et on étudiera l’indépendance du nombre de plantes
de seconde génération dans deux domaines contigus du plan.
Exercice 6.12. On se propose de tirer au hasard une famille de droites dans le plan. On représente pour
cela toute droite D par son équation normale x cos θ + y sin θ − p = 0, où θ ∈ [0, 2π[ est l’angle polaire
de la normale à D et p > 0 la distance de l’origine à D. On suppose que les points (p, θ) associés à la
famille de droites aléatoires constituent une réalisation d’un processus de Poisson d’intensité constante λ
sur [0, +∞[×[0, 2π[.
1) Représenter l’intersection du carré [−A, +A]2 , où A est un réel donné, avec les droites de ce processus.
2) On peut montrer que la loi de cette famille de droites est invariante par toutes les isométries du plan.
Vérifier que les distances d’un point fixé du plan à cette famille de droites constituent bien une réalisation
d’un processus de Poisson sur [0, +∞[ et préciser l’intensité de ce processus.
76
6.2
6.2.1
Processus markoviens de sauts
Définition et propriétés
Un processus à temps continu (Xt )t≥0 à valeurs dans un espace fini ou dénombrable E est un
processus de sauts s’il existe une suite strictement croissante (Tn )n≥1 tendant vers l’infini d’instants aléatoires (les instants de sauts) tels que Xt soit constant sur chaque intervalle [Tn , Tn+1 [
et vérifie XTn+1 6= XTn pour tout n ≥ 0 (en posant T0 = 0).
Un processus de sauts est markovien si, pour tout t ≥ 0, la loi conditionnelle du futur (Xs )s≥t
du processus sachant tout son passé (Xs )0≤s≤t est égale à la loi conditionnelle du futur (Xs )s≥t
sachant Xt .
Un processus markovien de sauts peut se décrire de la façon suivante : si à l’issue du saut intervenu à l’instant Tn , le processus se trouve en un état x de E, il reste en x pendant un temps
aléatoire Tn+1 − Tn suivant une loi exponentielle de paramètre λ(x) (dépendant de x) et indépendant de son passé ; à l’instant Tn+1 , il saute de l’état x en un état y avec une probabilité p(x, y)
indépendante de tout son passé (y compris la durée de séjour Tn+1 − Tn en x). La matrice P
est donc la matrice de transition d’une chaîne de Markov à temps discret d’espace d’états E de
diagonale nulle. La chaîne de Markov (XTn )n≥0 est appelée chaîne incluse du processus (Xt )t≥0 .
Les probabilités de transition du processus (Xt )t≥0 sont définies par :
Pt (x, y) = P(Xt = y | X0 = x) = P(Xs+t = y | Xs = x)
pour tout (x, y) ∈ E × E et tout (s, t) ∈ [0, +∞[2 .
Ces probabilités de transition forment un semi-groupe : Pt+s = Pt Ps pour tout (s, t) ∈ [0, +∞[2
et les fonctions t 7→ Pt (x, y) sont dérivables à droite en tout point. La matrice Q dérivée à droite
en 0 de Pt , de coefficients :
(
λ(x)p(x, y) si x 6= y
Pt (x, y) − δx,y
q(x, y) = lim
=
t→0+
t
−λ(x)
si x = y
est appelée générateur du processus. Tous les coefficients hors de la diagonale de la matrice Q
sont positifs ou nuls, et la somme des coefficients d’une ligne est toujours nulle.
Les coefficients q(x, y) représentent les intensités de saut du processus :
P(Xt = y | X0 = x) = q(x, y)t + o(t)
pour tout y 6= x
et :
P(Xt = x | X0 = x) = 1 + q(x, x)t + o(t) = 1 − λ(x)t + o(t) .
Le semi-groupe (Pt )t≥0 vérifie les équations de Kolmogorov :
dPt
= Pt Q = QPt
dt
pour tout t ≥ 0 ,
dPt
désigne la dérivée à droite de Pt au point t.
dt
En particulier, si E est fini, ces équations s’intègrent : Pt = etQ .
où
6.2.2
Lois stationnaires
Une loi de probabilité π sur E est dite stationnaire (ou invariante) si elle vérifie πPt = π pour
tout t ≥ 0, ou encore πQ = 0. Si X0 a pour loi une loi stationnaire π, la loi de Xt est égale à π
pour tout t ≥ 0.
Il n’existe pas toujours de loi stationnaire (le processus de Poisson fournit un exemple élémentaire), mais on montre que s’il existe une et si le processus est irréductible (tous les états
communiquent), alors :
77
– cette probabilité invariante est unique ;
– Pt (x, y) tend vers π(y) pour tout (x, y) ∈ E 2 (où π est la probabilité invariante) quand t tend
vers
Z l’infini ;
1 t
–
1Xs =y ds tend presque sûrement vers π(y) pour tout y ∈ E quand t tend vers l’infini, et
t 0
ce quelle que soit la loi de X0 (théorème ergodique).
6.2.3
Simulation par variables exponentielles
Une interprétation possible de l’évolution du processus est la suivante : quand le processus arrive
dans l’état x, un saut potentiel vers l’état y a lieu au bout d’un temps aléatoire de loi exponentielle
de paramètre q(x, y) (et donc d’espérance 1/q(x, y)), tous ces temps étant indépendants ; c’est
le premier de ces sauts qui se produit effectivement. La loi du temps de séjour en x est donc la
loi du minimum d’une famille de variables aléatoires exponentielles
X indépendantes de paramètres
q(x, y).
q(x, y) (y 6= x), i.e. la loi exponentielle de paramètre λ(x) =
y6=x
On peut remarquer que c’est ainsi que se présentent naturellement certains processus markoviens
de sauts (le processus de Poisson ou les files d’attente M/M/s). Le programme suivant utilise
cette représentation pour simuler une trajectoire d’un processus markovien de sauts de générateur
donné à valeurs dans un espace d’états fini :
function [etats,temps]=markov1(n,Q,x0)
//simulation de n sauts d’un processus de générateur Q
//état initial x0
//etats: les états visités (y compris l’état initial)
//temps: les temps de séjour dans ces états
etats=zeros(1,n+1);
temps=zeros(1,n);
m=size(Q,’c’);
etats(1)=x0;
ieee(2);//pour autoriser les divisions par 0
P=Q-diag(diag(Q));
for k=1:n
t=grand(1,m,’exp’,1)./P(etats(k),:);
[temps(k),etats(k+1)]=min(t);
end;
etats=etats(1:$-1);
ieee(0);
endfunction;
Cette méthode de simulation n’est en général pas la plus efficace du point de vue du temps de
calcul.
6.2.4
Simulation par la chaîne incluse
La simulation par la chaîne incluse se base sur la représentation suivante d’un processus markovien de sauts : si (Xn )n≥0 est une chaîne de Markov à temps discret de matrice de transition
P , et (Vn )n≥0 une suite i.i.d. de variables aléatoires exponentielles de paramètre 1, la suite des
temps
n
X
V (Xk )
Tn =
λ(Xk )
k=1
78
est la suite des instants de sauts d’un processus markovien de sauts visitant successivement les
états Xk .
Le programme suivant utilise cette représentation :
function [etats,temps]=markov2(n,Q,x0)
//simulation d’une trajectoire de longueur n issue de x0
//d’un processus markovien de sauts de générateur Q
//etats: les états visités, temps: les temps de séjour
lambda=-diag(Q);
P=Q+diag(lambda);
P=P./(lambda*ones(lambda’));//matrice de transition de la chaine incluse
etats=[x0,grand(n,’markov’,P,x0)];
temps=(grand(n+1,1,’exp’,1)./lambda(etats))’;
endfunction;
6.2.5
Simulation par la chaîne harmonisée
Une autre méthode de simulation consiste à utiliser la chaîne de Markov à temps discret de
1
matrice de transition R = I + Q, où Λ est un majorant de {λ(x) | x ∈ E} si λ est majorée
Λ
(ce qui est toujours le cas si E est fini). Cette matrice est bien la matrice de transition d’une
chaîne de Markov à temps discret d’espace d’états E (tous ses coefficients sont positifs et la
somme des coefficients de chaque ligne est égale à 1). On montre alors que si (Xn )n≥0 est une
chaîne de Markov à temps discret de matrice de transition R, (Vn )n≥0 une suite i.i.d. de variables
n
X
Vk
aléatoires exponentielles de paramètre 1, et Tn =
, le processus à temps continu égal à Xn
Λ
k=1
sur l’intervalle [Tn , Tn+1 [ est un processus markovien de sauts de générateur Q. Le programme
suivant utilise ce résultat pour simuler une trajectoire de ce processus :
function [etats,temps]=markov3(n,Q,x0)
//simulation d’une trajectoire de longueur n issue de x0
//d’un processus markovien de sauts de générateur Q
//etats: les états visités, temps: les temps de séjour
lambda=-diag(Q);
lambdamax=max(lambda);
R=eye(Q)+Q/lambdamax;
etats=[x0,grand(n,’markov’,R,x0)];
temps=grand(1,n+1,’exp’,1)/lambdamax;
endfunction;
Il faut remarquer que l’on n’obtient pas ainsi n sauts du processus, certains sauts de la chaîne
harmonisée étant fictifs : si l’on veut vraiment obtenir n sauts du processus à temps continu, il
faut simuler davantage de pas de la chaîne harmonisée. Cette méthode peut néanmoins se révéler
plus efficace numériquement que la précédente.
Un des avantages de la chaîne harmonisée est que sa loi stationnaire est aussi la loi stationnaire
du processus de sauts (ce qui n’est pas le cas pour la chaîne incluse, sauf si les intensités de
sauts λ(x) ne dépendent pas de x). La fonction suivante utilise cette remarque pour calculer la
loi stationnaire :
function pi=eigen(Q)
//loi stationnaire d’un processus markovien de saut de générateur Q
lambda=-diag(Q);
lambdamax=max(lambda);
79
P=eye(Q)+Q/lambdamax;
pi=eigenmarkov(P);
endfunction;
Exercice 6.13. Écrire une autre fonction (utilisant les fonctions d’algèbre linéaire de Scilab) pour calculer
la loi stationnaire d’un processus markovien de sauts de générateur donné.
Exercice 6.14. Tester les trois méthodes de simulation proposées pour un processus markovien de sauts
à deux états. Vérifier dans ce cas le théorème ergodique.
Exercice 6.15. Un système est constitué de trois composants A, B, C dont les durées de vie sont des
variables aléatoires X, Y , Z indépendantes de lois exponentielles de paramètres respectifs λ, µ, ν. Á
l’instant initial, les trois composants sont en état de marche. Une panne de C ou une panne simultanée
de A et B entraîne l’arrêt du système.
Proposer une modélisation du sytème par un processus de Markov homogène (on distinguera 4 états
pour le système, dont l’un absorbant). Écrire le générateur infinitésimal de ce processus. Écrire, puis
résoudre les équations de Kolmogorov associées. Simuler le fonctionnement d’un tel système et comparer
les probabilités de fonctionnement empiriques aux probabilités de fonctionnement calculées.
6.3
Files d’attente
Une file d’attente est constituée d’un ou plusieurs serveurs dans lesquels arrivent des clients
qui sont servis suivant certaines règles ou disciplines (le plus souvent : premier arrivé premier
servi, en anglais FIFO : first in first out, ou dernier arrivé premier servi, en anglais LIFO :
last in first out, mais il peut y en avoir d’autres...). Le flot d’arrivée des clients constitue un
processus de renouvellement à temps continu et les temps de service sont des variables aléatoires
indépendantes équidistribuées, indépendantes du processus des arrivées.
Nous considérerons d’abord des files d’attente à un seul serveur, où le premier arrivé est le premier
servi. Une telle file se note traditionnellement G/G/1, en utilisant les notations de Kendall.
Une file d’attente est représentée, dans ce système, par une suite de symboles A/S/P/..., où A
représente le type du processus d’arrivées, S la loi du temps de service, P le nombre de serveurs
et les points de suspension d’autres paramètres éventuels dont nous ne parlerons pas ; A et S
peuvent prendre par exemple les valeurs G (loi générale), D (loi déterministe, pour des temps qui
ne dépendent pas du hasard), M (pour Markov : loi exponentielle, ou sans mémoire). La chaîne
M/M/1 correspond par exemple à des temps inter-arrivées et de services exponentiels et à un
seul serveur.
6.3.1
La file d’attente G/G/1
On considère ici une file d’attente à un serveur. On note An (n ≥ 1) les instants d’arrivée des
clients et Yn = An − An−1 les temps inter-arrivées (en posant A0 = 0). Les variables aléatoires Yn
sont supposées indépendantes équidistribuées intégrables et on note 1/λ leur espérance commune.
Le temps de service du n-ième client est noté Sn . Les variables aléatoires Sn sont également
indépendantes équidistribuées, intégrables, indépendantes des instants d’arrivées, d’espérance
commune 1/µ. Ces notations s’expliquent : si les arrivées constituent un processus de Poisson,
λ
E(S1 )
λ en est le paramètre et représente l’intensité du flot d’arrivées. Le quotient ρ =
=
µ
E(Y1 )
s’appelle l’intensité de trafic. On note Nt le nombre de clients dans le système à l’instant t (c’està-dire le nombre de clients en attente ou en train d’être servis).
Le comportement asymptotique de la file dépend fortement de la valeur de ρ : si ρ > 1, il arrive en
moyenne plus de clients que l’on ne peut en servir ; le serveur va donc finir par se congestionner.
Au contraire, si ρ < 1, la file va presque sûrement finir par être vide à certains instants, comme
le montre la proposition suivante.
80
Proposition : Si l’intensité de trafic ρ est strictement plus petite que 1, la file se vide presque
sûrement une infinité de fois.
La fonction suivante prend en entrée les instants d’arrivées des clients et les durées de service
d’une file G/G/1 et retourne les instants où un événement (arrivée ou départ) se produit, ainsi
que le nombre de clients présents dans la file après chaque événement :
function [e,d,n]=GG1(a,s)
//file d’attente générale FIFO à un serveur
//a: vecteur ligne des instants d’arrivée
//s: vecteur ligne des temps de service
//(deux vecteurs de même longueur m)
//e: instants des événements (arrivées ou départs)
//d: vecteur ligne des instants de départs
//n: nombre de clients dans la file après chaque événement
d=zeros(a);m=length(a);
dn=ones(1,2*m);//variation du nombre de clients dans le système: +1 ou -1
d(1)=a(1)+s(1);//premier client
for k=1:m-1
d(k+1)=max(a(k+1),d(k))+s(k+1);
end;
[e,ind]=gsort([a,d],’g’,’i’);
dn(ind>m)=-1;//departs
n=cumsum(dn);
endfunction;
Exercice 6.16. Ecrire une fonction retournant le temps d’attente moyen d’un client (temps séparant
son arrivée du début de son service), le temps total moyen passé par un client dans le système (temps de
réponse = temps d’attente + temps de service), ainsi que la longueur moyenne de la file.
Exercice 6.17. Soit R le temps total moyen qu’un client d’une file G/G/1 passe dans le système :
n
1X
Rk , où Rk est le temps passé par le k-ième client dans le système, et N le nombre
R = lim
n→+∞ n
k=1
Z
1 t
moyen de clients présents : N = lim
Ns ds. On peut montrer que N = λR (formule de Little).
t→+∞ t 0
Vérifier ce résultat par la simulation.
6.3.2
Le cas markovien
Dans le cas des files d’attente M/M/p, où les temps inter-arrivées et les temps de service suivent
tous des lois exponentielles et p est un entier ≥ 1 ou +∞, le nombre Nt de clients présents dans
le système à l’instant t est un processus markovien de sauts de générateur Q donné par :
q(n, n + 1) = λ
pour n ≥ 1
q(n, n − 1) = µ min(n, p)
pour m 6∈ {n − 1, n, n + 1}.
q(n, m) = 0
6.3.2.1
La file d’attente M/M/1
Le processus d’arrivées est dans ce cas un processus de Poisson d’intensité λ et les temps de service
i.i.d. de loi exponentielle de paramètre µ. Le processus Nt admet une probabilité invariante et
une seule si λ < µ. Cette probabilité est alors la loi géométrique sur N de paramètre λ/µ. Le
système tend dans ce cas vers un régime stationnaire, le nombre moyen de clients présents dans
81
λ
et le facteur d’utilisation du serveur (pourcentage de temps où le serveur est
µ−λ
occupé, ou probabilité qu’à un instant donné il y ait au moins un client présent dans le système)
est λ/µ en régime stationnaire. Si λ > µ, la longueur de la file tend vers l’infini avec le temps.
la file est
Exercice 6.18. Simuler en utilisant la fonction GG1 une file d’attente M/M/1 pour différentes valeurs
des paramètres λ et µ. Représenter graphiquement l’évolution de la longueur de la file. Vérifier que si
ρ < 1 la file évolue vers un régime stationnaire, i.e. Nt converge en loi quand t tend vers l’infini. Identifier
la loi limite. Déterminer la longueur moyenne de la file en régime stationnaire. Vérifier que le temps total
passé par un client dans le système (temps d’attente + temps de service) suit en régime stationnaire la
loi exponentielle de paramètre µ − λ. Démontrer cette dernière propriété.
Exercice 6.19. Proposer une autre modélisation de la file M/M/1 basée sur les deux propriétés suivantes :
1. l’absence de mémoire de la loi exponentielle ;
2. le fait que le minimum de deux variables aléatoires exponentielles indépendantes de paramètres λ
et µ suit la loi exponentielle de paramètre λ + µ.
(En appelant événement un départ ou une arrivée dans la file, on remarquera que le temps séparant deux
événements est le minimum de deux variables aléatoires exponentielles indépendantes.)
6.3.2.2
La file d’attente M/M/∞
Dans ce cas, il y a une infinité de serveurs : le temps d’attente est donc nul quelle que soit
l’intensité du flot d’arrivées. Le processus Nt admet comme unique probabilité invariante la loi
de Poisson de paramètre λ/µ. Le nombre moyen de serveurs occupés est donc λ/µ en régime
stationnaire.
Exercice 6.20. Simuler une file d’attente M/M/∞ sur un temps suffisamment long. Représenter graphiquement une trajectoire du processus Nt . Vérifier le théorème ergodique et étudier la convergence de
Nt vers la loi stationnaire.
6.3.3
Files d’attente à plusieurs serveurs
On peut modifier la fonction GG1 pour gérer une file d’attente LIFO à p serveurs, où p est un
entier ≥ 1 :
function [e,d,n]=GGp(a,s,p)
//file d’attente générale FIFO à p serveurs
//a: vecteur ligne des instants d’arrivée
//s: vecteur ligne des temps de service
//(deux vecteurs de même longueur m)
//e: instants des événements (arrivées ou départs)
//d: vecteur ligne des instants de départs
d=zeros(a);m=length(a);
fds=zeros(1,p);//fins de service des différents serveurs
dn=ones(1,2*m);//variation du nombre de clients: +1 ou -1
for k=1:m
[fdsmin,servmin]=min(fds);
serv=min(servmin);//premier serveur libre
fds(serv)=max(a(k),fds(serv))+s(k);
d(k)=fds(serv);
end;
[e,ind]=gsort([a,d],’g’,’i’);
dn(ind>m)=-1;//départs
n=cumsum(dn);
endfunction;
82
Dans le cas particulier d’une file M/M/p, on peut montrer que le processus Nt admet une
λ
probabilité invariante si et seulement si ρ =
< 1. La file évolue donc dans ce cas vers un
pµ
régime stationnaire.
Exercice 6.21. On peut montrer qu’en régime stationnaire le nombre moyen de serveurs occupés est
égal à λ/µ (comme dans le cas p = ∞). Vérifier ce résultat par la simulation.
Exercice 6.22. Vérifier par la simulation que, dans le cas non saturé (i.e. λ < pµ) le flot des sorties
d’une file M/M/p, où p est un entier ≥ 1 ou ∞, est en régime stationnaire un processus de Poisson de
même paramètre que le processus de Poisson des arrivées (théorème de Burke).
6.4
Exercices
Exercice 6.23. Processus de renouvellement alterné
On veut modéliser le fonctionnement d’une machine qui est alternativement dans deux états : en marche
ou en panne. Pour cela, on introduit deux suites (Un )n∈N∗ et (Vn )n∈N∗ de variables aléatoires réelles
positives : Un représente la durée de fonctionnement de la machine, Vn le temps qu’il faut pour la réparer. Les variables aléatoires Wn = (Un , Vn ) sont supposées indépendantes et de même loi (mais on ne
suppose pas Un indépendant de Vn ). La durée totale du n-ième cycle fonctionnement+réparation est donc
Yn = Un + Vn . On voudrait connaître la proportion de temps pendant lequel la machine est en marche.
On introduit pour cela un processus (Xt )t≥0 où la variable aléatoire Xt vaut 1 si la machine est en marche
Z
1 t
Xs ds. Le
à l’instant t et 0 sinon. Le but est alors d’étudier la limite quand t tend vers l’infini de
t 0
Pn
processus (Tn )n∈N , où Tn = k=1 Yk est un processus de renouvellement et il est intuitivement clair (c’est
E(U1 )
une conséquence de la loi des grands nombres) que la limite cherchée existe et est égale à
E(U1 ) + E(V1 )
si les Un et les Vn sont intégrables.
Simuler un tel processus et vérifier cette propriété (on pourra commencer par représenter quelques trajectoires en prenant par exemple pour Un des variables aléatoires exponentielles et pour Vn des variables
aléatoires uniformes sur un intervalle compact). Vérifier également que la probabilité que la machine soit
E(U1 )
en service à l’instant t tend vers
quand t tend vers l’infini.
E(U1 ) + E(V1 )
Exercice 6.24. Coalescent de Kingman
On reprend l’étude du processus généalogique dans le modèle de Wright-Fisher (cf. exercice 5.3) en
supposant que la taille N de la population totale est très grande. On s’intéresse à la généalogie d’un
échantillon de taille n fixée de cette population en remontant dans le temps. Si en remontant jusqu’à la
k-ième génération, les n individus de l’échantillon ont i ancêtres distints, la probabilité qu’à
la génération
1
1 i
+O
précédente (i.e. la k + 1-ième, puisqu’on remonte dans le temps) ils en aient i − 1 est
N 2
N2
1
et celle qu’ils en aient j est O
pour tout j < i − 1. Si maintenant on fait tendre N vers l’infini en
N2
renormalisant le temps en posant k = N t, où t est un réel positif, on voit que le nombre Xt d’ancêtres
de l’échantillon à l’instant t constitue un processus markovien de sauts à temps continu de générateur
i
infinitésimal Q donné par q(i, i − 1) =
= −q(i, i) pour tout i = 2, . . . , n.
2
Simuler ce processus et estimer la loi et l’espérance du temps de coalescence, i.e. le temps d’apparition
de l’ancêtre commun de l’échantillon le plus proche dans le temps (on remarquera que la chaîne incluse
de ce processus est triviale, ce qui en rend la simulation aisée).
On peut raffiner le modèle en ne s’intéressant pas seulement au nombre Xt d’ancêtres de l’échantillon
à l’instant t, mais à la partition Pt de l’échantillon dont les blocs sont constitués des individus ayant
un même ancêtre en remontant de t dans le temps. Le processus Pt est aussi une chaîne de Markov à
temps continu d’espace d’états l’ensemble des partitions de {1, . . . , n} (en supposant qu’on ait numéroté
les individus de 1 à n), d’état initial la partition constituée de tous les singletons, et de générateur
infinitésimal Q donné par q(α, β) = 1 silapartition β est obtenue à partir de α en regroupant exactement
i
deux classes en une seule, q(α, α) = −
si i est le nombre de blocs de la partition α. Autrement dit,
2
deux blocs quelconques fusionnent à un taux constant 1. Le temps de coalescence T est le premier instant
83
où Pt est la partition triviale constituée d’un seul bloc.
Simuler cette version du processus, en remarquant par exemple que pour la chaîne incluse la probabilité
de transition p(α, β) est uniforme sur l’ensemble des partitions obtenues en regroupant deux blocs de la
partition α.
Exercice 6.25. Évolution d’une population de bactéries (urne de Polya en temps continu)
Une population est constituée de deux types de bactéries, A et B. Chaque bactérie de type A se reproduit
à un taux λ et chaque bactérie de type B à un taux µ, indépendamment les unes des autres, et les
bactéries ne sont pas supposées mourir, de sorte que le nombre Xt de bactéries de type A et le nombre Yt
de bactéries de type B à l’instant t constituent des processus markoviens de saut de générateurs respectifs
qA (n, n + 1) = nλ et qB (n, n + 1) = nµ. Ces processus explosent en un temps fini.
Simuler sur un temps suffisamment long l’évolution de cette population de bactéries pour pouvoir observer
ce phénomène.
Montrer que si λ = µ, la chaîne incluse dans la chaîne à temps continu (Xt , Yt ) est une urne de Polya.
Xt
Etudier en fonction de a = X0 et b = Y0 la loi limite de Zt =
quand t tend vers le temps
Xt + Y t
d’explosion de la population.
84
Chapitre 7
Statistique
7.1
7.1.1
Régions et intervalles de confiance
Régions et intervalles de confiance exacts
Si X1 , . . . , Xn est un échantillon de taille n d’une loi normale de moyenne inconnue m et de
variance connue σ 2 , l’estimateur du maximum de vraisemblance de m est la moyenne empirique
X1 + · · · + Xn
Xn =
de l’échantillon. De plus X n suit la loi normale de moyenne m et de
n
2
σ
variance
. Il en résulte que
n
P(X n − a ≤ m ≤ X n + b) = P(m − b ≤ X n ≤ m + a) = P(−b ≤ Z ≤ a)
pour tout couple (a, b) de réels, où Z est une variable aléatoire réelle de loi normale de moyenne
σ2
nulle et de variance
. Tout intervalle [−b, a] vérifiant P(−b ≤ Z ≤ a) = α est donc un intervalle
n
de confiance exact pour m au niveau α. Le choix le plus naturel consiste à prendre un intervalle
1−α
de confiance symétrique, i.e. vérifiant a = b. On a alors P(Z ≤ −a) =
et la fonction
2
cdfnor permet de calculer a en fonction de n, α et σ.
Le programme suivant calcule un intervalle de confiance au niveau 0.95 pour un échantillon de
taille 100 d’une loi normale d’écart-type 3. Il vérifie ensuite ce calcul en simulant 10000 fois un
tel échantillon : on constate bien que dans environ 95% des cas la vraie valeur du paramètre
appartient à l’intervalle de confiance obtenu.
alpha=0.95;n=100;sigma=3;
a=-cdfnor(’X’,0,sigma/sqrt(n),(1-alpha)/2,(1+alpha)/2)
//vérification
m=2;nbsimul=10000;
x=grand(nbsimul,n,’nor’,m,sigma);
mx=mean(x,’c’);
sum(abs(mx-m)<a)/nbsimul
Exercice 7.1. Soit X1 , . . . , Xn un échantillon de taille n d’une loi exponentielle de paramètre inconnu
1
λ. Montrer que l’estimateur du maximum de vraisemblance de l’espérance de cette loi est la moyenne
λ
X1 + · · · + Xn
empirique X n =
de l’échantillon. Montrer que nλX n = λ(X1 + · · · + Xn ) suit la loi
n
Gamma de paramètres 1 et n. En déduire un intervalle de confiance exact pour l’espérance de cette loi.
85
7.1.1.1
Échantillons gaussiens
Il n’est pas toujours possible d’expliciter un intervalle de confiance exact pour le paramètre à
estimer. On doit alors se contenter d’intervalles de confiance approchés (voir 7.1.2). Dans le cas
où l’échantillon est gaussien, le calcul est possible, tant pour la moyenne que pour la variance, l’un
de ces paramètres étant éventuellement connu. On a déjà étudié le cas où la variance était connue
et l’espérance inconnue. Les lois reliées à la loi normale (loi du χ2 et de Student) permettent de
traiter les autres.
Espérance connue : estimation de la variance Si X1 , . . . , Xn est un échantillon de taille
n d’une loi normale de moyenne connue m et de variance inconnue σ 2 , la variable aléatoire
n
nS 2
1X
Dn2 = 2n , où Sn2 =
(Xk − m)2 , suit la loi du χ2 à n degrés de liberté. Si [κ1 , κ2 ] est un
σ
n
k=1
intervalle de probabilité α pour cette loi, en particuliersi κ1 et κ2 sont
niveau
les2 quantiles de2 1−α
1+α
nSn2
nS
nSn
n
et
pour cette loi, on a P κ1 ≤ 2 ≤ κ2 = α, d’où P
≤ σ2 ≤
= α.
2
2
σ
κ
κ
2
1
nSn2 nSn2
est donc un intervalle de confiance au niveau α pour σ 2 .
,
L’intervalle
κ2 κ1
Espérance et variance inconnues : estimation de la variance Si X1 , . . . , Xn est un
échantillon de taille n d’une loi normale de moyenne m et de variance σ 2 inconnues, la variable
n
1X
nS̃n2
2
2
(Xk −X n )2 est la variance empirique (biaisée) de l’échantillon,
aléatoire D̃n = 2 , où S̃n =
σ
n
k=1
suit la loi du χ2 à n − 1 degrés de liberté. Si [κ1 , κ2 ] est un intervalle de probabilité α pour cette
1+α
1−α
et
pour cette loi, on a
loi, en particulier si κ1 et κ2 sont les quantiles de niveau
2
2 "
!
!
#
nS̃n2
nS̃n2
nS̃n2 nS̃n2
nS̃n2
2
≤σ ≤
= α. L’intervalle
,
est donc
P κ1 ≤ 2 ≤ κ2 = α, d’où P
σ
κ2
κ1
κ2 κ1
un intervalle de confiance au niveau α pour σ 2 .
Espérance et variance inconnues : estimation de l’espérance Si X1 , . . . , Xn est un
échantillon de taille n √d’une loi normale de moyenne m et de variance σ 2 inconnues, la van
1X
n − 1(X n − m)
riable aléatoire Tn =
, où S̃n2 =
(Xk − X n )2 , suit la loi de Student à
n
S̃n
k=1
n − 1 degrés de liberté. Si [t1 , t2 ] est un intervalle de probabilité α pour cette loi, en particu1+α
1−α
et
pour cette loi (t1 = −t2 par symélier si t1 et t2 sont les quantiles de niveau
2
2
!
t2 S̃n
t1 S̃n
= α. L’intervalle
≤ m ≤ Xn − √
trie), on a P (t1 ≤ Tn ≤ t2 ) = α, d’où P X n − √
n−1
n−1
"
#
t2 S̃n
t1 S̃n
est donc un intervalle de confiance au niveau α pour m.
, Xn − √
Xn − √
n−1
n−1
Exercice 7.2. Écrire une fonction Scilab retournant un intervalle de confiance au niveau α pour σ 2 ou
m dans ces trois cas. Vérifier ces niveaux de confiance par la simulation.
7.1.2
Régions et intervalles de confiance approchés
Si les échantillons ne sont pas gaussiens, on ne peut en général pas calculer d’intervalles de
confiance exacts. On doit alors se contenter de valeurs approchées.
86
7.1.2.1
Intervalles de confiance par excès
L’inégalité de Bienaymé-Tchebychev permet souvent de majorer la probabilité qu’un paramètre
estimé appartienne à un intervalle donné.
Par exemple si X1 , . . . , Xn est un échantillon d’une loi de Bernoulli de paramètre inconnu p,
X1 + · · · + Xn
l’estimateur X n =
du maximum de vraisemblance de p vérifie P(|X n − p| ≥ ε) ≤
n
p(1 − p)
p(1 − p)
1
puisque la variance de X n est égale à
. Mais p(1 − p) ≤ pour tout p ∈ [0, 1].
2
nε
n
4
1
indépendamment
de
la
vraie
valeur
du paramètre p.
Il en résulte que P(|X n − p| ≥ ε) ≤
4nε2
On obtient ainsi un intervalle de confiance par excès au niveau α :
"
#!
1
1
P p ∈ Xn − p
, Xn + p
≥α.
2 n(1 − α)
2 n(1 − α)
n=30;
alpha=0.95;
dp=1/2/sqrt(n*(1-alpha))
//vérification:
p=0.4;
nbsimul=10000;
x=bool2s(rand(nbsimul,n)<p);
pemp=mean(x,’c’);
sum(abs(p-pemp)<alpha)
dp =
0.4082483
ans =
10000.
7.1.2.2
Intervalles de confiance asymptotiques
On voit que l’intervalle de confiance obtenu dans l’exemple précédent pour un échantillon de
taille 30 est très médiocre, puisqu’il est de longueur supérieure à 0.8. En conséquence, les 10000
simulations donnent toutes un intervalle contenant la vraie valeur de p. En fait, la loi de X1 +
· · · + Xn est connue : c’est la loi binomiale de paramètres n et p, et cette loi s’approche, quand
np et n(1 − p) sont suffisamment grands, par une loi normale (c’est le théorème limite central).
On obtient un intervalle de confiance asymptotique en remplaçant l’utilisation
r de l’inégalité
n
de Bienaymé-Tchebychev par cette approximation. La variable Zn = (X n − p)
suit
p(1 − p)
approximativement la loi normale N (0, 1) ; P(|Zn | > a) est donc proche de 2F (−a), où F est la
fonction de répartition de la loi normale réduite. Or :
!
√
√
ε n
P(|X n − p| > ε) = P |Zn | > p
≤ P(|Zn | > 2ε n) .
p(1 − p)
1−α
au moyen de la fonction cdfnor. L’intervalle de
2
a
a
confiance asymptotique est alors [X n − √ , X n + √ ].
2 n
2 n
Le programme ci-dessous permet de constater la validité de cette approximation pour n = 30,
p = 0.4.
On calcule donc a tel que F (−a) =
n=30;p=0.4;alpha=0.95;nbsimul=10000;
a=-cdfnor(’X’,0,1,(1-alpha)/2,(1+alpha)/2);
87
epsilon=a/2/sqrt(n)
x=bool2s(rand(nbsimul,n)<p);
pemp=mean(x,’c’);
sum(abs(p-pemp)<epsilon)
epsilon =
0.1789194
ans =
9598.
7.2
7.2.1
7.2.1.1
Tests d’adéquation
Test du χ2
Adéquation à une loi connue
Soit (X1 , · · · , Xn ) un échantillon indépendant à valeurs dans un ensemble fini E = {x1 , · · · , xm }
et p = (p1 , · · · , pm ) une loi de probabilité sur E. On se propose de tester l’hypothèse H0 : « la
loi commune des Xi est p ». On définit pour cela la « distance » du χ2 de la loi empirique de
l’échantillon à la loi p par :
m
m
j=1
j=1
X (Fj − pj )2
1 X (Nj − npj )2
Dn =
=n
n
pj
pj
où, pour tout j = 1, . . . , m, Nj = card{k | Xk = j} est le nombre d’occurences du résultat xj et
Nj
Fj =
la fréquence d’obtention de ce résultat dans l’échantillon (Dn n’est naturellement pas
n
une distance, puisqu’elle n’est pas symétrique).
L’espérance de Dn sous l’hypothèse H0 est m − 1 : en effet (N1 , N2 , . . . , Nm ) suit sous cette
hypothèse la loi multinomiale de paramètres (n, p1 , . . . , pm ), de sorte que E[(Nj − npj )2 ] =
Var(Nj ) = npj (1 − pj ) pour tout j. Par contre, si la loi de l’échantillon est différente de p, Dn
tend presque sûrement vers l’infini avec n par la loi des grands nombres, puisque l’un au moins
des termes (Fj − pj )2 a une limite non nulle.
On montre en fait que, sous l’hypothèse H0 , la loi de Dn converge quand n tend vers l’infini vers
la loi du χ2 à m − 1 degrés de liberté. Pour tester l’hypothèse H0 au niveau de confiance α, on
rejette l’hypothèse nulle H0 si Dn > z, où z est défini par P(W > z) = α, où W est une variable
aléatoire suivant la loi du χ2 à m − 1 degrés de liberté. On accepte cette hypothèse sinon.
Il faut remarquer que le test du χ2 est un test asymptotique. En pratique, on l’utilise si les Ni
ou les npi sont tous supérieurs à 5 ou 10. Sinon, on commence par regrouper certaines valeurs xi
pour diminuer le nombre de classes et ainsi augmenter l’effectif de celles-ci.
Exemple : On veut tester si les chiffres obtenus à la sortie d’un générateur de nombres aléatoires sont uniformément répartis sur {0, 1, . . . , 9}. On observe 100 chiffres et on obtient le tableau
suivant :
i
Ni
0
5
1
9
2
16
3
9
4
10
5
16
6
10
7
6
8
11
9
8
Le programme suivant calcule la distance du χ2 entre la loi empirique et la loi uniforme, puis la
p-valeur du test :
n=100;m=10;
N=[5 9 16 9 10 16 10 6 11 8];
d=n*m*sum((N/n-ones(1,m)/m).^2)
88
pval=1-cdfchi(’PQ’,d,m-1)
d =
12
pval =
0.2133093
Il n’y a donc pas de raison de rejeter l’hypothèse d’équirépartition, puisque la probabilité qu’une
variable aléatoire suivant la loi du χ2 à 9 degrés de liberté prenne une valeur supérieure à la
distance observée est 0.2133093.
7.2.1.2
Cas de paramètres inconnus
Si on veut simplement tester l’hypothèse H0 : « la loi de l’échantillon appartient à une classe
donnée de lois dépendant d’un paramètre inconnu θ ∈ Rd », on commence par estimer ce paramètre au moyen d’un estimateur du maximum de vraisemblance θ̂n , et on calcule ensuite la
distance du χ2 de la loi empirique à la loi théorique correspondant au paramètre θ̂n . On montre
alors que, sous des hypothèses de régularité assez larges, la loi de cette distance Dn converge
vers la loi du χ2 à m − 1 − q degrés de liberté, où q est le nombre de paramètres indépendants à
estimer.
Exemple : On lance 1000 fois 10 pièces et on observe à chaque fois le nombre de piles obtenu.
On obtient le tableau suivant :
i
Ni
0
0
1
4
2
32
3
78
4
158
5
239
6
242
7
168
8
57
9
20
10
2
On veut tester l’hypothèse H0 : « le résultat de chaque expérience suit la loi binomiale de
paramètre 1/2 ».
n=1000;m=11;
N=[0 4 32 78 158 239 242 168 57 20 2];
p=binomial(0.5,m-1);
d=sum((N-n*p).^2 ./p)/n
pval=1-cdfchi(’PQ’,d,m-1)
d =
76.099657
pval =
2.905D-12
L’hypothèse H0 est donc clairement à rejeter. On se propose donc de tester l’hypothèse moins
restrictive H0′ : « le résultat de chaque expérience suit une loi binomiale ».
q=1;
theta=N*(0:m-1)’/n/(m-1)
p=binomial(theta,m-1);
d=sum((N-n*p).^2 ./p)/n
pval=1-cdfchi(’PQ’,d,m-1-q)
theta =
0.5413
d =
6.2317831
pval =
0.7165150
L’hypothèse est cette fois parfaitement acceptable.
89
7.2.1.3
Test d’indépendance
On peut en particulier utiliser les résultats du paragraphe précédent pour tester sur un échantillon
((X1 , Y1 ), . . . , (Xn , Yn )) de variables aléatoires à valeurs dans un produit E × F d’ensembles finis
E = {x1 , . . . , xr } et F = {y1 , . . . , ys } si les variables aléatoires Xk et Yk sont indépendantes. On
introduit pour cela les nombres
Ni,j =
n
X
1Xk =xi ,Yk =yj ,
Ni,. =
s
X
Ni,j ,
N.,j =
Ni,j
i=1
j=1
k=1
r
X
d’observations du résultat (xi , yj ) (resp. xi , yj ) et les fréquences empiriques
Fi,j =
Ni,j
,
n
Fi,. =
Ni,.
,
n
F.,j =
N.,j
n
de ces observations.
Les estimateurs du maximum de vraisemblance des lois marginales P(Xk = xi ) et P(Yk = yj )
sont alors les fréquences empiriques Fi,. et F.,j et la statistique Dn mesurant la distance du χ2
de la loi empirique du couple à la loi produit des lois marginales empiriques est donnée par :
s
r X
X
(Fi,j − Fi,. F.,j )2
.
Dn = n
Fi,. F.,j
i=1 j=1
Cette distance suit asymptotiquement la loi du χ2 à (r − 1)(s − 1) degrés de liberté. Ici encore
on peut être amené à regrouper des classes pour éviter que les effectifs ne soient trop faibles.
Exemple : Soit Z une variable aléatoire suivant la loi de Poisson de paramètre λ, p ∈ [0, 1]
un réel, X une variable aléatoire à valeurs entières dont la loi conditionnelle sachant Z est la loi
binomiale de paramètres Z et p, et Y = Z − X (de telles variables aléatoires interviennent de
manière naturelle dans l’étude de la décomposition de processus de Poisson : voir section 6.1.3).
On peut alors montrer que les variables aléatoires X et Y sont indépendantes, de lois respectives
les lois de Poisson de paramètres pλ et (1 − p)λ. Le programme suivant génère un échantillon
de taille 10000 de telles variables aléatoires et teste l’indépendance de X et Y (sans chercher à
tester les lois marginales de ces variables) :
lambda=5;p=0.3;n=10000;
X=zeros(1,n);Y=X;
for k=1:n
r=grand(1,1,’poi’,lambda);
X(k)=grand(1,1,’bin’,r,p);
Y(k)=r-X(k);
end;
r=6;s=8;N=zeros(r,s);
for i=0:r-2
for j=0:s-2,N(i+1,j+1)=sum(X==i&Y==j);end;
N(i+1,$)=sum(X==i&Y>s-2);
end;
for j=0:s-2, N($,j+1)=sum(X>r-2&Y==j);end;
N($,$)=sum(X>r-2&Y>s-2);
FX=sum(N,’c’)/n;FY=sum(N,’r’)/n;FXY=N/n;FP=FX*FY;
d=n*sum((FXY-FP).^2 ./FP)
pval=1-cdfchi(’PQ’,d,(r-1)*(s-1))
pval=
90
d
=
40.951028
pval =
0.2256433
7.2.2
Test de Kolmogorov-Smirnov
La fonction de répartition de la loi de Kolmogorov-Smirnov n’est pas préprogrammée dans le
noyau de Scilab, mais elle est accessible par la commande pks de la boîte à outils Stixbox :
x=linspace(0,2);y=pks(x);
plot(x,y,’b’);
xtitle(’Fonction de répartition de la loi de Kolmogorov-Smirnov’);
Fonction de répartition de la loi de Kolmogorov−Smirnov
1.0
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
0.0
7.3
7.3.1
0.2
0.4
0.6
0.8
1.0
1.2
1.4
1.6
1.8
2.0
Comparaison de deux échantillons
Test de Wilcoxon-Mann-Whitney
Ce test s’appuie sur la statistique de Wilcoxon étudiée à l’exercice 2.17. Il teste si deux échantillons X = (X1 , . . . , Xn ) et Y = (Y1 , . . . , Ym ) suivent une même loi continue sur R.
On sait que dans ce cas la variable aléatoire U égale au nombre de couples d’indices (i, j) tels que
mn
U − E(U )
mn(n + m + 1)
Yj < Xi a pour espérance E(U ) =
et pour variance σU2 =
et que
2
12
σU
suit asymptotiquement la loi normale N (0, 1) (en pratique on utilise ce test si n et m sont tous
deux supérieurs à 8). On se donne un seuil d’erreur α (par exemple 0.05, ou 0.01) et on rejette
U − E(U )
> cα , où cα est l’unique
l’hypothèse que les deux échantillons suivent la même loi si
σU
réel vérifiant P(|Z| > cα ) = α si Z suit la loi normale réduite.
Exercice 7.3. Générer deux échantillons indépendants et de même taille X = (X1 , . . . , Xn ) et Y =
(Y1 , . . . , Yn ) de deux lois gamma de paramètres α et β, ainsi qu’un échantillon de taille Z1 , . . . , Zm de la
loi bêta de paramètres α et β et tester si les échantillons X1 /(X1 + Y1 ), . . . , Xn /(Xn + Yn ) et Z1 , . . . , Zm
proviennent d’une même loi.
7.3.2
Test de Smirnov
Soient (X1 , . . . , Xn ) et (Y1 , . . . , Ym ) deux échantillons, Fn et Gm leurs fonctions de répartition
empiriques. On cherche à tester l’hypothèse H0 : « ces deux échantillons proviennent d’une même
loi continue ». Soit alors Dn,m la statistique
Dn,m = sup |Fn (x) − Gm (x)| .
x∈R
91
q
mp
Dm,p cconverge en loi quand n et m tendent
On montre que si l’hypothèse est vérifiée, m+p
tous deux vers l’infini vers une variable aléatoire W suivant la loi de Kolmogorov-Smirnov :
K(x) = P(W ≤ x) = 1 − 2
+∞
X
(−1)k e−2k
2 x2
.
1
Sinon cette quantité tend vers l’infini.
q
mp
La région critique du test au niveau α est donc m+p
Dm,p ≥ w, où P(W ≥ w) = 1−K(w) = α.
Ce test est implémenté dans la boîte à outils Stixbox sous le nom kstwo.
Exercice 7.4. Reprendre l’exercice 7.3 en utilisant le test de Smirnov.
7.4
7.4.1
Régression
Ajustement affine par la méthode des moindres carrés
On dispose de données statistiques ou expérimentales mesurant deux caractères X et Y d’une
population (par exemple en statistique la taille et le poids d’un individu, la taille du père et
celle du fils,. . .ou en physique l’intensité Y du courant passant dans un circuit en fonction de
la différence de potentiel X appliquée aux bornes . . .). Ces données permettent de penser qu’il
existe une relation approximativement affine entre ces deux caractères, cette relation pouvant
soit traduire une relation exacte (loi physique) perturbée par des erreurs de mesure ou une simple
tendance statistique. Cette relation se constate graphiquement par la forme allongée du nuage
de points (xi , yi )1≤i≤n dans le cas d’une tendance statistique, ou par sa quasi linéarité dans le
cas d’une loi physique. Le problème de l’ajustement affine consiste à trouver la droite d’équation
y = ax + b qui approche au mieux ce nuage de points. Le critère le plus souvent retenu et le plus
maniable du point de vue mathématique est de mesurer la qualité de cette approximation par la
n
X
(yi − axi − b)2 des carrés des différences des ordonnées entre les points du nuage et
somme
i=1
ceux de même abscisse sur la droite.
Un calcul élémentaire permet de montrer que ce problème admet, si tous les points du nuage
n’ont pas la même abscisse, une unique solution donnée par
â = ρx,y
σy
,
σx
b̂ = ȳ − âx̄
!1/2
!1/2
n
n
n
n
1X
1X
1X
1X
2
2
où x̄ =
xi , ȳ =
yi , σ x =
(xi − x̄)
(yi − ȳ)
, σy =
,
n
n
n
n
i=1
i=1
i=1
Pn i=1
i=1 (xi − x̄)(yi − ȳ)
sont respectivement les moyennes et les écarts-types empiriques
ρx,y =
n σx σy
de X et Y et le coefficient de corrélation empirique de ces deux variables.
Les coefficients â et b̂ sont appelés coefficients de régression de Y en X. La droite d’équation
y = âx + b̂, appelée droite de régression de Y en X, passe par le point moyen (x̄, ȳ) du nuage.
On remarque que les deux variables X et Y ne jouent pas des rôles symétriques dans ce problème.
La variable X, appelée variable explicative, peut être celle dont on choisit les valeurs lors d’une
expérimentation physique, ou celle à laquelle on attribue un rôle de causalité dans une relation
statistique. La variable Y s’appelle variable réponse.
Si on échange les rôles de ces variables, on obtient une autre droite de régression. Ces deux
droites de régression (de Y en X et de X en Y ) ont des pentes de même signe et sont d’autant
plus proches que la corrélation entre les deux variables est forte (elles seraient naturellement
confondues s’il existait une relation affine exacte entre les deux caractères).
92
Le programme suivant génère un nuage aléatoire de points (xi , yi )1≤i≤n , calcule les coefficients
de régression en utilisant les formules précédentes et trace les deux droites de régression (dans
une application réelle, les valeurs xi et yi résultent naturellement d’observations ou de mesures :
on génère ici un échantillon artificiel pour ne pas avoir à utiliser un tableau de données externe) :
x=rand(1,50);y=-2*x+3+0.3*rand(x,’n’);
xbasc();
plot(x,y,’.b’);//trace le nuage
mx=mean(x);my=mean(y);
plot(mx,my,’or’);//point moyen du nuage
cov=corr(x,y,1);//covariance de x et y
vx=corr(x,x,1);//variance de x
t=[min(x),max(x)];
z=my+cov*(t-mx)/vx;
plot2d(t,z,style=5);//droite de régression de y en x
vy=corr(y,y,1);
u=[min(y),max(y)];
v=mx+cov*(u-my)/vy;
plot2d(v,u,style=3);//droite de régression de x en y
3.5
3.0
2.5
2.0
1.5
1.0
0.5
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Scilab possède plusieurs commandes permettant de calculer ces coefficients de régression et même
de tracer la droite de régression sans avoir à recourir à ces formules. Les fonctions regress,
reglin, lsfit font partie du noyau de Scilab, le fonction linreg de la boîte à outils Stixbox
(attention à l’ordre de retour des coefficients) :
coeffs=regress(x,y)
[a,b]=reglin(x,y)
On peut
 quece problème est un pur problème d’algèbre linéaire. En posant
 remarquer
 aussi
x1 1
y1
 .. .. 
 .. 
Y =  .  et X =  . . , il s’agit de résoudre au sens des moindres carrés le système
xn 1
yn
a
a
linéaire Y = X
, d’inconnues
.
b
b
C’est précisément ce que fait la commande \ (division à gauche) :
X=[x(:),ones(x(:))];Y=y(:);ab=X\Y
93
7.4.2
Régression linéaire simple
D’un point de vue probabiliste, ce problème s’inscrit dans le cadre général de l’étude de la
régression. On peut en effet considérer, dans le cas d’une série statistique, le nuage de points
(xi , yi )1≤i≤n comme un échantillon de taille n d’une variable aléatoire vectorielle (X, Y ) dont les
deux composantes X et Y sont liées. Il s’agit alors d’approcher au mieux Y par une fonction
affine aX + b de X. En supposant X et Y de carré intégrable, on peut prendre comme mesure
de la qualité de cette approximation l’espérance du carré de Y − (aX + b), i.e. le carré de la
distance de Y au plan vectoriel engendré par X et les constantes dans l’espace de Hilbert L2 (Ω)
des variables aléatoires de carré intégrable (en supposant X non presque sûrement constante).
La solution est donnée par la projection orthogonale âX + b̂ de Y sur ce plan vectoriel, où
Cov(X, Y )
σY
â =
= ρX,Y
et b̂ = E(Y ) − âE(X) (cette dernière formule traduisant le fait que
Var(X)
σX
la droite d’équation y = ax + b passe par le point de coordonnées (E(X), E(Y ))).
Le problème posé est alors celui de l’estimation des coefficients de régression â et b̂ au vu des
observations.
7.4.3
Le modèle linéaire
Dans le cas de données expérimentales, on peut souvent considérer les valeurs xi comme déterministes, et parfois choisies par l’expérimentateur. Le modèle linéaire consiste alors à considérer
que Y est donnée par une expression de la forme Y = aX + b + ε, où ε est une variable aléatoire
réelle centrée de carré intégrable. On observe alors n valeurs y1 , . . . , yn de Y correspondant à des
valeurs distinctes, mais déterministes x1 , . . . , xn de X, de sorte que yi = axi + b + εi pour tout
i = 1, . . . , n. On suppose les résidus ε1 , . . . , εn indépendants et de même variance (inconnue) σ 2
et on cherche à estimer les paramètres a, b, σ 2 de ce modèle.
Le théorème de Gauss-Markov nous apprend alors que l’estimateur (Â, B̂) de variance minimale
parmi tous les estimateurs linéaires sans biais des paramètres a et b est l’estimateur des moindres
carrés obtenu précédemment :
 = ρx,Y
σY
,
σx
B̂ = Ȳ − Âx̄
!1/2
!1/2
n
n
n
n
1X
1X
1X
1X
2
2
xi , Ȳ =
Yi , σx =
(xi − x̄)
(Yi − Ȳ )
où x̄ =
, σY =
,
n
n
n
n
i=1
i=1
i=1
i=1
Pn
(xi − x̄)(Yi − Ȳ )
ρx,Y = i=1
.
n σx σY
Dans le cas particulier où les variables aléatoires εi sont gaussiennes, ces estimateurs sont aussi
les estimateurs du maximum de vraisemblance. L’estimateur du maximum de vraisemblance de
la variance V = σ 2 des résidus est alors donné par :
n
V̂ =
1X
(Yi − Âxi − B̂)2 .
n
i=1
La variable aléatoire (Â, B̂) est gaussienne et indépendante de V̂ , qui suit la loi du χ2 à n − 2
degrés de liberté.
Ces estimateurs permettent ensuite de faire de la prédiction, i.e. de donner un estimateur de
Y = ax + b + ε pour une valeur x du caractère X pour laquelle on ne dispose pas d’observations.
La fonction reglin retourne une estimation de la variance des résidus :
[a,b,sig]=reglin(x,y)
La fonction lsfit retourne en outre les résidus et des intervalles de confiance (par défaut au
niveau 0.95) pour les coefficients a et b.
94
[ab,Iab,s,e,Is]=lsfit(y’,x’)
La fonction linreg de la boîte à outils Stixbox représente directement le nuage de points, la
droite de régression et des intervalles de confiance pour les estimateurs  et B̂, ainsi que pour
les valeurs de Y obtenues par prédiction :
linreg(y,x)
4.0
3.5
3.0
2.5
2.0
1.5
1.0
0.5
0.0
−0.2
7.4.4
0.0
0.2
0.4
0.6
0.8
1.0
1.2
Régression linéaire multiple
Tous ces résultats se généralisent au cas de plusieurs variables explicatives, i.e. au modèle Y =
a1 X (1) + · · · + am X (m) + b + ε, où les variables X (1) , . . .,X (m) sont les variables explicatives, a1 ,
. . ., am , b les constantes réelles que l’on cherche à optimiser, et ε le résidu aléatoire de variance
σ2.
(1)
(m)
On dispose dans ce cas d’un échantillon (Yk , Xk , . . . , Xk )k=1,...,n de taille n de telles observations. Le système peut ici encore s’écrire sous forme matricielle :
   
   (1)
(m)
ε1
a1
X1
. . . X1
1
Y1
   
. . .  
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.


  +  ..
 =
. . .   . . . . . . . . . . . . . . . . . . . . 
  a m  . . . 
(m)
(1)
εn
b
Yn
1
. . . Xn
Xn
et il s’agit donc encore de résoudre au sens des moindres carrés le système linéaire :
 
   (1)
(m)
a1
X1
. . . X1
1
Y1
 
. . .  
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
 ..
 =
.

. . .  
 . . . . . . . . . . . . . . . . . . . .   am 
(1)
(m)
b
Yn
Xn
. . . Xn
1
C’est ce que fait le programme suivant :
n=100;
x1=rand(1,n);
x2=2*rand(1,n)-3;
a1=4;a2=-1;b=1;sigma=0.3;epsilon=sigma*rand(x1,’n’);
y=a1*x1+a2*x2+b+epsilon;
[x1(:),x2(:),ones(x1(:))]\y(:)
ans =
3.8938953
- 0.9769580
1.1130642
95
Ici encore la fonction reglin fournit directement le résultat :
[aest,best,sest]=reglin([x1;x2],y)
sest =
0.2439004
best =
1.1130642
aest =
3.8938953 - 0.9769580
On pouvait également programmer à la main les formules théoriques :
X=[x1(:),x2(:)];Y=y(:);
X=X-ones(n,1)*mean(X,’r’);Y=Y-mean(Y);
A=inv(X’*X)*X’*Y
res=y-A(1)*x1-A(2)*x2;
b=mean(res)
sigma2=sum((res-b).^2)/n;
sqrt(sigma2)
96
Chapitre 8
Indications de solutions
8.1
Chapitre 1
1.1.
x=rand(1,10)
x($:-1:1)
1.2.
x=ones(1,10);x(2:2:10)=-1
y=2*round(rand(1,10))-1
y=2*floor(2*rand(1,10))-1
y=ones(1,10);y(rand(1,10)<0.5)=-1
1.3.
a=rand(4,4),b=a([4 2 3 4],:)
ou b=a;b(1,:)=b(4,:)
1.4.
a=rand(5,5);a=a-diag(diag(a))
1.5.
a=1:4;b=1:2:7;a’*b
1.6.
a=rand(3,5);b=a’*a;c=a*a’;spec(b),spec(c)
On constate bien que les valeurs propres non nulles de tAA et A tA sont les mêmes (voir cours d’algèbre).
1.7.
a=rand(5,5)
for k=1:5,a(:,k)=k*a(:,k);end;a
//Mieux:
a=rand(5,5)
a=a*diag(1:5)
//Pour les lignes:
a=rand(5,5)
a=diag(1:5)*a
a(2,:)=a(1,:)+a(5,:)
det(a),rank(a)
97
1.9.
function y=dif(x)
y=[x(1),x(2:$)-x(1:$-1)];
endfunction;
//vérification
x=rand(1,10),cumsum(dif(x)),dif(cumsum(x))
1.10.
q=ones(1,1000);q(1)=sqrt(2*%pi)/%e;
for n=1:999,q(n+1)=q(n)/%e*sqrt((n+1)/n)*((n+1)/n)^n;end;
r=q.*(1+1 ./(1:1000)/12);
On remarque que l’approximation est excellente, même pour de petites valeurs de n.
1.11. La fonction la plus naïve :
function c=bincoeff(n,p)
c=factorial(n)/factorial(p)/factorial(n-p);
endfunction;
200
ne permet pas de calculer
.
100
La fonction un peu moins naïve :
function c=bincoeff(n,p)
c=prod(n-p+1:n)/prod(1:p);
endfunction;
le permet, mais ne permet pas de calculer
400
. La version suivante le permet :
200
function c=bincoeff(n,p)
c=prod((n-p+1:n)./(1:p));
endfunction;
mais les fonctions les plus efficaces utilisent la fonction gamma ou, mieux, son logarithme. Par exemple :
function c=bincoeff(n,p)
c = exp(gammaln(n+1)-gammaln(p+1)-gammaln(n-p+1));
endfunction;
1000
calcule correctement
, mais présente l’inconvénient de ne pas renvoyer un entier :
500
-->format(20);bincoeff(10,5)
ans =
252.000000000000682
Il suffit de le lui demander en ajoutant la ligne
c=round(c)
à l’intérieur de sa définition. Elle admet des vecteurs (ou même des matrices) en argument :
-->bincoeff([5 5;10 10],[3 4;3 4])
ans =
10.
5.
120.
210.
98
C’est essentiellement cette méthode qu’utilise la fonction bincoef disponible dans la boîte à outils
Stixbox.
1.12.
function T=pascal(n)
//triangle de Pascal
T=zeros(n+1,n+1);
T(:,1)=1;
for k=2:n+1
T(k,2:$)=T(k-1,2:$)+T(k-1,1:$-1);
end;
endfunction;
Cette fonction permet de calculer les coefficients
du binôme sans avoir à manipuler des nombres inuti1000
lement grands. On peut ainsi calculer
et vérifier en utilisant l’approximation par la formule de
500
2n
(2n)!
2n
2
Stirling :
=
∼√ .
2
n
(n!)
πn
n=500;T=pascal(2*n);T(2*n+1,n+1)
2^(2*n)/sqrt(%pi*n)
--> ans =
2.703+299
ans =
2.704+299
1.13.
function [P,T]=crible(n)
//crible d’Eratosthene
T=ones(1,n);T(1)=0;
for k=2:sqrt(n)
ind=k*(2:n/k);
ind=ind(ind<=n);
T(ind)=0;
end;
P=find(T);
endfunction;
n=10000;
[P,T]=crible(n);
plot2d(1:n,cumsum(T).*log(x)./x);
8.2
Chapitre 2
2.6.
La fonction de répartition de la loi de Weibull définit une bijection de ]0, +∞[ sur ]0, 1[ dont la bijection
1
1/a
réciproque est donnée par F −1 (y) = − [ln(1 − y)] . Il en résulte que si U suit la loi uniforme sur [0, 1],
λ
1
1/a
F −1 (U ) suit la loi de Weibull ; mais 1 − U suit aussi la loi uniforme sur [0, 1], et − [ln U ]
suit donc
λ
la loi de Weibull, ce qui permet de la simuler rapidement.
On voit ainsi que le paramètre λ est un paramètre d’échelle : si X suit la loi de Weibull de paramètres a
1
et 1, X suit la loi de Weibull de paramètres a et λ.
λ
Pour a = 1, on retrouve la loi exponentielle (et une façon rapide de la simuler à partir de la loi uniforme).
99
Si X suit la loi de Weibull de paramètres a et λ, alors, pour tout entier n ≥ 0 :
E(X n ) =
1 n
Γ
1
+
λn
a
(effectuer le changement de variable (λx)a = t).
a α
2.7. La fonction de répartition F (x) = e−( x ) s’inverse aisément : F −1 (x) = a(− ln x)−1/α . Il en résulte
que a(− log U )−1/α suit la loi de Fréchet de paramètres a et α si U suit la loi uniforme sur [0, 1].
//simulation de la loi de Fréchet
a=2;alpha=4;
t=linspace(0.01,6);
plot2d(t,exp(-(a ./t).^alpha));//fonction de répartition
n=10000;
x=a*(-log(rand(1,n))).^(-1/alpha);//échantillon
xx=gsort(x,’g’,’i’);
plot2d2([0,xx],(0:n)/n,style=5);
2.9.
n=1000;
alpha=0.1;
x=grand(n,3,’gam’,alpha,1);
s=sum(x,’c’);
subplot(121);
plot(x(:,1)./s,x(:,2)./s,’.r’);
a=gca();a.data_bounds=[0,0;1,1];
xtitle(’Loi de Dirichlet : alpha=0.1’);
alpha=3;
x=grand(n,3,’gam’,alpha,1);
s=sum(x,’c’);
subplot(122);
plot(x(:,1)./s,x(:,2)./s,’.r’);
a=gca();a.data_bounds=[0,0;1,1];
xtitle(’Loi de Dirichlet : alpha=3’);
100
Loi de Dirichlet : alpha=0.1
Loi de Dirichlet : alpha=3
1.0
1.0
0.9
0.9
0.8
0.8
0.7
0.7
0.6
0.6
0.5
0.5
0.4
0.4
0.3
0.3
0.2
0.2
0.1
0.1
0.0
0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
0.0
0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
2) Si X suit la loi exponentielle de paramètre λ > 0, F (x) = 1 − e−λx pour x ≥ 0, d’où
1
1
F −1 (y) = − ln (1 − y). La formule précédente s’écrit Z = m − ln (1 − U ). Mais la variable aléatoire
λ
λ
1
− ln (1 − U ) suit la loi exponentielle de paramètre λ. Il en résulte que m + X suit la loi conditionnelle de
λ
X sachant X > m. On retrouve ainsi la propriété bien connue d’absence de mémoire de la loi exponentielle.
2.10.
2.11.
nmax=5;
nb=10000;//nombre de simulations
pr=zeros(1,nmax);//probabilites empiriques
d=ones(1,nmax);//estimation de (det(A))^2
for n=2:nmax
r=zeros(1,nb);
for k=1:nb
a=ones(n,n);
a(rand(a)<0.5)=-1;
r(k)=det(a);
end;
pr(n)=sum(r==0)/nb;
d(n)=mean(r.^2);
end;
xbasc();
plot2d(2:nmax,pr(2:nmax))
pr,d
On ne connaît pas de formule explicite pour la probabilité que le déterminant de A soit nul, mais l’espérance de (det A)2 = det(A2 ) est facile à calculer (elle est égale à n!).
2.12.
//etude du temps de retour en 0 de X
nbsimul=10000;n=50;t=zeros(1,nbsimul);
for k=1:nbsimul
x=cumsum(2*round(rand(1,n))-1);
101
t(k)=min(find(x==0));
end;
xbasc();xselect();
subplot(121);
histplot(0.5:n+0.5,t);
p=zeros(1:n);
p(2)=0.5;
for k=2:n/2
p(2*k)=p(2*k-2)*(2*k-3)/2/k;
end;
plot2d3(1:n,p,style=5);
legends([’Loi empirique’,’Loi théorique’],[1 5],1);
xtitle(’Loi de T1’);
n=100;
p=zeros(1:n);
p(2)=0.5;
for k=2:n/2
p(2*k)=p(2*k-2)*(2*k-3)/2/k;
end;
subplot(122);
plot2d2(1:n,1-cumsum(p),style=2);
plot2d(1:n,sqrt(2/%pi ./(1:n)),style=5);
legends([’Valeur exacte’,’Equivalent’],[2 5],1);
xtitle(’Queue de la loi de T1’);
2.13. La formule de Stirling donne :
P(S2n = 0) =
2n 1
n 22n
∼
n→∞
1
√ .
πn
La proportion de trajectoires conservées dans une méthode de rejet tend donc vers 0 quand n tend vers
l’infini. Cette méthode n’est donc pas utilisable si n est grand.
On peut par contre simuler directement une telle marche conditionnée à revenir en 0 à l’instant 2n en
remarquant que
P(Sk+1 = l + 1 | Sk = l) =
2n − k − l
,
2(2n − k)
P(Sk+1 = l − 1 | Sk = l) =
2n − k + l
2(2n − k)
pour tout couple (k, l) vérifiant 0 ≤ k ≤ 2n − 1, |l| ≤ min(k, 2n − k).
On peut par exemple utiliser cette méthode pour étudier la loi du maximum d’une telle marche :
//marche aleatoire conditionnee a revenir en 0
n=100;
x=zeros(1,2*n+1);
for k=1:2*n
if rand()<(2*n-k+1-x(k))/2/(2*n-k+1) then
x(k+1)=x(k)+1;
else x(k+1)=x(k)-1;
end;
end;
plot2d(0:2*n,x)
//version vectorialisee
ns=1000;//nombre de simulations
x=zeros(ns,2*n+1);
for k=1:2*n
ind=find(rand(ns,1)<(2*n-k+1-x(:,k))/2/(2*n-k+1));
x(:,k+1)=x(:,k)-1;
102
x(ind,k+1)=x(ind,k)+1;
end;
xbasc();
histplot(20,max(x,’c’))
14
0.09
12
0.08
0.07
10
0.06
8
0.05
6
0.04
4
0.03
2
0.02
0
0.01
−2
0.00
0
20
40
60
80
100
120
140
160
180
200
0
5
10
15
20
25
30
2.14.
function [n,t]=nbappar(x,s)
m=length(s);
b=x(1:$-m+1)==s(1);
for k=2:m
b=b&x(k:$-m+k)==s(k);
end;
n=sum(b);
t=min(find(b));
if t<>[] then t=t+m-1;end;
t(t>length(x))==%inf;
endfunction;
function [n,t]=nbappar2(x,s)
m=length(s);
b=x(:,1:$-m+1)==s(1);
for k=2:m
b=b&x(:,k:$-m+k)==s(k);
end;
n=sum(b,’c’);
t=sum(cumprod(1-bool2s(b),’c’),’c’)+m;
t(t>size(x,’c’))=%inf;
endfunction;
nbsimul=10000;longueur=100;
x=round(rand(nbsimul,longueur));
[n0,t0]=nbappar2(x,[0 0]);
mean(n0),mean(t0)
[n1,t1]=nbappar2(x,[0 1]);
mean(n1),mean(t1)
2.17. La fonction nb renvoie la somme des rangs des xi dans le vecteur obtenu en concaténant x et y,
n(n + 1)
. Or cette somme vaut :
diminuée de
2


m
n
n
n m
X
X
X
n(n + 1) X X

1yj <xi  =
1xk ≤xi +
1yj <xi .
+
2
j=1
i=1
i=1 j=1
k=1
103
nbsimul=10000;
n=100;m=300;
nbs=zeros(1,nbsimul);
for k=1:nbsimul
nbs(k)=nb(rand(1,n),rand(1,m));
end;
disp(’Moyenne empirique: ’+string(mean(nbs)));
mth=n*m/2;
disp(’Moyenne théorique: ’+string(mth));
disp(’Variance empirique: ’+string(variance(nbs)));
vth=n*m*(n+m+1)/12;
disp(’Variance théorique: ’+string(vth));
histplot(50,(nbs-mth)/sqrt(vth));
t=linspace(-4,4);
plot2d(t,exp(-t.^2/2)/sqrt(2*%pi),style=5);
2.19.
function [xs,nb]=tri(x)
//xs: x ordonné par ordre croissant
//nb: nombre de comparaisons
//tri par insertion
xs=x(1);nb=0;//initialisation
for i=2:length(x)
//on compare x(i) aux elements deja ranges:
j=1;nb=nb+1;
while (j<i)&(x(i)>xs(j))
j=j+1;nb=nb+1;
end;
if j==i then nb=nb-1;end;
//on met x(i) a sa place:
xs=[xs(1:j-1),x(i),xs(j:$)];
end;
endfunction;
n=20;//taille du vecteur
nbs=10000;//nombre de simulations
nbcomps=zeros(1,nbs);//nombres de comparaisons
for k=1:nbs
x=rand(1,n);
[xs,nb]=tri(x);
nbcomps(k)=nb;
//on verifie quand meme en envoyant un message d’erreur
//si une des simulations renvoie un resultat faux
if or(xs<>gsort(x,’g’,’i’)) then error (’Erreur!’);end;
end;
mean(nbcomps)
n*(n+3)/4-sum(1 ./(1:n))
histplot(10,nbcomps);
8.3
Chapitre 3
3.1. On effectue 10000 simulations d’un échantillon de taille 10 et on calcule la moyenne des variances
empiriques de ces échantillons :
nb=10000;n=10;
x=rand(nb,n);
104
xbar=mean(x,’c’);
sigma2=sum((x-xbar(:,ones(1,n))).^2,’c’);
mean(sigma2)
--> ans =
0.7480254
On sait que la variance théorique est 1/12 :
(n-1)/n/12
--> ans =
0.075
La commande variance de Scilab donne la variance empirique sans biais :
mean(variance(x,’c’))
ans =
0.0831139
3.2. La probabilité P(Xi = max(Xj | j ≤ i)) que i soit un record est égale à 1/i pour tout i. L’espérance
n
X
1
du nombre de records est donc égale à
.
i
i=1
n=100;nb=1000;
x=rand(nb,n);
mx=zeros(x);
for k=1:n,
mx(:,k)=max(x(:,1:k),’c’);
end;
r=sum(x==mx,’c’);
mean(r)
sum(1 ./[1:n])
3.3.
n=20;
xy=2*rand(2,n)-1;
square();
t=linspace(0,2*%pi);
plot2d(cos(t),sin(t));
plot(xy(1,:),xy(2,:),’or’);
sum(sum(xy.^2,’r’)<1)
n=100000;
xy=2*rand(2,n)-1;
4*sum(sum(xy.^2,’r’)<1)/n
On obtient ainsi une valeur approchée de π par une méthode de Monte-Carlo.
3.4.
n=10;//nombre de pas
ns=500;//nombre de simulations
theta=2*%pi*rand(ns,n);
x=sum(cos(theta),’c’);
y=sum(sin(theta),’c’);
xbasc;square;
plot2d(x,y,style=-1);
sum(x^2+y^2<1)/ns
1/(n+1)
3.7.
105
alpha=1;
n=10000;
x=grand(1,n,’unf’,-1,1).*(1:n)^alpha;
m=cumsum(x)./(1:n);
//converge si alpha<0.5
xset(’window’,0);
xbasc();
plot2d(1:n,m);
n=1000;
nb=10000;
stacksize(3e7);
x=grand(nb,n,’unf’,-1,1).*(ones(nb,1)*(1:n)^alpha);
v=sum((1:n)^(2*alpha))/3;
y=sum(x,’c’)/sqrt(v);
//converge vers la loi normale pour tout alpha>0
xset(’window’,1);
xbasc();
histplot(20,y);
t=linspace(min(y),max(y));
plot2d(t,exp(-t.^2/2)/sqrt(2*%pi),style=5);
8.4
Chapitre 4
4.1.
b=[4 -2];
y=b*points;//échantillon obtenu par combinaison linéaire
mu=b*m;//moyenne théorique de l’échantillon transformé
sigma2=b*Gamma*b’;//variance théorique de l’échantillon transformé
histplot(20,y);//histogramme
t=linspace(min(y),max(y));
//densité théorique
plot2d(t,exp(-(t-mu).^2/2/sigma2)/sqrt(2*%pi*sigma2),style=5);
0.09
0.08
0.07
0.06
0.05
0.04
0.03
0.02
0.01
0.00
−15
−10
−5
0
5
10
15
4.2.
c=[2 -1;-2 1;4 2];//matrice de la transformation linéaire
p3=c*points;//nuage de points de R^3
param3d1(p3(1,:),p3(2,:),list(p3(3,:),-ones(p3(1,:))))
106
20
40
−6
−4
30
−2
Z
20
0
10
2
0
4
−10
6
−10
−8
−6
X
8
−4
−2
Y
0
10
2
4
6
4.3.
pts=points-m(:,ones(1,n));//échantillon centré
xi=sum((inv(Gamma)*pts).*pts,’r’);//échantillon de (X-m)Gamma^(-1)(X-m)
histplot(20,xi);
t=linspace(min(xi),max(xi));
plot2d(t,exp(-t/2)/2,style=5);//densité de la loi du chi-deux
0.50
0.45
0.40
0.35
0.30
0.25
0.20
0.15
0.10
0.05
0.00
0
2
4
6
8
10
4.4.
n=100;
p=[0.2;0.5;0.3];
//échantillon généré par tirages répétés de la loi p
r=rand(1,n);
cp=[0;cumsum(p)];
x=zeros(length(p),n);//échantillon de taille n de la loi p
for k=1:length(p)
x(k,r>=cp(k)&r<cp(k+1))=1;
end;
y=sum(x,’c’);//réalisation de la loi multinomiale
Gamma=mvvacov(x’)//matrice de covariance empirique de x
det(Gamma)//vérification: det(Gamma)=0
ones(1,length(p))*Gamma*ones(length(p),1)//vérification: 0
cov=diag(p)-p*p’//matrice de covariance théorique
107
12
d2=sum((y-n*p).^2 /n ./p)//distance du chi-deux sur l’échantillon
//échantillon de la loi multinomiale par grand
y1=grand(1,’mul’,n,p(1:$-1));
d2=sum((y1-n*p).^2 /n ./p)//distance du chi-deux
//échantillon de la loi multinomiale par grand
//et comparaison à la loi du chi-deux
nbsimul=1000;
y2=grand(nbsimul,’mul’,n,p(1:$-1));
pp=p(:,ones(1,nbsimul));
d2=sum((y2-n*pp).^2 ./pp/n,’r’);//distance du chi-deux
histplot(50,d2);
t=linspace(min(d2),max(d2));
plot2d(t,exp(-t/2)/2,style=5);//la densité de la loi du chi-deux à 2 degrés
4.8.
//simulation du pont brownien
stacksize(3e7);
nbsimul=1000;
nbpas=1000;
Z=grand(nbsimul,nbpas,’nor’,0,1/sqrt(nbpas));
Z=cumsum(Z,’c’);
Z=Z-Z(:,$)*(1:nbpas)/nbpas;
//représentation graphique de quelques trajectoires
xset(’window’,0);
xbasc();
for k=2:6
plot2d((0:nbpas)/nbpas,[0,Z(k,:)],style=k);
end;
//étude de la loi du maximum
Zmax=max(abs(Z),’c’);
xset(’window’,1);
xbasc();
histplot(20,Zmax,style=2);
t=linspace(0,max(Zmax));
plot2d((t(1:$-1)+t(2:$))/2,(pks(t(2:$))-pks(t(1:$-1)))/(t(2)-t(1)),style=5);
8.5
Chapitre 5
5.1.
P=genmarkov([1 3],4)
P^100
[M,Q]=eigenmarkov(P);
L=Q*M
La matrice M a deux lignes représentant les deux mesures invariantes extrémales portées par les deux
classes récurrentes, et la matrice Q deux colonnes représentant les probabilités de terminer dans l’une de
ces deux classes en partant d’un état donné. La i-ième ligne de la matrice QM représente la loi limite de
Xn sachant X0 = i, comme on peut le vérifier :
ns=10000;//nombre de simulations
x=grand(100,’markov’,P,8*ones(1,ns));
[ind,occ]=dsearch(x(:,$),1:8,’d’);
occ/ns
L(8,:)
108
5.2.
N=5;
P=genmarkov(N,0);
n=1000000;
x=grand(n,’markov’,P,1);
Q=zeros(P);
for i=1:N
ni=sum(x(2:$)==i);
for j=1:N
Q(i,j)=sum(x(2:$)==i&x(1:$-1)==j)/ni;
end;
end;
pi=eigenmarkov(P);
Q
Q1=diag(1 ./pi)*P’*diag(pi)
norm(Q-Q1)
Remarque : on montre facilement que si Xn est stationnaire (la loi de Xn est π pour tout n), alors le
processus retourné est une chaîne de Markov de matrice de transition Q ; il en résulte, comme un calcul
immédiat le montre également, que π est aussi vecteur propre à gauche de Q. La chaîne de Markov Xn
atteint rapidement son équilibre, ce qui explique que Q̃ est proche de Q.
5.3.
function nbs=nbsancetres(N)
x=1:N;
nbs=N;
while nbs($)>1
r=grand(1,N,’uin’,1,N);
x=r(x);
nbs=[nbs,length(unique(x))];
end;
endfunction;
20
18
16
14
12
10
8
N=20;
nbsimul=5;
temps=zeros(1,nbsimul);
xset(’window’,0);xbasc();
for k=1:nbsimul
nbs=nbsancetres(N);
plot2d(1:length(nbs),nbs,style=k+1);
temps(k)=length(nbs);
end;
6
4
2
0
0
10
20
30
40
50
60
0.030
0.025
0.020
0.015
nbsimul=1000;
temps=zeros(1,nbsimul);
for k=1:nbsimul
nbs=nbsancetres(N);
temps(k)=length(nbs);
end;
xset(’window’,1);xbasc();
histplot(20,temps);
0.010
0.005
0.000
0
5.4.
n=10;N=2*n;//nombre total d’individus
m=5;//nombre initial d’individus de type A
P=zeros(N+1,N+1);//matrice de transition
109
20
40
60
80
100
120
140
for i=0:N, P(i+1,:)=binomial(i/N,N);end;
nbsimul=10000;nbgen=200;
x=grand(nbgen,’markov’,P,(m+1)*ones(1,nbsimul));
ind0=find(x(:,$)==1);//fixation en 0
x0=x(ind0,:);//trajectoires se fixant en 0
temps0=sum(x0>1,’c’)+1;//temps de fixation empirique en 0
subplot(221);
histplot(0:50,temps0,style=2);
indN=find(x(:,$)==N+1);//fixation en N
xN=x(indN,:);//trajectoires se fixant en N
tempsN=sum(xN<N+1,’c’)+1;//temps de fixation empirique en N
subplot(222);
histplot(0:50,tempsN,style=2);
P0=zeros(N+1,N+1);//matrice de transition de la chaîne conditionnée à se fixer en 0
P0(N+1,N+1)=1;
for i=0:N-1, P0(i+1,1:$-1)=binomial(i/N,N-1);end;
x00=grand(nbgen,’markov’,P0,(m+1)*ones(1,nbsimul));
temps00=sum(x00>1,’c’)+1;//temps de fixation empirique en 0
subplot(223);
histplot(0:50,temps00,style=5);
PN=zeros(N+1,N+1);//matrice de transition de la chaîne conditionnée à se fixer en N
PN(1,1)=1;
for i=1:N, PN(i+1,2:N+1)=binomial(i/N,N-1);end;
xNN=grand(nbgen,’markov’,PN,(m+1)*ones(1,nbsimul));
tempsNN=sum(xNN<N+1,’c’)+1;//temps de fixation empirique en N
subplot(224);
histplot(0:50,tempsNN,style=5);
0.07
0.035
0.06
0.030
0.05
0.025
0.04
0.020
0.03
0.015
0.02
0.010
0.01
0.00
0.005
0
5
10
15
20
25
30
35
40
45
50
0.000
0.07
0.035
0.06
0.030
0.05
0.025
0.04
0.020
0.03
0.015
0.02
0.010
0.01
0.00
0
5
10
15
20
25
30
35
40
45
50
0
5
10
15
20
25
30
35
40
45
50
0.005
0
5
10
15
20
25
30
35
40
45
50
0.000
5.5.
function p=borel(theta,nmax)//la loi de Borel
//loi de Borel de parametre theta
p=exp(-theta)*ones(1,nmax);
for k=2:nmax
p(k)=p(k-1)*theta*exp(-theta)*(k/(k-1))^(k-2);
end;
endfunction;
function y=poptot(theta)//simulation de la population totale
110
z=1;y=1;
while z>0
z=sum(grand(1,z,’poi’,theta));
y=y+z;
end;
endfunction;
nbsimul=10000;theta=0.9;
y=zeros(1,nbsimul);
for k=1:nbsimul
y(k)=poptot(theta);
end;
nmax=30;
disp(’Moyenne: ’+string(mean(y))+’ ; Espérance théorique: ’+string(1/(1-theta)));
p=borel(theta,nmax);
histplot(0:nmax,y);
plot(1:nmax,p,’or’);
8.6
Chapitre 6
6.1. //loi de S_n
n=10;nbsimul=10000;lambda=2;
Sn=sum(grand(nbsimul,n,’exp’,1/lambda),’c’);
histplot(50,Sn);
x=linspace(0,max(Sn));
plot2d(x,exp(-lambda*x)*lambda^n .*x.^(n-1)/prod(1:n-1),style=5);
6.2. nbsimul=10000;
lambda=2;t=10;
results=zeros(1,nbsimul);
T=cumsum(grand(nbsimul,50,’exp’,1/lambda),’c’);
for k=1:nbsimul
ind=max(find(T(k,:)<t));
results(k)=T(k,ind+1)-T(k,ind);
end;
mean(results)
(2-exp(-lambda*t))/lambda
//test du chi-deux
mu=lambda*t;
p=exp(-mu)*mu.^(0:30)./[1,cumprod(1:30)];//loi theorique
//ou: cp=cdfpoi(’PQ’,0:30,mu*ones(1,31));
//p1=cp-[0,cp(1:$-1)];
[ind,occ]=dsearch(Nt,0:30,’d’);
pth=[sum(p(1:10)),p(11:31),1-sum(p)];//regroupement de valeurs
fr=[sum(occ(1:10)),occ(11:31),nbsimul-sum(occ)]/nbsimul;//frequences empiriques
d2=nbsimul*sum((fr-pth).^2 ./pth);//distance du chi-deux
cdfchi(’PQ’,d2,length(pth)-1)
6.3.
//non-correlation des accroissements sur [a,b] et [c,d] disjoints
a=2;b=5;c=5;d=10;
lambda=2;
nbsimul=10000;
T=cumsum(grand(nbsimul,50,’exp’,1/lambda),’c’);
111
Nab=sum(T>a&T<b,’c’);Ncd=sum(T>b&T<d,’c’);
cv=corr(Nab,Ncd,1)//covariance empirique
cv/sqrt(corr(Nab,Nab,1)*corr(Ncd,Ncd,1))//coefficient de correlation
6.6. //superposition
t=1000;
lambda=2;mu=3;
Nt=grand(1,1,’poi’,t*lambda);
Mt=grand(1,1,’poi’,t*mu);
S1=t*rand(1,Nt);
S2=t*rand(1,Mt);
S=gsort([S1,S2],’g’,’i’);
X=S-[0,S(1:$-1)];
histplot(20,X);
x=linspace(0,max(X));
nu=lambda+mu;
plot2d(x,nu*exp(-nu*x),style=5)
6.7. On peut commencer par représenter quelques trajectoires des processus obtenus en décomposant
un processus de Poisson :
lambda=5;p=0.3;n=20;
s=cumsum(grand(1,n,’exp’,1/lambda));//instants d’arrivée du processus initial
u=rand(s);
s1=s(u<p);s2=s(u>=p);//les deux processus obtenus par décomposition
plot2d2([0,s],0:n,style=2);
plot2d2([0,s1],0:length(s1),style=3);
plot2d2([0,s2],0:length(s2),style=5);
Le programme suivant teste la non-corrélation des valeurs en t = 10 des deux processus obtenus en
décomposant un processus de Poisson de paramètre λ = 5.
lambda=5;p=0.3;t=10;nbsimul=10000;
Nt1=zeros(1,nbsimul);Nt2=Nt1;
for k=1:nbsimul
Nt=grand(1,1,’poi’,lambda*t);//nombre d’arrivées du processus initial
Nt1(k)=grand(1,1,’bin’,Nt,p);//nombre d’arrivées des processus décomposés
Nt2(k)=Nt-Nt1(k);
end;
corr(Nt1,Nt2,1)
6.8. //processus de Poisson composé à loi de sauts gaussienne
nmax=30;lambda=2;nbsimul=10000;t=5;m=0.5;sigma=1;
Zt=zeros(1,nbsimul);
for k=1:nbsimul
S=cumsum(grand(1,nmax,’exp’,1/lambda));
n=sum(S<t);
if n==nmax then warning(’augmentez nmax’);end;
Zt(k)=sum(grand(1,n,’nor’,m,sigma));
end;
mean(Zt)
lambda*t*m
variance(Zt)
lambda*t*(m^2+sigma^2)
6.9. Simulation d’un processus de Poisson d’intensité λ(t) = 50(1 + cos 2πt) :
112
lambda=100;
n=1000;
s=cumsum(grand(1,n,’exp’,1/lambda));//processus de Poisson d’intensité 100
u=rand(s);
s1=s(u<(1+cos(s*2*%pi))/2);
plot2d2([0,s1],0:length(s1),style=2);
length(s1(cos(s1*2*%pi)<0))/length(s1)
On vérifie que les accroissements de ce processus sur un intervalle de temps
[a, b] suivent la loi de Poisson
Rb
sin(2πt)
:
de paramètre m(b) − m(a) = a λ(u) du, i.e. m(t) = 50 t +
2π
a=1.25;b=1.5;lambda=100;n=300;
nbsimul=10000;
Delta=zeros(1,nbsimul);
for k=1:nbsimul
s=cumsum(grand(1,n,’exp’,1/lambda));
u=rand(s);
s1=s(u<(1+cos(s*2*%pi))/2);
Delta(k)=sum(s1>a&s1<=b);
end;
histplot(-0.5:20.5,Delta)
mu=50*(0.25-1/2/%pi);//moyenne théorique
p=exp(-mu).*mu.^(0:20)./[1,cumprod(1:20)];
plot2d3(0:20,p,style=3);
On peut aussi effectuer un grand nombre de simulations et représenter l’intensité empirique du processus
des arrivées :
n=100;nbsimul=10000;lambda=50;
s=cumsum(grand(nbsimul,n,’exp’,1/lambda),’c’);
u=rand(s);
s=s(u<(1+cos(s*2*%pi))/2);
s=s(s<1);
histplot(50,s);
t=linspace(0,1);
plot(t,1+cos(2*%pi*t),’r’);
6.10.
lambda=100;
nbsimul=10000;
N1=zeros(1,nbsimul);N2=N1;
for k=1:nbsimul
N=grand(1,1,’poi’,lambda);
x=rand(1,N);y=rand(1,N);
N1(k)=sum((x-0.2).^2+(y-0.6).^2<0.2^2);
N2(k)=sum(y<=x);
end;
mean(N1)
ans =
12.5686
mean(N2)
ans =
50.0367
corr(N1,N2,1)
ans =
- 0.3520676
113
On constate par contre que si le nombre total de points était fixé (égal à λ), les espérances de N1 et
N2 ne changeraient pas, mais la covariance serait beaucoup plus importante : en remplaçant la ligne
N=grand(1,1,’poi’,lambda); par N=lambda; on obtient :
corr(N1,N2,1)
ans =
- 6.2280674
6.12.
n=20;lambda=2;
//for k=1:10
p=cumsum(grand(1,n,’exp’,1/lambda));
theta=2*%pi*rand(1,n);
pmax=max(p);
x=[p.*cos(theta)-pmax*sin(theta);p.*cos(theta)+pmax*sin(theta)];
y=[p.*sin(theta)+pmax*cos(theta);p.*sin(theta)-pmax*cos(theta)];
xbasc();plot2d(x,y,axesflag=1,style=2*ones(1,n));
square(-pmax/sqrt(2),-pmax/sqrt(2),pmax/sqrt(2),pmax/sqrt(2));
//xpause(1e6);
//end;
n=10000;x0=20;y0=-40;
p=cumsum(grand(1,n,’exp’,1/lambda));
theta=2*%pi*rand(1,n);
//distances des doites au point (x0,y0)
dist=abs(x0*cos(theta)+y0*sin(theta)-p);
dist=gsort(dist(1:n/2),’g’,’i’);
//differences
inter=dist-[0,dist(1:$-1)];
histplot(50,inter)
t=linspace(0,max(inter));
plot2d(t,lambda*exp(-lambda*t),style=5);
6.13.
function pi=eigen1(Q)
p=kernel(Q’);
pi=p’/sum(p);
endfunction;
6.14.
l=3;m=4;Q=[-l,l;m,-m];n=100000;x0=1;
timer();[x1,t1]=traj1(n,Q,x0);timer()
timer();[x2,t2]=traj2(n,Q,x0);timer()
timer();[x3,t3]=traj3(n,Q,x0);timer()
sum(x3(2:$)<>x3(1:$-1))//nombre réel de sauts
pi=eigen(Q);pi1=eigen1(Q);
pi(1),pi1(1)
sum(t1(x1==1))/sum(t1)
sum(t2(x2==1))/sum(t2)
sum(t3(x3==1))/sum(t3)
6.15. Le système peut se trouver dans l’un des quatre états suivants :
1. les trois composants fonctionnent ;
2. A est en panne, B et C fonctionnent ;
3. B est en panne, A et C fonctionnent ;
114
4. le système est en panne.
Le caractère exponentiel des durées de vie des différents composants et leur indépendance font alors du
système un processus de Markov à temps continu de générateur :


−λ − µ − ν
λ
µ
ν

0
−µ − ν
0
µ + ν
 .
Q=

0
0
−λ − ν λ + ν 
0
0
0
0
La loi p(t) = (p1 (t), p2 (t), p3 (t), p4 (t)) du système à l’instant t vérifie alors l’équation de Kolmogorov
p′ (t) = p(t)Q, i.e. p(t) = p(0)etQ . On peut, pour représenter l’évolution de la loi de l’état du système
en fonction du temps, utiliser la commande ode qui permet de résoudre l’équation différentielle, ou la
commande expm qui calcule l’exponentielle d’une matrice.
lambda=3;mu=2;nu=4;
Q=[-(lambda+mu+nu) lambda mu nu;
0 -mu-nu 0 mu+nu;
0 0 -lambda-nu lambda+nu;
0 0 0 0];
function dy=f(t,y)
dy=Q’*y;
endfunction;
//résolution numérique de l’équation différentielle
t=linspace(0,1);
p=ode([1 0 0 0]’,0,t,f);
subplot(121);
plot2d(t(ones(1,4),:)’,p’);
legends([’p1’ ’p2’ ’p3’ ’p4’],1:4,4);
//utilisation de l’exponentielle matricielle
subplot(122);
h=0.01;
t=0:h:1;
Ph=expm(h*Q);
P=zeros(length(t),4);
P(1,:)=[1 0 0 0];
for k=1:length(t)-1, P(k+1,:)=P(k,:)*Ph; end;
plot2d(t(ones(1,4),:)’,P);
legends([’p1’ ’p2’ ’p3’ ’p4’],1:4,4);
On peut ensuite simuler la durée de fonctionnement des divers composants :
nbsimul=1000;
A=grand(nbsimul,1,’exp’,1/lambda);
B=grand(nbsimul,1,’exp’,1/mu);
C=grand(nbsimul,1,’exp’,1/nu);
Pemp=zeros(length(t),4);
for k=1:length(t)
Pemp(k,1)=sum(A>t(k)&B>t(k)&C>t(k));
Pemp(k,2)=sum(A<=t(k)&B>t(k)&C>t(k));
Pemp(k,3)=sum(A>t(k)&B<=t(k)&C>t(k));
Pemp(k,4)=sum((A<=t(k)&B<=t(k))|(C<=t(k)));
end;
Pemp=Pemp/nbsimul;
subplot(122)
plot2d(t(ones(1,4),:)’,Pemp);
legends([’p1’ ’p2’ ’p3’ ’p4’],1:4,4);
xtitle(’Loi empirique’);
Loi théorique
1.0
Loi empirique
1.0
p1
0.9
p2
p1
0.9
p3
0.8
6.16.
115
p4
p2
p3
0.8
p4
0.7
0.7
0.6
0.6
0.5
0.5
0.4
0.4
0.3
0.3
0.2
0.2
0.1
0.1
0.0
0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
0.0
0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
function [ma,mr,mn]=moyennes(a,s,e,d,n)
//a,s,e,d,n: mêmes notations que dans la fonction GG1
//ma: temps d’attente moyen
//mr: temps de réponse moyen
//mn: longueur moyenne de la file
rep=d-a;mr=mean(rep);
att=rep-s;ma=mean(att);
temps=e(2:$)-e(1:$-1);
mn=sum(temps.*n(1:$-1))/(e($)-e(1));
endfunction;
6.18.
//file MM1
m=50000;lambda=2;mu=2.5;
a=cumsum(grand(1,m,’exp’,1/lambda));
s=grand(1,m,’exp’,1/mu);
[e,d,n]=GG1(a,s);
[ma,mr,mn]=moyennes(a,s,e,d,n)
lambda*mr//formule de Little
//xset(’window’,1);xbasc();
//plot2d2([0,e],[0,n]);
//recherche de la loi stationnaire
nmax=max(n);//longueur maximale de la file
//on élimine les temps d’initialisation et de vidage
m0=0.1*m;m1=1.8*m;
t=zeros(1,nmax+1);
for k=0:nmax
ind=find(n(m0:m1)==k);
t(k+1)=sum(e(ind+m0)-e(ind+m0-1));
end;
t=t/(e(m1+1)-e(m0));
loi=(1-lambda/mu)*(lambda/mu).^(0:nmax);//loi géométrique
xset(’window’,2);xbasc();
plot2d2(0:nmax,t,style=2);
plot2d2(0:nmax,loi,style=5);
6.19.
tmax=100;lambda=1;mu=1.2;
t=-log(rand())/lambda;//première arrivée
n=1;//longueur de la file
while t($)<tmax
if n($)==0 then t=[t,t($)-log(rand())/lambda];n=[n,n($)+1];
else
r1=-log(rand())/lambda;
r2=-log(rand())/mu;
if r1<r2 then t=[t,t($)+r1];n=[n,n($)+1];
else t=[t,t($)+r2];n=[n,n($)-1];
end;
end;
end;
plot2d2([0,t],[0,n],style=2,rect=[0 0 tmax max(n)+1])
6.20.
//file MMinf
lambda=10;//intensité d’arrivées
mu=1;//inverse du temps moyen de service
116
//représentation d’une trajectoire
n=10000;//nombre d’arrivées
x=grand(1,n,’exp’,1/lambda);//temps inter-arrivées
a=cumsum(x);//instants d’arrivées
s=grand(a,’exp’,1/mu);//temps de service
d=a+s;//instants de départs
evts=[a,d];//événements (arrivées ou départs)
dnt=[ones(a),-ones(d)];//variation du nombre de clients
[evts,ind]=gsort(evts,’g’,’i’);//événements ordonnés
dnt=dnt(ind);
nt=cumsum(dnt);//nombre de clients aux instants d’arrivées ou de départs
xset(’window’,1);xbasc();
plot2d2([0,evts],[0,nt]);
//théorème ergodique:
n1=50;n2=2*n-50;
temps=evts(n1+1:n2+1)-evts(n1:n2);//durées entre deux événements
nbs=nt(n1:n2);//nombre de clients présents
mnbs=sum(temps.*nbs)/sum(temps)//nombre moyen de clients
nbmax=max(nbs);
fr=zeros(1,nbmax+1);
for k=0:nbmax
fr(k+1)=sum(temps(nbs==k));
end;
fr=fr/sum(fr);
xset(’window’,2);xbasc();
subplot(121);
xtitle(’Theoreme ergodique’);
plot2d2(-0.5:nbmax-0.5,fr);
pc=cdfpoi(’PQ’,0:max(nbs),lambda/mu*ones(1,nbmax+1));
p=pc-[0,pc(1:$-1)];//loi de Poisson
plot2d3(0:nbmax,p,style=5);
//convergence vers la loi stationnaire:
//loi empirique de Nt pour t=10
nbsimul=1000;n=200;t=10;
x=grand(nbsimul,n,’exp’,1/lambda);//temps inter-arrivées
a=cumsum(x,’c’);//instants d’arrivées
s=grand(a,’exp’,1/mu);//temps de service
d=a+s;//instants de départs
Nt=sum(a<t,’c’)-sum(d<t,’c’);//nombre de clients présents à l’instant t
subplot(122);
xtitle(’Loi empirique de N10’);
histplot(-0.5:max(Nt)+0.5,Nt)
plot2d3(0:nbmax,p,style=5);
6.22. Représentation du flot de sortie d’une file M/M/p (on utilise la fonction MMp du texte) :
//file MMp
m=50;lambda=2.9;mu=1;p=3;
a=cumsum(grand(1,m,’exp’,1/lambda));
s=grand(1,m,’exp’,1/mu);
[e,d,n]=GGp(a,s,p);
departs=gsort(d,’g’,’i’);//départs
xbasc();
subplot(211);
plot2d2([0,e],[0,n],style=2);
xtitle(’Nombre de clients dans la file’);
subplot(212);
plot2d2([0,a],[0:m],style=2);//flot d’arrivées
117
plot2d2([0,departs],[0:m],style=3);//flot de départs
xtitle(’Flots d’’arrivées et de départs’);
legends([’arrivées’,’départs’],[2,3],2)
Nombre de clients dans la file
10
9
8
7
6
5
4
3
2
1
0
0
2
4
6
8
10
12
14
16
18
12
14
16
18
Flots d’arrivées et de départs
50
45
arrivées
40
départs
35
30
25
20
15
10
5
0
0
2
4
6
8
10
6.23.
//représentation d’une trajectoire
n=10;//nombre de cycles
EU=7;//espérance du temps de service
EV=1;//espérance du temps de panne
U=grand(1,n,’exp’,EU);//durées de service
V=2*EV*rand(1,n);//durées de réparation
UV=zeros(1,2*n);UV(1:2:2*n-1)=U;UV(2:2:2*n)=V;UV=cumsum(UV);
S=ones(1,2*n);S(2*(1:n))=0;
//plot2d2([0,UV],[0,S],frameflag=1,rect=[0,0,max(UV),3],style=2);
//proportion de temps de service
n=100000;
U=grand(1,n,’exp’,EU);
V=2*EV*rand(1,n);
sum(U)/sum(U+V)
p=EU/(EU+EV)
//état de la machine à un instant fixé
nbsimul=10000;
n=10;
U=grand(nbsimul,n,’exp’,EU);
V=2*EV*rand(nbsimul,n);
UV=zeros(nbsimul,2*n);
UV(:,1+2*(0:n-1))=U;UV(:,2*(1:n))=V;
UV=cumsum(UV,’c’);
t=linspace(0,20);
St=zeros(t);
for k=1:length(t)
St(k)=1-sum(pmodulo(sum(UV<t(k),’c’),2))/nbsimul;
end;
xbasc();
plot(t,St);
plot([0 20],[p p],’r’)
6.24. Le temps de coalescence T est somme de n − 1 variables aléatoires exponentielles indépendantes,
118
n
X
i(i − 1)
i
2
de paramètres respectifs
=
(i = 2, . . . , n). Son espérance est donc E(T ) =
=
2
2
i(i
−
1)
i=2
1
.
2 1−
n
n=20;//taille de l’echantillon
nbs=100000;//nombre de simulations
t=zeros(nbs,n-1);
for k=n:-1:2
t(:,k-1)=grand(nbs,1,’exp’,2/k/(k-1));
end;
T=sum(t,’c’);
mean(T)//moyenne empirique
2*(1-1/n)//esperance theorique
xbasc();
histplot(20,T)
On peut également représenter quelques trajectoires du processus (nombre d’ancêtres distincts en fonction
du temps) :
X=[zeros(5,1),cumsum(t(1:5,:),’c’)];
plot2d2(X’,(n:-1:1)’*ones(1,5));
6.25.
//évolution d’une population de bacteries en temps continu
//cas lambda=mu=1
a=10;b=20;//population initiale
nbsimul=10;nmax=2000;
tA=cumsum(grand(nbsimul,nmax,’exp’,1)./(ones(nbsimul,1)*(a:a+nmax-1)),’c’);
tB=cumsum(grand(nbsimul,nmax,’exp’,1)./(ones(nbsimul,1)*(b:b+nmax-1)),’c’);
[t,k]=gsort([tA,tB],’c’,’i’);
dx=zeros(t);
dx(k<=nmax)=1;
x=[a*ones(nbsimul,1),a*ones(dx)+cumsum(dx,’c’)];
y=x ./ (ones(nbsimul,1)*((a+b):(a+b)+2*nmax));
y=y(:,1:nmax);
plot2d(y’)
8.7
Chapitre 7
Si X1 , . . . , Xn est un échantillon de taille n d’une loi exponentielle de paramètre inconnu λ,
1
de cette loi est la moyenne empirique
l’estimateur du maximum de vraisemblance de l’espérance
λ
X1 + · · · + Xn
de l’échantillon. Or nλX n = λ(X1 + · · · + Xn ) suit la loi Gamma Γ(1, n). Il en
Xn =
n
résulte que
Z 1/a
1
1
1
1 =
∈ naX n , nbX n = P
≤ nλX n ≤
tn−1 e−t dt .
P
λ
b
a
Γ(n) 1/b
7.1.
1
L’intervalle naX n , nbX n est donc un intervalle de confiance de niveau α pour dès que les constantes
λ
Z 1/a
1
a et b vérifient
tn−1 e−t dt = α.
Γ(n) 1/b
La recherche de ces constantes ne dépend pas de λ et s’effectue au moyen de la fonction cdfgam. On
remarque qu’on dispose d’un certain degré de liberté dans le choix de l’une des constantes ; l’autre est
alors parfaitement déterminée.
119
n=30;//taille de l’échantillon
//intervalle de confiance au niveau alpha
alpha=0.95;
a=1/cdfgam(’X’,n,1,(1+alpha)/2,(1-alpha)/2);
b=1/cdfgam(’X’,n,1,(1-alpha)/2,(1+alpha)/2);
n*a,n*b
//vérification par simulation
lambda=3;nbsimul=10000;
x=grand(nbsimul,n,’exp’,1/lambda);
sum(a*sum(x,’c’)<1/lambda&1/lambda<b*sum(x,’c’))/nbsimul
ans =
0.7203082
ans =
1.4821494
ans =
0.9474
7.2.
function moy=idcm(x,alpha)
//intervalle de confiance au niveau alpha pour l’espérance m
//d’un échantillon gaussien x de variance inconnue
n=size(x,’*’);
xbar=mean(x);
s=sqrt(sum((x-xbar).^2)/n);
t=cdft(’T’,n-1,(1-alpha)/2,(1+alpha)/2);
moy=[xbar+t*s/sqrt(n-1),xbar-t*s/sqrt(n-1)];
endfunction;
function v=idcv(x,alpha,m)
//intervalle de confiance au niveau alpha pour la variance v
//d’un échantillon gaussien x d’espérance connue m
n=size(x,’*’);
s2=sum((x-m).^2);
k1=cdfchi(’X’,n,(1-alpha)/2,(1+alpha)/2);
k2=cdfchi(’X’,n,(1+alpha)/2,(1-alpha)/2);
v=[s2/k2,s2/k1];
endfunction;
function v=idcv2(x,alpha)
//intervalle de confiance au niveau alpha pour la variance v
//d’un échantillon gaussien x d’espérance inconnue
n=size(x,’*’);
xbar=mean(x);
s2=sum((x-xbar).^2);
k1=cdfchi(’X’,n-1,(1-alpha)/2,(1+alpha)/2);
k2=cdfchi(’X’,n-1,(1+alpha)/2,(1-alpha)/2);
v=[s2/k2,s2/k1];
endfunction;
//vérification
n=10;alpha=0.95;m=-3;sigma=2;
nbsimul=10000;
test1=0;test2=0;test3=0;
for k=1:nbsimul
x=sigma*rand(1,n,’n’)+m;
moy=idcm(x,alpha);
v=idcv(x,alpha,m);
120
v2=idcv2(x,alpha);
if moy(1)<m&m<moy(2) then test1=test1+1;end;
if v(1)<sigma^2&sigma^2<v(2) then test2=test2+1;end;
if v2(1)<sigma^2&sigma^2<v2(2) then test3=test3+1;end;
end;
disp([test1,test2,test3]/nbsimul)
Il est naturellement souhaitable (et facile) de vectorialiser ces fonctions pour en accélérer l’exécution.
7.3.
n=50;m=30;alpha=2;beta=3;
x=grand(1,n,’gam’,alpha,1);
y=grand(1,n,’gam’,beta,1);
z=grand(1,m,’bet’,alpha,beta);
//on utilise la fonction nb définie à l’exercice ???
u=nb(x./(x+y),z);
v=(u-n*m/2)/sqrt(n*m*(n+m+1)/12);
cdfnor(’PQ’,v,0,1)
7.4.
n=300;m=500;alpha=2;beta=4;
x=grand(n,1,’gam’,alpha,1);
y=grand(n,1,’gam’,beta,1);
z=grand(m,1,’bet’,alpha,beta);
[d,p]=kstwo(x./(x+y),z)
On peut également redéfinir soi-même cette fonction :
function [dmax,pval]=ks2(t,z)
z=z(:);t=t(:);n=length(t);m=length(z);
zt=[z;t];
[zts,k]=gsort(zt,’g’,’i’);
indz=bool2s(k<=m);
indt=bool2s(k>m);
fz=[0;cumsum(indz)/m];
ft=[0;cumsum(indt)/n];
xbasc();xselect();
plot2d2([0;zts],fz,style=2);
plot2d2([0;zts],ft,style=5);
dmax=max([abs(fz-ft);abs(fz(2:$)-ft(1:$-1))])
N=sqrt(n*m/(n+m));
w=(N+0.12+0.11/N)*dmax;
pval=1-pks(w);
endfunction;
t=x./(x+y);
[dmax,pval]=ks2(t,z)
121
122
Bibliographie
[1] P. Baldi, Mazliak L., Priouret P., Martingales et chaînes de Markov, Hermann, 2000.
[2] B. Bercu, D. Chafaï, Modélisation stochastique et simulation, Dunod, 2007.
[3] J.-F. Delmas, B. Jourdain, Modèles aléatoires : applications aux sciences de l’ingénieur et
du vivant, Springer, 2006.
[4] C. Graham, Chaînes de Markov, Dunod, 2008.
[5] J.-Y. Ouvrard, Probabilités, Maîtrise, agrégation, Cassini, 2000.
[6] V. Rivoirard, G. Stoltz, Statistique en action, Vuibert, 2009.
[7] G. Saporta, Probabilités, analyse des données et statistique, Technip, 2006.
[8] P. Toulouse, Thèmes de probabilités et statistique, Dunod, 1999.
[9] P. Vallois, Modélisations stochastiques et simulations, Ellipses, 2007.
[10] B. Ycart, Modèles et algorithmes markoviens, Springer, 2002.
[11] S. L. Campbell, J. -P. Chancelier, R. Nikoukhah, Modeling and simulation in Scilab/Scicos,
Springer, 2006.
123