Leibniz formula for π - Is this any good? (Python)

Question

I\'m doing an exercise that asks for a function that approximates the value of pi using Leibniz\' formula. These are the explanations on Wikipedia:

Answer 1

Using pure Python you can do something like:

def term(n):
    return ( (-1.)**n / (2.*n + 1.) )*4.

def pi(nterms):
    return sum(map(term,range(nterms)))

and then calculate pi with the number of terms you need to reach a given precision:

pi(100)
# 3.13159290356

pi(1000)
# 3.14059265384

Answer 2

This was my approach:

def estPi(terms):
    outPut = 0.0
    for i in range (1, (2 * terms), 4):
        outPut = (outPut + (1/i) - (1/(i+2)))
    return 4 * outPut

I take in the number of terms the user wants, then in the for loop I double it to account for only using odds.

at 100 terms I get        3.1315929035585537
at 1000 terms I get       3.140592653839794
at 10000 terms I get      3.1414926535900345
at 100000 terms I get     3.1415826535897198
at 1000000 terms I get    3.1415916535897743
at 10000000 terms I get   3.1415925535897915
at 100000000 terms I get  3.141592643589326
at 1000000000 terms I get 3.1415926525880504
Actual Pi is              3.1415926535897932

Got to love a convergent series.

Answer 3

def myPi(iters):
    pi = 0
    sign = 1
    denominator = 1

    for i in range(iters):
        pi = pi + (sign/denominator)
        # alternating between negative and positive
        sign = sign * -1
        denominator = denominator + 2

    pi = pi * 4.0
    return pi

pi_approx = myPi(10000)
print(pi_approx)

Answer 4

The following version uses Ramanujan's formula as outlined in this SO post - it uses a relation between pi and the "monster group", as discussed in this article.

import math

def Pi(x):
    Pi = 0
    Add = 0
    for i in range(x):
        Add =(math.factorial(4*i) * (1103 + 26390*i))/(((math.factorial(i))**4)*(396**(4*i)))
        Pi = Pi + (((math.sqrt(8))/(9801))*Add)
    Pi = 1/Pi
    print(Pi)

Pi(100)

Answer 5

The capital sigma here is sigma notation. It is notation used to represent a summation in concise form.

So your sum is actually an infinite sum. The first term, for n=0, is:

(-1)**0/(2*0+1)

This is added to

(-1)**1/(2*1+1)

and then to

(-1)**2/(2*2+1)

and so on for ever. The summation is what is known mathematically as a convergent sum.

In Python you would write it like this:

def estimate_pi(terms):
    result = 0.0
    for n in range(terms):
        result += (-1.0)**n/(2.0*n+1.0)
    return 4*result

If you wanted to optimise a little, you can avoid the exponentiation.

def estimate_pi(terms):
    result = 0.0
    sign = 1.0
    for n in range(terms):
        result += sign/(2.0*n+1.0)
        sign = -sign
    return 4*result

....

>>> estimate_pi(100)
3.1315929035585537
>>> estimate_pi(1000)
3.140592653839794

Answer 6

The Leibniz formula translates directly into Python with no muss or fuss:

>>> steps = 1000000
>>> sum((-1.0)**n / (2.0*n+1.0) for n in reversed(range(steps))) * 4
3.1415916535897934