## Algorithm for finding the smallest power of two that's greater or equal to a given value

By : Boyan
Source: Stackoverflow.com
Question!

I need to find the smallest power of two that's greater or equal to a given value. So far, I have this:

``````int value = 3221; // 3221 is just an example, could be any number
int result = 1;

while (result < value) result <<= 1;
``````

It works fine, but feels kind of naive. Is there a better algorithm for that problem?

EDIT. There were some nice Assembler suggestions, so I'm adding those tags to the question.

By : Boyan

How about a recursive template version to generate a compile constant:

``````template<uint32_t A, uint8_t B = 16>
struct Pow2RoundDown { enum{ value = Pow2RoundDown<(A | (A >> B)), B/2>::value }; };
template<uint32_t A>
struct Pow2RoundDown<A, 1> { enum{ value = (A | (A >> 1)) - ((A | (A >> 1)) >> 1) }; };

template<uint32_t A, uint8_t B = 16>
struct Pow2RoundUp { enum{ value = Pow2RoundUp<((B == 16 ? (A-1) : A) | ((B == 16 ? (A-1) : A) >> B)), B/2>::value }; };
template<uint32_t A >
struct Pow2RoundUp<A, 1> { enum{ value = ((A | (A >> 1)) + 1) }; };
``````

Can be used like so:

``````Pow2RoundDown<3221>::value, Pow2RoundUp<3221>::value
``````

pow ( 2 , ceil( log2(value) );

log2(value) = log(value) / log(2);

By : Sorana

Here's a template version of the bit shifting technique.

``````template<typename T> T next_power2(T value)
{
--value;
for(size_t i = 1; i < sizeof(T) * CHAR_BIT; i*=2)
value |= value >> i;
return value+1;
}
``````

Since the loop only uses constants it gets flattened by the compiler. (I checked) The function is also future proof.

Here's one that uses __builtin_clz. (Also future proof)

``````template<typename T> T next_power2(T value)
{
return 1 << ((sizeof(T) * CHAR_BIT) - __builtin_clz(value-1));
}
``````
By : Zacrath