Cómo calcular Pi con Python: métodos y ejemplos

En este artículo, te mostraré como calcular Pi con Python de varias maneras. Comenzaremos con la forma más sencilla, que es usar la constante Pi de la biblioteca math.

Abordaremos el método de los polígonos, uno de los más antiguos pero también uno de los más sencillos de entender.

Luego, veremos cómo calcular Pi usando varios métodos de series infinitas. Por ejemplo el método de Gregory-Leibniz (con algunas variantes) y el método Nilakantha que es una forma más precisa con menos ciclos.

En cada sección, proporcionaremos ejemplos de código para que puedas ver cómo funciona cada método.

Tengo que aclarar que este artículo lo escribo por puro gusto personal y en el camino me encontré con algunas sorpresas que ya les contaré más adelante.

En este artículo

¿Qué es Pi?

Pi (π) es una constante matemática que representa la relación entre la circunferencia y el diámetro de un círculo.

No importa el tamaño del círculo, si es pequeño o es enorme, su relación entre el diámetro y la circunferencia es siempre la misma.

Es un número irracional, lo que significa que sus decimales no se acaban. Su valor aproximado es 3.14159265358979323846… y así … ¡Hasta el infinito y más allá!

Pi es importante en matemáticas, física, geometría, ingeniería y muchas otras áreas. Se utiliza para calcular el perímetro, el área y el volumen de círculos y esferas.

Pi es una constante fundamental de la naturaleza, y se encuentra en muchas expresiones matemáticas que describen el universo. Por ejemplo, se utiliza para calcular la órbita de los planetas, la forma de las ondas electromagnéticas, la estructura de los átomos y un largo etcétera.

¿Cómo calcular Pi?

Wikipedia tiene esta bonita animación sobre Pi.

Cuando era niño, en la primaria nos encargaron llevar la tapita de un frasco y algo de estambre. Cortamos 3 piezas de estambre del tamaño del diámetro de la tapa y la pegamos en el borde. Siempre faltaba un pedacito para completar la circunferencia. Bueno, pues ese «pedacito» faltante es todo un tema.

A lo largo del tiempo se han hecho varios intentos por calcular el valor de Pi.

  • Los Babilonios allá por 2,000 A.C. calcularon el valor de Pi en 3 + 1/8 = 3.125
  • Los Egipcios más o menos por el mismo año en (16/9)² = 3.160 494
  • Los chinos por el 1,200 A.C. no batallaron mucho y lo redondearon a 3
  • La biblia en el Primer Libro de los Reyes 7:23 esboza también un valor de 3: «El hizo además el Mar de metal fundido, que medía cinco metros de diámetro y tenía forma circular; su altura era de dos metros y medio, y una cuerda de quince metros medía su circunferencia.»
  • Arquímedes en el 300 A.C. calcula que π = 211875/67441 = 3.14163

Y como pueden ver, a partir de los griegos se hizo un gran avance en cuanto al número de decimales de Pi.

El advenimiento de las calculadoras electrónicas permitió un gran avance en el cálculo de Pi.

Muchas aproximaciones de Pi se basan en series infinitas, que se vuelven más precisas a medida que se repiten más veces.

Las computadoras son muy eficientes para repetir cálculos, por lo que han permitido obtener un gran número de decimales de Pi.

El módulo math

Creo que es conveniente comenzar diciendo que en Python no es necesario calcular el valor de Pi.

El módulo math de Python que contiene una buena cantidad de funciones matemáticas lo incluye.

Veamos un ejemplo:

from math import pi
print(pi)
3.141592653589793

El método de los polígonos

El método de los polígonos para calcular pi es un método geométrico que consiste en inscribir y circunscribir polígonos regulares en una circunferencia, y calcular el perímetro de estos polígonos para obtener límites inferiores y superiores del valor de pi.

El método fue desarrollado por el matemático griego Arquímedes en el siglo III A.C., y es el método más antiguo conocido para calcular pi con precisión.

Para aplicar el método, primero se dibuja una circunferencia con un diámetro dado. Luego, se inscribe (al interior del círculo) un polígono regular de n lados en la circunferencia, y se circunscribe (al exterior del círculo) otro polígono regular de n lados alrededor de la circunferencia.

El perímetro del polígono inscrito es una aproximación inferior del perímetro de la circunferencia, mientras que el perímetro del polígono circunscrito es una aproximación superior del perímetro de la circunferencia.

Al dividir el perímetro de cada polígono por el diámetro, se obtiene una aproximación de pi.

Pero para no hacernos bolas creo que es mejor ver la explicación de este método en un video.

El método de los polígonos es un método simple y eficaz para calcular pi. Sin embargo, su precisión no es muy buena como podemos ver en los resultados

Le hice unos ajustes a la función para mostrar en la pantalla valores intermedios. Para ver la evolución del algoritmo y como al calcular un mayor número de lados el resultado se va refinando y aproximando a Pi.

from math import sqrt

