Précédent
Suivant

II) Les moments

1) Moment d'odre zéro

La somme des probabilités de chaque valeurs possibles est appelée le moment d'ordre zéro `mu_0` et vaut par principe `1`. Une loi de probabilité est toujours normée ainsi à `1`, une valeur de probabilité qui représente la certitude et qui regroupe de façon exhaustive tous les évènements possibles.

Dans le cas discret, toute fonction définie de `{0, 1, 2..., n}` vers `"["0, oo"["` dont la somme converge vers une valeur finie, et que l'on divise par cette valeur, peut constituer une loi de probabilité. Autrement dit on peut construire une variable possédant cette loi discrète. Et dans le cas continue, toute fonction définie de `"]"0, n"["` vers `"["0, oo"["` dont l'intégrale converge vers une valeur finie, et que l'on divise par cette valeur, constitue une loi de probabilité. Autrement dit on peut construire une variable possédant cette loi continue.

Dans le cas d'une variable `x` de loi discrète `f` définie sur `{0, 1, 2, 3..., n}` , le moment d'ordre zéro s'écrit comme suit :

  `mu_0 = P(overset(***)x"="0) + P(overset(***)x"="1) + P(overset(***)x"="2)... + P(overset(***)x"="n)`  
  `mu_0 = f(0) + f(1) + f(2) + ... + f(n)`
  `mu_0 = sum_x f(x)`

Et dans le cas d'une variable `x` de loi continue `f` définie sur `"]"0, n"["`, le moment d'ordre zéro s'écrit comme suit :

  `mu_0 = int_x P(overset(***)x "∈]"x, x"+"dx"[")`  
  `mu_0 = int_x f(x)dx`

Par principe, la loi de probabilités est normée à `1`, autrement dit le moment d'ordre zéro vaut `1`

  `mu_0 = 1`  

2) La moyenne

Il existe deux façons de définir la moyenne. Il existe une façon intérieure, calculant le moment d'ordre `1` noté `mu_1`, en sommant les valeurs possibles de `x` multipliées par leur probabilitées respectives. Et il existe une façon extérieure plus empirique calculant la moyenne `"<"x">"`, en prenant la limite lorsque le nombre de tirage tend vers l'infini de la somme des valeurs de chaque tirage divisé par le nombre de tirages. Les deux procédés donnent le même résultat appelé moyenne ou moment d'ordre un, `mu_1"=<"x">"`.

Dans le cas d'une variable `x` de loi discrète `f` définie sur `{0,1,2,3,...,n}`, cela s'écrit comme suit :

  `mu_1 = 0P(overset(***)x"="0) + 1P(overset(***)x"="1) + 2P(overset(***)x"="2)+ ... + (n"-"1)P(overset(***)x"="n)`  
  `mu_1 = 0f(0) + 1f(1) + 2f(2)+ ... + (n"-"1)f(n)`  
  `mu_1 = sum_x xf(x)`  

Et dans le cas d'une variable `x` de loi continue `f` définie sur `"]"0, n"["`, cela s'écrit comme suit :

  `mu_1 = int_x xP(overset(***)x "∈]"x, x"+"dx"[")`  
  `mu_1 = int_x xf(x)dx`  

La moyenne est ce sur quoi converge la somme de `k` tirages divisée par `k` lorsque `k` tend vers l'infini. On note `x(k)` la valeur de la variable `x` à l'instant `k`.

  `"<"x">" = lim_(k->∞) 1/k sum_(k=1)^k x(k)`  

Les valeurs possibles de `x` étant bornées et les tirages étant indépendants entre-eux, cette limite doit converger quelque soit la loi de probabilité de `x`. Ces deux conditions que sont l'existance d'une borne sur les valeurs envisageables de `x` et l'indépendances des tirages entre-eux, sont suffisantes pour garantir la convergence de la moyenne empirique.

