Sujet

Description haut niveau

Le programme que vous allez écrire, qui se décomposera en deux fichiers Python, doit :

• calculer une valeur approximative de π à l'aide d'une simulation de Monte-Carlo ;
• générer une image animée représentant la simulation comme ci-dessous.

Pour calculer une approximation de π à l'aide d'une simulation de Monte-Carlo en tirant n points aléatoires (comme au casino), l'algorithme simple que vous utiliserez est le suivant :

• initialiser un compteur à 0 ;
• pour i allant de 1 à n :
  • générer un point aléatoire (x,y) dans un carré de longueur 2 et de centre (0,0). Pour cela il suffit de générer x dans [-1,1] et y dans [-1,1] ;
  • si le point est dans le cercle de centre (0,0) et de rayon 1, ajouter 1 au compteur ;
• l'estimation de π/4 est la valeur du compteur divisée par le nombre n.

Pour en savoir plus sur le sujet, nous nous référerons au très clair billet de Bruno Tuffin sur le site interstices.info.

Pour la création de l'image animée, nous générerons des images au format PPM puis nous les agrégerons comme expliqué dans la prochaine section.

Travail à réaliser

Le travail à réaliser se décompose en deux parties.

Première partie : cœur de la simulation

La première partie du projet consiste à écrire un module Python approximate_pi.py qui sera le cœur de notre simulation. Autrement dit, ce module se charge uniquement du travail en lien avec le calcul d'une approximation de π sans se préoccuper des questions de visualisation sous forme d'image.

Le module approximate_pi.py doit fournir au programme draw.py décrit ci-dessous :

• les points aléatoires tirés avec x appartenant à [-1,1] et y appartenant à [-1,1] pour tous les points ;
• l'information indiquant si un point aléatoire est dans le cercle unitaire ou non.

Il est demandé que le module approximate_pi.py soit également un programme exécutable permettant de donner une approximation de π en utilisant un nombre de points donné sur la ligne de commande tel qu'illustré ci-dessous :

[selvama@ensipc215 projet_bpi]$ ./approximate_pi.py 100000000
3.14152532

Deuxième partie : génération d'images PPM puis d'un GIF

Nous allons maintenant utiliser approximate_pi.py comme un module pour passer aux choses sérieuses, c'est à dire à la génération de notre image animée représentant une simulation. Le travail demandé consiste à écrire un programme Python draw.py qui :

• reçoit 3 arguments dans l'ordre suivant depuis la ligne de commande :
  • la taille de l'image en pixels, qui est carrée donc un seul entier qui devra être supérieur ou égale à 100 ;
  • le nombre de point n à utiliser dans la simulation, qui devra être supérieur à 100 ;
  • le nombre de chiffres après la virgule à utiliser dans l'affichage de la valeur approximative de π, qui devra être compris entre 1 et 5.
• implémente une fonction generate_ppm_file(...) qui génère une image au format PPM. L'image doit montrer les points qui sont à l'intérieur du cercle d'une certaine couleur, les points qui sont à l'extérieur du cercle d'une autre couleur et la valeur approchée de π comme l'illustre l'image animée ci-dessus. La couleur de fond de l'image, blanc sur l'image ci-dessus, peut également être n'importe quoi d'autre. Le nom de l'image doit être au format img0_3-13776.ppm : 0 indique le numéro de l'image dans la simulation totale (0 en l'occurrence, donc la première image) et 3-13776 correspond à l'approximation courante de π en utilisant le nombre de chiffres après la virgule spécifié sur la ligne de commande (5 en l'occurrence). La signature de la fonction n'est volontairement pas donnée pour que chacun puisse réaliser sa propre solution ;
• génère une image PPM, en utilisant la fonction generate_ppm_file, représentant l'état courant de la simulation à chaque fois qu'un dixième du nombre total de points a été tiré. Dix images seront donc générées. On le répète, les points doivent êtres fournis par le module approximate.py. Comme ce dernier s'occupe uniquement du cœur de la simulation et n'a donc pas connaissance de la taille de l'image, la conversion des points avec x appartenant à [-1,1] et y appartenant à [-1,1] vers des pixels dans l'image doit se faire dans draw.py;
• utilise le programme convert pour créer une image animée au format GIF à partir des dix images PPM.

Si plusieurs point tirés par approximate_pi.py "tombent" sur le même pixel alors que certains points sont dans le cercle et d'autres non (ce peut arriver pour les points à la frontière du cercle), alors draw.py doit dessiner le pixel de la couleur associée au dernier point tiré correspondant au pixel.

Consignes à respecter

Il est demandé de respecter scrupuleusement les consignes suivantes :

• respecter précisément les noms des fichiers Python et images indiqués ci-dessus ;
• votre programme draw.py doit lancer une exception sans l'attraper si une ou plusieurs entrées incorrectes sont données par l'utilisateur sur la ligne de commande. Autrement dit, si l'utilisateur lance le programme avec ./draw.py tutu 10000 4 ou avec ./draw.py -800 100000 4 il doit voir dans son terminal une erreur indiquant l'exception qui a été lancée ainsi que la pile d'appels. L'interpréteur se charge de tout cet affichage pour nous quand on lance une exception et que celle-ci n'est jamais attrapée et donc remonte jusqu'au sommet de la pile d'appels ;
• utiliser des f-string quand cela est pertinent ;
• ne PAS lancer eog automatiquement depuis votre programme python ;
• votre programme draw.py doit créer les images dans le répertoire courant et non pas dans un sous dossier ;
• utiliser le module subprocess pour générer l'image animée GIF à partir des images PPM ;
• il est interdit d'utiliser numpy ;
• il est interdit d'utiliser un module externe pour rajouter le texte de π par dessus votre image. Autrement dit l'objectif est de coder cet affichage à la main en pensant à l'afficheur 7 segments de votre gadget électronique préféré ;
• idéalement, la taille du texte de π par dessus votre image s'adapte à la taille de l'image.