pi_generator.py

def calculate_pi(limit: int) -> str:
    """
    https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80
    Leibniz Formula for Pi

    The Leibniz formula is the special case arctan 1 = 1/4 Pi .
    Leibniz's formula converges extremely slowly: it exhibits sublinear convergence.

    Convergence (https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80#Convergence)

    We cannot try to prove against an interrupted, uncompleted generation.
    https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80#Unusual_behaviour
    The errors can in fact be predicted;
    but those calculations also approach infinity for accuracy.

    Our output will always be a string since we can defintely store all digits in there.
    For simplicity' sake, let's just compare against known values and since our outpit
    is a string, we need to convert to float.

    >>> import math
    >>> float(calculate_pi(15)) == math.pi
    True

    To further proof, since we cannot predict errors or interrupt any infinite alternating series generation since they approach infinity,
    or interrupt any alternating series, we are going to need math.isclose()

    >>> math.isclose(float(calculate_pi(50)), math.pi)
    True

    >>> math.isclose(float(calculate_pi(100)), math.pi)
    True

    Since the math.pi-constant is only 16 digits long, here some test with preknown values:

    >>> calculate_pi(50)
    '3.14159265358979323846264338327950288419716939937510'
    >>> calculate_pi(80)
    '3.14159265358979323846264338327950288419716939937510582097494459230781640628620899'

    In the Leibniz formula for calculating pi, the variables q, r, t, k, n, and l are used for the iteration process.
    """  # noqa: E501
    q = 1
    r = 0
    t = 1
    k = 1
    n = 3
    l = 3
    decimal = limit
    counter = 0

    result = ""

    """
    We will avoid using yield since we otherwise get a Generator-Object,
    which we can't just compare against anything. We would have to make a list out of it
    after the generation, so we will just stick to plain return logic:
    """
    while counter != decimal + 1:
        if 4 * q + r - t < n * t:
            result += str(n)
            if counter == 0:
                result += "."

            if decimal == counter:
                break

            counter += 1
            nr = 10 * (r - n * t)
            n = ((10 * (3 * q + r)) // t) - 10 * n
            q *= 10
            r = nr
        else:
            nr = (2 * q + r) * l
            nn = (q * (7 * k) + 2 + (r * l)) // (t * l)
            q *= k
            t *= l
            l += 2
            k += 1
            n = nn
            r = nr
    return result


def main() -> None:
    pi_digits = calculate_pi(50)
    print(pi_digits)
    import doctest

    doctest.testmod()


if __name__ == "__main__":
    main()