mpmath

mpmath é um substituto para float / tipos complexos do Python e módulos math / cmath com precisão e expoente tamanhos ilimitados. O software mpmath é inteiramente escrito em Python sem quaisquer dependências externas e, portanto, funciona quase em qualquer lugar, sem a necessidade de compilação.
Para instalar, descompacte o arquivo e execute mpmath
  python setup.py install
Documentação e uso:
Importação mpmath com
    mpmath de importação *
Isso fornece os MPF classes e mpc que funcionam de forma análoga ao flutuador do Python e tipos complexos:
    >>> MPF (2) / MPF (3)
    MPF (',66666666666666663')
    >>> Mpc (0, -1)
    mpc (= reais '0', imag = '- 1')
    >>> MPF (-0,6) ** MPF (-0,2)
    mpc (= reais ",89603999408558288 ', imag =' - ,65101116249684809 ')
Para a saída mais bonita (que também esconde pequenos erros de arredondamento), uso de impressão ou str ():
    >>> Print MPF (2) / MPF (3)
    0,666666666666667
    >>> Print mpc (1 + 2j) ** 0,5
    (1,27201964951407 + 0.786151377757423j)
A precisão é controlada pelas propriedades mpf.prec (número de bits) e mpf.dps (número de casas decimais). Estas propriedades estão ligadas, então mudar uma atualiza automaticamente o outro para corresponder. Definir prec ou dps muda a precisão com que todas as operações são realizadas eo número de dígitos para exibir ao imprimir números. O padrão é
prec = 53 e dps = 15, o mesmo que Python flutua.
    >>> Mpf.dps = 30
    >>> MPF (2) / MPF (3)
    MPF ('0,66666666666666666666666666666663')
    >>> Print _
    ,666666666666666666666666666667
    >>> mpf.dps = 15 # restaurar para o padrão
Você pode criar MPFS e PPM a partir de números Python, ou combinar MPFS e PPM com números Python em operações aritméticas, mas esteja ciente de que Python normal flutua só tem precisão finita. Para inicializar uma MPF com um valor total de precisão, use uma string:
    >>> MPF (0,1)
    MPF ('0,10000000000000001') # mesma precisão como float
    >>> Mpf.dps = 50
    >>> MPF (0,1)
    MPF ('0,1000000000000000055511151231257827021181583404541016') # lixo
    >>> MPF ('0,1')
    MPF ('0,1000000000000000000000000000000000000000000000000001') # ok
As seguintes funções padrão estão disponíveis e suporta ambos os argumentos reais e complexas:
  sqrt, exp, log, poder, cos, sin, tan, cosh, sinh, tanh,
  acos, asin, atan, acosh, asinh, atanh
Exemplo:
    >>> Mpf.dps = 15
    >>> cos de impressão (1)
    0,540302305868140
    >>> Mpf.dps = 50
    >>> cos de impressão (1)
    0,54030230586813971740093660744297660373231042061792
Algumas funções menos comuns também estão disponíveis: gamma (função gama), factorial, erf (função de erro), lower_gamma / upper_gamma (função gama incompleta) e zeta (função zeta de Riemann).
Finalmente, as funções de conveniência hypot e atan2 estão disponíveis (definida apenas para números reais).
As constantes pi, e, e cgamma (constante de Euler) estão disponíveis como objetos especiais que se comportam como MPFS mas cujos valores se ajustam automaticamente à precisão.
    >>> Mpf.dps = 15
    >>> Print pi
    3,14159265358979
    >>> Mpf.dps = 50
    >>> Print pi
    3,1415926535897932384626433832795028841971693993751
    >>> Mpf.dps = 15
    >>> E ** (- pi * 1-J)
    mpc (real = '- 1', imag = '- 1.2289836075083701E-16')
    >>> Mpf.dps = 50
    >>> E ** (- pi * 1-J)
    mpc (real = '- 1', imag = '1,0106 [...] E-51')
Dirigido arredondamento é parcialmente implementado. Por exemplo, isso computa e verifica um intervalo de aproximação de 15 dígitos para 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     True

O que é novo nesta versão:

• Geral
• Agora é possível criar vários objetos de contexto e usar métodos ao contexto local, em vez de estado / funções globais (por exemplo, mp2 = mp.clone (); mp2.dps = 50; mp2.cos (3)). Nem todas as funções foram convertidos aos métodos de contexto, e há alguns erros, por isso este recurso é atualmente experimental.
• Se mpmath está instalado no sábio 4.0 ou posterior, mpmath vai agora usar sage.Integer em vez de Python longo internamente.
• instâncias removidas de divisão inteira de estilo antigo da base de código.
• runtests.py pode ser executado com -coverage para gerar estatísticas de cobertura.
• Tipos e aritmética básica
• comparação fixo com -inf.
• formato de repr Mudou o tipo de intervalo MPI para fazer eval (repr (x)) == x.
• Melhorado impressão de intervalos, com formato de saída configurável (contribuído por Vinzent Steinberg baseado no código por Don Peterson).
• Os intervalos suportados por mpmathify () e NSTR () (contribuído por Vinzent Steinberg).
• mpc é agora Hashable.
• Adicionado mais opções de formatação para a para_str funcionamento interno.
• Faster puro-Python raiz quadrada.
• Corrigir espaços em branco dando valores errados em Str- & gt;. Conversão MPF
• Calculus
• NSUM Fixa () com Euler-Maclaurin somatório que anteriormente ignorar o índice inicial e soma de n = 1.
• Implementado o método de Newton para FindRoot () (contribuído por Vinzent Steinberg).
• Álgebra linear
• Fixed LU_decomp () para reconhecer as matrizes singulares (contribuídos por Vinzent Steinberg).
• As várias funções da norma foram substituídos pela função de norma genérica vector norma (x, p) ea função mnorm genérico matriz norma (x, p).
• As funções especiais:
• Alguns caches internos foram alteradas para sempre um pouco de precisão overallocate. Isso corrige o comportamento de pior caso, onde anteriormente o valor em cache teve de ser recalculada em cada chamada de função.
• log Fixo (número minúsculo) retornando absurdo a alta precisão.
• gamma Fixo () e funções de derivados, como binomial () retornar resultados errados nas entradas inteiras sendo divisível por uma grande potência de 2.
• asin Fixo () não levantar uma exceção em alta precisão (contribuído por Vinzent Steinberg).
• Otimizado o código AGM para o logaritmo natural, tornando o método Newton utilizado anteriormente em precisões intermediários obsoletos.
• A função média aritmética agm-geométrica () agora é uma ordem de magnitude mais rápido em baixa precisão.
• implementações mais rápidas de ellipk () e ellipe ().
• continuação analítica de ellipe () para | x | & gt;. = 1 implementada
• Implementado a função gama log (loggamma ()) com cortes de filial corretas (lento, de implementação espaço reservado).
• cortes filial fixos de hyperfac ().
• Implementado o Z-função Riemann-Siegel (siegelz ()).
• Implementado a função teta Riemann-Siegel (siegeltheta ()).
• Implementado cálculo de pontos de Gram (grampoint ()).
• cálculo Implementado de Riemann zeros da função zeta (zetazero ()).
• Implementado a função de contagem privilegiada: uma versão exata lento (primepi ()). e uma versão aproximada rápido (primepi2 ()) que dá um intervalo delimitadora.
• Implementado a função de contagem privilegiada Riemann R (riemannr ()).
• números e polinômios (sino ()) de Bell implementado.
• Implementado a função expm1 ().
• Implementado a «função poliexponencial '(polyexp ()).
• Implementado a constante primos gêmeos (Twinprime) e Mertens 'constantes (Mertens).
• Implementado a função zeta prime (primezeta ()).

O que é novo na versão 0.10:

• As adições incluem plotagem de apoio, matrizes e funções de álgebra linear, novos Encontrando-raiz e em quadratura algoritmos, maior aritmética intervalo, e algumas novas funções especiais.
• Muitas melhorias de velocidade foram cometidos (algumas funções são uma ordem de magnitude mais rápido do que em 0.9), e vários bugs foram corrigidos.
• É importante ressaltar que esta versão corrige mpmath para trabalhar com Python 2.6.

Requisitos :

• Python