Simulation des lois de probabilités en Scilab

Simulation de lois de probabilité en Scilab

Scilab dispose de deux fonctions principales pour générer des nombres aléatoires : rand pour une utilisation simple et rapide, et grand pour des simulations statistiquement plus rigoureuses. Ces outils permettent de simuler toutes les grandes lois de probabilité classiques.

Définition — Générateur de nombres aléatoires Un générateur de nombres aléatoires produit une suite de valeurs x₁, …, xₙ ∈ [0, 1] représentant n réalisations de variables aléatoires indépendantes X₁(ω), …, Xₙ(ω) de loi uniforme sur [0, 1]. Ces valeurs servent ensuite à simuler n'importe quelle autre loi de probabilité par transformation.

I. Fonctions utilitaires

1. Le générateur aléatoire `rand`

La fonction rand génère des matrices de nombres aléatoires selon la loi uniforme sur [0, 1] (par défaut) ou la loi normale centrée réduite.

Syntaxe — rand Scilab

rand(m, n)        // matrice m×n — loi uniforme sur [0, 1]
rand(A)           // matrice de même taille que A
rand()            // scalaire aléatoire

rand("uniform")   // bascule vers loi uniforme [0,1] (défaut)
rand("normal")    // bascule vers loi normale N(0,1)

Appel	Résultat	Loi
`rand(m, n)`	Matrice m×n de valeurs aléatoires	Uniforme sur [0, 1]
`rand(A)`	Matrice de même taille que A	Uniforme sur [0, 1]
`rand()`	Scalaire aléatoire	Uniforme sur [0, 1]
`rand("uniform")`	Bascule la loi courante	Uniforme sur [0, 1]
`rand("normal")`	Bascule la loi courante	Normale N(0, 1)

Exemple n°1 — Usages de rand

// Matrice 3×4 de valeurs uniformes
rand(3, 4)

// Matrice de même taille qu'un vecteur existant
A = [1 2 3]
rand(A)

// Scalaire aléatoire
rand()

Sortie

rand(3,4) =
   0.2113249   0.3303271   0.8497452   0.0683740
   0.7560439   0.6653811   0.6857310   0.5608486
   0.0002211   0.6283918   0.8782165   0.6623569

rand([1 2 3]) =
   0.7263507   0.1985144   0.5442573

rand() =
   0.2320748

Attention — rand("normal") modifie l'état global rand("normal") et rand("uniform") changent la loi utilisée pour tous les appels suivants de rand dans la session. Toujours rétablir rand("uniform") après un changement de loi si on souhaite retrouver le comportement par défaut.

2. Le générateur aléatoire `grand`

La fonction grand offre des générateurs statistiquement plus performants que rand et supporte directement de nombreuses lois de probabilité classiques.

Syntaxe — grand Scilab

X = grand(N, M, "code_loi", param1, param2, ...)
// Retourne une matrice N×M selon la loi spécifiée

