Comments on: Stand-alone error function erf(x)

By: John

John — Thu, 06 May 2010 16:08:07 +0000

Allen: The code is public domain. Do whatever you'd like. Here is some similar stand-alone code, also in the public domain.

By: Allen Downey

Allen Downey — Thu, 06 May 2010 14:50:19 +0000

Thanks for this — I would like to distribute a modified version of this code — can you tell me what license you intend to distribute this under?

(My version will be support code for Think Stats, a book I am working on. The current draft is at thinkstatsbook.com)

By: Vishal

Vishal — Thu, 15 Oct 2009 22:29:58 +0000

Can I use the code snippet above to compute the erf(x) or are there any issues with the code snippet? Thanks

By: Jaime

Jaime — Tue, 24 Feb 2009 13:58:58 +0000

Gene, I’m quoting below a couple of paragraphs, from “The Art of Scientific Computing” by Press et al…

—–

We assume that you know enough never to evaluate a polynomial this way:
p=c[0]+c[1]*x+c[2]*x*x+c[3]*x*x*x+c[4]*x*x*x*x;
or (even worse!),
p=c[0]+c[1]*x+c[2]*pow(x,2.0)+c[3]*pow(x,3.0)+c[4]*pow(x,4.0);
Come the (computer) revolution, all persons found guilty of such criminal behavior will be summarily executed, and their programs won’t be! It is a matter of taste, however, whether to write
p=c[0]+x*(c[1]+x*(c[2]+x*(c[3]+x*c[4])));
or
p=(((c[4]*x+c[3])*x+c[2])*x+c[1])*x+c[0];
If the number of coefficients c[0..n-1] is large, one writes
p=c[n-1];
for(j=n-2;j>=0;j–) p=p*x+c[j];
or
p=c[j=n-1];
while (j>0) p=p*x+c[--j];

By: Keith

Keith — Tue, 17 Feb 2009 16:39:17 +0000

Just found this through a google search. Very helpful… epecially now that I’ve tried it and it works. Thanks.

By: John

John — Tue, 20 Jan 2009 22:16:10 +0000

Sorry about that. Maybe the A & S abbreviation isn’t as well-known as I thought.

By: Charles McCreary

Charles McCreary — Tue, 20 Jan 2009 21:46:22 +0000

I had never heard about “A&S” so I followed the Amazon link only to see the very familiar cover of my Abramowitz & Stegun!

By: Gene

Gene — Tue, 20 Jan 2009 14:48:09 +0000

I re-factored a sixth order polynomial using Horner’s method. The evaluation is called many times. The re-factoring lead to a dramatic improvement in execution times.

Definitely worth the effort, and unfortunately, easy to make an error until you’ve performed the operation a few times.

So much for plowing through a polynomial using Math.Pow(x, y).

By: John

John — Mon, 19 Jan 2009 22:30:56 +0000

Thanks! That’s handy sample code for other problems too.

On POSIX systems, erf is included in math.h. But it’s not part of the ISO standard requirement, and Microsoft doesn’t implement it with their compiler. For reasons I don’t understand, Microsoft does implement Bessel functions, but it doesn’t implement function that I imagine are more commonly used, particularly the gamma function.

By: Sergey Fomel

Sergey Fomel — Mon, 19 Jan 2009 22:21:16 +0000

erf is actually a standard function in C "math.h" For some reason, it is not included in Python's math module but, if you have SWIG, it is easy to write a SWIG wrapper for it. An example on a Linux machine:

bash$ cat erf.i

%module erf
#include 
double erf(double);

bash$ swig -o erf_wrap.c -python erf.i
bash$ gcc -o erf_wrap.os -c -fPIC -I/usr/include/python2.4 erf_wrap.c
bash$ gcc -o _erf.so -shared erf_wrap.os
bash$ python
>>> from erf import erf
>>> erf(1)
0.84270079294971489