double powa(double x, double a)

which he says compute x^a for a close to 1.0.

The code is

double powa(double x, double a)
{
double lnx = log(x);
double am1 = a – 1;
double product = lnx * am1;

return (product + x * product^2 + x);
}

I at first thought he was using three terms of a Talor series about 1.0. However, it doesn’t seem to be that.

Where did this come from. BTW, I tested it and it does work, i.e. gives the same result as pow(x,a).

So if you’re writing say a game with projectiles traveling a certain trajectory it’s good enough

Could you explain it please

Thanks
Michel Hummel

You don’t need to do the addition as floating point, I have move the braces around…

public static double exp(double val) {
    final long tmp = (long) (1512775 * val) + (1072693248 - 60801);
    return Double.longBitsToDouble(tmp << 32);
}

Additionally if you analyse the error there is a correlation to the mantissa of the result, which you can then correct for. The error is approximately (mantissa – mantissa^2)/2.9. Doing this all as integer math in fixed point format you get.

public static double exp(double val) {
    final long tmp = (long) (1512775 * val) + 1072693248;
    final long mantissa = tmp & 0x000FFFFF;
    int error = mantissa >> 7;   // remove chance of overflow
    error = (error - a * a) / 186; // subtract mantissa^2 * 64
                                   // 64 / 186 = 1/2.90625
    return Double.longBitsToDouble((tmp - error) << 32);
}

PS hope this is valid Java, I converted from C.

The explain the shifting. The mantissa has 20 bits to the right of the decimal place. a is formed by shift right 7, leaving 13 bits to the right. When a is squared you double the number of decimal bits arriving at 26. Which is 20 bits times the scaling factor or 64 (6 bits). Now a squared matches error so the subtraction is valid.

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