mpmath

Mpmath es un sustituto de flotador / tipos complejos de Python y los módulos de matemáticas / cmath con tamaños de precisión y exponente ilimitados. El software Mpmath está escrito enteramente en Python sin dependencias externas y por lo tanto funciona en casi cualquier lugar, sin necesidad de compilación.
Para instalarlo, descomprimir el archivo y ejecutar Mpmath
  python setup.py install
Documentación y uso:
Mpmath importación con
    desde Mpmath import *
Esto proporciona las clases mpf y mpc que funcionan de manera análoga a la carroza de Python y tipos complejos:
    >>> MPF (2) / MPF (3)
    mpf (',66666666666666663')
    >>> Mpc (0, -1)
    mpc (= reales '0', imag = '- 1')
    >>> Mpf (-0,6) ** mpf (-0,2)
    mpc (= reales ",89603999408558288 ', imag =' - 0.65101116249684809 ')
Para la salida más bonita (que también esconde pequeños errores de redondeo), uso de impresión o str ():
    >>> Mpf de impresión (2) / mpf (3)
    ,666666666666667
    >>> Mpc impresión (1 + 2j) ** 0.5
    (1.27201964951407 + 0.786151377757423j)
La precisión es controlada por las propiedades mpf.prec (número de bits) y mpf.dps (número de decimales). Estas propiedades están vinculados, por lo que cambiar uno actualiza automáticamente el otro a la altura. Ajuste prec o dps cambia la precisión a la que todas las operaciones se llevan a cabo y el número de dígitos para mostrar al imprimir números. El valor predeterminado es
prec = 53 y dps = 15, lo mismo que flota Python.
    >>> Mpf.dps = 30
    >>> MPF (2) / MPF (3)
    mpf ('0,66666666666666666666666666666663')
    >>> Print _
    0.666666666666666666666666666667
    >>> mpf.dps = 15 # restaurar a los valores predeterminados
Puede crear MPFS y PSM de los números de Python, o combinar MPFS y PSM con los números de Python en las operaciones aritméticas, pero tenga en cuenta que Python regulares flota sólo tienen precisión finita. Para inicializar un mpf con un valor de precisión completa, utilice una cadena:
    >>> Mpf (0.1)
    mpf ('0,10000000000000001') misma precisión # como flotador
    >>> Mpf.dps = 50
    >>> Mpf (0.1)
    mpf ('0,1000000000000000055511151231257827021181583404541016') # basura
    >>> Mpf ('0.1')
    mpf ('0,1000000000000000000000000000000000000000000000000001') # ok
Las siguientes funciones estándar están disponibles y apoyan ambos argumentos reales y complejos:
  sqrt, exp, registro, potencia, cos, el pecado, tan, cosh, senh, tanh,
  acos, asin, atan, acosh, asinh, atanh
Ejemplo:
    >>> Mpf.dps = 15
    >>> cos de impresión (1)
    ,540302305868140
    >>> Mpf.dps = 50
    >>> cos de impresión (1)
    0,54030230586813971740093660744297660373231042061792
Algunas funciones menos comunes también están disponibles: gamma (función gamma), factorial, erf (función de error), lower_gamma / upper_gamma (función gamma incompleta) y zeta (función zeta de Riemann).
Por último, las funciones de confort y hypot atan2 disponibles (definidos por solo números reales).
Las constantes pi, e, y Cgamma (la constante de Euler) son disponibles como objetos especiales que se comportan como MPFS pero cuyos valores ajustará automáticamente a la precisión.
    >>> Mpf.dps = 15
    >>> Print pi
    3.14159265358979
    >>> Mpf.dps = 50
    >>> Print pi
    3,1415926535897932384626433832795028841971693993751
    >>> Mpf.dps = 15
    >>> E ** (- pi * 1j)
    mpc (real = '- 1', imag = '- 1.2289836075083701E-16')
    >>> Mpf.dps = 50
    >>> E ** (- pi * 1j)
    mpc (real = '- 1', imag = '1.0106 [...] E-51')
Dirigida redondeo se implementa parcialmente. Por ejemplo, este calcula y comprueba un intervalo de aproximación de 15 dígitos de pi:
    >>> Mpf.dps = 15
    >>> Mpf.round_down (); pi1 = pi +
    >>> Mpf.round_up (); pi2 = pi +
    >>> Pi1
    mpf ('3,1415926535897931')
    >>> Pi2
    mpf ('3,1415926535897936')
    >>> Mpf.dps = 30
    >>> Pi1     Verdadero

¿Qué hay de nuevo en esta versión:

• generales
• Ahora es posible crear varios objetos de contexto y utilizar métodos al contexto local de estado / funciones globales (por ejemplo, mp2 = mp.clone (); mp2.dps = 50; mp2.cos (3)). No todas las funciones se han convertido en métodos de contexto, y hay algunos errores, por lo que esta característica es actualmente experimental.
• Si Mpmath se instala en Sage 4.0 o posterior, Mpmath ahora utilizar sage.Integer lugar de Python mucho internamente.
• casos eliminados de viejo estilo de la división entera del código base.
• runtests.py se puede ejecutar con -Cobertura para generar estadísticas de cobertura.
• Tipos y aritmética básica
• Comparación fijo con -inf.
• Formato repr cambiado del tipo de intervalo mpi hacer eval (repr (x)) == x.
• Mejora de la impresión de los intervalos, con formato de salida configurable (aportado por Vinzent Steinberg basado en el código de Don Peterson).
• Intervalos apoyados por mpmathify () y NSTR () (aportado por Vinzent Steinberg).
• mpc es ahora hashable.
• Añadido más opciones de formato a la to_str funcionamiento interno.
• pure-Python raíz cuadrada más rápido.
• Fix espacios en blanco dando valores erróneos en str- & gt;. Conversión mpf
• Cálculo
• NSUM Fijo () con Euler-Maclaurin suma que ignorar previamente el índice de partida y la suma de n = 1.
• Implementado el método de Newton para findroot () (aportado por Vinzent Steinberg).
• Álgebra lineal
• Fijo LU_decomp () para reconocer matrices singulares (aportados por Vinzent Steinberg).
• Las diversas funciones normativas fueron sustituidos por la norma norma vector genérico función (x, p) y la función mnorm norma matriz genérica (x, p).
• Funciones especiales:
• Algunos cachés internas se cambiaron a la precisión siempre un poco overallocate. Esto corrige el comportamiento peor de los casos donde anteriormente el valor almacenado en caché tuvo que ser recalculado en cada llamada a la función.
• Registro fijo (número pequeño) volviendo absurdo a alta precisión.
• gamma Fijo () y funciones derivados como binomial () devolver resultados erróneos en las entradas enteros siendo divisible por una gran potencia de 2.
• asin Fijo () no plantear una excepción a alta precisión (aportado por Vinzent Steinberg).
• Optimizado el código AGM para el logaritmo natural, por lo que el método de Newton utilizado anteriormente en precisiones intermedios obsoletos.
• La función de media agm-aritmética geométrica () ahora es un orden de magnitud más rápido a baja precisión.
• implementaciones más rápidas de ellipk () y ellipe ().
• de continuación analítica de ellipe () para | x | & gt;. = 1 implementados
• Implementado la función gamma log (loggamma ()) con cortes de rama correctos (, implementación marcador de posición lenta).
• cortes de rama fijos de hyperfac ().
• Implementado el Z-función de Riemann-Siegel (siegelz ()).
• Implementado la función zeta de Riemann-Siegel (siegeltheta ()).
• Implementado cálculo de puntos de Gram (grampoint ()).
• cálculo Implementado de Riemann ceros de la función zeta (zetazero ()).
• Implementado la función de conteo de primera: una versión exacta lento (primepi ()). y una versión aproximada rápido (primepi2 ()) que da un intervalo de delimitación.
• Implementado la función de conteo primer Riemann R (riemannr ()).
• números de Bell implementadas y polinomios (campana ()).
• la función Implementado expm1 ().
• Implementado la "función poliexponencial '(polyexp ()).
• Implementado la constante de primer gemelo (twinprime) y Mertens 'constantes (mertens).
• Implementado la función zeta prime (primezeta ()).

¿Qué hay de nuevo en la versión 0.10:

• Las adiciones incluyen trazado de apoyo, matrices y funciones de álgebra lineal, nuevos algoritmos de raíz-hallazgo y en cuadratura, aritmética intervalo mejorada y nuevas funciones especiales.
• Muchas mejoras de velocidad se han cometido (unas pocas funciones son un orden de magnitud más rápido que en 0.9), y varios errores han sido corregidos.
• Es importante destacar que esta versión soluciona Mpmath trabajar con Python 2.6.

Requisitos

• Python