C ++ 2的最大功效<= n

Question

How do I calculate the largest power of two <= some number n?

Right now I am using floor(log(n)/log(2)+.05) but it doesn't seem to be reliable for all n. Is there anything a little cleaner / not at the mercy of rounding errors?

Answer 1

I assume that the number is unsigned. You can use the knowledge of the binary representation.

That number will be the number with 1 at same MSB position and with all zero.

Following loop will help you.

do {
    y = x;
    x = x&(x-1);
}while(x);
return y;

where x is the original number and the y is the result.

Branch free code is given below.

unsigned flp2(unsigned x) {
  x = x| (x>>1);
  x = x| (x>>2);
  x = x| (x>>4);
  x = x| (x>>8);
  x = x| (x>>16);
return x - (x>>1);
}

or (counting on loop unrolling, which all modern compilers can do)

unsigned log2(unsigned x)
{
  for (int i = 0; i < std::numeric_limits<unsigned>::digits; i*=2)
     x |= (x>>i);
  return x - (x>>1);
}

Source: Hacker's Delight.

Answer 2

I'm not entirely sure which integral type you're targeting, so at the behest of trying to cover them all...

#include <iostream>
#include <cmath>

template<typename T>
typename std::enable_if<std::is_integral<T>::value,T>::type fn(T N)
{
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    return T(1) << static_cast<T>(std::floor(std::log2(N)));
}

int main()
{
    std::cout << fn(4095) << std::endl;
    std::cout << fn(4096) << std::endl;
    std::cout << fn(4097) << std::endl;
    std::cout << fn(281474976710655) << std::endl;
    std::cout << fn(281474976710656) << std::endl;
    std::cout << fn(281474976710657) << std::endl;
    return 0;
}

Output

typename std::enable_if<std::is_integral<T>::value, T>::type fn(T) [T = int]
2048
typename std::enable_if<std::is_integral<T>::value, T>::type fn(T) [T = int]
4096
typename std::enable_if<std::is_integral<T>::value, T>::type fn(T) [T = int]
4096
typename std::enable_if<std::is_integral<T>::value, T>::type fn(T) [T = long]
140737488355328
typename std::enable_if<std::is_integral<T>::value, T>::type fn(T) [T = long]
281474976710656
typename std::enable_if<std::is_integral<T>::value, T>::type fn(T) [T = long]
281474976710656

Answer 3

In binary (assuming you have an integral type) the largest power of 2 is the Most Significant Bit

There are several ways to calculate this efficiently

the most efficent is to use a built-in that uses machine code that can execute in one cycle

the least efficient is to loop through removing the lowest bit

Here is one I like if you can't use built-ins:

unsigned int v;  // 32-bit value to find the log2 of 
const unsigned int b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
const unsigned int S[] = {1, 2, 4, 8, 16};
int i;

register unsigned int r = 0; // result of log2(v) will go here
for (i = 4; i >= 0; i--) // unroll for speed...
{
  if (v & b[i])
  {
    v >>= S[i];
    r |= S[i];
  } 
}

you can find more like this at: http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogLookup

Answer 4

This test worked for 32 bit signed int where best is assigned the closest power of 2 to the candidate value, x in the domain of 4 to ~2 billion:

for (int x = 4; x < (1<<31)-1; x++)
{
    int best = (int)(log((double)x)/log(2.0));

    int test = (int)pow((double)2, best);

    if (test > x || (test*2 <= x && test*2 > 0)) // test*2 < 0 when very large
        break; // fail
}