Nombres aléatoires et simulation

Dernière mise à jour : 18 Août 1999

  1. Théorie

    1. Introduction

    2. Loi uniforme

      1. Générateurs congruentiels
      2. Générateurs de type "Multiplication avec retenue"

    3. Loi normale

      1. Introduction
      2. Simulation d'une loi normale

    4. Loi multinormale

      1. Introduction
      2. Simulation d'une loi multinormale

    5. Loi multi-lognormale

      1. Introduction
      2. Simulation d'une loi multi-lognormale

  2. Programmation en Turbo Pascal

    1. L'unité RANDOM.PAS

    2. Programmes de démonstration

      1. Test du générateur
      2. Simulation d'une loi normale
      3. Simulation d'une loi multinormale
      4. Simulation d'une loi multi-lognormale

I. Théorie

I.A. Introduction

Générer des nombres aléatoires sur ordinateur revient à créer une suite d'entiers :

In+1 = f(In)

où f est une fonction qui doit être choisie judicieusement pour que la répartition des nombres In ne puisse pas être distinguée de ce que donnerait le hasard. On parle alors de nombres pseudo-aléatoires.

La suite peut fournir M nombres aléatoires dans l'intervalle [0, M-1]. M dépend du type des entiers :

La valeur de départ I0, appelée graine (seed), doit être fournie par l'utilisateur. La même graine donnera toujours la même suite de nombres. D'autre part, la suite se reproduit au bout d'un nombre de valeurs appelé période. Cette période doit être la plus grande possible.

Si la fonction f a été correctement choisie, chaque nombre a la même probabilité d'apparaître. On dit que les nombres aléatoires suivent une loi uniforme.

On montre que les autres lois de probabilité (binomiale, normale...) peuvent être simulées à partir de cette loi uniforme.

Nous décrirons ici des méthodes permettant de générer des nombres aléatoires répartis selon :

I.B. Loi uniforme

I.B.1. Générateurs congruentiels

C'est la base des générateurs implantés dans les langages de programmation. Ils sont du type :

In+1 = (aIn + c) mod b

avec b = 216 par exemple.

Ces générateurs ont plusieurs inconvénients qui les font déconseiller dans la pratique.

I.B.2. Générateurs de type "Multiplication avec retenue" (Multiply With Carry, MWC)

Ces générateurs, introduits par George Marsaglia, sont du type :

In+1 = (aIn + cn) mod b
cn+1 = (aIn + cn) div b

a est le multiplicateur, b la base, cn la retenue. On peut prendre c0 = 0.

Un générateur 32 bits peut aussi être obtenu en concaténant 2 nombres de 16 bits. La période est alors égale au produit des périodes des deux générateurs.

Ces générateurs ont de meilleures propriétés que les précédents et sont donc recommandés.

I.C. Loi normale

I.C.1. Introduction

La loi normale, notée N(m, s), est caractérisée par sa moyenne m et son écart-type s (ou sa variance s2). Elle est telle que :

La loi N(0, 1) est appelée loi normale réduite. Elle est représentée sur la courbe suivante (courbe de Gauss) :


Figure 1. Loi normale réduite.

I.C.2. Simulation d'une loi normale