Code loi	Loi simulée	Paramètres	Exemple
`"def"`	Uniforme continue sur [0, 1[	—	`grand(1,5,"def")`
`"unf"`	Uniforme continue sur [a, b[	a, b	`grand(1,5,"unf",1,7)`
`"uin"`	Uniforme discrète sur {n1, …, n2}	n1, n2	`grand(1,5,"uin",1,10)`
`"bin"`	Binomiale B(n, p)	n, p	`grand(1,5,"bin",10,0.5)`
`"geom"`	Géométrique G(p)	p	`grand(1,5,"geom",0.5)`
`"poi"`	Poisson P(λ)	λ	`grand(1,5,"poi",3)`
`"gam"`	Gamma Γ(b, ν)	ν, 1/b	`grand(1,5,"gam",2,0.5)`
`"bet"`	Bêta β(a, b)	a, b	`grand(1,5,"bet",2,3)`

Exemple n°2 — Différentes lois avec grand

// 5 entiers aléatoires uniformes entre 1 et 10
grand(1, 5, "uin", 1, 10)

// 5 réalisations de B(10, 0.5) — nb de succès sur 10 essais
X = grand(1, 5, "bin", 10, 0.5)

// 5 réalisations de la loi géométrique G(0.5)
X = grand(1, 5, "geom", 0.5)

// 5 réalisations de la loi uniforme continue sur [1, 7[
X = grand(1, 5, "unf", 1, 7)

// 5 réalisations de la loi de Poisson P(3)
X = grand(1, 5, "poi", 3)

Sortie

grand(1,5,"uin",1,10) =   2.  10.   6.   9.   4.
grand(1,5,"bin",10,0.5) = 3.   6.   8.   8.   8.
grand(1,5,"geom",0.5) =   1.   1.   3.   3.   1.
grand(1,5,"unf",1,7) =    4.8  5.7  6.3  6.8  4.0
grand(1,5,"poi",3) =      2.   4.   3.   1.   5.

Astuce — rand vs grand

Critère	`rand`	`grand`
Facilité d'utilisation	✅ Très simple	⚠️ Syntaxe à retenir
Qualité statistique	Correcte	✅ Meilleure
Lois disponibles	Uniforme + Normale	✅ 8+ lois
Usage recommandé	Prototypage rapide	Simulations sérieuses

II. Simulation des lois classiques avec `rand`

Il est possible de simuler toutes les lois classiques à partir de la seule fonction rand, en exploitant des transformations mathématiques. Cette approche est pédagogiquement importante car elle illustre le principe de la méthode de la transformée inverse.

1. Loi de Bernoulli B(p)

Définition — Loi de Bernoulli B(p) X suit une loi de Bernoulli de paramètre p si X prend la valeur 1 (succès) avec probabilité p, et la valeur 0 (échec) avec probabilité 1 − p. Elle est la brique de base de la simulation discrète.

Principe : on tire U ∈ [0, 1] uniformément. Si U < p, on retourne 1 (la probabilité que U tombe dans [0, p[ est exactement p).

Algorithme — Bernoulli B(p) Scilab

function X = bernoulli(p)
    U = rand()
    if (U < p) then
        X = 1
    else
        X = 0
    end
endfunction

Exemple n°3 — Simulation de 10 tirages Bernoulli(0.3)

p = 0.3
n = 10
U = rand(1, n)
X = (U < p)     // vecteur booléen → 1 si succès, 0 sinon
disp(X)
disp("Nombre de succès : " + string(sum(X)))
disp("Fréquence observée : " + string(mean(X)))

Sortie

X = 0  1  0  0  1  0  0  1  0  0
Nombre de succès : 3
Fréquence observée : 0.3

Remarque — Vectorisation L'expression (U < p) appliquée à un vecteur retourne un vecteur de booléens (%t/%f) traités comme des 0/1 dans les calculs arithmétiques. C'est la façon idiomatique et efficace de simuler plusieurs Bernoulli simultanément en Scilab.

2. Loi discrète uniforme sur {a, …, b}

Définition — Loi uniforme discrète X suit la loi uniforme discrète sur {a, a+1, …, b} si chacun des b − a + 1 entiers a la même probabilité 1/(b − a + 1) d'être choisi.

Principe : rand(n) retourne un entier aléatoire dans {0, …, n−1}. En prenant n = b − a + 1 et en ajoutant a, on obtient une valeur dans {a, …, b}.

Algorithme — Uniforme discrète sur {a, …, b} Scilab

X = a + rand(b - a + 1)   // un entier uniforme dans {a, ..., b}

Exemple n°4 — Simuler un dé à 6 faces

// Simulation d'un dé à 6 faces : X ∈ {1, 2, 3, 4, 5, 6}
a = 1
b = 6
n_tirages = 600

des = zeros(1, n_tirages)
for i = 1:n_tirages
    des(i) = a + rand(b - a + 1)
end

// Fréquences observées pour chaque face
for face = 1:6
    freq = sum(des == face) / n_tirages
    disp("Face " + string(face) + " : " + string(freq))

Sortie (résultat typique)

Face 1 : 0.168
Face 2 : 0.162
Face 3 : 0.170
Face 4 : 0.165
Face 5 : 0.171
Face 6 : 0.164

3. Loi binomiale B(n, p)

Définition — Loi binomiale B(n, p) X ∼ B(n, p) compte le nombre de succès parmi n expériences de Bernoulli indépendantes de paramètre p. Sa valeur est dans {0, 1, …, n}.

Principe : on simule n variables de Bernoulli(p) simultanément et on somme les succès.

Algorithme — Binomiale B(n, p) Scilab

U = rand(1, n)   // n tirages uniformes
Y = (U < p)      // vecteur de Bernoulli(p)
X = sum(Y)       // somme = nombre de succès ~ B(n, p)

Exemple n°5 — Vérification de l'espérance de B(20, 0.4)

n = 20
p = 0.4
N_sim = 10000   // nombre de simulations

resultats = zeros(1, N_sim)
for i = 1:N_sim
    U = rand(1, n)
    Y = (U < p)
    resultats(i) = sum(Y)
end

disp("Espérance théorique  E[X] = n*p = " + string(n*p))
disp("Espérance simulée         = " + string(mean(resultats)))
disp("Variance théorique  V[X]  = " + string(n*p*(1-p)))
disp("Variance simulée          = " + string(variance(resultats)))

Sortie

Espérance théorique  E[X] = n*p = 8
Espérance simulée         = 7.9982
Variance théorique  V[X]  = 4.8
Variance simulée          = 4.793

4. Loi géométrique G(p)

Définition — Loi géométrique G(p) X ∼ G(p) représente le rang du premier succès dans une suite d'expériences de Bernoulli(p) indépendantes. X ∈ {1, 2, 3, …} avec P(X = k) = (1−p)^(k−1) × p.

Principe : on répète des tirages de Bernoulli jusqu'à obtenir le premier succès. Le compteur donne la réalisation.

Algorithme — Géométrique G(p) Scilab

function X = geometrique(p)
    X = 1
    U = rand()
    while (U > p)
        X = X + 1
        U = rand()
    end
endfunction

Exemple n°6 — Vérification de l'espérance de G(0.25)

p = 0.25
N_sim = 5000
resultats = zeros(1, N_sim)

for i = 1:N_sim
    X = 1
    U = rand()
    while (U > p)
        X = X + 1
        U = rand()
    end
    resultats(i) = X
end

disp("Espérance théorique  E[X] = 1/p = " + string(1/p))
disp("Espérance simulée         = " + string(mean(resultats)))

Sortie

Espérance théorique  E[X] = 1/p = 4
Espérance simulée         = 3.9874

5. Loi uniforme continue sur [a, b]

Définition — Loi uniforme continue U([a, b]) X ∼ U([a, b]) si X a une densité constante égale à 1/(b−a) sur [a, b] et 0 ailleurs. L'espérance est (a+b)/2 et la variance est (b−a)²/12.

Principe : par la méthode de la transformée inverse, si U ∼ U([0, 1]) alors X = a + (b−a)·U ∼ U([a, b]).

Algorithme — Uniforme continue U([a, b]) Scilab

X = a + (b - a) * rand()        // un scalaire
X = a + (b - a) * rand(m, n)    // matrice m×n

Exemple n°7 — Simulation de U([2, 5]) et vérification

a = 2
b = 5
N_sim = 10000

X = a + (b - a) * rand(1, N_sim)

disp("Espérance théorique  (a+b)/2    = " + string((a+b)/2))
disp("Espérance simulée               = " + string(mean(X)))
disp("Variance théorique  (b-a)²/12   = " + string((b-a)^2/12))
disp("Variance simulée                = " + string(variance(X)))
disp("Minimum observé                 = " + string(min(X)))
disp("Maximum observé                 = " + string(max(X)))

Sortie

Espérance théorique  (a+b)/2    = 3.5
Espérance simulée               = 3.4973
Variance théorique  (b-a)²/12   = 0.75
Variance simulée                = 0.7481
Minimum observé                 = 2.0003
Maximum observé                 = 4.9998

Récapitulatif — Lois et algorithmes

Loi	Paramètres	Algorithme avec `rand`	Avec `grand`
Bernoulli B(p)	p ∈ (0,1)	`(rand() < p)`	`grand(1,1,"bin",1,p)`
Uniforme discrète {a,…,b}	a, b entiers	`a + rand(b-a+1)`	`grand(1,1,"uin",a,b)`
Binomiale B(n, p)	n entier, p ∈ (0,1)	`sum(rand(1,n) < p)`	`grand(1,1,"bin",n,p)`
Géométrique G(p)	p ∈ (0,1)	Boucle while Bernoulli	`grand(1,1,"geom",p)`
Uniforme continue U([a,b])	a < b réels	`a + (b-a)*rand()`	`grand(1,1,"unf",a,b)`
Poisson P(λ)	λ > 0	Algorithme de Knuth	`grand(1,1,"poi",lambda)`

Précédent Matrices et vecteurs en Scilab

Suivant TD 1 structures conditionnelles corrigé Scilab

Simulation des lois de probabilités en Scilab

Simulation de lois de probabilité en Scilab

I. Fonctions utilitaires

1. Le générateur aléatoire `rand`

2. Le générateur aléatoire `grand`

II. Simulation des lois classiques avec `rand`

1. Loi de Bernoulli B(p)

2. Loi discrète uniforme sur {a, …, b}

3. Loi binomiale B(n, p)

4. Loi géométrique G(p)

5. Loi uniforme continue sur [a, b]

Récapitulatif — Lois et algorithmes

Discussion (0)

Laisser un commentaire

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Simulation des lois de probabilités en Scilab

Simulation de lois de probabilité en Scilab

I. Fonctions utilitaires

1. Le générateur aléatoire rand

2. Le générateur aléatoire grand

II. Simulation des lois classiques avec rand

1. Loi de Bernoulli B(p)

2. Loi discrète uniforme sur {a, …, b}

3. Loi binomiale B(n, p)

4. Loi géométrique G(p)

5. Loi uniforme continue sur [a, b]

Récapitulatif — Lois et algorithmes

Discussion (0)

Laisser un commentaire

1. Le générateur aléatoire `rand`

2. Le générateur aléatoire `grand`

II. Simulation des lois classiques avec `rand`