Elaboración de un programa en C++, basado en el Algoritmo de espiga,

para calcular cien decimales de pi

Castillo Bustamante Josué Miguel
1. INTRODUCCIÓN
Existen muchas expresiones matemáticas para el numero irracional pi, entre estas destacan las series
infinitas. Truncando estas series en un número elevado de términos puede obtenerse un resultado para pi,
limitado por el número de decimales. Algunas series son más eficientes que otras en el sentido de converger
más rápido con pocas iteraciones. Justamente, es la serie de Euler, junto con un algoritmo denominado
Algoritmo de espiga, que se implementarán en el programa en C++ para calcular como mínimo cien
decimales de pi.
2. OBJETIVO
2.1 OBJETIVO GENERAL
Elaborar un algoritmo matemático y programa informático capaz de determinar el valor de pi con cien
decimales.
2.2 OBJETIVOS ESPECÍFICOS
Elaborar un programa en el lenguaje C++ que calcule, en un tiempo razonable, mínimamente cien decimales
de pi.
3. METODOLOGÍA
La expansión decimal de un número real muestra los decimales de dicho número como un cociente donde
el denominador siempre es una potencia de diez. De manera general
𝑐1 𝑐2
𝑎 = 𝑎𝑛 10𝑛 +𝑎𝑛−1 10𝑛−1 + ⋯ + 𝑎1 101 + + +⋯
101 102
Esta notación también puede ser generada para un numero racional, sin embargo es imposible una expansión
decimal para números que además de irracionales sean trascendentales, como es el caso de pi y e.
A partir de la serie de Euler
∞
𝑖!2 2𝑖+1 1 1∗2 1∗2∗3
∑ = 2 (1 + + + +⋯)
(2𝑖 + 1)! 3 3∗5 3∗5∗7
𝑖=0

Resulta útil expresar esta serie en una representación encajada respecto de una base estática B
𝑏1 𝑏2 𝑏3
𝑚 = 𝑎0 + (𝑎2 + (𝑎3 + (𝑎4 + ⋯ ))))
̃
𝑏1 ̃2
𝑏 ̃3
𝑏
𝑏 𝑏
𝐵 = {𝑏̃1 , 𝑏̃2 , … } 𝐴 = {𝑎0 , 𝑎1 , … } ∈ ℕ ∀𝑖: 𝑎𝑖 < ̃ ̃1
𝑏1 ; 𝑏𝑖 < 𝑏
1 2

Es decir
 ∞
𝑖!2 2𝑖+1 1 2 3 4
∑ = 2 + (2 + (2 + (2 + (2 + ⋯ ))))))
(2𝑖 + 1)! 3 5 7 9
𝑖=0

1 2
𝐵 = {3 , 5 , … } 𝐴 = {2,2, … }

3.1 ALGORITMO
El motivo para obtener la forma de la anterior serie radica en la característica del orden de los números: la
repetición de 2, un incremento en unidad de los numeradores y números impares en los denominadores.
Esto favorece la conversión a una expansión decimal aproximado.
El Algoritmo de espiga consiste en dicha conversión, de tal forma que al tener una expansión decimal se
obtendrán los decimales de pi.
Por ejemplo, para la serie truncada
3
𝑖!2 2𝑖+1 1 2 3
𝜋𝑎𝑝𝑟𝑜𝑥 = ∑ = 2 + (2 + (2 + (2)))
(2𝑖 + 1)! 3 5 7
𝑖=0

Desarrollando a la expansión decimal

1 1 2 3
𝜋𝑎𝑝𝑟𝑜𝑥 = (20 + (20 + (20 + (20))))
10 3 5 7

1 1 2 6
𝜋𝑎𝑝𝑟𝑜𝑥 = (20 + (20 + (26 + (1))))
10 3 5 7

1 1 2 6
𝜋𝑎𝑝𝑟𝑜𝑥 = (20 + (30 + (1 + (1))))
10 3 5 7

1 1 2 6
𝜋𝑎𝑝𝑟𝑜𝑥 = (30 + (0 + (1 + (1))))
10 3 5 7

1 1 2 6
𝜋𝑎𝑝𝑟𝑜𝑥 = 3 + (0 + (0 + (1 + (1))))
10 3 5 7

1 2
𝐵 = {3 , 5 , … } 𝐴 = {0,0,1,1}

Al recorrer por completo la serie truncada se obtiene el primer digito de pi. El procedimiento anterior se
repite hasta dar con todos los posibles dígitos.
El número de dígitos obtenidos 𝑛 mediante este algoritmo es correctos siempre y cuando la base A tenga un
número de elementos igual a
 10 ∗ 𝑛
( )+1
3

Para los primeros 4 dígitos se tiene