On utilise la méthode de Box-Muller : si x1 et x2 sont deux nombres aléatoires uniformes sur ]0,1[, les nombres y1 et y2 définis par :

suivent la loi normale réduite.

On en déduit que les nombres z1 = m + sy1 et z2 = m + sy2 suivent la loi normale N(m, s).

I.D. Loi multinormale

I.D.1. Introduction

La loi multinormale correspond à l'extension de la loi normale au cas de n variables x1, x2,... xn. Elle est caractérisée par un vecteur de moyennes m et une matrice de variance-covariance V. On la note N(m, V).

I.D.2. Simulation d'une loi multinormale

Pour simuler une loi multinormale N(m, V) de dimension n, on applique l'algorithme suivant :

  1. Soit u un vecteur constitué de n nombres aléatoires indépendants distribués selon la loi normale réduite.
  2. Soit L la matrice triangulaire inférieure résultant de la décomposition de Cholesky de la matrice V (voir cours sur le calcul matriciel).
  3. Le vecteur x = m + Lu suit la loi multinormale N(m, V).

I.E. Loi multi-lognormale

I.E.1. Introduction

On dit que le vecteur x suit la loi multi-lognormale LN(m, V), où m désigne le vecteur de moyennes et V la matrice de variance-covariance, si le vecteur x° tel que :

x°i = ln(xi)

suit une loi multinormale.

I.E.2. Simulation d'une loi multi-lognormale

Si x suit la loi multi-lognormale LN(m, V), de dimension n, on définit la variable auxiliaire x° distribuée selon la loi multinormale L(m°, V°) telle que :

Le vecteur x tel que xi = exp(x°i) suit alors la loi multi-lognormale LN(m, V).

II. Programmation en Turbo Pascal

La programmation des calculs précédents peut être réalisée au moyen de la bibliothèque TP MATH.

II.A. L'unité RANDOM.PAS

L'unité RANDOM.PAS, contenue dans TPMATH1.ZIP fournit les fonctions et procédures suivantes :

II.B. Programmes de démonstration

Les programmes suivants sont disponibles dans TPMATH2.ZIP :

II.B.1. Test du générateur

Le programme RANTEST.PAS a pour seul but de vérifier que le générateur de nombres aléatoires fonctionne avec votre compilateur. Pour cela, le programme tire 20000 nombres entiers, avec l'initialisation par défaut RMarIn(1802, 9373), affiche les 6 nombres suivants et les compare à leurs valeurs théoriques.

Les résultats obtenus doivent être les suivants : 

  Test of Marsaglia random number generator
---------------------------------------------
       Correct           Actual
---------------------------------------------
     921625997        921625997           OK
    1094293978       1094293978           OK
     115775252        115775252           OK
     499820504        499820504           OK
   -1929018715      -1929018715           OK
    2008943384       2008943384           OK
---------------------------------------------

II.B.2. Simulation d'une loi normale

Le programme RANGAUS.PAS simule le tirage d'un échantillon aléatoire à partir d'une population gaussienne. Il estime la moyenne et la variance de cette population au moyen des formules classiques :

où n désigne la taille de l'échantillon.

Ces estimations sont faites par les fonctions Average et EstVar de l'unité STAT.PAS

Le programme calcule ensuite un intervalle de confiance à 95% pour la moyenne, selon la formule :

valable pour les "grands" échantillons (n > 30), pour lesquels la moyenne suit une distribution normale.

Cet intervalle de confiance a 95% de chances de recouvrir la moyenne de la population.

Le programme affiche :

Avec l'initialisation par défaut du générateur de nombres aléatoires, les résultats sont les suivants : 

Population mean =    10.0000
Population SD   =     2.0000

Sample size     =        100
Sample mean     =    10.0005
Sample SD       =     1.9670

95% CI of mean  = [    9.6150 ,    10.3860 ]

II.B.3. Simulation d'une loi multinormale

Le programme RANMUL.PAS simule une loi multinormale. Le vecteur de moyennes et la matrice de variance-covariance sont lus dans un fichier ASCII dont la structure est la suivante :

Le fichier par défaut (RANMUL.DAT) est un exemple avec N = 2.

La procédure ReadParam lit le fichier de données. La matrice de variance-covariance est recalculée à partir des écart-types et des coefficients de corrélation : 

procedure ReadParam(FileName : String; 
                    var Name : String; 
                    var N    : Integer; 
                    var M    : PVector; 
                    var V    : PMatrix);
var
  F : Text;        { Fichier de données }
  I, J : Integer;  { Variables de boucle }
  S : PVector;     { Ecart-types }
  R : Float;       { Coefficient de corrélation }
begin
  Assign(F, FileName);
  Reset(F);

  Readln(F, Name);
  Readln(F, N);

  DimVector(M, N);
  DimVector(S, N);
  DimMatrix(V, N, N);

  { Lire les moyennes et écart-types. 
    Calculer les variances }
  for I := 1 to N do
    begin
      Read(F, M^[I], S^[I]);
      V^[I]^[I] := Sqr(S^[I]);
    end;

  { Lire les coefficients de corrélation.
    Calculer les covariances }
  for I := 2 to N do
    for J := 1 to Pred(I) do
      begin
        Read(F, R);
        V^[I]^[J] := R * S^[I] * S^[J];
        V^[J]^[I] := V^[I]^[J];
      end;

  Close(F);
  DelVector(S, N);
end;

Le programme principal effectue la décomposition de Cholesky de la matrice de variance-covariance et appelle la procédure RanMult autant de fois que nécessaire. Les vecteurs aléatoires ainsi générés sont écrits dans le fichier de sortie, à raison d'un vecteur par ligne. Le fichier de sortie par défaut est RANMUL.OUT 

{ Décomposer la matrice de variance-covariance }
Cholesky(V, 1, N, L);

{ NSIM est le nombre de simulations }
for I := 1 to NSIM do
  begin
    { Tirer un vecteur aléatoire X }
    RanMult(M, L, N, X);

    { Ecrire le vecteur dans le fichier de sortie }
  end;

II.B.4. Simulation d'une loi multi-lognormale

Le programme RANMULL.PAS simule une loi multi-lognormale. Les fichiers d'entrée et de sortie ont le même format que pour le programme précédent.