I ran them on an Intel Core Duo processor T2050, 1.60 GHz. But that’s only part of the difference. I didn’t mention that my loop that called each function 2^32 times also included a verification that the result was correct (seems kind of recursive, doesn’t it?). I really shouldn’t have left the checks in after I verified the algorithms, so I repeated the runs without them and updated the tables above. The algorithms still perform in the same relative order.

As an aside, I also re-ran your “table method” algorithm against #7 without short-circuiting the while loops (so counted all 1 bits). Your table algorithm did indeed perform better in that case.

So I tried it on my machine (Mac w/ 2.16 GHz Intel Cor 2 Duo, and gcc 4.0.1 (Apple Inc. build 5465, using only default options).

I also added a modified lookup function where the lookup array was a global. I repeated the three cases (the first two literally cut-and-pasted from above) 10 times each, and got…

#7: 152 seconds
lookup table w/ local array: 105 s
lookup table w/ global array: 80 s

So, one could conclude that
a) chip and compiler can make a BIG difference
b) you need a faster machine!

I coded your idea, but in the spirit of how I coded #7 (quitting once the bit count exceeds 1):

int isPowerOfTwo (unsigned int x)
{
 unsigned int numberOfOneBits = 0;
 unsigned int oneBits[16] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};

 while(x && numberOfOneBits < =1)
   {
    numberOfOneBits += oneBits[x & 0xF];
    x >>= 4; /* Examine next 4 bits */
   }

 return (numberOfOneBits == 1); /* 'True' if only one 1 bit */
}

This ran in 16 minutes, 38 seconds 13 minutes, 1 second, making it slower than #7.

The algorithms with the table lookups seem good in principle, but are among the slowest. Maybe they’d compare better for 64-bit integers? (Of course humans may no longer inhabit the planet when those runs finish )

int bitpop[16] = { 0, 1, 1, 2 … 2, 3, 3, 4 };

Shift and mask by 8 and index into a 256-element array fir more speed (and memory).

Offsetting the slowness of counting ones is you get back more information than just whether or not a value is a power of two.