CODEWITHSUNDEEP
python
iKyriaki
iKyriaki

Reputation: 609

Approximating pi within error

To start off, this is the problem.

The mathematical constant π (pi) is an irrational number with value approximately 3.1415928... The precise value of π is equal to the following infinite sum: π = 4/1 - 4/3 + 4/5 - 4/7 + 4/9 - 4/11 + ... We can get a good approximation of π by computing the sum of the first few terms. Write a function approxPi() that takes as a parameter a floating point value error and approximates the constant π within error by computing the above sum, term by term, until the absolute value of the difference between the current sum and the previous sum (with one fewer terms) is no greater than error. Once the function finds that the difference is less than error, it should return the new sum. Please note that this function should not use any functions or constants from the math module. You are supposed to use the described algorithm to approximate π, not use the built-in value in Python.

I'd really appreciate it if someone could help me understand what the problem is asking, since I've read it so many times but still can't fully understand what it's saying. I looked through my textbook and found a similar problem for approximating e using e's infinite sum: 1/0! + 1/1! + 1/2! + 1/3!+...

def approxE(error):
    import math
    'returns approximation of e within error'
    prev = 1 # approximation 0
    current = 2 # approximation 1
    i = 2 # index of next approximation
    while current-prev > error:
        #while difference between current and previous
        #approximation is too large
                            #current approximation
        prev = current      #becomes previous
                            #compute new approximation
        current = prev + 1/math.factorial(i) # based on index i
        i += 1              #index of next approximation
    return current

I tried to model my program after this, but I don't feel I'm getting any closer to the solution.

def approxPi(error):
    'float ==> float, returns approximation of pi within error'
    #π = 4/1 - 4/3 + 4/5 - 4/7 + 4/9 - 4/11 + ...
    prev = 4 # 4/1 = 4 : approx 0
    current = 2.6666 # 4/1 - 4/3 = 2.6666 : approx 1
    i = 5 # index of next approx is 5
    while current-prev > error:
        prev = current
        current = prev +- 1/i
        i = i +- 2
    return current

The successful program should return

approxPi(0.5) = 3.3396825396825403 and approxPi(0.05) = 3.1659792728432157

Again, any help would be appreciated. I'd like to just understand what I'm doing wrong in this.

Upvotes: 2

Views: 5999

Answers (3)

Blender
Blender

Reputation: 298166

If you're trying to approximate pi using that series, start by writing out a few terms:

π = 4/1 - 4/3 + 4/5 - 4/7 + 4/9 - 4/11 + ...
     0     1     2     3     4     5     ...

And then write a function that returns the nth term of the series:

def nth_term(n):
    return 4 / (2.0 * n + 1) * (-1) ** n

From there, the code is pretty generic:

def approximate_pi(error):
    prev = nth_term(0)  # First term
    current = nth_term(0) + nth_term(1)  # First + second terms
    n = 2  # Starts at third term

    while abs(prev - current) > error:
        prev = current
        current += nth_term(n)
        n += 1

    return current

It seems to work for me:

>>> approximate_pi(0.000001)
    3.1415929035895926

Upvotes: 4

duffymo
duffymo

Reputation: 308763

Here's how I'd do it:

def approxPi(error):
    # pi = 4/1 - 4/3 + 4/5 - 4/7 + 4/9 - 4/11 + ...
    value = 0.0
    term = 1.0e6
    i = 1
    sign = 1
    while fabs(term) > error:
        term = sign/i
        value += term
        sign *= -1
        i += 2
    return 4.0*value

print approxPi(1.0e-5)

Upvotes: 1

rodrigo
rodrigo

Reputation: 98348

There are several issues:

A) i = i +- 2 does not do what you think, not sure what it is.

The correct code should be something like (there are a lot of ways):

if i < 0:
    i = -(i-2)
else:
    i = -(i+2)

The same is for:

current = prev +- 1/i

It should be:

current = prev + 4.0/i

Or something, depending on what exactly is stored in i. Beware! In python2, unless you import the new division from the future you have to type the 4.0, not just 4.

Personally I would prefer to have to variables, the absolute value of the divisor and the sign, so that for each iteration:

current = current + sign * 4 / d
d += 2
sign *= -1

That's a lot nicer!

B) The ending of the loop should check the absolute value of the error:

Something like:

while abs(current-prev) > error:

Because the current value jumps over the target value, one value bigger, one smaller, so one error is positive, one is negative.

Upvotes: 1

Related Questions