Parcontre s'il n'y a pas d'indépendance entre les tirages, il est facile de construire une fonction de tirage `x` dont la moyenne empirique ne converge pas. Il suffit de prendre comme tirages, la valeur `0` pour les tirages numéros `2^(2j)` à `2^(2j+1)-1` et la valeur `1` pour les tirages numéros `2^(2j+1)` à `2^(2j+2)-1` pour tout `j` entier. La divergence de la moyenne empirique `"<"x">"` nécessite, soit des valeurs non bornées pour la variable `x`, ou soit une dépendance entre les tirages consécutifs.

Le moment d'ordre `1`, noté `mu_1`, désigne habituelement la moyenne intérieur obtenue en sommant les valeurs possibles de `x` multipliées par leur probabilitées respectives. La moyenne, notée `"<"x">"`, désigne habituellement la moyenne extérieur obtenue empiriquement par passage à la limite. Les deux procédés donnent le même résultat.

  `mu_1 = "<"x">"`  

La moyenne de `x` est quelque fois notée `m` ou `m_x`, ou encore `E(x)`, l'espérance mathèmatique de `x`. Elle possède la même unité physique que `x`.

3) La loi équirépartie (ou loi uniforme)

La loi équirépartie est la loi la moins arbitraire de toute. C'est la loi de probabilité constante, ou dite uniforme. Toutes les probabilités élémentaires sont égales entre-elles.

Prenons une variable aléatoire `x` ayant une loi équirépartie `f`. Autrement dit la loi `f` est constante.

Loi `f` équirépartie sur `{0, 1, 2..., n}`
Loi `f` équirépartie sur `"]"0, n"["`
  `f(x)` est constant.
  `mu_0 = sum_x f(x)`
 `mu_0 = f(x)sum_x 1`
  `mu_0 = f(x) (n"+"1)`
donc `f(x) = 1/(n"+"1)`
 
  `mu_1 = sum_x x f(x)`
  `mu_1 =1/(n"+"1) sum_x x`
  `mu_1 = 1/(n"+"1) ((n"+"1)n)/2`
donc `mu_1 = n/2`
 
  `f(x)` est constant.
  `mu_0 = int_x f(x)dx`
  `mu_0 = f(x)int_x dx`
  `mu_0 = f(x)[x]_(x=0)^n`
  `mu_0 = f(x) n`
donc `f(x) = 1/n`
  `mu_1 = int_x x f(x)dx`
  `mu_1 = 1/n int_x xdx`
  `mu_1 = 1/n [x^2/2]_(x=0)^n`
  `mu_1 = 1/n n^2/2`
donc `mu_1 = n/2`

En conclusion :

Loi équirépartie discrète
sur `{0, 1, 2,..., n}`

`f(x) = 1/(n+1)`
`"<"x">" = n/2`
Loi équirépartie continue
sur
`"]"0, n"["`

`f(x) = 1/n`
`"<"x">" = n/2`

  `"<"x">"` : Moyenne de `x`.
  `f` : Loi `x`.
  `x` : Paramètres.
  `n` : Taille de l'intervalle des valeurs possibles pour la variable `x`.
  `x` de type `"Arr"(x)` : Variable de loi équirépartie.

4) Générateurs de nombres aléatoires selon une loi équirépartie (ou loi uniforme)

4.1) Générateur à congruence linéaire

Park & Miller ont proposé en 1988, un générateur de nombres pseudo-aléatoires, à congruence linéaire, standard, convenablement testé. Ils l'ont appelé le Standard minimal. Il est défini comme suit :

`"x"_("n"+1) = 16807"x"_"n" mod (2^31- 1)`

La graine `"x"_0` ne doit pas être nulle. Il existe de nombreuses méthodes analogue (voir (GNU) Other random number generators) qui peuvent être plus rapides mais moins fiables en utilisant une puissance de `2` comme modulo. Elles engendrent une suite couvrant presque tous les nombres dans un ordre pseudo-aléatoire de période donc trés longue. La fonction rand( ) du langage C qui est programmée sur le même principe, retourne un nombre pseudo-aléatoire sur 31 ou 63 bits (compris entre `0` et RAND_MAX).

