1000 цифр pi в python

Ответ 1

Запустить это

def make_pi():
    q, r, t, k, m, x = 1, 0, 1, 1, 3, 3
    for j in range(1000):
        if 4 * q + r - t < m * t:
            yield m
            q, r, t, k, m, x = 10*q, 10*(r-m*t), t, k, (10*(3*q+r))//t - 10*m, x
        else:
            q, r, t, k, m, x = q*k, (2*q+r)*x, t*x, k+1, (q*(7*k+2)+r*x)//(t*x), x+2


my_array = []

for i in make_pi():
    my_array.append(str(i))

my_array = my_array[:1] + ['.'] + my_array[1:]
big_string = "".join(my_array)
print "here is a big string:\n %s" % big_string 

И прочитайте об операторе yield здесь: что делает ключевое слово yield?

Вот ответ:

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337

Ответ 2

Если вы не хотите реализовывать свой собственный алгоритм, вы можете использовать mpmath.

try:
    # import version included with old SymPy
    from sympy.mpmath import mp
except ImportError:
    # import newer version
    from mpmath import mp
mp.dps = 1000  # set number of digits
print(mp.pi)   # print pi to a thousand places

Ссылка

Обновление: код поддерживает более старые и новые установки SymPy (см. Комментарий). *

Ответ 3

Я не знаком с вашим алгоритмом. Это реализация BBP?

В любом случае ваш make_pi является генератором. Попробуйте использовать его в цикле for:

for digit in make_pi():
    print digit

Обратите внимание, что этот цикл бесконечен: make_pi() никогда не бросает StopIteration

Ответ 4

Здесь вы можете проверить, выводит ли ваша программа 1000 цифр: http://spoj.com/CONSTANT

Конечно, вы можете использовать diff или tc, но вам нужно будет скопировать эти 1000 цифр откуда-то, и там вы просто отправляете свою программу и проверяете, больше ли баллов, чем 999.

Вы можете попытаться напечатать еще больше цифр и тем самым получить больше очков. Возможно, вам понравится.

Ответ 5

Это делает то, что вы хотите?

i = 0;
pi_str = ""
for x in make_pi():
    pi_str += str(x)
    i += 1
    if i == 1001:
        break

print "pi= %s.%s" % (pi_str[0],pi_str[1:])

Ответ 6

Здесь я нашел другой способ → Python pi расчет?, чтобы приблизиться к python на основе формулы братьев Чудновских для генерации Pi, который я видоизменил для моя программа.

def pifunction():
    numberofdigits = int(input("please enter the number of digits of pi that you want to generate"))
    getcontext().prec = numberofdigits

def calc(n):
    t = Decimal(0)
    pi = Decimal(0)
    deno = Decimal(0)
    k = 0
    for k in range(n):
        t = (Decimal(-1)**k)*(math.factorial(Decimal(6)*k))*(13591409+545140134*k)
        deno = math.factorial(3*k)*(math.factorial(k)**Decimal(3))*(640320**(3*k))
        pi += Decimal(t)/Decimal(deno)
    pi = pi * Decimal(12)/Decimal(640320**Decimal(1.5))
    pi = 1/pi
    return str(pi)
print(calc(1))

Я надеюсь, что это поможет, поскольку вы можете сгенерировать любое количество цифр pi, которое вы хотите создать.

Ответ 7

Уоллис формула может получить 3.141592661439964, но для решения этой проблемы необходим более эффективный способ.

https://www.youtube.com/watch?v=EZSiQv_G9HM

а теперь мой код

x, y, summing = 2, 3, 4

for count in range (0,100000000):
    summing *= (x/y)
    x += 2
    summing *= (x/y)
    y += 2
    print (summing)

Ответ 8

Принятый ответ неверен, как отмечено в комментариях.

Код OP, кажется, основан на реализации алгоритма Spigot, скопированного отсюда.

Чтобы исправить код в соответствии с вопросом OP (хотя я переименовал переменные и функции, чтобы они соответствовали тому, что они были в исходном коде), одним из решений может быть:

#!/usr/bin/env python

DIGITS = 1000

def pi_digits(x):
    """Generate x digits of Pi."""
    q,r,t,k,n,l = 1,0,1,1,3,3
    while x >= 0:
        if 4*q+r-t < x*t:
            yield n
            x -= 1
            q,r,t,k,n,l = 10*q, 10*(r-n*t), t, k, (10*(3*q + r))/t-10*n, l
        else:
            q,r,t,k,n,l = q*k, (2*q+r)*l, t*l, k+1, (q*(7*k+2)+r*l)/(t*l), l+2

digits = [str(n) for n in list(pi_digits(DIGITS))]
print("%s.%s\n" % (digits.pop(0), "".join(digits)))

Кроме того, здесь реализована гораздо более быстрая * реализация, также основанная на алгоритме Spigot:

#!/usr/bin/env python

DIGITS = 1000

def pi_digits(x):
    """Generate x digits of Pi."""
    k,a,b,a1,b1 = 2,4,1,12,4
    while x > 0:
        p,q,k = k * k, 2 * k + 1, k + 1
        a,b,a1,b1 = a1, b1, p*a + q*a1, p*b + q*b1
        d,d1 = a/b, a1/b1
        while d == d1 and x > 0:
            yield int(d)
            x -= 1
            a,a1 = 10*(a % b), 10*(a1 % b1)
            d,d1 = a/b, a1/b1

digits = [str(n) for n in list(pi_digits(DIGITS))]
print("%s.%s\n" % (digits.pop(0), "".join(digits)))

Я протестировал оба несколько раз на этом онлайн-генераторе цифр Пи.

Все заслуги в этом Gist по глубокому взгляду.

* На основе тестирования 10000 цифр, где я получил около 7 секунд по сравнению с около 1 секунды.

Ответ 9

С сайта Фабрис Беллард: алгоритм вычисления Пи. Извините за такую простую реализацию. 1000 достаточно быстрый (для меня 0,1 с), но 10000 не такой быстрый - 71 с :-(

import time
from decimal import Decimal, getcontext

def compute(n):
    getcontext().prec = n
    res = Decimal(0)
    for i in range(n):
        a = Decimal(1)/(16**i)
        b = Decimal(4)/(8*i+1)
        c = Decimal(2)/(8*i+4)
        d = Decimal(1)/(8*i+5)
        e = Decimal(1)/(8*i+6)
        r = a*(b-c-d-e)
        res += r
    return res

if __name__ == "__main__":
    t1 = time.time()
    res = compute(1000)
    dt = time.time()-t1
    print(res)
    print(dt)