Est-il facilement accessible de la mise en œuvre de l'erf() de Python?

Je peux mettre en œuvre la fonction d'erreur, erf, moi-même, mais je préfère ne pas le faire. Est-il un paquet python sans dépendances externes qui contient une implémentation de cette fonction? J'ai trouvé cette mais ce qui semble être une partie de certains beaucoup plus grand ensemble (et il n'est même pas clair lequel!).

InformationsquelleAutor rog | 2009-01-19

math python

62

Depuis la v. 2.7. la norme mathématiques module contient erf fonction. Ce devrait être le moyen le plus facile.

http://docs.python.org/2/library/math.html#math.erf
- Est-il un module Python qui fournit de l'erf⁻1(x) ?
- oui, les maths.erfc
InformationsquelleAutor golobor
47

Je recommande SciPy pour les fonctions numériques en Python, mais si vous voulez quelque chose avec plus de dépendances, voici une fonction avec un message d'erreur d'erreur est de moins de 1,5 * 10^-7 pour toutes les entrées.
```
def erf(x):
    # save the sign of x
    sign = 1 if x >= 0 else -1
    x = abs(x)

    # constants
    a1 =  0.254829592
    a2 = -0.284496736
    a3 =  1.421413741
    a4 = -1.453152027
    a5 =  1.061405429
    p  =  0.3275911

    # A&S formula 7.1.26
    t = 1.0/(1.0 + p*x)
    y = 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*math.exp(-x*x)
    return sign*y # erf(-x) = -erf(x)
```
L'algorithme vient de Manuel des Fonctions Mathématiques, formule 7.1.26.
- Ce code donne une division par zéro pour l'erf(0.0).
- Vous avez raison. J'ai édité ma réponse pour trouver le signe de x une autre façon de résoudre ce problème. Maintenant, c'est OK.
- de wikipedia: "le 'manuel' est le travail du gouvernement fédéral AMÉRICAIN [employés], ne sont pas protégés par le droit d'auteur". Je mets ici un lien plus direct pour le livre: math.sfu.ca/~cbm/aands/frameindex.htm
- Je suis en train d'utiliser cette fonction, mais en passant un tableau numpy pour x et retour numy tableau comme réponse, sans succès. Pouvez-vous réécrire tableau version de la fonction?
InformationsquelleAutor John D. Cook
25

Je vous recommande de télécharger numpy (pour avoir efficace la matrice en python) et scipy (une boîte à outils Matlab substitut, qui utilise numpy). Le fer de la fonction se trouve dans scipy.
```
>>>from scipy.special import erf
>>>help(erf)
```
Vous pouvez également utiliser le fer de la fonction définie dans pylab, mais c'est plus destiné à comploter les résultats de choses que vous calculez avec numpy et scipy. Si vous voulez un tout-en-un
l'installation de ces logiciels, vous pouvez utiliser directement le Python Enthought de distribution.
- SciPy est le motherload de les logiciels de calcul numérique pour Python. Mais la mise en route, il peut être un peu difficile. Commencez par regarder scipy.org
- Je dois dire que j'ai totalement échoué à installer. Il y avait une raison que j'ai demandé pour un forfait sans dépendances externes. Numpy est pas le seul. UMFPack en est une autre. Il sera plus facile d'écrire mon propre erf()!
- essayez Python Enthought comme je l'ai mentionné, ils ont livré tout ce dont vous avez besoin.
- 363MB de licence grevés de téléchargement est plus loin que je suis prête à aller pour une 30 de la ligne de fonction... comme il arrive, il semble que macports ne scipy. C'est la recompilation de l'intégralité de gcc que je vous parle. Il ya quelque chose de mal ici!
- L'exemple devrait lire "import scipy.spécial comme fer", c'est à dire se débarrasser de la première "erf" et de garder le deuxième. Depuis erf est une fonction et pas un module, il ne devrait pas être partie de l'importation chemin. "import scipy.spécial comme foobar" serait trop de travail. Le "comme" est une commodité.
- Il serait moins à confusion "de scipy.spéciales d'importation erf" que les importations n'ont erf fonction.
InformationsquelleAutor Mapad
8

Un pur python de mise en œuvre peuvent être trouvés dans la mpmath module (http://code.google.com/p/mpmath/)

De la doc de la chaîne:
```
>>> from mpmath import *
>>> mp.dps = 15
>>> print erf(0)
0.0
>>> print erf(1)
0.842700792949715
>>> print erf(-1)
-0.842700792949715
>>> print erf(inf)
1.0
>>> print erf(-inf)
-1.0
```
Pour les grandes réel x, \mathrm{erf}(x) approches 1 très
rapidement::
```
>>> print erf(3)
0.999977909503001
>>> print erf(5)
0.999999999998463
```
L'erreur est une fonction impaire::
```
>>> nprint(chop(taylor(erf, 0, 5)))
[0.0, 1.12838, 0.0, -0.376126, 0.0, 0.112838]
```
:func:erf met en œuvre une précision arbitraire de l'évaluation et de
prend en charge les nombres complexes::
```
>>> mp.dps = 50
>>> print erf(0.5)
0.52049987781304653768274665389196452873645157575796
>>> mp.dps = 25
>>> print erf(1+j)
(1.316151281697947644880271 + 0.1904534692378346862841089j)
```
Fonctions liées à la

Voir aussi :func:erfc, ce qui est plus précis pour les grandes x,
et :func:erfi qui donne la antiderivative de
\exp(t^2).

Les intégrales de Fresnel :func:fresnels et :func:fresnelc
sont également liées à la fonction d'erreur.
- c'est vraiment intéressant. il s'agit probablement de multi-précision de la mise en œuvre est un peu juste plus lent que d'utiliser natif de virgule flottante?
InformationsquelleAutor

Pour répondre à ma propre question, j'ai fini par utiliser le code suivant, adapté d'une version de Java que j'ai trouvé ailleurs sur le web:

# from: http://www.cs.princeton.edu/introcs/21function/ErrorFunction.java.html
# Implements the Gauss error function.
#   erf(z) = 2 /sqrt(pi) * integral(exp(-t*t), t = 0..z)
#
# fractional error in math formula less than 1.2 * 10 ^ -7.
# although subject to catastrophic cancellation when z in very close to 0
# from Chebyshev fitting formula for erf(z) from Numerical Recipes, 6.2
def erf(z):
    t = 1.0 / (1.0 + 0.5 * abs(z))
        # use Horner's method
        ans = 1 - t * math.exp( -z*z -  1.26551223 +
                            t * ( 1.00002368 +
                            t * ( 0.37409196 + 
                            t * ( 0.09678418 + 
                            t * (-0.18628806 + 
                            t * ( 0.27886807 + 
                            t * (-1.13520398 + 
                            t * ( 1.48851587 + 
                            t * (-0.82215223 + 
                            t * ( 0.17087277))))))))))
        if z >= 0.0:
            return ans
        else:
            return -ans

Sympa, mais comme de 2,7 nous devrions faire from math import erf (pour la portabilité, la précision, la vitesse, etc.)

InformationsquelleAutor rog

6

J'ai une fonction qui ne 10^5 erf appels. Sur ma machine...

scipy.spécial.erf en fait de temps à 6,1 s

erf Manuel des Fonctions Mathématiques prend 8.3 s

erf Numérique Recettes 6.2 prend 9.5 s

(trois-run moyennes, code d'affiches ci-dessus).
- erf appelé avec ctypes de libm.donc (c standard de la bibliothèque math, 64 bits de linux ici) descend à 5,6 s.
- J'ai aussi besoin 1000s de fer appels. Basé sur les chiffres de votre activité, je vais avec scipy.spécial.erf. Avez-vous trouvé quelque chose de plus rapide depuis? J'ai demandé à ce sujet à l'aide d'une recherche..
- FWIW, comment utilisez-vous scipy est erf fonction? Avec la configuration suivante: from scipy.special import erf; import numpy as np; data = np.random.randn(10e5), je reçois très rapide en temps d'exécution à partir de: result = erf(data). En particulier, je reçois 32ms par boucle dans ce cas. La seule manière pour moi runtimes > 1s est si j'ai naïvement en boucle sur tous les éléments dans un numpy tableau.
InformationsquelleAutor meteore

Une remarque pour ceux qui ont des pour de meilleures performances: vectoriser, si possible.

import numpy as np
from scipy.special import erf

def vectorized(n):
    x = np.random.randn(n)
    return erf(x)

def loopstyle(n):
    x = np.random.randn(n)
    return [erf(v) for v in x]

%timeit vectorized(10e5)
%timeit loopstyle(10e5)

donne des résultats

# vectorized
10 loops, best of 3: 108 ms per loop

# loops
1 loops, best of 3: 2.34 s per loop

InformationsquelleAutor 8one6

Vous devez vous connecter pour publier un commentaire.