Si nous avons besoin d'un nombre entier pseudo-aléatoire `"x"` compris entre `0` et `"n"-1`, nous pouvons prendre le modulo `"n"`, c'est à dire exécuter l'instruction x = rand( )%n; néanmoins il faut se méfier des bits de poid faible qui dans de nombreuses implémentation de la fonction rand( ) ne sont pas vraiment pseudo-aléatoires, et cette méthode introduit un biais lorsque RAND_MAX n'est pas un multiple de `"n"`. La méthode suivante (voir FAQ C de Developpez.com) permet d'éliminer ces biais sans favoriser les bits de poids faibles. On programme la fonction randn( ) suivante, qui appliquée à `"n"`, retourne un nombre aléatoire compris entre `0` et `"n"-1`.

#include <stdlib.h>

int
randn(int n)
{
       n--;
       int p = 1+(n==RAND_MAX ? 0 : (RAND_MAX-n) / (n+1));
       int m = p*n + (p - 1);
       int d;
       do {d = rand( );} while (d > m);
       return d/p;
}

Intuitivement, on peut vouloir introduire ou pas du vrai hasard en ajoutant à la graine `"x"_"n"` après chaque tirage une valeur volatile correspondant au nombre de cycles machines écoulés. Sur architecture x86 vous pouvez pour cela utiliser la procédure rdtsc ainsi programmée (voir FAQ de commentcamarche.net). Puis on peut vouloir extraire les 16 ou 8 premiers bits juste après le premier bit qui est toujours à zéro. On construit ainsi quatre générateurs rapides comme suit :

#include <stdlib.h>

unsigned int* seedp;

typedef union {
     unsigned char c[4];
     struct {unsigned short x,y;} s;
     int i;
} INT;

int rdtsc( ) { __asm__  __volatile__("rdtsc");}
unsigned short rand16(void) {return ((INT)(rand( )<<1)).s.y;}
unsigned
char
rand8(void) {return ((INT)(rand( )<<1)).c[3];}
unsigned
short
randsys16(void) {*seedp += rdtsc(); return ((INT)(rand_r(seedp)<<1)).s.y;}
unsigned
char
randsys8(void) {*seedp += rdtsc(); return ((INT)(rand_r(seedp)<<1)).c[3];}

Pour les fonctions rand8( ) et rand16( ) qui génèrent des nombres pseudo-aléatoires, on peut fixer la graine `"x"_0` à une valeur `"g"` arbitraire à l'aide de la commande srand(g), ce qui permet de générer toujours la même suite de nombres pseudo-aléatoires. Pour les fonctions randsys8( ) et randsys16( ) qui génèrent des nombres aléatoires, la valeur courante de la graine change à chaque tirage selon les aléas hards et softs du système et est mémorisée dans seedp*.

On peut aussi utiliser les périphériques random et urandom générateurs aléatoires, du noyau Linux.

4.2) random, urandom - Périphériques générateurs aléatoires du noyau Linux

Extrait de http://manpagesfr.free.fr

Dans le système d'exploitation Linux, le périphérique /dev/random est un fichier spécial qui sert de générateur de nombres aléatoires. Le ficher /dev/random délivre des octects aléatoires qui sont récupéré à chaque lecture.

Le générateur de nombres aléatoires regroupe du bruit provenant de l'environnement recueillies auprès de pilotes de périphériques et d'autres sources et le stocke dans un réservoir d'entropie. Il mémorise une estimation du nombre de bits de bruit dans son réservoir d'entropie, et utilise son contenu pour créer des nombres aléatoires qui sont délivrés à chaque lecture du périphérique /dev/random. Lorsque le réservoir d'entropie est vide, les lectures depuis le périphérique /dev/random seront bloquantes jusqu'à l'obtention de suffisamment de bruit en provenance de l'environnement. Ainsi quand l'activité du système (source d'entropie) n'est pas suffisante, la lecture du fichier est bloquée.

