¿Qué lenguaje de programación o una biblioteca puede procesar Series Infinitas?

La mayoría de los lenguajes funcionales que evalúan perezosamente pueden simular el procesamiento de series infinitas. Por supuesto, en una computadora finita no es posible procesar series infinitas, como estoy seguro que saben. En la parte superior de mi cabeza, supongo que Mathematica puede hacer la mayoría de lo que quiera, sospecho que Maple también puede, tal vez Sage y otros sistemas de álgebra computacional y me sorprendería si no puede encontrar una implementación de Haskell que se adapte a usted.

EDITAR a clarificar para OP: No propongo generar bucles infinitos. La evaluación perezosa le permite escribir programas (o funciones) que simulan series infinitas, programas que a su vez son finitos en el tiempo y el espacio. Con estos lenguajes puede determinar muchas de las propiedades, como la convergencia, de la serie infinita simulada con una precisión considerable y un cierto grado de certeza. Pruebe Mathematica o, si no tiene acceso a él, pruebe Wolfram Alpha para ver qué sistema puedo hacerlo por ti.

Un lugar para buscar podría ser la categoría de Wikipedia de Computer Algebra Systems.

Hay dos herramientas disponibles en Haskell para esto más allá de simplemente soportar listas infinitas.

Primero hay un módulo que admite la búsqueda de secuencias en OEIS. Esto se puede aplicar a los primeros términos de su serie y puede ayudarlo a identificar una serie para la que no conoce la forma cerrada, etc. La otra es la biblioteca 'CReal' de reales computables. Si tiene la capacidad de generar un límite cada vez mejor en su valor (es decir, sumando el prefijo, puede declarar que como un número real computable que admite un pedido parcial, etc. En muchos sentidos, esto le da un valor que puede usar como la suma anterior.

Sin embargo, en general la computación de la igualdad de dos flujos requiere un oráculo para el problema de detención, por lo que ningún lenguaje hará lo que desea en general, aunque algunos sistemas de álgebra computacional como Mathematica pueden intentarlo.

Máxima puede calcular algunas sumas infinitas, pero en este caso en particular no parece encontrar la respuesta: - s

(%i1) sum((-1)^k/(2*k), k, 1, inf), simpsum;
                                 inf
                                 ====       k
                                 \     (- 1)
                                  >    ------
                                 /       k
                                 ====
                                 k = 1
(%o1)                            ------------
                                      2

Pero por ejemplo, esos funcionan:

(%i2) sum(1/(k^2), k, 1, inf), simpsum;
                                        2
                                     %pi
(%o2)                                ----
                                      6

(%i3) sum((1/2^k), k, 1, inf), simpsum;
(%o3)                                  1

Puede resolver el problema de la serie en Sage (un sistema de software matemático libre basado en Python) exactamente de la siguiente manera:

sage: k = var('k'); sum((-1)^k/(2*k+1), k, 1, infinity)
1/4*pi - 1

Detrás de las escenas, esto realmente está usando Máxima (un componente de Sage).

Para Python echa un vistazo a SymPy - clon de Mathematica y Matlab.

También hay una herramienta de procesamiento matemático más pesada basada en Python llamada Sage.

Hay una biblioteca llamada mpmath(python), un módulo de sympy, que proporciona el soporte de la serie para sympy( creo que también respalda a sage).
Más específicamente, todo el material de la serie se puede encontrar aquí: Documentación de la serie

La biblioteca de C++ iRRAM realiza aritmética real exactamente. Entre otras cosas, puede calcular límites exactamente usando la función limit. La página de inicio de iRRAM es aquí. Echa un vistazo a la función limit en la documentación. Tenga en cuenta que no estoy hablando de aritmética de precisión arbitraria. Esto es exacta aritmética, para una definición sensible de exacta. Aquí está su código para calcular e exactamente, extraído del ejemplo en su sitio web:

//---------------------------------------------------------------------
// Compute an approximation to e=2.71.. up to an error of 2^p
 REAL e_approx (int p)
{
  if ( p >= 2 ) return 0;

  REAL y=1,z=2;
  int i=2;
  while ( !bound(y,p-1) ) {
    y=y/i;
    z=z+y;
    i+=1;
  }
  return z;
};

//---------------------------------------------------------------------
// Compute the exact value of  e=2.71.. 
REAL e()
{
  return limit(e_approx);
};

Clojure y Haskell en la parte superior de mi cabeza.

Lo siento, no pude encontrar un mejor enlace a las secuencias de haskell, si alguien más lo tiene, por favor hágamelo saber y lo actualizaré.

He trabajado en un par de Enormes Series de Datos con fines de investigación. He utilizado Matlab por eso. No sabía que puede / no puede procesar Series Infinitas.

Pero creo que hay una posibilidad. Puedes probar :)

Esto se puede hacer en por ejemplo sympy y sage (entre las alternativas de código abierto) En los siguientes ejemplos usando sympy:

En [10]: suma(1 / k**2,(k,1, oo)) Fuera[10]: 2 π ── 6

En [11]: suma(1 / k**4, (k,1, oo)) Out[11]: 4 π ── 90

En [12]: suma( (-1)**k/k, (k,1,oo)) Out [12]:- log (2)

En [13]: suma( (-1)**(k+1)/k, (k,1,oo)) Out [13]: log (2)

Detrás de las escenas, esto está usando la teoría para series hipergeométricas, a bonita introducción es el libro "A = B" de Marko PetkovˇEks, Herbert S. Wilf y Doron Zeilberger que puedes encontrar en Google. ¿Qué es una serie hipergeométrica?

Todo el mundo sabe lo que es una serie geométrica: X X_1, x_2, x_3, \dots, x_k, \dots is es geométrica si la relación de términos contecutivos x x_{k+1}/x_k is es constante. Es hipergeométrica si la relación de términos consecutivos es una función racional en k k!! sympy puede manejar básicamente todas las sumas infinitas donde se cumple esta última condición, pero muy pocos otros.

Simplemente instale sympy en su computadora. Luego haga el siguiente código:

from sympy.abc import i, k, m, n, x
from sympy import Sum, factorial, oo, IndexedBase, Function
Sum((-1)**k/(2*k+1), (k, 0, oo)).doit()

El resultado será: pi / 4