El cálculo de PI con 500 decimales

Saludos de nuevo compañeros. Hoy tenemos un nuevo reto el cálculo de PI hasta de 500 decimales, esto como respuesta a un comentario que fue realizado en el post sobre Interfaces Genéricas, si ya sabemos, no tiene nada que ver, pero en ese post fue realizada la duda y en este post UNA posible solución.

Muchos métodos han sido utilizados para calcular el Valor de PI, hoy en día existen algoritmos que generan con gran precision este valor, En la clase Math existe una constante PI de tipo double que contiene el valor literal

public static final PI = 3.141592653589793d;

Pero por supuesto, es insuficiente para cálculos avanzados. No nos da mayor precisión, allí termina.

De hecho cuando he trabajado con los valores primitivos double he tenido dificultades para obtener mayor precisión, soy "todo oído" para soluciones.

Pero gracias a Dios contamos con la clase BigDecimal que permite obtener mayor precisión en el cálculos numérico con decimales, a pesar de que los cálculos son mas limitados.

Si quiere consultar la clase BigDecimal haga clic aqui.

En esta clase contamos con un constructor que recibe un MathContext que en su constructor recibe un parámetro que dice cual es la precisión con la que queremos trabajar en este caso yo paso 500 así:

MathContext mc = new MathContext(500);

Aunque en realidad me da mayor precisión que esa.

Ahora bien es hora de hablar de métodos de cálculo de PI.

Primero que todo debemos hablar de la Serie de Taylor.

Esta propone una serie para el cálculo de el arcotangente:



Siendo así podemos programar un método que calcule el arcotangente de un valor con la Serie de Taylor:

private static BigDecimal serieArcotangente (double x, int iteraciones) { MathContext mc = new MathContext(500); BigDecimal result = new BigDecimal(0.00, mc); BigDecimal uno = new BigDecimal(1.00); for(int i = 0; i < iteraciones; i++){ double div = (2.00*i+1.00) * (Math.pow(1.00/x, 2.00 * i + 1.00)); BigDecimal divisor = new BigDecimal(div); if(i % 2 == 0){ result = result.add(uno.divide(divisor, mc)); }else{ result = result.subtract(uno.divide(divisor, mc)); } } return result; }

Explicando un poco este método, tenemos que retorna un BigDecimal para mayor precision de PI, tenemos MathContext de 500 decimales de precision. Inicializamos un BigDecimal en cero pasandole este MathContext y un BigDecimal inicializado en 1.0 que servirá para el cálculo.

Después comenzamos las iteraciones (sentencia for), calculamos un double divisor (divisor de la Serie de Taylor) y lo inicializamos como otro BigDecimal, luego tenemos:

if(i % 2 == 0){ pi = pi.add(uno.divide(divisor, mc)); }else{ pi = pi.subtract(uno.divide(divisor, mc)); }

Que significa que si i es par sumo, sino resto, ya que -1 en la serie está elevada a la n (si n es par se convierte en positivo - se suma - sino es negativo y por lo tanto se resta). Además se divide uno entre el divisor con el MathContext de 500 decimales de precisión.

Una vez hecho esto podemos ver las de arcotangentes desarrolladas por algunos matemáticos para calcular el valor de PI:

Haciendo historia, en 1844, Dase, un calculista ultrarrápido, utilizó otra fórmula del tipo arcotangente para conseguir una aproximación con 200 decimales correctos. La fórmula descubierta por Strassnitzky es:

PI/4 = arctan(1/2) + arctan(1/5) + arctan(1/8)

En programación sería:

public static BigDecimal calculoPiDase(){ BigDecimal pi = serieArcotangente(1.00/2.00, 100) .add(serieArcotangente(1.00/5.00, 100)) .add(serieArcotangente(1.00/8.00,100)) .multiply(new BigDecimal(4.00)); return pi; }

El gran matemático alemán, Karl Friedrich Gauss (1777-1855), también descubrió algunas fórmulas similares a las anteriores. Una de las más utilizadas ha sido:

PI/4 = 12*arctan(1/18) + 8*arctan(1/57) - 5*arctan(1/239)

este sería así:

public static BigDecimal calculoPiGauss(){ BigDecimal pi = serieArcotangente(1.00/18.00, 60) .multiply(new BigDecimal(12.00)) .add(serieArcotangente(1.00/57.00, 60) .multiply(new BigDecimal(8.00)) .subtract(serieArcotangente(1.00/239.00, 60) .multiply(new BigDecimal(5.00))) ); return pi.multiply(new BigDecimal(4.00)); }

Y otra fórmula similar descubierta por Störmer (1896):

PI/4 = 6*arctan(1/8) + 2*arctan(1/57) + arctan(1/239)

public static BigDecimal calculoPiStormer(){ BigDecimal pi = serieArcotangente(1.00/8.00, 60) .multiply(new BigDecimal(6.00)) .add(serieArcotangente(1.00/57.00, 60) .multiply(new BigDecimal(2.00)) .add(serieArcotangente(1.00/239.00, 60))); return pi.multiply(new BigDecimal(4.00)); }

Bueno por si acaso, ahora voy a estructurar bien el codigo:

public class PIPreciso { public static void main(String[] args) { System.out.println("DASE: "+calculoPiDase()); System.out.println("GAUSS: "+calculoPiGauss()); System.out.println("STORMER: "+calculoPiStormer()); } public static BigDecimal calculoPiDase(){ //Este codigo ya fue visto } public static BigDecimal calculoPiGauss(){ //Este codigo ya fue visto } public static BigDecimal calculoPiStormer(){ //Este codigo ya fue visto } private static BigDecimal serieArcotangente (double x, int iteraciones) { //Codigo ya visto } }

Ya tenemos tres métodos para calcular PI con 500 decimales o mas, espero esto haya podido ayudarte. Cualquier pregunta no dudes en escribir aquí o en cualquier post. Hasta Luego