Pow() vs. exp() performance
javascript, performance
Solution
Yes, `exp` will be faster than `pow` in general.
The `exp` and `log` functions will be optimized for the target platform; many techniques can be used such as Pade approximation, linear or binary reduction followed by approximation, etc.
The `pow` function will generally be implemented as `exp(log(a) * b)` as you say, so it is obviously slower than `exp` alone. There are many special cases for `pow` such as negative exponents, integral exponents, exponents equal to 1/2 or 1/3, etc. These will slow down `pow` even further in the general case because these tests are expensive.
See this SO question on `pow`.
Problem
I was wondering if `exp()` is faster than more general `pow()`. I run fast benchmark on JsPerf http://jsperf.com/pow-vs-exp and it shown interesting results for me. ``` Math.exp(logBase * exponent); // fastest Math.exp(Math.log(base) * exponent); // middle Math.pow(base, exponent); // slowest ``` I know that results will heavily vary on architecture and language but I am also interested in theoretical point of view. Is `pow(a, b)` implemented as `exp(log(a) * b)` or is there some more clever way how co compute power "directly" (in C++, C# or JavaScript). Are there CPU instructions for exp, log or pow on some architectures? As far as I know, both `exp()` and `log()` are computed using some Taylor series and are pretty expensive to compute. This makes me believe that for constant base of power, this code ``` double logBase = log(123.456); for (int i = 0; i < 1024; ++i) { exp(logBase * 654.321); } ``` is better than this ``` for (int i = 0; i < 1024; ++i) { pow(123.456, 654.321); } ``` Is that correct assumption?