Tom=C3=A1s =C3=93 h=C3=89ilidhe wrote:

Would it not make sense for the standard library to have a pow funct=

that deals only with integer exponents?

Compilers do have specialized pow() functions when the exponent is
integer.

unsigned pow_int(unsigned const x,unsigned exp)
{
unsigned retval =3D 1;
while ( ; exp; --exp) retval *=3D x;
return retval;
}

That's *not* the fastest way of calculating pow(x, integer).

Jerry Coffin wrote:

I don't know of any processor that would let you implement pow in a
single instruction -- but Intel floating point includes instructions for
logarithm and inverse logarithm, which make pow pretty easy to
implement.

Actually it's not "pretty easy", as there's a twist.

pow(x, y) = pow(2, y*log2(x)), and the 387 happens to have both an
opcode for calculating y*log2(x), fyl2x, and one for calculating
pow(2, x)-1, f2xm1. The twist is, however, that with the latter x must
be inside the range from -1.0 to +1.0. This means that the x in the
original pow(x, y) cannot be used as it is with f2xm1, but it must be
split using the property 2^(a+b) = 2^a*2^b.

The complete asm code for calculating pow(x, y), assuming x and y have
already been loaded into the FPU, is something like (with reported clock
cycles for the pentium):

fyl2x ; 22-111
fld st ; 1
frndint ; 9-20
fsub st(1), st ; 3
fxch st(2) ; 0-1
f2xm1 ; 13-57
fld1 ; 2
fadd ; 3
fscale ; 20-31
fstp st(1) ; 1

I suppose the absolute best case scenario is a total of 74 clock
cycles, and the worst is 230 clock cycles, with possible stalls.

I suppose I overestimated the required clock cycles.