def poligonos(n):
    """
    En este método n funciona como limite máximo de lados.
    """
    r=1  #Este es el radio de la circunferencia. Puede ser cualquier valor, pero 1 simplifica mucho los cálculos.
    A=4*sqrt(2)*r
    B=8*r
    m=4
    
    print("   lados   pi inferior         pi superior")
    print(" ===============================================")
    
    while m*2<=n:
        B=2*A*B/(A+B)
        A=sqrt(A*B)
        m=m*2
        # Imprimo los valores intermedios para ver la evolución del algoritmo.
        print("{0:8d}   {1:1.15f}   {2:1.15f}".format(m,A/2,B/2))        
        
    # Regresamos como Pi la media entre el estimado superior y el inferior.
    return (A/2/r + B/2/r)/2;    
    
print("\n  El valor estimado de pi es: ",poligonos(2000000))

Resultado:

   lados   pi inferior         pi superior
 ===============================================
       8   3.061467458920719   3.313708498984761
      16   3.121445152258053   3.182597878074529
      32   3.136548490545940   3.151724907429257
      64   3.140331156954753   3.144118385245905
     128   3.141277250932773   3.142223629942458
     256   3.141513801144302   3.141750369168967
     512   3.141572940367092   3.141632080703182
    1024   3.141587725277160   3.141602510256809
    2048   3.141591421511200   3.141595117749589
    4096   3.141592345570118   3.141593269629308
    8192   3.141592576584873   3.141592807599645
   16384   3.141592634338563   3.141592692092254
   32768   3.141592648776986   3.141592663215408
   65536   3.141592652386591   3.141592655996197
  131072   3.141592653288993   3.141592654191394
  262144   3.141592653514593   3.141592653740193
  524288   3.141592653570993   3.141592653627393
 1048576   3.141592653585092   3.141592653599192

  El valor estimado de pi es:  3.14159265359214

Para obtener una mayor precisión, se pueden utilizar polígonos de más lados. Sin embargo, esto requiere un mayor esfuerzo computacional.

El código me lo encontŕe en C++ en un video de Quantum Fracture ¡Muchas gracias por la divulgación de la ciencia!

Serie de Gregory-Leibniz

Comenzamos con las series infinitas. La serie de Gregory-Leibniz es uno de los algoritmos más famosos para calcular Pi.

La serie de Gregory-Leibniz es una serie infinita que converge a π. Fue descubierta independientemente por el matemático irlandés James Gregory en 1671 y el matemático alemán Gottfried Leibniz en 1676.

\sum_{n=0}^{\infty }\frac{(-1)^{n}}{2n+1}=\frac{\pi}{4} \\ \\

O de una forma desarrollada

\huge 1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}-\cdot \cdot \cdot=\frac{\pi}{4}

Esta serie es convergente, lo que significa que sus términos se acercan cada vez más a π a medida que aumenta el número de términos. Sin embargo, la serie converge lentamente, por lo que se necesitan muchos términos para obtener una aproximación precisa de π.

Veamos el código.

def gregory_leibniz(n):
    sum = 0
    for i in range(n):
        term = (-1) ** i /(2*i+1)
        sum += term
    return sum * 4

print(gregory_leibniz(1000))

Resultado:
3.140592653839794

Y después de repetir el proceso 1000 veces apenas tenemos 2 decimales. A mano es una pesadilla, pero con una computadora actual no hay tanto problema.

¿Notaron la elegancia de que para generar la alternancia entre sumas y restas elevaron -1 a una potencia?

Hay otras formas de hacer esto, lo dejé porque respeta la expresión de la sumatoria, pero hay otras formas de generar este comportamiento.

Código en una sola línea

Durante el proceso de investigación me encontré que se puede hacer la serie completa en una sola línea gracias a una Expresión de Python.

Tal parece que va tomando la información de derecha a izquierda. Tengo que confesar que debo de estudiar más este tipo de expresiones, pero lo pongo de todos modos por si se le ofrece a alguno de mis 4 lectores o a mi yo del futuro.

def gregory_leibniz_una_linea(n):
    return 4*sum(pow(-1, k)/(2*k + 1) for k in range (n))

print(gregory_leibniz_una_linea(1000))

Resultado:
3.140592653839794

Como pueden ver el resultado es exactamente el mismo que el código anterior.

El método misterioso

La semana pasada estaba revisando una página web que mostraba una terminal de linux para hacer prácticas sin la necesidad de tener un linux instalado.

Al ejecutar el comando ls solo había un par de archivos. Uno de ellos era un programa escrito en Lua que precisamente era una aproximación a Pi.

No tenía la opción para descargar el archivo así que le hice una captura de pantalla.

Como pueden ver el código es muy sencillo y pasarlo a Python no representó mayor problema.

def otra_forma_pi(n):
    """
    Esta forma de calcular Pi me la encontré en una página,
    pero desconozco como se llama el método.
    """
    x=0
    for k in range(1,n,2):
        x = x +1 / (k * k)
    return (x*8)**0.5

print(otra_forma_pi(1000))

Resultado:
3.140955969513533

