Table des matières

1 Nombre pseudo-aléatoire 3
1.1 Générateur physique . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Générateur algorithmique . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Principe général . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Cycle et transitoire . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Variable pseudo-aléatoire 9
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.1 Méthodes génériques et méthodes spécifiques . . . . . . . 9
2.1.2 Variable pseudo-uniforme . . . . . . . . . . . . . . . . . . 10
2.2 Variable aléatoires de loi discrète . . . . . . . . . . . . . . . . . . 10
2.2.1 Méthode de découpage d’intervalles . . . . . . . . . . . . 11

1
2 TABLE DES MATIÈRES
Chapitre 1

Nombre pseudo-aléatoire

En informatique, il est impossible de générer des nombres aléatoires et il n’est

pas très pratique de connecter un ordinateur à une source externe d’évènement
aléatoires. En pratique, les applications en statistique, en ingénierie ou en science
ne nécessitent pas la simulation d’un phénomène aléatoire du moment qu’on
arrive à obtenir des échantillons qui semblent être tirés au hasard suivant une
distribution connue. C’est ce que nous appelons les nombres pseudo-aléatoire.
Il est important à ce niveau de relever deux défis majeurs : simuler la ca-
ractère aléatoire d’un phénomène et la connaissance de la distribution dont il est
issu. Bien qu’il soit possible d’utiliser des processus physiques externes comme
source de nombre aléatoire, il resterait la question de trouver la distribution
parente du processus physique utilisé. Car, sans cette information les nombres
aléatoires ne sont pas en générale très utiles. Un dernier défi auquel nous devons
faire face est l’indépendance des réalisations consécutives.
Le but de ce cours n’est pas d’étudier les différentes technologies qui existent
à ce jours pour générer les nombres aléatoires mais d’étudier les algorithmes
qui nous permettent, grâce à un ordinateur ordinaire, de générer des nombres
pseudo-aléatoires qui suivent une distribution fixée d’avance.

1.1 Générateur physique

L’idée d’utiliser des phénomènes physiques considérés comme étant aléatoires
est la plus à même de fournir des nombres aléatoires. Il suffit alors de choisir une
expérience qu’on pourra répéter un certain nombre de fois et d’enregistrer les
résultats obtenus. L’automatisation d’un tel procédé nécessite néanmoins la fa-
brication de dispositifs qui permettent, d’un côté, de répéter la même expérience
dans les même conditions. D’un autre côté, il faudra capturer le résultat de
chaque expérience dans le but de les envoyer à l’ordinateur.
Malheureusement, cette façon de faire présente plusieurs désavantages. En
plus du coût relativement onéreux du développement et de la fabrication de
ces dispositifs, leurs fonctionnements en temps réel est difficilement conciliable

3
4 CHAPITRE 1. NOMBRE PSEUDO-ALÉATOIRE

avec l’objectif de générer rapidement une grande quantité de nombres aléatoires.

D’autre part, une suite de nombres aléatoires ainsi obtenue ne peut être repro-
ductible. C’est pour ces raisons que ce type de méthode est très peu employé
pour la génération massive de nombres au hasard en simulation.
Une solution a été proposée pour palier ces problèmes, elle consiste à stocker
un grand nombre de valeurs aléatoires mesurées expérimentalement afin de les
utiliser librement par la suite. Plusieurs tables de ce genre ont vu le jours dans
le siècle dernier la plus connu est une liste d’un million de nombres publiée dans
les années 40 qui a même été implémenté sur ordinateur.
Dans l’époque moderne, ces tables ne sont plus vraiment utilisées surtout
que les générateurs algorithmiques sont de plus en plus performants.

1.2 Générateur algorithmique

1.2.1 Principe général
Chaque langage de programmation a son propre générateur de nombre pseudo-
aléatoire. Mais, comment un ordinateur, dont le fonctionnement est complètement
déterministe, peut-il produire des nombres supposés aléatoires ? Que se passe-
t-il vraiment lors de l’exécution de l’instruction qui nous permettra d’avoir une
séquence de nombres aléatoires ?
L’algorithme suivant est utilisé dans le langage C pour avoir un nombre
aléatoire entre 0 et 231 − 1 :

Algorithme 1 généré un nombre aléatoire à partir d’une racine

Entrée: xn
Sortie: xn+1
x ← xn ∗ 1103515245 + 12345
xn+1 ← x%231

