C/C++ Math – Fast Implementation of pow() Function

c++gccmathnumeric

I m looking for a faster implementation or good a approximation of functions provided by cmath.

I need to speed up the following functions

pow(x,y)
exp(z*pow(x,y))

where z<0. x is from (-1.0,1.0) and y is from (0.0, 5.0)

Best Answer

Here are some approxmiations:

Optimized pow Approximation for Java and C / C++. This approximation is very inaccurate, you have to try for yourself if it is good enough.
Optimized Exponential Functions for Java. Quite good! I use it for a neural net.

If the above approximation for pow is not good enough, you can still try to replace it with exponential functions, depending on your machine and compiler this might be faster:

x^y = e^(y*ln(x))
And the result: e^(z * x^y) = e^(z * e^(y*ln(x)))

Another trick is when some parameters of the formula do not change often. So if e.g. x and y are mostly constant, you can precalculate x^y and reuse this.

Related Solutions

C – Most Efficient Way to Implement an Integer Based Power Function

Exponentiation by squaring.

int ipow(int base, int exp)
{
    int result = 1;
    for (;;)
    {
        if (exp & 1)
            result *= base;
        exp >>= 1;
        if (!exp)
            break;
        base *= base;
    }

    return result;
}

This is the standard method for doing modular exponentiation for huge numbers in asymmetric cryptography.

C – Replacing Slow pow() Function

Well, hold on now. The library isn't calling __slowpow() just to toy with you; it's calling __slowpow() because it believes the extra precision is necessary to give an accurate result for the values you're giving it (in this case, base very near 1, exponent of order 1). If you care about the accuracy of this computation, you should understand why that is and if it matters before trying to work around it. It might be the case that for (say) large negative F0 this whole thing can be safely rounded to 1; or it might not, depending on what's done with this value later. If you ever need 1.d0 minus this result, you're going to want that extra precision.

Best Answer

Related Solutions

C – Most Efficient Way to Implement an Integer Based Power Function

C – Replacing Slow pow() Function

Related Question