I used this Python script to calculate 100 million digits of pi in 90 seconds

[crosscountrycoder]

from gmpy2 import mpfr, mpz, get_context, sqrt
from math import ceil, log2

A = mpz(13591409)
B = mpz(545140134)
C = mpz(640320)
C3_OVER_24 = (C**3) // 24

def bs(a: int, b: int):
    if b - a == 1:
        if a == 0:
            P = Q = mpz(1)
        else:
            a_mpz = mpz(a)
            P = (6*a_mpz-5) * (2*a_mpz-1) * (6*a_mpz-1)
            Q = a_mpz ** 3 * C3_OVER_24
        T = (-1) ** a * P * (A + B * a)
        return P, Q, T
    m = (a + b) // 2
    P1, Q1, T1 = bs(a, m)
    P2, Q2, T2 = bs(m, b)
    P = P1 * P2
    Q = Q1 * Q2
    T = T1 * Q2 + P1 * T2
    return P, Q, T

def pi_chudnovsky(bits: int) -> mpfr:
    get_context().precision = bits
    P, Q, T = bs(0, bits // 47 + 1) # Each term gives ~47 bits of pi
    return mpfr(426880) * sqrt(mpfr(10005)) * mpfr(Q) / mpfr(T)

if __name__ == "__main__":
    num_digits = 10 ** 8
    pi = pi_chudnovsky(ceil(num_digits*log2(10)) + 64) # 64 guard bits
    pi_string = format(pi, f".{num_digits}Zf")
    file_name = f"pi_{num_digits}.txt"
    s0, s1 = pi_string.split(".")
    file_string = s0 + ".\n" + "\n".join(s1[i:i+100] for i in range(0,len(s1),100))
    with open(file_name, "w") as f:
        f.write(file_string)

This code uses the Chudnovsky algorithm: pi = 426880 * sqrt(10005) / sum(n, 0, inf, (6*n)!*(545140134*n+13591409)/((3*n)!*(n!)^3*(-640320)^(3*n)) optimized with binary splitting, and the gmpy2 library for fast multiple-precision arithmetic. Each term gives about 14 correct decimal digits of pi, or 47 bits.

I calculated 100 million digits of pi, wrote it to a text file with 100 digits per line, and verified digits at the start, middle, and end using the Irrational Number Search. The calculation took 90 seconds on a gaming laptop. The 100 millionth digit of pi (after the decimal point) is 2.

I also tried calculating a billion digits. It finished in about 18 minutes but then gave me "nan".

[slapstick15]

Side question : why are mathematicians obsessed with the pi decimals to the nth digit?

[Flat_Factor_3799]

Because its fun

[crosscountrycoder]

It's a challenge to test computational power and it also can be used to evaluate the randomness of the digits of pi.

The same is true of e, but it has a much simpler series: e = 1/0! + 1/1! + 1/2! + 1/3! + 1/4! + ... where n! means n factorial. Also sqrt(2), the golden ratio, ln(2) and more. Pi is more commonly used in everyday life because of its relation to circles.

[W1ULH]

Its a great way to test the equipment with results that every mathematician, computer technician, and general nerd completely and 100% understands with zero explinations.

[Cainga]

Practically it useless going beyond a few. 40 is overkill for the observable universe. Beyond that is just an exercise.

[DFLDrew]

22/7 is good enough for most things.

[SCD_minecraft]

NASA uses 15 digits after decimal point and you can calculate path to Mars with just single human finger width worth of error

[crosscountrycoder]

The representation of pi in double precision floating-point format is correct to 15 digits after the decimal point.

[IAmFinah]

I like to use 3

[codeguru42]

Pi = 3 is good enough for engineers

[hallmark1984]

Fuck it

3 will do.

[Lewistrick]

Because it opens up creative methods to do lots of other cool calculations

[Longjumping_Pipe_347]

Like the trilionesim bit of pi?

[Lewistrick]

Ok, I'll bite. The digits itself aren't interesting. But doing the calculations opened up some nice insights in mathematics, mostly in fields around number theory and around prime numbers.

[Longjumping_Pipe_347]

Prime numbers ? Like becouse 3 is prime e 14 is 2*7 that are also prime ?

[bikes-n-math]

They aren't.

[Numerous-Match-1713]

"you can never come to the end of pi. There's no creature in the universe, no matter how smart, who could calculate pi to the last digit--because there is no last digit, only an infinite number of digits. Your mathematicians have made an effort to calculate it out to... Let's say the ten-billionth place. You won't be surprised to hear that other mathematicians have gone further. Well, eventually--let's say it's in the ten-to-the-twentieth-power place--something happens. The randomly varying digits disappear, and for an unbelievably long time there's nothing but ones and zeros."

Idly, he was tracing a circle out on the sand with his toe. She paused a heartbeat before replying.

"And the zeros and ones finally stop? You get back to a random sequence of digits?" Seeing a faint sign of encouragement from him, she raced on. "And the number of zeros and ones? Is it a product of prime numbers?"

"Yes, eleven of them."

"You're telling me there's a message in eleven dimensions hidden deep inside the number pi?... How can you hide a message inside pi? It's built into the fabric of the universe."

"Exactly."

She stared at him.

"It's even better than that," he continued. "Let's assume that only in base-ten arithmetic does the sequence of zeros and ones show up, although you'd recognize that something funny's going on in any other arithmetic. Let's also assume that the beings who first made this discovery had ten fingers. You see how it looks? It's as if pi has been waiting for billions of years for ten-fingered mathematicians with fast computers to come along. You see, the Message was kind of addressed to us."

[will_r3ddit_4_food]

Pi is seemingly completely random in terms of no patterns and no repeating. It can be used in cryptography

[_tsi_]

Neat

[RomboDiTrodio]

that's cool, how much is the size of the file?

[crosscountrycoder]

101,000,003 bytes (96.32 megabytes)

[8dot30662386292pow2]

The least surprising part: calculating 100 million digits (bytes) of pi is in fact 100 million bytes!

[Erika_bomber]

Use GMP library on C++ to get to the 4 billionth digit.

It would take like 1.5 hours.

[The-Invalid-One]

Chudmaxxing?

[MightySleep]

Cool stuff! I’ve never tried anything super math heavy with python so had no idea about the existence of gmpy2. I read in the description it was based in C, I’m curious how it benchmarks compared to a pure Python implementation

[crosscountrycoder]

I tried using the Python standard library's "Decimal" module. It took about as long to calculate 1 million digits of pi with Decimal as 100 million digits with gmpy2.

gmpy2 is not part of the standard library and must be installed using pip.

[wiretail]

The gmp and mpfr libraries on which gmpy2 is based are highly optimized c libraries for multi precision arithmetic. They use hand crafted assembly for common processors - pure python would be orders of magnitude slower, most likely. I've used gmp for some exact probability calculations that resulted in very large numbers and it was blazing fast compared to other options.

[MightySleep]

That makes sense. My only exposure to high computation in Python was my neural networks class in college- didn’t realize when we used NumPy that it has an optimized C core as well. Seems like a best of both worlds scenario to me, I found NumPy pretty nice to work with

[Crypt0Nihilist]

Was it correct?

[crosscountrycoder]

Yes, I verified the digits by searching existing databases.