Par contre le périphérique /dev/urandom qui fonctionne de façon analogue n'est jamais bloqué. L'aléa produit est donc de moins bonne qualité.

Pour accéder à ces périphériques en langage C on utilise les instructions suivantes :

#include <stdio.h>

unsigned int x;
FILE* random = fopen("/dev/random", "r");
fread(&x, sizeof(int),
1, random);
fclose(random);
#include <stdio.h>

unsigned int x;
FILE* urandom = fopen("/dev/urandom", "r");
fread(&x, sizeof(int),
1, urandom);
fclose(urandom);

4.3) Autres générateurs

Générateur Mersenne-Twister :
https://en.wikipedia.org/wiki/Mersenne_Twister
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html

Générateur WELL:
http://www.iro.umontreal.ca/~panneton/WELLRNG.html

Générateur SFMT :
http://www.researchgate.net/publication/221211361_SFMT_pseudo_random_number_generator_for_Erlang

Générateur ISAAC, voir :
http://sebsauvage.net/isaac/

4.4) Générateurs aléatoires dans le logiciel R

Le logiciel R propose différents générateurs aléatoires :

(à voir...)

5) Les moments

Il existe deux façons de calculer les moments d'ordre `r`, une façon intérieure qui consiste à sommer les puissances `r` des valeurs possibles de la variable `x` multipliées par leur probabilitées respectives, et une façon extérieure plus empirique qui consiste à passer en revue l'ensemble des tirages, et à calculer la moyenne `"<"x^r">"`.

On note `x(k)` la valeur de la variable `x` à l'instant `k`.

  `"<"x^r">" = lim_(k->oo) 1/k sum_(k=1)^k x_(k)^r`  

Les tirages de `x` étant bornées et indépendants entre-eux, cette limite converge.

Moment d'ordre `r`
d'une variable `x`
de loi discrète `f`
sur `{0, 1, 2,..., n}`

  `mu_r = sum_(x=0)^n x^rf(x)`

Moment d'ordre `r`
d'une variable `x`
de loi continue `f`
sur `]0, n[`

  `mu_r = int_(x=0)^n x^rf(x)dx`

  `f` : Loi de `x`
  `mu_r` : Moment d'ordre `r` de la variable `x`
  `"<"x^r">"` : Moyenne des puissances `r` de la variable `x`
  `r` : Paramètres entiers.
  `x` : Paramètre appartenant à `"Arr"(x)`.
  `x` de type `NN"→Arr"(x)` : Variable de loi `f`

Les deux procédés donnent le même résultat `mu_r` qu'est la moyenne des tirages à la puissances `r` appelée moment d'ordre `r`

  `mu_r = "<"x^r">"`  

La loi `f` est déterminée par la connaissance de tous ses moments `mu_0, mu_1, mu_2, mu_3,...`. Nous savons calculer la liste des moments à partir de la loi de probabilité. Pour mettre en oeuvre le calcul inverse, c'est à dire calculer la loi de probabilité à partir de la liste des moments, il nous faut étudier la fonction caractéristique, ce que nous ferons dans la partie 3.

Le moment d'ordre `r` de la variable `x` peut se noter `mu_r(x)`.

6) Les moments de la loi équirépartie

Pour une variable discrète `x` de loi `f` équirépartie sur `{0, 1, 2, 3,..., n}`. Comme `n"+"1` est le nombre de valeurs possible de la variable `x`, nous avons `f(x)=1 "/" (n"+"1)`.

`mu_r = sum_x x^rf(x)`
`mu_r = sum_x x^r 1/(n"+"1)`
`mu_r = 1/(n"+"1) sum_x x^r`

Et pour une variable continue `x` de loi `f` équirépartie sur `"]"0, n"["`, nous avons `f(x)=1/n`.

