Ah, okay. In that case, I suggest we all list some methods of computing pi.
My first submission is the following functional program, written in Haskell:
type Sequence a = [a]
limit :: (Eq a) => Sequence a -> a
limit (a0:as@(a1:a2:a3:a4:a5:a6:a7:_))
= if and [a0==a1,a1==a2,a2==a3,a3==a4,a4==a5,a5==a6,a6==a7]
then a0
else limit as
flimit :: (Eq a) => (a -> a) -> a -> a
flimit f = limit . iterate f
powers :: (Fractional a) => a -> Sequence a
powers x = iterate (*x) 1.0
nats :: (Num a) => Sequence a
nats = iterate (+1) 0
facts :: (Num a, Enum a) => Sequence a
facts = map (\n -> product [1..n]) nats
taylor :: (Fractional a, Enum a) => Sequence a -> a -> a
taylor df dx = limit s
where s = scanl (+) 0 y
y = zipWith (/) (zipWith (*) df (powers dx)) facts
dsin0, dcos0 :: Sequence Double
dsin0 = 0.0 : dcos0
dcos0 = 1.0 : map negate dsin0
sin = taylor dsin0
piA = 1 : map (\x -> x + (sin x)) piA
pi = limit piA
This program will compute π as the limit of the sequence generated by the iterated map a(n+1) = a(n) + sin a(n); a(0) = 1. The sin function is computed with a Taylor series. The program will compute π as accurately as possible using the floating-point processor on your computer.