Necesito calcular el número pi hasta el décimo quinto dígito, pero mi función se congela. Yo uso esta serie de Taylor:

atan (x) = \ sum_ {n = 0} ^ \ infty \ frac {(- 1) ^ {n} \ cdot x ^ {2n + 1}} {2n + 1}

enter image description here

Y x es igual a 1.

Ahí está mi función:

public static decimal Pi()
{
   decimal curr = 4m, 
   prev = 0m,
   one = -1m,
   den = 3.0m;

   while (Math.Abs(curr - prev) > 1e-15m)
   {
      prev = curr;
      curr += 4.0m * one / den;
      one = -one;
      den += 2.0m;
   }
        
   return curr;
}

Lo he depurado, pero no encontré por qué. Enlace a REPL

-3
Dmitry Vasiliev 21 ago. 2020 a las 20:55

2 respuestas

La mejor respuesta

De la fórmula,

|cur - prev| = 1 / (2n+1) + 1 / (2n-1)

Tu función debería estar funcionando correctamente, solo tienes que esperar hasta el término número 250.000.000.000.000. Un poco de paciencia (solo unos días).

Pero no hay garantía de que obtenga 15 dígitos exactos al final.


Nunca use la fórmula de Leibnitz. Usa la variante de Machin. https://en.wikipedia.org/wiki/Machin-like_formula

0
Yves Daoust 23 ago. 2020 a las 10:23

El problema es que el algoritmo es exponencial en el número de dígitos de precisión que desea. Para demostrar que he cambiado un poco su código para rastrear el número de iteraciones antes de que obtengamos un resultado con más y más precisión

decimal curr = 4m, 
prev = 0m,
one = -1m,
den = 3.0m;

int i = 0;
decimal epsilon = 1;

while(true)
{
  prev = curr;
  curr += 4.0m * one / den;
  one = -one;
  den += 2.0m;
  
  i++;
  
  if(Math.Abs(curr - prev) <= epsilon)
  {
    Console.WriteLine(curr);
    Console.WritleLine(i);
    epsilon /= 10m;
  } 
 
}

Aquí está la salida resultante después de que llega a 8 dígitos de precisión.

3.4666666666666666666666666667
2
3.1891847822775947292439110472
20
3.1465677471829564012877876609
200
3.1420924036835276076022995132
2000
3.1416426510898869869000847891
20000
3.1415976535647933322124871234
200000
3.1415931535895432385563933310
2000000
3.1415927035897907384627370503
20000000
3.1415926585897932134626435385
200000000

Como puede ver, cada dígito adicional de precisión toma 10 veces más iteraciones y, por lo tanto, 15 dígitos tomarán 10,000,000 veces más tiempo que para obtener 8.

1
juharr 21 ago. 2020 a las 18:46