1000 dígitos de pi en python

Question

He estado pensando en este tema y no puedo resolverlo. Quizás puedas ayudarme. El problema es que mi código no funciona para generar 1000 dígitos de pi en el lenguaje de codificación python.

Aquí está mi código:

def make_pi(): 
    q, r, t, k, m, x = 1, 0, 1, 1, 3, 3 
    while True: 
     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) 

digits = make_pi() 
pi_list = [] 
my_array = [] 
for i in range(1000): 
    my_array.append(str("hello, I'm an element in an array \n")) 
big_string = "".join(my_array) 

print "here is a big string:\n %s" % big_string 

Sé que este código puede ser fijado a trabajar, pero no estoy seguro de qué se debe corregir ... La sentencia print diciendo que aquí hay una cadena grande y la my_array.append(str("hello, im an element in an array \n)) es solo un relleno por ahora. Sé cómo se usa todo el código para trabajar, pero como he dicho antes, no logro sacar el código.

Answer 1

Ejecutar este

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 


digits = make_pi() 
pi_list = [] 
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 

y leer sobre yield operador desde aquí: What does the "yield" keyword do in Python?

Aquí está la respuesta:

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337 

Answer 2

No estoy familiarizado con su algoritmo. ¿Es una implementación de BBP?

En cualquier caso, su make_pi es un generador. Trate de usarlo en un bucle for:

for digit in make_pi(): 
    print digit 

Tenga en cuenta que este bucle es infinito: make_pi() nunca tira StopIteration

Answer 3

hace esto lo que quieres?

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:]) 

Answer 4

Si no quieren poner en práctica su propio algoritmo, puede usar 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 

Reference

Actualización:. Código compatible con las instalaciones antiguas y nuevas de SymPy (véase comment) *

Answer 5

Aquí se puede comprobar si sus productos de los programas correctos 1000 dígitos: http://spoj.com/CONSTANT

Por supuesto, puede usar diff o tc también, pero tendría que copiar estos 1000 dígitos de algún lugar y allí simplemente envíe su programa y verifique si el puntaje es más grande que 999.

Puede tratar de imprimir aún más dígitos allí y así obtener más puntos. Quizás lo disfrutes.

Answer 6

Aquí hay una forma diferente que encontré aquí ->Python pi calculation? para aproximar Python basado en la fórmula de hermanos Chudnovsky para generar Pi que he modificado visualmente para mi programa.

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)) 

espero que esto ayude como se puede generar cualquier número de dígitos de pi que desea generar.

Answer 7

La fórmula wallis puede llegar a 3.141592661439964, pero se necesita una forma más eficiente para resolver este problema.

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

and now my code 
x = 2 
y = 3 
summing = 4 
for count in range (0,100000000): 
    summing *= (x/y) 
    x += 2 
    summing *= (x/y) 
    y += 2 
print (summing)