Accelerating Leibniz Series for calculating Pi

Question

When I was studying math I read about the series named Leibniz Series for Pi:

Image of the formula: https://d2vlcm61l7u1fs.cloudfront.net/media%2F0ee%2F0eeaa57b-570b-4444-93bc-7bc2f4d83931%2FphpHCRPXf.png

So I made an program for it which sums n terms of this series:

def leibniz(n):
    pi = 0
    for i in range(1,n+1):
        if(i % 2 == 0):
            pi -= 1 / (2*i - 1)
        else:
            pi += 1/(2*i - 1)
    pi = 4 * pi
    return pi

This code works but the thing is that it converges very slowly to Pi.

So I read about different series acceleration and basically the one which is best in my case is Euler Acceleration
The slow convergence is because my version is an alternating series, i.e. contains (-1)^n. But I am lot more confused how can I program it.

Edit:

I learned about the Shanks transformation and programed it

def accelrate(n,depth):
    if depth == 1:
        a = lebniez(n + 1)
        b = lebniez(n)
        c = lebniez(n-1)
        return (a*c - b*b)/(a + c - 2*b) 
    a = accelrate(n + 1,depth - 1)
    b = accelrate(n,depth - 1)
    c = accelrate(n-1,depth - 1)
    return (a*c - b*b)/(a + c - 2*b)

So what htis does is that it recursively applies Shanks transformation and keep on accelerating the series . But the problem now is that due to recursion it is very slow and the accuracy does not imporve if you increase the depth.

Is this the inefficiency of Shanks Transformation

See this for a fancier, faster way than using plain Euler: https://stackoverflow.com/questions/19550135/pi-calculation-in-python/19555966#19555966 — Tim Peters, Jul 31 '20 at 04:55
Hello Tim Peters I am confused that how have you Coded it as it is a bit confusing Because I am new to programing — Dhaval Bothra, Jul 31 '20 at 04:59
To attribute it correctly, you didn't "come up with" [Leibniz's approximation for pi](https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80), it was published in the 17th century based on 14th-century work. — smci, Jul 31 '20 at 05:00
Thanks smci I am weak in english but i didnt mean that sorry — Dhaval Bothra, Jul 31 '20 at 05:02
Ok just attributing things correctly :) You found Leibniz's approximation. — smci, Jul 31 '20 at 05:06
why not use the Chudnovsky formula? it converges much faster. — Z4-tier, Jul 31 '20 at 05:37

score 0 · Accepted Answer · answered Aug 01 '20 at 14:04

So after thinking around I came up with Cache reduction in My this shanks transformation .

It does not imporves a lot but still it is a good improvement.

Here it is:

import functools as ft

@ft.lru_cache(maxsize=32)
def lebniez(n):
    pi = 0
    n = n + 1
    for i in range(1,n):
        if(i % 2 == 1):
            pi -= 1 / (2*i - 1)
        else:
            pi += 1/(2*i - 1)
    pi = abs(4 * pi)
    return pi

@ft.lru_cache(maxsize=128)
def accelrate(n,depth):
    if depth == 1:
        a = lebniez(n + 1)
        b = lebniez(n)
        c = lebniez(n-1)
    else:
        a = accelrate(n + 1,depth - 1)
        b = accelrate(n,depth - 1)
        c = accelrate(n-1,depth - 1)

    return (a*c - b*b)/(a + c - 2*b)

So this basic helps in make it more stable.

Next about the Inefficiency , the reason is that Shanks Transformation is just for such sequence where ratio of Error(n + 1) / Error(n) is a constant. But after applying Shanks Transformation again this can lead to inefficiency

Accelerating Leibniz Series for calculating Pi

1 Answers1