Super User is a question and answer site for computer enthusiasts and power users. It's 100% free, no registration required.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

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

I don't care about slow download speeds.

share|improve this question

closed as off-topic by Journeyman Geek Apr 24 '15 at 5:55

This question appears to be off-topic. The users who voted to close gave this specific reason:

  • "Questions seeking product, service, or learning material recommendations are off-topic because they become outdated quickly and attract opinion-based answers. Instead, describe your situation and the specific problem you're trying to solve. Share your research. Here are a few suggestions on how to properly ask this type of question." – Journeyman Geek
If this question can be reworded to fit the rules in the help center, please edit the question.

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 Jul 16 '09 at 3:17
@Idigas: Don't you ever make pi? – Nosredna Jul 16 '09 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 Jul 16 '09 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. – Troggy Feb 10 '11 at 10:24
up vote 9 down vote accepted

I know you say you don't care, but I seriously suspect your cpu can calculate them faster than your network card is capable of downloading them.

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.

share|improve this answer
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 Jul 15 '09 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...) – R. Martinho Fernandes Jul 15 '09 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". – Joel Coehoorn Jul 15 '09 at 21:35
Sorry, wrong link:, It was in frames – bgw Jul 15 '09 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.

share|improve this answer
PiFast is faster. – bgw Dec 17 '09 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.

share|improve this answer

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

Here's the code with a small fix:

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

See: for more

Nick Craig-Wood <>

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)
                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
            # 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)
    #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))
                print("Last 5 digits %05d wrong should be %05d" % (last_five_digits, check_digits[digits]))
share|improve this answer

Not the answer you're looking for? Browse other questions tagged or ask your own question.