Il est important de noter que dans cet algorithme le seul élément possible-
ment aléatoire est l’initialisation de la suite xn autrement dit la valeur de x0 .
Le reste des valeurs produites par les appels successifs à cet algorithme étant
alors entièrement déterminé.
Cet exemple est un exemple extrêmement simple de générateur algorith-
mique de nombres pseudo-aléatoires. D’une manière générale, tout générateur
algorithmique de nombres pseudo-aléatoires est caractérisé par un couple (E, f ),
où
- E est un ensemble fini de nombre,
- f est une application de E dans lui même
Ensuite et à partir d’une valeur initiale x0 appelé graine (seed en anglais)
qui appartient souvent à E, il suffit d’appliquer la fonction f autant de fois que
1.2. GÉNÉRATEUR ALGORITHMIQUE 5

nécessaire sur x0 . Ce qui donne une liste de n valeur xi ∈ E, où

xi = f ◦ . . . ◦ f (x0 ) (1.1)
| {z }
if ois

En pratique, la valeur de xi s’obtient directement à partir de xi−1 :

xi = f ◦ . . . ◦ f (x0 )
| {z }
if ois

= f (f ◦ . . . ◦ f (x0 )) (1.2)
| {z }
i−1f ois

= f (xi−1 )
Ainsi, pour chaque choix de la graine on obtient une suite de nombres pseudo-
aléatoires différentes. Une fois la graine fixée le reste de la suite est complètement
déterministe. Pourtant, le résultat est supposé avoir un comportement aléatoire
indépendant et de loi discrète uniforme sur les éléments de E.
Une valeur par défaut pour la graine est souvent fournie par l’ordinateur elle
est basée généralement sur l’heure à laquelle nous lançons le générateur.

1.2.2 Exemples
Nous allons voir dans la suites les principales familles de générateurs de
nombres pseudo-aléatoires utilisés en pratique.

Générateur linéaire congruentiel

Une première famille, appelée générateurs linéaires congruentiels, est définie
par le couple
(E = {0, ..., m − 1}, f (x) = (ax + b) modulo m)
l’exemple que nous avons vu au début fait partie de cette famille où
m = 231 a = 1103515245 b = 12345
D’autres langage utilisent le générateur linéaire congruentiel avec
m = 248 a = 25214903917 b = 11
Bien évidement les valeurs de m, a et de b ne sont pas le fruit du hasard mais
le résultat d’une optimisation minutieuse par rapport à des critères de qualité
que nous allons voir plus tard. Un choix quelconque de ces paramètres conduit
généralement à des générateurs médiocres. Autrement dit, des générateurs qui
représentent mal la loi uniforme en donnant lieu par exemple à des suites de
nombres périodiques de très courte période. Ou, des générateurs qui donnent des
suites de nombres dépendants, c’est-à-dire des nombres qui sont générés suivant
un lien logique facilement identifiable.
Cette famille de générateurs est de loin la plus simple mais pas nécessairement
la plus performante. C’est pour cette raison que de nombreux raffinements ont
été proposés.
6 CHAPITRE 1. NOMBRE PSEUDO-ALÉATOIRE

