int iResidue = sizeof(array) / sizeof(array[0]);
for(; iResidue; iBits++)
{
    iResidue >>= 1;
    iBits++;
}

VD>int iResidue = sizeof(array) / sizeof(array[0]);
VD>for(; iResidue; iBits++)
VD>{
VD>    iResidue >>= 1;
VD>    iBits++;
VD>}
VD>

template<unsigned n>
struct NBits
{
  enum { value = NBits<(n >> 1)>::value + 1 };
};

template<>
struct NBits<0>
{
  enum { value = 0 };
};

unsigned iBits = NBits<sizeof(array) / sizeof(array[0])>::value;

ПК>> template<unsigned n>
ПК>> struct NBits
ПК>> {
ПК>>  enum { value = NBits<(n >> 1)>::value + 1 };
ПК>> };

ПК>> template<>
ПК>> struct NBits<0>
ПК>> {
ПК>>  enum { value = 0 };
ПК>> };

ПК>> unsigned iBits = NBits<sizeof(array) / sizeof(array[0])>::value;
ПК>>

NBits<13>::value = NBits<(13 >> 1)>::value + 1
                 = NBits<6>::value         + 1
                 = NBits<(6 >> 1)>::value  + 1 + 1
                 = NBits<3>::value         + 1 + 1
                 = NBits<(3 >> 1)>::value  + 1 + 1 + 1
                 = NBits<1>::value         + 1 + 1 + 1
                 = NBits<(1 >> 1)>::value  + 1 + 1 + 1 + 1
                 = NBits<0>::value         + 1 + 1 + 1 + 1
                 = 0                       + 1 + 1 + 1 + 1
                 = 4;

floor(log2(n)) + 1;

exp(b) = 1<<(b)
mid(l,u) = (l+u)/2
grow(u) = u*2

bits(v) =
  v == 0
    ? 0
    : bits(v,0,1)

bits(v,l,u) =
  exp(u+1) <= v
    ? bits(v,u+1,grow(u))
    :
  u == l
    ? u
    :
  exp(mid(l,u)+1) < v
    ? bits(v,mid(l,u)+1,u)
    : bits(v,l,mid(l,u))

v = (1<<19)+1

bits() =
bits(0,1) =
bits(2,4) =
bits(5,8) =
bits(9,16) =
bits(17,32) =
bits(17,24) =
bits(17,20) =
bits(18,20) =
bits(19,20)

VD>Боюсь, в виду простоты вычислений в моем случае будет быстрее прогнать тупой цикл (вычисления то полевые). К тому же мне скорость если честно в данном случае не актульна. В программе производится 12 расчетов. Просто зачела неспрпведливость. Я понимаю, что вычисление ностантное (все параметры константы), а компилятор собака генерирует цикл (по кройней мере в менеджед-режиме).

#define _BIT(v,n) ((v) < (1<<(n))) ? (n) :

#define _BIT_4(v,n) _BIT(v,n) _BIT(v,n+1) _BIT(v,n+2) _BIT(v,n+3)
#define _BIT_8(v,n) _BIT_4(v,n) _BIT_4(v,n+4)
#define _BIT_16(v,n) _BIT_8(v,n) _BIT_8(v,n+8)
#define _BIT_32(v,n) _BIT_16(v,n) _BIT_16(v,n+16)

#define BIT(v) ( _BIT_32(v,0) 32 )

template<unsigned v> struct Bit
{
  enum { n = BIT(v) };
};

inline unsigned bit(unsigned v)
{
  return BIT(v);
}