Comments on: Optimized pow() approximation for Java, C / C++, and C#

By: martinus

martinus — Wed, 25 Jan 2012 20:15:14 +0000

Nice to hear that this is of use for you. I have just wtriten a new blog post with union version, and a more precise version:

http://martin.ankerl.com/2012/01/25/optimized-approximative-pow-in-c-and-cpp/

By: Bob

Bob — Wed, 25 Jan 2012 20:11:15 +0000

I’m using Visual Studio 2008′s compiler. It is at least somewhat faster and perhaps more so with optimization so I am going to use it in my fast max filtering. This does not depend strongly on small errors in pow so it looks indistinguishable (to my eyes). Thanks!

By: martinus

martinus — Wed, 25 Jan 2012 19:38:29 +0000

thanks!

By: martinus

martinus — Wed, 25 Jan 2012 19:03:02 +0000

I get a speedup of a factor of about 4.2 when I enable optimization, fast floating point, and SSE2.

At http://pastebin.com/DRvPJL2K I have also added a new method fastPrecisePow that is much more precise for large exponents, but a bit slower. It is 3.3 times faster than pow on my PC.

By: Bob

Bob — Wed, 25 Jan 2012 18:49:00 +0000

Same results as before (~ 4.5 sec). Largest error is 33% or so at the upper end of x and y. I’m not using optimization so that may change things.

By: martinus

martinus — Wed, 25 Jan 2012 18:29:50 +0000

Could you try this code:

double fastPow(double a, double b) {
  union {
    double d;
    int x[2];
  } u = { a };
  u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447);
  u.x[0] = 0;
  return u.d;
}

Also take care that your CPU’s speedstep does not produce strange results, so you should do a warmup first to ensure the CPU is in the highest frequency for the whole benchmark.

I have copied a benchmark here: http://pastebin.com/DRvPJL2K

By: Bob

Bob — Wed, 25 Jan 2012 17:51:00 +0000

Martinus,

Good idea as that checked something else. Turned out the pow function as implemented above was giving a few infinities, which lead to the slowdown. When I replaced it with this:
double powFast(double a, double b)
{
int one = 1;
int tmp = (*(one + (int *)&a));
int tmp2 = (int)(b * (tmp – 1072632447) +1072632447);
double p = 0.0;
*(one + (int * )&p) = tmp2;
return p;
}

it ran quite a bit faster than before and even faster than native. Still the difference between powFast and the native pow was pretty small on my machine.
pow() – 5.9 sec, sum=2.5243×10^36
powFast() – 4.5 sec, sum=3.3048×10^36

By: martinus

martinus — Wed, 25 Jan 2012 14:09:26 +0000

Hi bob, are you sure that the compiler does not just optimize the pow(x,y) call away? Could you try to change the benchmark into something like this, and try again:

sum=0;
x=.01;
y=.1;
for(i=0;i<100000000;i++) {
    x += .00001;
    y += .0000001;
    sum += pow(x,y);
}
std::cout << sum << std::endl;

By: Bob

Bob — Wed, 25 Jan 2012 14:07:09 +0000

Further more careful testing suggest that this is actually quite a bit slower than the native pow function for C (didn’t test C++). I did 100 million pow calculations and this “fast” pow(double,double) method took 5 times longer than the native C pow(double,double). Here was the test code section:

x=.01;
y=.1;
for(i=0;i<100000000;i++)
{
x += .00001;
y += .0000001;
pow(x,y);
}

It took 26 seconds using the above pow code, and ony 6 seconds with the native C pow function.

So…I would definitely do some testing on your machine before jumping onto this. Perhaps Java is quite different.

By: Bob

Bob — Tue, 24 Jan 2012 21:59:30 +0000

On my machine I found little difference in cpu time between the native exact pow and this fast pow function. I was doing x^5 with x from 10 to 500, and the x^1/5 with larger numbers

Maybe the native pow is better optimized on my 6-core?