Where could I find a large amount of digits of pi? I have already calculated 3.14 billion using PiFast (works well under wine).

• Do you need it for some even remotely practical purpose, or just for ... ? I can't see the point, so I'm just curious.
– Rook
Commented Jul 16, 2009 at 3:17
• @Idigas: Don't you ever make pi? Commented Jul 16, 2009 at 5:04
• Soon's i can find the algorithm for calculating pi, i'll write something up to calculate as many as you want...
– RCIX
Commented Jul 16, 2009 at 8:32
• Go ahead and try accepting a new answer to your question. The original accepted answer had a single link that no longer exists, so it has been deleted. Go ahead and flag the question if you have any questions for the moderators. Commented Feb 10, 2011 at 10:24

Given the last digit and the current state of the calculator used to generate it, the next digit can be found in constant time. It doesn't get progressively harder like finding the next prime does.

• Yes, but it is a lot of cpu time to dedicate, and I would rather dedicate some bandwidth rather than all that cpu time.
– bgw
Commented Jul 15, 2009 at 21:12
• @Joel: by the way, can you show a pointer to an algorithm for that? (Yeah, I know that's more like SO content, but since we're here...) Commented Jul 15, 2009 at 21:16
• The math is beyond me, but read way down in wikipedia and one of the series is said to "deliver 14 digits per term". Commented Jul 15, 2009 at 21:35
• Sorry, wrong link: numbers.computation.free.fr/Constants/PiProgram/algo.html, It was in frames
– bgw
Commented Jul 15, 2009 at 21:40

Adding on to Joel's comment, SuperPi is one of the most popular tools for this. It's also used for stress testing.

• PiFast is faster.
– bgw
Commented Dec 17, 2009 at 21:27

On Ubuntu, you can `sudo apt-get install pi`

and then:

```\$ pi 100 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067```

It calculates arbitrary precision given the number of digits to calculate.

If you want to use Python to calculate it, here's an extremely fast method (using Python and the gmpy2 library):

http://www.craig-wood.com/nick/articles/pi-chudnovsky/

Here's the code with a small fix:

``````"""
Python3 program to calculate Pi using python long integers, binary
splitting and the Chudnovsky algorithm

See: http://www.craig-wood.com/nick/articles/pi-chudnovsky/ for more
info

Nick Craig-Wood <[email protected]>
"""

import math
from gmpy2 import mpz
from time import time
import gmpy2

def pi_chudnovsky_bs(digits):
"""
Compute int(pi * 10**digits)

This is done using Chudnovsky's series with binary splitting
"""
C = 640320
C3_OVER_24 = C**3 // 24
def bs(a, b):
"""
Computes the terms for binary splitting the Chudnovsky infinite series

a(a) = +/- (13591409 + 545140134*a)
p(a) = (6*a-5)*(2*a-1)*(6*a-1)
b(a) = 1
q(a) = a*a*a*C3_OVER_24

returns P(a,b), Q(a,b) and T(a,b)
"""
if b - a == 1:
# Directly compute P(a,a+1), Q(a,a+1) and T(a,a+1)
if a == 0:
Pab = Qab = mpz(1)
else:
Pab = mpz((6*a-5)*(2*a-1)*(6*a-1))
Qab = mpz(a*a*a*C3_OVER_24)
Tab = Pab * (13591409 + 545140134*a) # a(a) * p(a)
if a & 1:
Tab = -Tab
else:
# Recursively compute P(a,b), Q(a,b) and T(a,b)
# m is the midpoint of a and b
m = (a + b) // 2
# Recursively calculate P(a,m), Q(a,m) and T(a,m)
Pam, Qam, Tam = bs(a, m)
# Recursively calculate P(m,b), Q(m,b) and T(m,b)
Pmb, Qmb, Tmb = bs(m, b)
# Now combine
Pab = Pam * Pmb
Qab = Qam * Qmb
Tab = Qmb * Tam + Pam * Tmb
return Pab, Qab, Tab
# how many terms to compute
DIGITS_PER_TERM = math.log10(C3_OVER_24/6/2/6)
N = int(digits/DIGITS_PER_TERM + 1)
# Calclate P(0,N) and Q(0,N)
P, Q, T = bs(0, N)
one_squared = mpz(10)**(2*digits)
#sqrtC = (10005*one_squared).sqrt()
sqrtC = gmpy2.isqrt(10005*one_squared)
return (Q*426880*sqrtC) // T

# The last 5 digits or pi for various numbers of digits
check_digits = {
100 : 70679,
1000 :  1989,
10000 : 75678,
100000 : 24646,
1000000 : 58151,
10000000 : 55897,
}

if __name__ == "__main__":
digits = 100
pi = pi_chudnovsky_bs(digits)
print(pi)
#raise SystemExit
for log10_digits in range(1,9):
digits = 10**log10_digits
start =time()
pi = pi_chudnovsky_bs(digits)
print("chudnovsky_gmpy_mpz_bs: digits",digits,"time",time()-start)
if digits in check_digits:
last_five_digits = pi % 100000
if check_digits[digits] == last_five_digits:
print("Last 5 digits %05d OK" % last_five_digits)
open("%s_pi.txt" % log10_digits, "w").write(str(pi))
else:
print("Last 5 digits %05d wrong should be %05d" % (last_five_digits, check_digits[digits]))
``````