`mu_r = int_x x^rf(x) dx`
`mu_r = int_x x^r1/n dx`
`mu_r = 1/n int_x x^r dx`
`mu_r = 1/n [x^(r+1)/(r"+"1)]_(x=0)^n`
`mu_r = 1/n (n^(r+1)/(r"+"1))`
`mu_r = n^r/(r+1)`

Récapitulons :

Moments de la variable `x`
de loi discrète `f`
équirépartie sur `{0,1,2,...,n}`

  `mu_r = 1/(n"+"1) sum_(x=0)^n x^r`
Moments de la variable `x`
de loi continue `f`
équirépartie sur `"]"0,n"["`

  `mu_r = n^r/(r+1)`
  `mu_r` : Moment d'ordre `r` de la variable `x`
  `mu_1` : Moyenne de `x`
  `mu_2` : Variance de `x`
  `x, r` : Paramètres.
  `n` : Taille de l'intervalle des valeurs possibles de la variable `x`

Lorsque `n` devient grand, la variable discrète définie sur `{0, 1, 2..., n}`, approxime la variable continue définie sur `"]"0,n"["`, les moments de la variable discrète convergent vers les moments de la variable continue.

7) Variable centrée

On centre la variable `x` en lui soustrayant sa moyenne `m`. On obtient ainsi une nouvelle variable :

`x"-"m`

Nommons cette nouvelle variable `y`. Cela signifie qu' à chaque instant `k` nous avons `y(k) = x(k) "-" "<"x">"`. La moyenne de `y` est nulle :

`y = x "-" "<"x">"`
`"<"y">" = "<" x "-" "<"x">" ">"`
`"<"y">" = "<"x">""-" "<"x">"`
  car `"<"x">"` est une constante.
`"<"y">" = 0`

8) Variance et écart type

La variance de `x` notée `V` ou `V(x)` est le moment d'ordre `2` de la variable centrée `x"-<"x">"`. Il existe deux façons de calculer la variance, une façon intérieure, et une façon extérieur dite empirique. Les deux procédés donnent le même résultat :

Dans le cas d'une variable `x` de loi discrète `f` :

  `V = sum_x (x"-<"x">")^2f(x)`  

Et dans le cas d'une variable `x` de loi continue `f` :

   `V = int_x (x"-<"x">")^2f(x)dx`   

La variance est la moyenne des carrés des tirages de la variable centrée `x"-<"x">"`. On note `x(k)` la valeur de la variable `x` à l'instant `k`.

  `V = "<" (x"-<"x">")^2 ">"`
  `V = lim_(k->oo) 1/k sum_(k=1)^k (x(k)"-<"x">")^2`  

Les valeurs de `x` étant bornées et indépendantes entre-elles, cette limite converge nécessairement.

On remarque que :

`V = "<"(x "-<"x">")^2">"`
`V = "<" x^2 "-" 2x"<"x">" "+" "<"x">"^2 ">"`
`V = "<"x^2">" "-" 2"<"x">"^2 "+" "<"x">"^2`
`V = "<"x^2">" "-" "<"x">"^2`
`V = mu_2 - mu_1^( 2)`

L'écart type de `x` notée `sigma`, ou `sigma_x`, est la racine carré de la variance :

`sigma = sqrt("<" (x"-<"x">")^2 ">")`
`sigma = sqrt(mu_2 - mu_1^( 2))`

Notez que `m_x` et `sigma_x` possède la même unité physique que celle de `x`.

9) Variable centrée réduite

On centre la variable `x` en soustrayant sa moyenne. Puis on réduit la variable ainsi obtenue en la divisant par son écart-type (racine-carré de la variance). On obtient ainsi une nouvelle variable de moyenne nulle et de variance égale à `1`:

`(x - m) / sigma`
`(x -"<"x">") / sqrt( "<" (x -"<"x">")^2 ">")`
`(x -"<"x">") / sqrt( "<"x^2">" -"<"x">"^2)`
`(x - mu_1) / sqrt( mu_2 - mu_1^( 2))`

