![\"\"](\"https:\/\/wollen.org\/blog\/wp-content\/uploads\/2022\/03\/pi_dimension_diagram.gif\")
<\/a><\/p>\nHere we have a circle circumbscribed by a square. That’s a fancy way of saying the square’s overall width is the same as the circle’s overall width. In more formal terms, the circle’s radius is length R and the square’s sides are length 2R.<\/p>\n
A circle’s area is defined as \u03c0*r\u00b2, where r is the radius. Notice that this expression includes pi, so if we’re trying to estimate pi then we’re starting to get somewhere. A square’s area is even easier to calculate: [side]*[side].<\/p>\n
Now look at what happens if we divide the above circle’s area by the area of its square counterpart:<\/p>\n
The R\u00b2 terms cancel and we’re left with a constant: \u03c0\/4. We can then simply multiply by 4 to solve for pi.<\/p>\n So where does Python come in? Well, assuming for some reason that we can’t draw the shapes and measure them, the next-best approach might be to randomly generate points within the square and check how many fall within the circle.<\/p>\n If the points are uniformly distributed across the x and y axes, the probability of a point falling within a shape is proportional to the shape’s area. If, as we saw above, [Area of Circle] \/ [Area of Square] is equal to \u03c0\/4, then \u03c0\/4 percent of the points will fall within the circle. That’s about 78.5%. We can run a simulation to randomly generate thousands of points, calculate this ratio, and then multiply by 4 to estimate the value of pi.<\/p>\n Begin by randomly generating 10,000 points within a square of size 2R. This should be enough data to provide a reasonable estimate.<\/p>\n We’ll locate the center of the figure at (0, 0) and set R equal to 1.0. This will keep the code simple, but the final result would be no different if we used a larger square centered at (8, -4.5), for example.<\/p>\n With data in hand, check how many points fall within an inscribed circle of radius R. The easiest approach is to test<\/a> whether a point lies within 1.0 units of the center (0, 0).<\/p>\n Now we know how many points are within the circle. And we know all<\/em> 10,000 points fall within the square because that’s how we designed the simulation.<\/p>\n These numbers are analogous to the area of each shape, since the probability of a point landing within a shape is equal to its share of the entire figure.<\/p>\n So we have estimates of each shape’s area, and we know their ratio should be equal to \u03c0\/4. We’re almost there!<\/p>\n And we’re there! Just like that.<\/p>\n Before moving on we should calculate how close the simulation came to pi’s true value.<\/p>\n Rather than printing the estimate to screen, let’s display everything on a nice plot.<\/p>\n Because the Matplotlib<\/em> code is so simple I’ll skip the commentary. But as always, the full code will be available at the end of this post.<\/p>\n Without further ado, our estimate of pi:<\/p>\n With 10,000 randomly generated points we came within 0.42% of the actual value (3.14159265…). That’s not bad! Maybe we couldn’t build a particle accelerator with that sort of precision but we could certainly write blog posts all day.<\/p>\n Obviously with more data comes more precision. I put together an animated GIF to show how an estimate emerges from a larger simulation. Error generally trends toward zero but it’s not a straight path!<\/p>\n<\/a><\/p>\n
\n
\nimport matplotlib.pyplot as plt\r\nfrom random import uniform\r\nfrom math import sqrt, pi\r\n\r\nR = 1.0\r\n\r\nscatter_x, scatter_y = [], []\r\n\r\nfor _ in range(10000):\r\n scatter_x.append(uniform(-R, R))\r\n scatter_y.append(uniform(-R, R))<\/pre>\n
inside_circle = 0\r\n\r\nfor x, y in zip(scatter_x, scatter_y):\r\n distance = sqrt(x**2 + y**2)\r\n if distance < R:\r\n inside_circle += 1<\/pre>\n
inside_square = len(scatter_x)<\/pre>\n
ratio = inside_circle \/ inside_square\r\n\r\npi_estimate = ratio * 4<\/pre>\n
error_percent = (pi_estimate - pi) \/ pi * 100<\/pre>\n
<\/a><\/p>\n