From 580b3046347b9f76f2bc55da8f4d33ada81b96fa Mon Sep 17 00:00:00 2001
From: Rnhmjoj <micheleguerinirocco@me.com>
Date: Mon, 13 Jan 2014 22:01:52 +0100
Subject: [PATCH] English translation

---
 License.txt  | 10 ----------
 README.md    | 39 +++++++++++++++++++++------------------
 de Buffon.py | 48 ++++++++++++++++++++++++------------------------
 3 files changed, 45 insertions(+), 52 deletions(-)
 delete mode 100644 License.txt

diff --git a/License.txt b/License.txt
deleted file mode 100644
index 6b8c4d5..0000000
--- a/License.txt
+++ /dev/null
@@ -1,10 +0,0 @@
- * Ago di Buffon
- *
- * Simulazione del metodo dell'ago di Buffon in python 3.
- *
- * Dual licensed under the MIT and GPL licenses:
- * http://www.opensource.org/licenses/mit-license.php
- * http://www.gnu.org/licenses/gpl.html
- * 
- * @author Michele Guerini Rocco aka Rnhmjoj
- * @since 2013
\ No newline at end of file
diff --git a/README.md b/README.md
index 6b5918a..d97ccd2 100644
--- a/README.md
+++ b/README.md
@@ -1,22 +1,25 @@
-Ago di Buffon
-=============
+# Ago di Buffon
 
-Simulazione del metodo dell'ago di Buffon in python 3.
-------------------------------------------------------
+## Simulation of de Buffon's needle method in python 3.
 
-### Informazioni
-Un semplice modulo per stimare π usando il metodo dell'ago di Buffon.
-Tramite turtle graphics è generato un pavimento e disegnati gli aghi casualmente.
-Se un ago incrocia le assi diventa rosso e viene conteggiato.
-Il valore stimato di π è continuamente stampato e al termine viene mostrato lo scarto dal valore reale.
+### Info
+A simple module to estimate π using the Buffon's needle method.
+With Turtle graphics a floor is generated and needles are randomly drawn.
+If a needle crosses the axis it turns red and it is counted.
+The estimated value of π is continuously printed and at the end the deviation from the real value is shown.
 
-È predisposto con la "stima" di Lazzarini per buoni risultati.
-Il migliore trovato è stato con uno scarto di 8*10^-6.
-	
-### Istruzioni
-Parametri:
+It is set with the "estimation" of Lazzarini for better results.
+The best find was a difference of `8*10^-6`.	
 
-	X,Y: lunghezze degli assi;
-	T: distanza tra le assi del parquet;
-	L: lunghezza dell'ago;
-	N: numero di iterazioni.
\ No newline at end of file
+### Usage
+Parameters:
+
+	X, Y: axes lenght;
+	T: distance between parquet's axes;
+	L: length of the needle;
+	N: number of iterations.
+
+### License
+Dual licensed under the MIT and GPL licenses:
+http://www.opensource.org/licenses/mit-license.php
+http://www.gnu.org/licenses/gpl.html
diff --git a/de Buffon.py b/de Buffon.py
index 840ad91..b46b66d 100644
--- a/de Buffon.py	
+++ b/de Buffon.py	
@@ -1,57 +1,57 @@
-import math, random
+import math
+import random
 import turtle
 
-#Parametri
-
+#Parameters
 X = 100
 Y = 100
 T = 20
 L = 5 / 6 * T
 N = 213
 
-assi = ()
+axes = ()
 
 
-def impostazioni():
-	"""Impostazioni per inizializzare turtle"""
-	turtle.title("Ago di Buffon")
+def settings():
+	"""Turtle settings"""
+	turtle.title("de Buffon's needle")
 	turtle.setworldcoordinates(-(X + 2), -(Y), X + 2, Y)
 	turtle.hideturtle()
 	turtle.speed(0)
 
 
-def vai(x, y):
-	"""Sposta il cursore al punto (x, y) senza tracciare una linea."""
+def go(x, y):
+	"""Move cursor to the point (x, y) without drawing a line."""
 	turtle.pu()
 	turtle.goto(x, y)
 	turtle.pd()
 
 
 def parquet(t):
-	"""Disegna le assi del parquet."""
-	global X, assi
-	vai(-X, -Y)
+	"""Draw parquet's axes."""
+	global X, axes
+	go(-X, -Y)
 	for x in range(-X, X + 1, t):
-		assi += x,
+		axes += x,
 		turtle.lt(90)
 		turtle.goto(x, Y)
-		vai(x, -Y)
+		go(x, -Y)
 		turtle.rt(90)
-		vai(x + t, -Y)
+		go(x + t, -Y)
 
 
-def ago(l):
+def needle(l):
 	"""
-	Lancia un'ago.
-	Se incrocia le assi lo colora di rosso e restituisce 1,
-	altrimenti restituisce 0.
+	Throw a needle.
+	If it crosses the axes it colors red and returns 1,
+	otherwise it returns 0.
 	"""
-	vai(random.uniform(-X, X), random.uniform(-Y, Y))
+	go(random.uniform(-X, X), random.uniform(-Y, Y))
 	x1 = turtle.xcor()
 	turtle.lt(random.uniform(0, 360))
 	turtle.fd(l)
 	x2 = turtle.xcor()
-	for x in assi:
+	for x in axes:
 		if (x1 < x < x2) or (x2 < x < x1):
 			turtle.pencolor("red")
 			turtle.bk(l)
@@ -60,16 +60,16 @@ def ago(l):
 	else:
 		return 0
 
-impostazioni()
+settings()
 parquet(T)
 p = 0
 for i in range(N):
-	p += ago(L)
+	p += needle(L)
 	try:
 		π = (2 * L) / (T * p / N)
 	except ZeroDivisionError:
 		π = 0
 	print(π)
 
-print("Scarto:", abs(100 - (π / math.pi * 100)), "%")
+print("Deviation:", abs(100 - (π / math.pi * 100)), "%")
 turtle.mainloop()