Imprimer
Affichages : 34808

Vote utilisateur: 5 / 5

Etoiles activesEtoiles activesEtoiles activesEtoiles activesEtoiles actives
 

Algorithmique - Loi binomiale


1. Loi de bernoulli

Une variable aléatoire suivant la loi de Bernoulli est appelée variable de Bernoulli, du nom du mathématicien suisse Jacques Bernoulli (1654-1705).

La loi de Bernoulli est la loi de la variable aléatoire qui modélise le résultat d'une épreuve qui n'admet que deux issues (épreuve de Bernoulli) : 1 pour « succès », 0 pour « échec ».

On note généralement \(p\) la probabilité du succès (soit d'obtenir 1) et donc \(1-p\) celle d'obtenir 0 (échec). Donc si la variavle aléatoire \(X\) suit une loi de Bernoulli de paramètre \(p\) on a :

$$P(X=k) = \left\lbrace \begin{array}{ll} p~~~~&\text{si}~~k=1\\1-p~~~~&\text{si}~~k=0\\0~~~~&\text{sinon} \end{array}\right.$$

from random import *

# Le module random est un module qui regroupe des fonctions permettant de simuler le hasard. Pour pouvoir l'utiliser, il faut l'importer pour le mettre en mémoire. Donc dès qu'on voudra utiliser les fonctions qui suivent pour simuler le hasard, on devra mettre en entête la commande from random import *.

# random() : Donne un flottant au hasard dans l'intervalle [0 ; 1[.
# uniform(a,b) : Donne un flottant au hasard entre a et b. 

# Ecrire une fonction bernoulli(p) qui renvoie 0 ou 1 avec la probabilité p

def bernoulli(p):
    x=uniform(0,1)
    if ... :
        return 1
    else:
        return 0

 

 

 

# Exercice 2 : Ecrire une fonction nombredesucces(n,p) qui renvoie le nombre de succès (de 1) obtenus pour une répétion de n épreuves de Bernoulli.

def nombredesucces(n,p):
    ...
    for ... :
        ...
    return ...

n=100
p=0.3
print(nombredesucces(n,p))

 

2. Loi Binomiale

La loi binomiale modélise le nombre de succès obtenus lors de la répétition indépendante de plusieurs expériences aléatoires identiques de Bernoulli. Pour chaque expérience appelée épreuve de Bernoulli, on utilise une variable aléatoire qui prend la valeur 1 lors d'un succès et la valeur 0 sinon. La variable aléatoire, somme de toutes ces variables aléatoires, compte le nombre de succès et est de loi binomiale.

La fonction B(n,p).

La fonction précédente nombredesucces(n,p) permet de simuler une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\).
Elle permet donc également de simuler une variable aléatoire suivant une loi de Bernoulli de paramètres p en prenant simplement \(n=1\).
On peut donc définir une fonction B(n,p) identique.

#  Exercice 3 : Ecrire une fonction listeB(n,p,nb) qui renvoie une liste de \(nb\) valeurs d'une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\).

def B(n,p):
    return nombredesucces(n,p)

def listeB(n,p,nb):
    return [B(n,p) for ... ]

 

 

 

#  Exercice 4 : Ecrire une fonction frequencelisteB(n,p,nb) qui renvoie une liste des fréquences des \((n+1)\) valeurs possibles par une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\) sur un échantillon de taille \(nb\).

def frequencelisteB(n,p,nb):
    f=[0]*(n+1) # permet de générer une liste de (n+1) valeurs égales à 0
    L= listeB(n,p,nb)
    for S in L:
        f[S]=f[S]+1/nb
    return f
>>> frequencelisteB(20,0.3,100)
([0.01, 0.01, 0.02, 0.04, 0.15, 0.16, 0.20000000000000004, 0.17, 0.12999999999999998, 0.08, 0.02, 0.01, 0, 0, 0, 0, 0, 0, 0, 0, 0])

 

>>> frequencelisteB2(20,0.3,100)
(0, 0)
(1, 0.02)
(2, 0.05)
(3, 0.07)
(4, 0.11999999999999998)
(5, 0.21000000000000005)
(6, 0.17)
(7, 0.13999999999999999)
(8, 0.060000000000000005)
(9, 0.12999999999999998)
(10, 0.03)
(11, 0)
(12, 0)
(13, 0)
(14, 0)
(15, 0)
(16, 0)
(17, 0)
(18, 0)
(19, 0)
(20, 0)

 

 

 

Articles Connexes