Feuille d’exercices 10

Objectifs

• Variables aléatoires

• Statistiques

Exercice 1 : variable aléatoire discrète

Question 1 : Créer une variable aléatoire discrète X de distribution :

\[ (0.4, 0.3, 0.2, 0.1) \]

X = GeneralDiscreteDistribution([0.4, 0.3, 0.2, 0.1])

Question 2 : Tirer aléatoirement \(10000\) valeurs selon \(X\), et stocker ces valeurs dans une liste L.

L = [ X.get_random_element() for _ in range(10000) ]

La méthode de liste L.count(i) permet de compter le nombre d’occurences de l’élément i dans le liste L.

Question 3 : Dans une liste B, stocker à la position i le nombre d’occurences de i dans la liste L créée à la question précédente.

B = [ L.count(i) for i in range(4) ]
print(B)

[4087, 2974, 1958, 981]

Question 4 : Visualiser la liste B sous forme de diagramme à barre, avec la fonction bar_chart(B, ymin=0).

bar_chart(B, ymin=0)

Exercice 2 : variable aléatoire continue

Question 1 : Créer une variable aléatoire \(G\) de distribution gaussienne et de variance \(\sigma = 1\).

sigma = 1
G = RealDistribution("gaussian", sigma)

Question 2 : Tirer aléatoirement \(10000\) valeurs selon \(G\), et stocker ces valeurs dans une liste M.

M = [ G.get_random_element() for _ in range(10000) ]

Question 3 : Calculer la moyenne de ces \(10000\) valeurs, puis comparer à la valeur espérée (\(0\)).

moyenne = sum(M)/10000
print(moyenne)

-0.006648411742059996

Question 4 : Calculer une approximation de l’écart-type de ces \(10000\) valeurs :

\[ \sqrt{\frac{1}{10000} \sum_{i=0}^{9999} M_i^2} \]

puis comparer à la valeur espérée (\(\sqrt{\sigma} = 1\)).

ecart = sqrt(sum([m**2 for m in M])/10000)
print(ecart)

1.0127707659248673

Exercice 3 : approximation de \(\pi\)

Question 1 : Écrire une fonction interieur_disque(x, y) qui teste si un point de coordonnées \((x,y)\) est à l’intérieur du cercle de centre \((0, 0)\) et de rayon \(1\).

def interieur_disque(x, y):
    return x**2 + y**2 <= 1

Question 2 : Écrire une fonction tirages_carre(N) qui retourne une liste de \(N\) points \((x, y)\), tirés uniformément dans \([-1, 1]^2\).

def tirages_carre(N):
    n = 0
    res = []
    for i in range(N):
        x = uniform(-1, 1)
        y = uniform(-1, 1)
        res.append([x,y])
    return res

Question 3 : Afficher sur un même grahique le cercle unité (en bleu) et \(100\) points tirés selon la méthode de la question pérécedente (en rouge).

Indication : pour afficher un cercle, on peut utiliser la fonction circle(P, r), qui crée un cercle de centre P (un point du plan sous la forme d’une liste de ses deux coordonnées) et de rayon r (une valeur positive).

T = tirages_carre(100)
circle([0,0], 1) + points(T, aspect_ratio=1, color='red')

Pour de grandes valeurs de \(N\), le rapport \(r = \frac{N_{\rm in}}{N}\) entre le nombre de tirages à l’intérieur du disque et le nombre de tirages total, tend vers le rapport \(a = \frac{{\rm aire(disque)}}{{\rm aire(carré)}}\) des aires du disque et du carré \([-1, 1]^2\).

Question 4 : Déduire de la remarque précédente une approximation de \(\pi\), en tirant \(10000\) points.

N = 10000
T = tirages_carre(N)

cpt = 0
for point in T:
    if interieur_disque(point[0], point[1]):
        cpt += 1
print(4*float(cpt)/N)

3.146

Exercice 4 : fougère de Barnsley

Le but de cet exercice est de produire la fractale appelée « fougère de Barnsley », référence ici.

Pour construire cette fractale, on considère \(4\) matrices \(M_1\), \(M_2\), \(M_3\), \(M_4\) et \(4\) vecteurs \(b_1\), \(b_2\), \(b_3\) et \(b_4\) :

\[\begin{split} M_1 = \begin{pmatrix} 0 & 0 \\ 0 & 0.16 \end{pmatrix},\quad M_2 = \begin{pmatrix} 0.8 & 0.04 \\-0.04 & 0.85 \end{pmatrix},\quad M_3 = \begin{pmatrix} 0.2 & -0.26 \\ 0.23 & 0.22 \end{pmatrix},\quad M_4 = \begin{pmatrix} -0.15 & 0.28 \\ 0.26 & 0.24 \end{pmatrix} \end{split}\]

\[\begin{split} b_1 = \begin{pmatrix} 0 \\ 0\end{pmatrix},\quad b_2 = \begin{pmatrix} 0 \\ 1.6 \end{pmatrix},\quad b_3 = \begin{pmatrix} 0 \\ 1.6 \end{pmatrix},\quad b_4 = \begin{pmatrix} 0 \\ 0.44 \end{pmatrix} \end{split}\]

Cette fractale est produite de la manière suivante :

• on part du point initial \(P_0 = (x_0, y_0) = (0, 0)\)

• puis, pour tout \(n\), le point \(P_n\) est construit en fonction de \(P_{n-1}\) avec un processus aléatoire :

  • avec probabilité \(0.01\), on a \(P_n = M_1 P_{n-1} + b_1\)

  • avec probabilité \(0.85\), on a \(P_n = M_2 P_{n-1} + b_2\)

  • avec probabilité \(0.07\), on a \(P_n = M_3 P_{n-1} + b_3\)

  • avec probabilité \(0.07\), on a \(P_n = M_4 P_{n-1} + b_4\)

Pour un entier \(N\) fixé, la fractale de Barnsley de taille \(N\) correspond à l’ensemble des points \(P_0, \dots, P_{N-1}\) ainsi construits.

Voici la fractale voulue (avec \(250000\) points).

Question. Construire une fonction fougere(N) qui construit la liste des points de la fractale de Barnsley de taille \(N\).

Puis, afficher cette fractale pour \(N = 1000\), \(N = 10000\) et si possible, \(N= 100000\). Pour l’affichage, on utilisera un nuage de points verts de taille size=2 ou size=1, et on enlèvera les axes de la figure avec l’option axes=False.

def fougere(N=10000, mysize=1, mycolor="green"):

    M1 = matrix(2, 2, [0., 0., 0., 0.16])
    M2 = matrix(2, 2, [0.85, 0.04, -0.04, 0.85]) # 0.85
    M3 = matrix(2, 2, [0.2, -0.26, 0.23, 0.22]) # 0.20
    M4 = matrix(2, 2, [-0.15, 0.28, 0.26, 0.24])

    b1 = vector([0., 0.])
    b2 = vector([0., 1.60])
    b3 = vector([0., 1.60])
    b4 = vector([0., 0.44])

    P = vector([0, 0])

    L = [P]

    for i in range(N):
        r = randint(0,99)
        if r < 1:
            P = M1*P + b1
        elif r < 86:
            P = M2*P + b2
        elif r < 93:
            P = M3*P + b3
        else:
            P = M4*P + b4
        L.append(P)
    return points(L, axes=False, size=mysize, color=mycolor)
    
fougere(1000).show()
fougere(10000).show()
fougere(100000).show()