En tête general

(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/

Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée.

Méthode de Monte Carlo (corrigé)

Dans un repère orthonormé, on considère les surfaces $C$ et $P$ définies respectivement par :

$ C=\left\{ \;M(x;y) \; / \; 0 \leqslant x \leqslant 1 \;; \; 0 \leqslant y \leqslant 1 \; \right\} $

$ P=\left\{ \;M(x;y) \; / \; 0 \leqslant x \leqslant 1 \;; \; 0 \leqslant y \leqslant x^2 \; \right\} $

1. Identifier ces deux surfaces et les représenter dans le repère fourni.

Repère à compléter

Déterminer l’aire de $C$.

*Le but de l’activité est de déterminer des valeurs approchées de l’aire de la surface $P$ à l’aide d’une méthode probabiliste.*

*On admet que lorsqu’on tire aléatoirement un point dans $C$, la probabilité qu’il soit dans $P$ vaut $ \frac{Aire(P)}{Aire(C)} $.*

*Ainsi, lorsqu’on tire aléatoirement plusieurs points dans $C$, la fréquence de ces points qui sont dans $P$ fournit une valeur approchée de $ \frac{Aire(P)}{Aire(C)} $, d’autant plus précise que le nombre de points est grand.*

Pour une présentation de la méthode, voir la vidéo suivante.

2. Modifier la fonction MonteCarlo donnée ci-dessous pour qu’elle reçoive un entier $n$ en argument et place $n$ points aléatoires de $C$ sur le graphique.

In [4]:
# Modifier la fonction

from random import*
import matplotlib.pyplot as plt

def MonteCarlo(n):
    
    for k in range(n):
        # generation de coordonnees aleatoires entre 0 et 1 pour un point M dans C
        x,y=random(),random()    
        # placement du point M dans le repere (en bleu)
        plt.scatter(x,y,color='blue')     

    # reglage des bornes des axes du repere
    plt.axis([0,1,0,1]) 
    # ouverture de la fenetre graphique et affichage
    plt.show() 
    
    #(fonctionnalités désactivées dans la version Jupyter Notebook)
    # attente d'une action de clic sur la fenetre puis fermeture
    # plt.waitforbuttonpress() 
    # plt.close() 
    
    return None
In [11]:
MonteCarlo(250)

3. Créer une fonction dans_P qui reçoit en argument les coordonnées $(x;y)$ d’un point de $C$ et renvoie True si ce point appartient à $P$ et False sinon.

In [7]:
def dans_P(x,y):
    return y<=x**2

4. Modifier la fonction MonteCarlo pour qu’elle place les points appartenant à $P$ en rouge et les autres en bleu. On utilisera la fonction dans_P pour le test.

In [15]:
def MonteCarlo_2(n):
       
    for k in range(n):
        # generation de coordonnees aleatoires entre 0 et 1 pour un point M dans C
        x,y=random(),random()    
        
        if dans_P(x,y):
            # placement du point M dans le repere (en rouge)
            plt.scatter(x,y,color='red')     
            # incrementation du compteur
        else:
            # placement du point M dans le repere (en bleu)
            plt.scatter(x,y,color='blue')      

    # reglage des bornes des axes du repere
    plt.axis([0,1,0,1]) 
    # ouverture de la fenetre graphique et affichage
    plt.show() 
    
    #(fonctionnalités désactivées dans la version Jupyter Notebook)
    # attente d'une action de clic sur la fenetre puis fermeture
    # plt.waitforbuttonpress() 
    # plt.close() 
    
    return None

MonteCarlo_2(250)

5. Modifier la fonction MonteCarlo pour :

  • qu’elle compte le nombre de points placés qui sont dans $P$ ;
  • qu’elle calcule la fréquence $f$ de ces points ;
  • qu’elle renvoie cette fréquence $f$.

*On pourra également faire apparaître cette fréquence dans la fenêtre à l’aide de l’instruction suivante :* plt.text(0,-0.1,"Fréquence des points dans P: "+str(f))*.*

In [16]:
def MonteCarlo_3(n):
    
    # initialisation du compteur de points dans P
    compteur=0
    
    for k in range(n):
        # generation de coordonnees aleatoires entre 0 et 1 pour un point M dans C
        x,y=random(),random()    
        
        if dans_P(x,y):
            # placement du point M dans le repere (en rouge)
            plt.scatter(x,y,color='red')     
            # incrementation du compteur
            compteur = compteur+1
        else:
            # placement du point M dans le repere (en bleu)
            plt.scatter(x,y,color='blue') 
        
    # calcul de la fréquence de points dans P
    f=compteur/n
    # affichage de la frequence dans la fenetre       
    plt.text(0,-0.1,"Fréquence des points dans C: "+str(f))
    
    # reglage des bornes des axes du repere
    plt.axis([0,1,0,1]) 
    # ouverture de la fenetre graphique et affichage
    plt.show() 
    
    #(fonctionnalités désactivées dans la version Jupyter Notebook)
    # attente d'une action de clic sur la fenetre puis fermeture
    # plt.waitforbuttonpress() 
    # plt.close() 
        
    return f

6. En appelant la fonction MonteCarlo avec $n=100$ ; $n=1000$ ; $n=10000$ … donner des approximations de l’aire de la surface $P$.

In [17]:
MonteCarlo_3(100)
MonteCarlo_3(1000)
MonteCarlo_3(10000)
Out[17]:
0.3283

7. On considère la surface $ D=\left\{ \;M(x;y) \; / \; 0 \leqslant x \leqslant 1 \;; \; 0 \leqslant y \leqslant 1 \;; \; x²+y² \leqslant 1 \; \right\} $.

Identifier cette surface $D$, et représenter $C$ et $D$ dans le repère fourni.

Repère à compléter

Déterminer la valeur exacte de l’aire de $D$.

Adapter la méthode vue précédemment pour obtenir des approximations de $\pi$ par la méthode de Monte-Carlo.

In [20]:
#redéfinition de P
def dans_P(x,y):
    return x**2+y**2<=1


approx_pi=4*MonteCarlo_3(2000)

approx_pi
Out[20]:
3.158

(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/

In [ ]: