What is the advantage of the monte carlo method – randomly picking n points where the x,y are independent and uniformly distributed – and the grid method, where you set up points on some defined lattice and then just keep making the lattice finer and finer?

Thanks!

from random import random
def pi(n):
return 4*float(sum(1 if (random()**2 + random()**2) <= 1 else 0 for i in range(n)))/n

You can view the results as an applet here: http://stungeye.com/processing/1009/

final int R = 400;
final color BLUE  = color(0, 0, 255);
final color WHITE = color(255, 255, 255);
final color RED   = color(255, 0, 0);
final color BLACK = color(0, 0, 0);

double n = 0;
double count = 0;

void setup () {
  size(R,R);
  background(0);
  fill(255);
  stroke(255);
  ellipse(0, R, R*2, R*2);
}

void draw() {
  count++;  

  int random_x = (int)random(R);
  int random_y = (int)random(R);

  loadPixels();
  color current_pixel_colour = pixels[random_y * R + random_x];

  if ((current_pixel_colour == WHITE) || (current_pixel_colour == BLUE)) {
    n++;
    set(random_x, random_y, BLUE);
    println(4 * n / count);
  } else {
    set(random_x, random_y, RED);
  }
}

(The applet version of the code is slightly more complex: http://stungeye.com/processing/1009/monte_carlo_pi.pde)

calc(Tally) ->
calc(Tally, 0, 0).

calc(0, Matches, Done) -> 4 * Matches / Done;

calc(Tally, Matches, Done) ->
X = random:uniform(), Y = random:uniform(),
calc (Tally – 1, if X*X + Y*Y Matches + 1; true -> Matches end, Done + 1).

Then I realized I could use the Bresenham circle algorithm and just calculate one point in each row. Since the basic BCA only finds points through a 45 degree angle, I ran it for 1/8th of the circle to find pi/8.

Here's how quickly it converged, using up to a billion iterations.

1: -8
10: 2.8
100: 3.1
1000: 3.137576
10000: 3.1411928
100000: 3.1415526136
1000000: 3.141588652488
10000000: 3.14159225361224
100000000: 3.14159261359012
1000000000: 3.14159264958976

The code is deceptively simple. In C, based on the sample code in Wikipedia.

#include 

double pi(int n)
{
    int f = 1 - n;
    int ddF_x = 1;
    int ddF_y = -2 * n;
    int x = 0;
    int y = n;
    long long int in;
    while (x < y) {
	if (f >= 0) {
	    --y;
	    ddF_y += 2;
	    f += ddF_y;
	}
	x++;
	ddF_x += 2;
	f += ddF_x;
	in += y - x;
    }
    return 8.0 * in / ((double)n * n);
}

main()
{
    int i;

    for (i = 1; i <= 1000000000; i *= 10)
	printf("%d: %.15g\n", i, pi(i));
}

(I wonder if the formatting will survive…)

import Control.Monad
import System.Random

monteCarloPi :: Int -> IO ()
monteCarloPi n = do
    hits <- fmap sum $ liftM2 (zipWith checkHit) rs rs
    print $ fromIntegral hits / fromIntegral n
    where rs = replicateM n $ randomRIO (0,1 :: Double)
          checkHit x y = if x*x + y*y < 1 then 4 else 0

boundPi :: Int -> (Double, Double)
boundPi n = iterate f (3/2 * sqrt 3, 3 * sqrt 3) !! (n - 1)
            where f (b, a) = let x = 2 / (1 / a + 1 / b)
                             in (sqrt $ b * x, x)