10) La moyenne de `x"+"y`

Dans le cas d'une variable aléatoire vectorielle `(x,y)`, la moyenne extérieure de `x"+"y` est la somme des moyennes extérieures de `x` et de `y`.

`"<"x"+"y">" = lim_(k->∞) 1/k sum_(k=1)^k (x(k)"+"y(k))`
`"<"x"+"y">" = lim_(k->∞) 1/k sum_(k=1)^k x(k)  + lim_(k->∞) 1/ksum_(k=1)^k y(k)`

`"<"x"+"y">" = "<"x">" + "<"y">"`

11) Transformation linéaire

Etant donné une variable aléatoire `x`, on se propose d'étudier la variable `ax + b``a≠0` et `b` sont des constantes. Nommons cette variable `y`. Nous avons `y=ax "+" b`, ce qui signifie que à chaque tirage nous avons `overset(***)y=a overset(***)x "+" b`. Et récirproquement `x= (y"-" b)"/"a`, ce qui signifie que à chaque tirage nous avons `overset(***)x=(overset(***)y"-" b)"/"a`. Et nous avons `"Arr"(y)=a"Arr"(x)"+"b`.

11.1) La loi

Déterminons la loi `Y` de cette variable `y`, en fonction de la loi `X` de `x` :

`Y(y)=P(overset(***)y∈"]"y, y"+"dy"[")`
`Y(y)=P(aoverset(***)x"+"b∈"]"ax"+"b, ax"+"b "+"d(ax"+"b)"[")`
`Y(y)=P(aoverset(***)x"+"b∈"]"ax"+"b, ax"+"b "+"adx"[")`
`Y(y)=P(aoverset(***)x∈"]"ax, ax"+"adx"[")`

`Y(y)=P(overset(***)x∈"]"x, x"+"dx"[")`

`Y(y)=X(x)`
`Y(ax"+"b)=X(x)`
`Y(ax)=X(x"-"b)`
`Y(x)=X((x"-"b)/a)`

11.2 Les moments

Déterminons les moments de cette variable `y`, en fonction des moments de `x` que l'on notent comme suit :

`mu_1"=<"x">"` `kappa_1"=<"y">"`
`mu_2"=<"x^2">"`       `kappa_2"=<"y^2">"`
`mu_3"=<"x^3">"` `kappa_3"=<"y^3">"`
`...` `...`

Calcul de la moyenne, nous avons :

`y = ax + b`
`"<"y">" = "<"ax + b">"`
`"<"y">" = a"<"x">" + b`

Calcul de la variance, nous avons :

`y = ax + b`
`y^2= (ax + b)^2`
`y^2 = a^2x^2 + 2abx + b^2`
`"<"y^2">" = "<" a^2x^2 + 2abx + b^2 ">"`
`"<"y^2">" = a^2"<"x^2">" + 2ab"<"x">" + b^2`

Calcul du moment d'ordre `3`, nous avons :

`(ax + b)^3 = a^3x^3 + 3a^2bx^2 + 3ab^2x + b^3`
`"<"(ax + b)^3">" = a^3"<"x^3">" + 3a^2b"<"x^2">" + 3ab^2"<"x">" + b^3`

Calcul du moment d'ordre `r`, nous avons :

Le développement de `(x"+"y)^r` est donnée par la formule du binôme :

`(x"+"y)^r = C_r^0 x^r+C_r^1 x^(r-1)y+C_r^2 x^(r-2)y^2+C_r^3 x^(r-3)y^3+ ... +C_r^r y^r`
`(x+y)^r = sum_(r=0)^r C_(overset(▴)r)^r x^(overset(▴)r-r) y^r`

La formule de Pascal nous permet de calculer les coefficients binomiaux `C_n^r` simplement (triangle de Pascal) :

`C_n^r = (n!) / ( r! (n-r)! )`
`C_n^r = C_(n-1)^(r-1) + C_(n-1)^r`
`C_n^0 = 1`
`C_n^n = 1`
1
1  1
1  2  1
1  3  3  1
1  4  6  4  1