Générateur multi-récursif
Les générateurs multi-récursifs d’ordre k basés sur la récurrence linéaire mul-
tiple définie par le couple
(E = {0, . . . , m−1}k , f (x0 , . . . , xk−1 ) = (x1 , . . . , xk−1 , (a0 x0 +. . . ak−1 xk−1 +b) modulo m)
ce générateur nécessite une graine sous la forme d’un vecteur de k entiers
positifs et inférieurs strictement à m. Ainsi, pour générer un nombre xn avec
n > k un tel générateur utilise les nombres {xn−k , xn−k+1 , . . . , xn−1 }

Générateur matriciel congruentiel

Le générateur multi-récursif peut être réécrit en utilisant le produit matriciel
entre la matrice carrée donnée par :
 
0 1 0 ··· 0
 0 0 1 ··· 0 
 
 .. .. .. .. 
.
 . . · · · . 

 0 0 0 ··· 1 
a0 a1 a2 · · · ak−1
et le vecteur donné par :  
x0

 x1


 ..



 .
xk−2 
xk−1
à qui on rajouté le vecteur suivant :
 
0
0
 
 .. 
.
 
0
b
Par conséquent,
      
x1 0 1 0 ··· 0 x1 0
 x2    0
   0 1 ··· 0 
 x2  0
  
 ..   .. .. .. ..   ..  +  ..  modulo m
 .  =  . . . ··· .  .    . 
   
  
xk−1   0 0 0 ··· 1  xk−1  0
xk a1 a2 a3 ··· ak xk b
L’écriture matricielle permet de généraliser les générateurs multi-récursif et
définir les générateur matriciel congruentiel d’ordre k par :
Xi = (AXi−1 + B) modulo m
1.3. CYCLE ET TRANSITOIRE 7

où Xi , Xi−1 et c sont des vecteur de taille k et A est une matrice carrée k × k.
Les éléments des vecteurs et de la matrice sont des entiers entre 0 et m − 1.

1.3 Cycle et transitoire

Puisque l’ensemble E est un ensemble fini, la séquence S générée par un
générateur ne prend qu’un nombre fini de nombre. Par conséquent,
∃p ≥ 0, ∃q ≥ 1 tq S = x0 , . . . , xp−1 , xp , xp+1 , . . . , xp+q−1 , xp , xp+1 , . . . , xp+q−1 . . .
L’ensemble {x0 , . . . , xp−1 } est appelé transitoire de la séquence S et l’ensemble
{xp , . . . , xp+q−1 } est appelé le cycle de la séquence S. L’entier p est alors appelé
la longueur du transitoire et l’entier q est appelé la longueur du cycle. Ainsi, la
séquence S peut être représentée par la figure 1.1 :

𝑥𝑝+𝑞 𝑥
𝑝+𝑞+1
𝑥𝑝−1 𝑥𝑝 𝑥𝑝+1
𝑥1 𝑥𝑝+𝑞−1
𝑥0

Figure 1.1 – La séquence S

Le transitoire peut être vide et dans ce cas sa longueur est nulle. Alors que
le cycle est au minimum égale à 1 ce qui donne une séquence constante. Le but
est évidement de générer des séquences sans transitoire et dont le cycle est le
plus long possible. Ce qui fait que tant que la taille de la séquence que nous
souhaitons générer est inférieure à la longueur du cycle, cette dernière peut être
considérée comme étant aléatoire. D’un autre côté, si la longueur du cycle est
inférieur au cardinal de E on en déduit à priori que les éléments de E n’ont pas
tous la même chance d’être tiré. Par conséquent, l’étude des transitoires et des
cycles des générateurs est indispensable.

Le cas des générateur linéaire congruentiel

On rappelle avant de commencer qu’une séquence S est issue d’un générateur
linéaire congruentiel si ses éléments sont donnée par la formule suivante :
xn+1 = (axn + b) mod m (1.3)
8 CHAPITRE 1. NOMBRE PSEUDO-ALÉATOIRE

avec m ∈ N et a, b ∈ {0, . . . , m − 1}. On a alors le théorème suivant :

Théorème 1 le transitoire des générateurs linéaires congruentiels est vide si
et seulement si P GCD(a, m) = 1
Ce résultat est important car il permet d’éliminer tous les générateurs dont
le transitoire n’est pas vide. Ces générateurs sont par défaut mauvais car des
générateurs dont le transitoire n’est pas vide ont par définitions un cycles d’au-
tant plus petit qu’il y a d’élément dans le transitoire. Néanmoins, éliminer ces
générateurs n’est pas suffisant car ça ne donne aucune garantie quant à la lon-
gueur du cycle. Le théorème 2 est un des résultats les plus essentiels concernant
les générateurs linéaires congruentiels.

Théorème 2 (Théorème de Hull-Dobell) le cycle d’un générateur linéaire

congruentiel est de longueur maximal égale à m et un tel générateur a un cycle
de taille m si et seulement si les quatre conditions suivantes sont vérifiées :
1. m n’est pas premier
2. P GCD(a, m) = P GCD(b, m) = 1
3. si un nombre premier l est un divisible de m alors l est un divisible de
a−1
4. si 4 est un divisible de m alors 4 est un divisible de a − 1
Chapitre 2

Variable pseudo-aléatoire

2.1 Introduction
Dans ce chapitre, nous nous intéressons à l’étape de transformation, qui
consiste à simuler des variables aléatoires de loi donnée à partir des nombres
pseudo-aléatoires produits par des générateurs du type décrit dans le chapitre
précédent.

2.1.1 Méthodes génériques et méthodes spécifiques

Pour la plupart des lois classiques telles que les lois gaussiennes, binomiales,
exponentielle, géométrique, de Poisson, Gamma, Beta, etc... de nombreux algo-
rithmes performants, souvent très astucieux, optimisés dans leur implémentation,
et reposant sur les propriétés particulières de ces lois et sur les relations qui
existent entre elles, ont été développés. Ces algorithmes spécifiques sont implémentés
dans divers logiciels (tels que R). Nous en donnerons quelques exemples, non
pas à titre de référence, mais plutôt d’illustration du type de propriétés sur les-
quelles ces méthodes sont basées. En revanche, nous nous attacherons dans ce
chapitre à décrire précisément les méthodes génériques de transformation, qui
permettent de simuler des variables aléatoires de loi quelconque, et ne reposent
pas comme les précédentes sur les propriétés particulières des lois classiques.
Les méthodes que nous allons découvrir supposent que l’on dispose de variables
aléatoires indépendantes U1 , U2 , . . . issu de la loi uniforme continue sur l’inter-
valle [0, 1]. Puis, elles transforment ces variables afin de produire une variable
aléatoire X issue de la loi souhaitée. On établie la validité de ces méthodes en
prouvant mathématiquement que, si l’on dispose en entrée de véritables variables
aléatoires indépendantes et issues de la loi uniforme continue sur l’intervalle
[0, 1], la variable aléatoire X produite par la méthode considérée est issue ef-
fectivement de loi de probabilité souhaitée. Pour produire plusieurs exemplaires
indépendants de même loi que X, on répète le procédé en employant en entrée
des parties disjointes de la suite de nombres pseudo-aléatoires pseudo-uniformes
produite par le générateur utilisé.

9
10 CHAPITRE 2. VARIABLE PSEUDO-ALÉATOIRE

2.1.2 Variable pseudo-uniforme

Nous avons vu dans la chapitre précédent comment obtenir des nombres

pseudo-aléatoire uniformément distribué à partir de l’ensemble {0, . . . , K − 1}.
Or, nous avons besoin de nombres uniformément distribués sur l’intervalle [0, 1].
Il suffira alors de diviser les nombres qu’on obtient avec un générateur congruen-
tiel linéaire par le module. Il est important de noter que de toute façon il n’est pas
possible de représenter un intervalle par un ordinateur et qu’en réalité un inter-
valle [0, 1] n’est autre que l’ensemble { M 0
,M1
, . . . , MM−1 , M
M
} avec M assez grand
pour donner l’impression que c’est un intervalle. Par conséquent, le générateur
linéaire congruentiel donnée par l’algorithme suivant :

Algorithme 2 généré un nombre aléatoire dans l’intervalle [0, 1]

Entrée: graine
Sortie: graine et u
graine ← graine ∗ a + b
graine ← graine%m
u ← graine/m

où m est choisie assez grand, a et b sont choisie de telle sorte à ce qu’on vérifie
les conditions du théorème 2 et graine est un entier fixé une fois d’une façon
aléatoire et qui change à chaque fois que l’algorithme est utilisé.
Un tel générateur nous donne des nombres pseudo-aléatoires uniformément
distribué sur l’intervalle [0, 1]. Simuler la loi uniforme sur [0, 1] est très important
car c’est à partir de cette variable que nous allons simuler n’importe quelle loi
de probabilité.
Simuler U[0,1] suffit pour simuler n’importe quelle loi uniforme continue car
Si X suit la loi U[0,1] alors Y = a + (b − a)X suit la loi U[a,b] pour tout réels a
et b.

2.2 Variable aléatoires de loi discrète

Soient un ensemble S fini ou dénombrable : S = {xi , i ∈ I} où I est un
ensemble d’indice : I = {0, 1, . . . , n} dans le cas fini et I = N dans le cas
dénombrable. Ainsi qu’une suite de nombres positifs ou nuls (pi )i∈I telle que
i∈I pi = 1. Une loi de probabilité discrète L est caractérisée par l’ensemble
P
des possibilité S et de des probabilité d’occurrence de chaque élément de S
donnée par la suite (pi )i∈I .
Notre objectif est de générer un échantillon issu de la loi L . Autrement dit,
on cherche à construire une séquence de nombre pris au hasard dans S avec pour
tout élément xi de S une probabilité d’occurrence pi .
2.2. VARIABLE ALÉATOIRES DE LOI DISCRÈTE 11

2.2.1 Méthode de découpage d’intervalles

P
Cette méthode se base sur le fait que i∈I pi = 1. Par conséquent, il est pos-
sible de décomposer l’intervalle [0, 1] en plusieurs sous-intervalles de longueurs
égales aux pi .
Ensuite, en partant d’un nombre pseudo-uniforme u sur [0, 1], il suffit de
chercher l’indice k, élément de I, vérifiant :
k−1
X k
X
pj ≤ u < pj
j=0 j=0

Un nombre pseudo-aléatoire l issu de la loi discrète L dont le support est

S = {xi , i ∈ I}, est alors le nombre donné par l’indice k i.e. xk . Pour avoir un
échantillons de cette loi il suffit de répéter cette opération autant de fois que
nous le souhaitons.
L’intervalle [0, 1] est ainsi découpé en sous-intervalles de longueurs pi et
l’indice de l’intervalle dans lequel se trouve le nombre u est l’indice du nombre
xi ∈ S que l’on renvoie. Il suffira alors de générer des nombres pseudo-uniformes
avec l’algorithme 2