Base estática A
Dígitos 1/3 2/5 3/7 4/9 5/11 6/13 7/15 8/17 9/19 10/21 11/23 12/25
B1 2 2 2 2 2 2 2 2 2 2 2 2 2
20 20 20 20 20 20 20 20 20 20 20 20 20
10 10 12 12 12 10 12 7 8 9 0 0 0
3 30 30 32 32 32 30 32 27 28 29 20 20 20
B2 0 2 2 4 3 10 1 13 12 1 20 20 20
0 20 20 40 30 100 10 130 120 10 200 200 200
13 20 33 40 65 48 98 88 72 150 132 96 0
1 13 40 53 80 95 148 108 218 192 160 332 296 200
B3 3 1 3 3 5 5 4 8 5 8 17 20 0
30 10 30 30 50 50 40 80 50 80 170 200 0
11 24 30 40 40 42 63 64 90 120 88 0 0
4 41 34 60 70 90 92 103 144 140 200 258 200 0
B4 1 1 0 0 0 4 12 9 4 10 6 16 0
10 10 0 0 0 40 120 90 40 100 60 160 0
4 4 9 24 55 84 63 48 72 60 66 0 0
1 14 14 9 24 55 124 183 138 112 160 126 160 0
B5 4 40 4 3 1 3 1 3 1 8 0 22 0

3.2 PROGRAMACIÓN
Expuesto el Algoritmo de espiga se presenta a continuación el código en C++

#include <iostream>
#include <conio.h>
#include <windows.h>
using namespace std;

int main(){
int i, j, numerador,denominador,decimal, digito,div, modulo, base;
system("Color F1");
cout<<"\t\tFACULTAD DE INGENIERIA-INGENIERIA MECATRONICA\n";
cout<<"\t\tCALCULO DE n DECIMALES DE PI\n";
cout<<"\t\tCASTILLO BUSTAMANTE JOSUE MIGUEL\n\n\n";
cout<<"INGRESE EL NUMERO DE DECIMALES A CALCULAR: ";
cin>>decimal;
digito=decimal+1;
int resultado[digito];
base=((digito*10)/3+1);
int lista[base];
system("cls");
for(i=0;i<base+1;i++){
lista[i]=20;
}
for(j=0;j<digito;j++){
for(i=base;i>=1;i--){
numerador=i;
denominador=2*i+1;
div=lista[i]/denominador;
modulo=lista[i]%denominador;
lista[i-1]=div*numerador+lista[i-1];
lista[i]=modulo;
}
resultado[j]=lista[0]/10;
if(resultado[j]==10)
{
resultado[j-1]= resultado[j-1]+1;
resultado[j]=0;
}
lista[0]=lista[0]%10;
for(i=0;i<base+1;i++)
lista[i]=lista[i]*10;
}
cout<<"El VALOR APROXIMADO DE PI CON "<<decimal<<" DECIMALES ES:\n\n";
 cout<<"3.";
for(j=1;j<digito;j++){
cout<<resultado[j];
}
cout<<"\n\nLA SIGUIENTE TABLA MUESTRA LA POSICION DE CADA DECIMAL DE PI:";

cout<<"\n\n NO.\tDec\t\tNO.\tDec\t\tNO.\tDec\t\tNO.\tDec\t\tNO.\tDec\t\t"<<endl;
cout<<"----------------------------------------------------------------------------------------------------
"<<endl;
for(i=1;i<digito;i++){
cout<<i<<"\t"<<resultado[i]<<"\t\t";
if(i%5==0)
cout<<"\n";
}
getch();
return 0;
}
4. RESULTADOS
El programa desarrollado permite al usuario introducir el número de decimales a calcular. A continuación
se muestra la ejecución para 100 y 1000 decimales.
 5. CONCLUSIONES
Se reconoció que el Algoritmo de espiga resulta ser muy indicado para situaciones en la que la memoria
asignada a variables no es suficiente para almacenar un número grande de dígitos. En el caso de C++, los
tipos double y long double, para el compilador usado devC++, solo almacenan 15 decimales, resulta
evidente que no es posible conseguir una única variable con cien o más decimales.
Un defecto del Algoritmo de espiga es cuando si el último elemento de cada base en cada serie de iteraciones
es mayor que 100, en este caso no se obtiene un digito, sino 2. Esto ocurre en la serie de iteraciones para el
decimal 31, 5000 y 600 000 000. Sin embargo, este problema se solucionó en el programa de C++, al
incorporar una estructura condicional que evaluá y corrige errores de este tipo.
El tiempo de cómputo para valores inferiores a 100 decimales es menor al segundo, por esta dificultad no
se muestra un tiempo exacto. Para 10 000 decimales el tiempo de computo resultó de 8.49 segundos. Cabe
resaltar que este tiempo comprende no solo el cálculo de los dígitos de pi, también está incluido el tiempo
de generación de la tabla de los lugares decimales, que va más allá del objetivo de hallar los decimales de
pi.
En resumen: se consiguió elaborar un programa en el lenguaje C++, basado en el Algoritmo de espiga, que
calcule, en un tiempo razonable, mínimamente cien decimales de pi.
6. REFERENCIAS
Rabinowitz, S. y Stanley, S.”A Spigot Algorithm for digits of 𝜋”, The American Mathematical Monthly
195-203,195.