Appliquons ce développement à notre transformation linéaire :

`(ax + b)^r = sum_(r=0)^r C_(overset(▴)r)^r (ax)^(overset(▴)r-r)b^r`
`"<"(ax + b)^r">" = sum_(r=0)^r C_(overset(▴)r)^r a^(overset(▴)r-r)b^r"<"x^(overset(▴)r-r)">" `
`kappa_r = sum_(r=0)^r C_(overset(▴)r)^r a^(overset(▴)r-r)b^r mu_(overset(▴)r-r)`

Récapitulons :

Transformation linéaire `y=ax"+"b`

Soit `X` la loi de `x`, et soit `Y` la loi de `y`, nous avons :

    `Y(x)=X((x"-"b)/a)`

Soit `mu_r` le moment d'ordre `r` de `x`, et soit `kappa_r` le moment d'ordre `r` de `y`, nous avons :

  `kappa_r = sum_(r=0)^r C_(overset(▴)r)^r a^(overset(▴)r-r)b^r mu_(overset(▴)r-r)`

`C_(n)^r` : Coefficient binomiaux.
C'est le nombre de sous-ensemble de `r` éléments d'un ensemble de `n` éléments.

`kappa_1` : Moyenne de la variable `(ax"+"b)`
`kappa_2` : Variance de la variable `(ax"+"b)`
`kappa_r` : Moment d'ordre `r` de la variable `(ax"+"b)`
`mu_1` : Moyenne de la variable `x`
`mu_2` : Variance de la variable `x`
`mu_r`
: Moment d'ordre `r` de la variable `x`
`a,b`
: Paramètres réels.
`r`
: Numéro d'ordre du momment
`r` dans l'itérateur somme : Indexe variant de `0` à `r`.
`overset(▴)r` dans l'itérateur somme : Numéro d'ordre du momment.

12) Notation (suite)

Pour éviter de démultiplier les variables ou leur appétence symbolique, on convient pour une variable aléatoire quelconque `x` de désigner :

12.1) Variable de loi continue

Pour une variable de loi continue `x`, Le domaine d'évolution est l'intervalle ouvert suivant :

`"Arr"(x) = ]x_min,x_max[`

Sa loi `X` est une distribution normée de densité de probabilité. La probabilité au voisinage de `x` est une probabilité différentiel, c'est la probabilité qu'un tirage de `x` appartienne à l'intervalle `]x,x"+"dx[`, et elle vaut :

`P(overset(***)x∈"]"x, x"+"dx"[") = X(x)dx`

`int_x X(x)dx = 1`

La fonction cumulative `bbX` est une fonction croissante, c'est l'intégrale de la loi, commençant par valoir `0` :

`bbX(x) = int_(x_"min")^x X(x)dx`

`bbX(x_"min") = 0`

`bbX(x_"max") = 1`

12.2) Variable de loi discrète

Pour une variable de loi discrète `x`, le domaine d'évolution est une suite finie de valeurs suivantes :

`"Arr"(x) = {f(0),f(1),f(2),...,f(n)}`

et la loi `X` est une distribution normée de probabilité.

`P(overset(***)x=x) = X(x)`

`sum_x X(x)dx = 1`

La fonction cumulative stricte est une fonction croissante, c'est la somme de la loi, commençant par valoir `0` :

`bbX(x) = sum_(x_"min")^x X(x)`

`bbX(x_"min") = 0`

`bbX(x_"max") = 1-X(x_max)`

La fonction d'échelle `f` de la variable `x` énumère dans l'ordre les `n` valeurs de `"Arr"(x)`. Le nombre de valeurs distinctes envisageables pour la variable `x` est donc égal à `n"+"1`.

`f(0) = x_min`
`f(n) = x_max`

Les lois de probabilités (volume 2)

 

Dominique Mabboux-Stromberg