Tirage aléatoire

Rappel sur le module random

On peut réaliser un tirage aléatoire à l’aide de ce module, de plusieurs façon.

import random
print(random.random()) # retourne un nombre entre 0 et 1.

0.29770583180487964

Pour tirer un nombre entier on peut soit tirer un nombre entre 0 et 1 et faire une translation et arrondir ou utiliser la fonction randint qui fait la même chose:

def randint1(min, max):
    """ retourne un nombre choisi uniformement entre min et max (inclu) """
    if max <= min:
        raise ValueError("max devrait être plus grand que min")
    return int((max+1-min)*random.random())

On peut également utiliser la fonction choice qui tire un élément au hasard dans une Sequence (typiquement une liste)

def randint2(min, max):
    """ retourne un nombre choisi uniformement entre min et max (inclu) """
    L = list(range(min, max+1))
    return random.choice(L)

On peut vérifier que c’est une distribution à peut prêt uniforme. Voici la distribution pour 2000 tirages de chacune de ces fonctions.

import collections
d_random = collections.Counter(random.randint(0, 10) for _ in range(2000)) # on réalise 2000 tirage
d_randint1 = collections.Counter(randint1(0, 10) for _ in range(2000)) # on réalise 2000 tirage
d_randint2 = collections.Counter(randint2(0, 10) for _ in range(2000)) # on réalise 2000 tirage
print("entier        ", "\t".join(str(i) for i in range(0, 11)))
print("random.randint", "\t".join(str(d_random[i]) for i in range(0, 11)))
print("randint1      ", "\t".join(str(d_randint1[i]) for i in range(0, 11)))
print("randint2      ", "\t".join(str(d_randint2[i]) for i in range(0, 11)))

entier         0    1   2   3   4   5   6   7   8   9   10
random.randint 163  180 168 172 200 166 198 201 186 189 177
randint1       173  171 185 175 204 174 199 194 184 178 163
randint2       188  182 159 199 193 178 192 190 175 173 171

Une classe pour les tirages aléatoire

On va réaliser une classe dont l’objectif est de modéliser les tirages aléatoires dans les entiers et de donner des informations à leur sujet. On ne modélise ici que les tirages indépendants.

Créer une classe tirage_aleatoire qui prend en argument une fonction un argument optionnel \(p\) dont la valeur par défaut est \(10^6\). Cette classe doit:

• implémenter une méthode tirage qui execute la fonction
• être itérable et dont les itérateurs sont des suites infinies d’appel à tirage
• implémente une propriété moyenne (en calculant la moyenne sur \(p\) tirages)
• implémente une propriété ecart_type (en calculant l’écart type sur \(p\) tirages)
• être additionnable: (implémente __add__)
• être multipliable: (implémente __mul__)
• implémenter une méthode support qui retourne l’ensemble des valeurs prise en executant tirage \(p\) fois.
• implémente une méthode distribution qui retourne la distribution de la fonction tirage estimé sur \(p\) tirage.
• implémente une méthode affiche qui dessine avec matplotlib la distribution de la classe.

Des tirages biaisés

Instancier tirage_aleatoire pour faire un dé pipé (valeur de 1 à 6) avec les probabilités suivante:

• \(1\to \frac{1}{3}\)
• \(2\to \frac{1}{6}\)
• \(3\to \frac{1}{6}\)
• \(4\to \frac{1}{6}\)
• \(5\to \frac{1}{9}\)
• \(6\to \frac{1}{18}\)

Une loi normale via une application du Théorème centrale limite

On pose:

T = tirage_aleatoire(lambda: randint(0, 10))

On définit la séquence suivante:

• \(T_0 = T\)
• \(T_{i+1} = T_i + T\)

Calculer les premier terme de cette suite et affichez sa distribution.

Vous devriez obtenir une loi normale!

Une distribution de Poisson

En posant:

T = tirage_aleatoire(lambda:randint(0, 1))

On définit la séquence suivante:

• \(T_0 = T\)
• \(T_{i+1} = T_i * T\).

Calculer les premiers terme de cette suite de tirage_aleatoire et affichez sa distribution.

• Calculer \(P = \Sigma_{i=0}^{100} T_i\) et afficher sa distribution.

Vous devriez retrouver une loi de Poisson (voir votre cours de math ou l’article wikipedia ici

Corrections

Compiled the: dim. 07 janv. 2024 23:19:07 CET