¿Qué lenguaje de progtwigción o biblioteca puede procesar Infinite Series?

¿Qué lenguaje de progtwigción o una biblioteca puede procesar series infinitas (como geométricas o armónicas)? Tal vez deba tener una base de datos de algunas series conocidas y dar automáticamente los valores adecuados en caso de convergencia, y tal vez generar una excepción en caso de divergencia.

Por ejemplo, en Python podría verse como:

sum = 0 sign = -1.0 for i in range(1,Infinity,2): sign = -sign sum += sign / i 

luego, la sum debe ser math.pi / 4 sin hacer ningún cálculo en el bucle (porque es una sum conocida).

Necesitas algo que pueda hacer una computación simbólica como Mathematica . También puedes considerar quering wolftwigplha: sum ((- 1) ^ i * 1 / i, i, 1, inf)

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 de que están al tanto. Desde lo alto de mi cabeza, creo que Mathematica puede hacer la mayor parte de lo que podrías querer, sospecho que Maple también puede hacerlo, tal vez Sage y otros sistemas de álgebra computacional y me sorprendería si no pudieras encontrar una implementación de Haskell que te acomoda.

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

Un lugar para mirar 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 soporta 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 mayor en su valor (es decir, sumndo el prefijo, puede declararlo como un número real computable que admite un pedido parcial, etc.) De muchas maneras, esto le da un valor que puede utilizar como la sum anterior.

Sin embargo, en general, calcular la igualdad de dos flujos requiere un oracle para el problema de la detención, por lo que ningún lenguaje hará lo que usted quiere con total generalidad, aunque algunos sistemas de álgebra computacional como Mathematica pueden intentarlo.

Maxima puede calcular algunas sums infinitas, pero en este caso 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 trabajan:

 (%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 gratuito de software matemático 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 escena, esto realmente está usando Maxima (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 basada en Python más pesada llamada Sage .

Hay una biblioteca llamada mpmath (python), un módulo de Sympy, que proporciona el soporte de serie para Sympy (creo que también respalda a Sage).
Más específicamente, todas las cosas de la serie se pueden encontrar aquí: documentación de la serie

La biblioteca C ++ iRRAM realiza aritmética real exactamente . Entre otras cosas, puede calcular límites utilizando la función de límite. La página de inicio de iRRAM está aquí . Echa un vistazo a la función de límite en la documentación. Tenga en cuenta que no estoy hablando de aritmética de precisión arbitraria. Esto es aritmética exacta , para una definición razonable 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 me quitan la 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 Huge Data Series para fines de investigación. Usé Matlab para eso. No sabía que puede / no puede procesar Infinite Series.

Pero creo que hay una posibilidad. Puedes intentarlo 🙂

Esto se puede hacer, por ejemplo, en sympy y sage (entre las alternativas de código abierto). A continuación, algunos ejemplos que usan sympy:

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

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

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

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

Detrás de las escenas, esto es utilizando la teoría para series hipergeométricas, una buena introducción es el libro “A = B” de Marko Petkovˇeks, Herbert S. Wilf y Doron Zeilberger, que puede encontrar en Google. ¿Qué es una serie hipergeométrica?

Todo el mundo sabe lo que es una serie geométrica: $ X_1, x_2, x_3, \ dots, x_k, \ dots $ es geométrico si la proporción de términos consecutivos $ x_ {k + 1} / x_k $ es constante. ¡Es hipergeométrico si la relación de términos consecutivos es una función racional en $ k $! Sympy puede manejar básicamente todas las sums infinitas donde se cumple esta última condición, pero solo muy pocas otras.

Simplemente instale Sympy en su computadora. Luego haz 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