Usually microoptimization is only done in C or C++, but it works quite well in Java too. For a project I needed very fast `log()` and `exp()` calculations, and Java’s `Math.log()` and `Math.exp()` just doesn’t cut it. After a bit of research I have found the following approximations that are good enough for me:

**UPDATE** This pow() approximation is obsolete. I have a much faster and more accurate approximation version here.

# Fast Exponential Function in Java

The paper “A Fast, Compact Approximation of the Exponential Function” describes a C macro that does a good job at exploiting the IEEE 754 floating-point representation to calculate e^x. I have transformed the macro into Java code:

1 2 3 4 |
public static double exp(double val) { final long tmp = (long) (1512775 * val + 1072632447); return Double.longBitsToDouble(tmp << 32); } |

This code is **5.3 times** faster than `Math.exp()` on my computer. Beware that it is only an approximation, for a detailed analysis read the paper.

# Fast Natural Logarithm in Java

I have found the following approximation here, and there is not much information about it except that it is called “Borchardt’s Algorithm” and it is from the book “Dead Reconing: Calculating without instruments”. The approximation is **not very good** (some might say very bad…), it gets worse the larger the values are. But the approximation is also a monotonic, slowly increasing function, which is good enough for my use case.

1 2 3 |
public static double log(double x) { return 6 * (x - 1) / (x + 1 + 4 * (Math.sqrt(x))); } |

This approximation is **11.7 times** faster than `Math.log()`.

# Fast Power Calculation

Equiped with these optimized functions, it is possible to do several other optimizations. For example you can replace

1 |
Math.pow(a, b) |

with

1 |
Math.exp(b * Math.log(a)) |

And then use the approximation functions for a highly optimized pow calculation. You can even combine the calculations and simplify it into this:

1 2 3 4 |
public static double pow(double a, double b) { final long tmp = (long) (9076650 * (a - 1) / (a + 1 + 4 * (Math.sqrt(a))) * b + 1072632447); return Double.longBitsToDouble(tmp << 32); } |

This is **8.7 times** faster than the `Math.pow(a, b)`.

# Accuracy

The above functions are very inaccurate, especially the log calculation. So before you use this code you have to test it if the approximation is good enough for you!

Have fun

19 Comments on "Optimized Exponential Functions for Java"

Here are some benchmarks from a Pentium IV, doing 20 million calculations. On this machine I get an even better performance than stated above. I use Sun’s JRE 1.5.0_08.

6.233 sec, Math.log(val)

0.531 sec, 6*(x-1)/ (x + 1 + 4*(Math.sqrt(x)))

5.920 sec, Math.exp()

1.108 sec, exp optimized with IEEE 754 trick

15.967 sec, Math.pow(a, b)

11.014 sec, e^(b * log(a))

7.607 sec, e^(b * log(a)) + IEEE 754 trick

2.109 sec, e^(b * log(a)) + IEEE 754 trick + LOG approximation

1.827 sec, simplified everything

[…] I have updated the code for the Math.pow() approximation, now it is 11 times faster on my Pentium IV. Read it this. […]

Thanks for this. Always good to get more performance tweaking out of Java. I use Processing for game dev in Java, and even with it’s use of Jikes, it could still use a boost.

Dr.E

http://www.turingshop.com/reports/01Java/

[…] I have already written about approximations of e^x, log(x) and pow(a, b) in my post Optimized Exponential Functions for Java. Now I have more . In particular, the pow() function is now even faster, simpler, and more accurate. Without further ado, I proudly give you the brand new approximation: […]

@John

Hello,

i’m very interested by the accuracy optimization you suggested but i don’t undertand what is variable “a” in the expression :

error = (error – a * a) / 186;

Could you explain it please

Thanks

Michel Hummel

I think a is just mantissa. I’m guessing John started changing the variable name and forgot what he was doing.

The

expfunctions also seems to be working quite forJ2MEwhich is lacking J2ME.So if you’re writing say a game with projectiles traveling a certain trajectory it’s good enough 🙂

I confirm that those work with J2ME. Thanks to your math approximations I’ve been able to run Speex voice decoding on a mobile with a decent performance 🙂

glad that it’s working 🙂

This post was really helpful. Thanks!

One thing to point out is that the exp() approximation is only valid for inputs of within the rough bounds of -700 to 700 (Schraudolph, 99).

Hi I tested the method for calculating x^n and this is not accurate for the powers of order 10 also. 🙁 . Disappointed

Have a look at my followup posts http://martin.ankerl.com/2007/10/04/optimized-pow-approximation-for-java-and-c-c/

and for a much more precise but slower version (but not as fast):

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

Schraudolph’s exponential function article is available at http://nic.schraudolph.org/pubs/Schraudolph99.pdf

Thanks, I have updated the link

PS: Just noticed that you also had the idea to use the inverse of my exp() approximation to get a fast logarithm, then combine them for the power function. If you do the same with the improved better_exp() version and its inverse, you get a power function that is still very fast but a lot more accurate. Best regards, nic

Hi Nic, thanks for your comments, and for your paper! I will give definitely give this a try, and write an updated blog post with the results.