Noten que otra forma de obtener una raíz cuadrada es elevar el número a 1/2. Con eso me evito la llamada a la función sqrt del módulo math, pero en un código posterior si lo hago.

Si algún lector despistado conoce este método de aproximación de Pi le agradezco que me diga como se llama. Intenté encontrarlo pero con muy poco éxito.

Método de Nilakantha

Me van a disculpar, pero los nombres hindúes si que son complicados.

Nilakantha Somayaji fue un matemático y astrónomo indio que vivió en el siglo XV. Es considerado uno de los matemáticos más importantes de la India medieval.

La serie infinita de Nilakantha para aproximar el número pi es la siguiente:

3+\frac{4}{2\times 3 \times 4}-\frac{4}{4\times 5 \times 6}+\frac{4}{6 \times 7 \times 8}-\frac{4}{8 \times 9 \times 10}+\cdot \cdot \cdot=\pi

Tiene la enorme bondad de que es relativamente simple y con pocas repeticiones logra una excelente aproximación.

def nilakantha(n):
    sum = 3
    denominadores = 2
    for i in range(n):
        signo = (-1) ** i
        sum += signo * 4 / (denominadores * (denominadores + 1) * (denominadores + 2))
        denominadores +=2
    return sum

print(nilakantha(1))
print(nilakantha(10))
print(nilakantha(100))
print(nilakantha(1000))

Resultado:
3.1666666666666665
3.1414067184965018
3.1415924109719824
3.141592653340544

Comparemos los métodos

Ahora que les parece si comparamos los métodos. Agregué una función más para comparar el resultado de las series con el valor de Pi y revisar que tanto se aproximan a ese valor.

from math import sqrt, pi

def poligonos(n):
    """
    En este método n funciona como limite máximo de lados.
    """
    r=1     #Este es el radio de la circunferencia. Puede ser cualquier valor, pero 1 simplifica mucho los cálculos.

    A=4*sqrt(2)*r
    B=8*r
    m=4

    while m*2<=n:
        B=2*A*B/(A+B)
        A=sqrt(A*B)
        m=m*2

    # Regresamos como Pi la media entre el estimado superior y el inferior.
    return (A/2/r + B/2/r)/2;

def gregory_leibniz(n):
    sum = 0
    for i in range(n):
        term = (-1) ** i /(2*i+1)
        sum += term
    return sum * 4

def gregory_leibniz_una_linea(n):
    return 4*sum(pow(-1, k)/(2*k + 1) for k in range (n))

def otra_forma_pi(n):
    """
    Esta forma de calcular Pi me la encontré en una página,
    pero desconozco como se llama el método.
    """
    x=0
    for k in range(1,n,2):
        x = x +1 / (k * k)
    return sqrt(x*8)

def nilakantha(n):
    sum = 3
    denominadores = 2
    for i in range(n):
        signo = (-1) ** i
        sum += signo * 4 / (denominadores * (denominadores + 1) * (denominadores + 2))
        denominadores +=2
    return sum

def aproximacion(n):
    return (n/pi) * 100

n = int(input("¿Cuántos términos quieres utilizar? "))

pol = poligonos(n)
gl = gregory_leibniz(n)
glul = gregory_leibniz_una_linea(n)
of = otra_forma_pi(n)
nil = nilakantha(n)

print("Valor de pi en python           : {}".format(pi))
print("Poligonos                       : {}    {}%".format(pol,aproximacion(pol)))
print("Gregory-Leibinz                 : {}    {}%".format(gl,aproximacion(gl)))
print("Gregory-Leibinz (una línea)     : {}    {}%".format(glul,aproximacion(glul)))
print("Otro método que no se su nombre : {}    {}%".format(of,aproximacion(of)))
print("Nilakantha                      : {}    {}%".format(nil,aproximacion(nil)))

Este es el resultado con 1000 repeticiones.

¿Cuántos términos quieres utilizar? 1000
Valor de pi en python           : 3.141592653589793
Poligonos                       : 3.141602510535137    100.00031375631507%
Gregory-Leibinz                 : 3.140592653839794    99.9681690193394%
Gregory-Leibinz (una línea)     : 3.140592653839794    99.9681690193394%
Otro método que no se su nombre : 3.140955969513533    99.97973371641507%
Nilakantha                      : 3.141592653340544    99.99999999206615%

Conclusiones


En conclusión, existen muchos métodos diferentes para calcular pi. Algunos son simples y fáciles de entender, mientras que otros son más complejos y requieren conocimientos matemáticos avanzados.

El cálculo de pi es un desafío matemático que ha fascinado a los matemáticos durante siglos. A pesar de que no se ha podido calcular el número pi con precisión infinita, los métodos de cálculo actuales permiten calcular millones de decimales de pi.

¿Qué les pareció este artículo? cualquier comentario y corrección es bienvenido.

¡Hasta la próxima!

¡Me encantaría saber que opinas!

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Descubre más desde LINUXMANR4

Suscríbete ahora para seguir leyendo y obtener acceso al archivo completo.

Seguir leyendo