diff --git a/module2/exo1/figure.png b/module2/exo1/figure.png
new file mode 100644
index 0000000000000000000000000000000000000000..f058d047596e77b749af1770eb523a0ef174340b
Binary files /dev/null and b/module2/exo1/figure.png differ
diff --git a/module2/exo1/toy_document_orgmode_python_fr.org b/module2/exo1/toy_document_orgmode_python_fr.org
index c7157ba42216cf2e1d291112bb351ce48811115c..887e2d17790662e59f53343f14fd43b19087cc81 100644
--- a/module2/exo1/toy_document_orgmode_python_fr.org
+++ b/module2/exo1/toy_document_orgmode_python_fr.org
@@ -1,6 +1,6 @@
-#+TITLE:  Votre titre
-#+AUTHOR: Votre nom
-#+DATE:   La date du jour
+#+TITLE:  À propos du calcul de \pi
+#+AUTHOR: Konrad Hinsen 
+#+DATE:   2019-03-28 Thu 11:06
 #+LANGUAGE: fr
 # #+PROPERTY: header-args :eval never-export
 
@@ -91,3 +91,64 @@ faisant ~<p~, ~<P~ ou ~<PP~ suivi de ~Tab~).
 
 Maintenant, à vous de jouer! Vous pouvez effacer toutes ces
 informations et les remplacer par votre document computationnel.
+
+* En demandant à la lib maths 
+Mon ordinateur m'indique que \pi vaut approximativement: 
+
+#+begin_src python :results output :session :exports both
+from math import *
+pi
+#+end_src
+
+#+RESULTS:
+
+* En utilisant la méthode des aiguilles de Buffon 
+
+Mais calculé avec la méthodes des [[https://fr.wikipedia.org/wiki/Aiguille_de_Buffon][aiguilles de Buffon]], on obtiendrait comme approximation : 
+
+#+begin_src python :results output :session :exports both
+import numpy as np
+np.random.seed(seed=42)
+N = 10000
+x = np.random.uniform(size=N, low=0, high=1)
+theta = np.random.uniform(size=N, low=0, high=pi/2)
+2/(sum((x+np.sin(theta))>1)/N)
+#+end_src
+
+#+RESULTS:
+
+* Avec un argument "fréquentiel" de surface 
+
+Sinon, une méthode plus simple à comprendre et ne faisant pas intervenir d'appel à la fonction sinus se basse sur le fait que si $$ X \sim U(0,1)$$ et $$ Y \sim U(0,1) $$ alors $$ P[ X^2 + Y^2 \leq 1 ] = \frac{\pi}{4} $$ ( voir  [[https://fr.wikipedia.org/wiki/M%C3%A9thode_de_Monte-Carlo#D%C3%A9termination_de_la_valeur_de_%CF%80][méthode de Monte Carlo sur Wikipedia]]). Le code suivant illustre ce fait : 
+
+#+begin_src python :results file :session :var matplot_lib_filename="./figure.png" :exports both
+import matplotlib.pyplot as plt
+
+np.random.seed(seed=42)
+N = 1000
+x = np.random.uniform(size=N, low=0, high=1)
+y = np.random.uniform(size=N, low=0, high=1)
+
+accept = (x*x+y*y) <= 1
+reject = np.logical_not(accept)
+
+fig, ax = plt.subplots(1)
+ax.scatter(x[accept], y[accept], c='b', alpha=0.2, edgecolor=None)
+ax.scatter(x[reject], y[reject], c='r', alpha=0.2, edgecolor=None)
+ax.set_aspect('equal')
+
+plt.savefig(matplot_lib_filename)
+print(matplot_lib_filename)
+#+end_src
+
+#+RESULTS:
+[[file:figure.png]]
+
+Il est alors aisé d'obtenir une approximation (pas terrible) de \pi en comptant combien de fois, en moyenne, $$ X^2 + Y^2$$ est inférieur à 1 : 
+
+#+begin_src python :results output :session :exports both
+4*np.mean(accept)
+#+end_src
+
+#+RESULTS:
+: 3.112