Быстрый подсчет количества бит

inline unsigned __int8 BitCount16( unsigned __int16 k )
{
   static unsigned __int8 mas[0x10000];
   static bool init = InitMas( mas );
   return mas[ k ];
}
 
template<>
inline unsigned __int8 BitCountImpl<__int32>( int *k )
{
   return BitCount16( *k >> 16 ) + BitCount16( *k & 0xFFFF );
}

uint8_t num_of_bits32(uint32_t _arg)
{
    _arg = (_arg & 0x55555555L) + ((_arg >> 1) & 0x55555555L);
    _arg = (_arg & 0x33333333L) + ((_arg >> 2) & 0x33333333L);
    _arg = (_arg + (_arg >> 4)) & 0x0F0F0F0FL;
    _arg = _arg + (_arg >> 8);
 
    return (uint8_t)(_arg + (_arg >> 16)) & 0x3F;
}

int fncSumm(unsigned int n)
{
int summ=0;
for(int i=0;i<sizeof(int)*8;i++)
{
int k=(n>>i)&0x01;
summ+=k;
}
return summ;
}

int fncSumm(unsigned int n)
{
int summ=0;
while(n)
{
summ+=n&0x01;
n/=2;
}
return summ;
}

int arr[16]={0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
 
int fncSumm(unsigned int n)
{
int summ=0;
while(n)
{
summ+=arr[n&0x0F];
n/=16;
}
return summ;
}

int arr[256];
void initArr()
{
  for(int i=0;i<256;i++)
   {
    int j=i;
    int summ=0;
    while(j)
    {
       summ+=n&jx01;
       j/=2;
    }
   arr[i]=summ;
  }
 
}
.........................
int fncSumm(unsigned int n)
{
int summ=0;
 while(n)
  {
   summ+=arr[n&0xFF];
   n/=256;
  }
 return summ;
}

int * arr;
void initArr()
{
 arr=new[65536]
 for(int i=0;i<65536;i++)
   {
    int j=i;
    int summ=0;
    while(j)
    {
       summ+=n&jx01;
       j/=2;
    }
   arr[i]=summ;
  }
 
}
.........................
int fncSumm(unsigned int n)
{
int summ=0;
summ+=arr[n&0xFFFF];
summ+=arr[(n>>16)&0xFFFF];
 return summ;
}

static bool init = InitMas( mas );

// предвычисленная в compile-time таблица числа единичных битов в байте
_int8 numBits[256] = { 0, 1, 1, 2, 1... };
 
template<>
inline unsigned __int8 BitCountImpl<__int32>( int *k )
{
   union {
      _int8 b0, b1, b2, b3;
      int a;
   } x;
   x.a = *k;
   return numBits[x.b0] + numBits[x.b1] + numBits[x.b2] + numBits[x.b3];
}

template<int N>
class BitMap
{   
public:
   BitMap()
   {
      Clear();
   }
   inline void Clear()
   {
      ZeroMemory( myMap, N * sizeof(__int32) );
   }
   inline bool GetBit( int n )
   {
      if( ( 1 << ( n % BITS_COUNT_INT ) ) & myMap[ n / BITS_COUNT_INT ] )
         return true;
      else
         return false;
   }
   inline void SetBit( int n )
   {
      myMap[ n / BITS_COUNT_INT ] |=  1 << ( n % BITS_COUNT_INT );
   }
   inline void ClearBit( int n )
   {
      myMap[ n / BITS_COUNT_INT ] &= ~( 1 << ( n % BITS_COUNT_INT ) );
   }
   int BitCount()
   {
      static unsigned __int8 mas[0x10000];
      static bool init = InitMas( mas );
      int res = 0;
      for( int i = 0; i < 11; ++i )
         res += mas[ (unsigned __int16)(myMap[i] >> 16) ] + mas[ (unsigned __int16)(myMap[i] & 0xFFFF) ];
      return res;
   }
   BitMap<N>& operator&=( const BitMap<N>& other )
   {
      for( int i = 0; i < N; ++i )
         myMap[i] &= other.myMap[i];
      return *this;
   }
   BitMap<N>& operator|=( const BitMap<N>& other )
   {
      for( int i = 0; i < N; ++i )
         myMap[i] |= other.myMap[i];
      return *this;
   }
private:
   static bool InitMas( unsigned __int8 *mas )
   {
      for( int i = 0; i < 0x10000; ++i )
      {
         unsigned __int8 count = 0;
         for( int tmp = i; tmp > 0; tmp = tmp / 2 )
         {
            if( tmp % 2 )
               ++count;
         }
         mas[i] = count;
      }
      return true;
   }
   __int32 myMap[N];
};