The Hamming weight of a string is the number of symbols that are different from the zero-symbol of the alphabet used. It is thus equivalent to the Hamming distance from the all-zero string of the same length. For the most typical case, a string of bits, this is the number of 1's in the string, or the digit sum of the binary representation of a given number and the ℓ₁ norm of a bit vector. In this binary case, it is also called the population count,[1]popcount, sideways sum,[2] or bit summation.[3]

In modular exponentiation by squaring, the number of modular multiplications required for an exponent e is log2e + weight(e). This is the reason that the public key value e used in RSA is typically chosen to be a number of low Hamming weight.

IrisCode lookups in biometric databases are typically implemented by calculating the Hamming distance to each stored record.

In computer chess programs using a bitboard representation, the Hamming weight of a bitboard gives the number of pieces of a given type remaining in the game, or the number of squares of the board controlled by one player's pieces, and is therefore an important contributing term to the value of a position.

Hamming weight can be used to efficiently compute find first set using the identity ffs(x) = pop(x ^ (~(-x))). This is useful on platforms such as SPARC that have hardware Hamming weight instructions but no hardware find first set instruction.[8][1]

The population count of a bitstring is often needed in cryptography and other applications. The Hamming distance of two words A and B can be calculated as the Hamming weight of AxorB.[1]

The problem of how to implement it efficiently has been widely studied. Some processors have a single command to calculate it (see below), and some have parallel operations on bit vectors. For processors lacking those features, the best solutions known are based on adding counts in a tree pattern. For example, to count the number of 1 bits in the 16-bit binary number a = 0110 1100 1011 1010, these operations can be done:

Expression

Binary

Decimal

Comment

a

01 10 11 00 10 11 10 10

The original number

b0 = (a >> 0) & 01 01 01 01 01 01 01 01

01 00 01 00 00 01 00 00

1,0,1,0,0,1,0,0

every other bit from a

b1 = (a >> 1) & 01 01 01 01 01 01 01 01

00 01 01 00 01 01 01 01

0,1,1,0,1,1,1,1

the remaining bits from a

c = b0 + b1

01 01 10 00 01 10 01 01

1,1,2,0,1,2,1,1

list giving # of 1s in each 2-bit slice of a

d0 = (c >> 0) & 0011 0011 0011 0011

0001 0000 0010 0001

1,0,2,1

every other count from c

d2 = (c >> 2) & 0011 0011 0011 0011

0001 0010 0001 0001

1,2,1,1

the remaining counts from c

e = d0 + d2

0010 0010 0011 0010

2,2,3,2

list giving # of 1s in each 4-bit slice of a

f0 = (e >> 0) & 00001111 00001111

00000010 00000010

2,2

every other count from e

f4 = (e >> 4) & 00001111 00001111

00000010 00000011

2,3

the remaining counts from e

g = f0 + f4

00000100 00000101

4,5

list giving # of 1s in each 8-bit slice of a

h0 = (g >> 0) & 0000000011111111

0000000000000101

5

every other count from g

h8 = (g >> 8) & 0000000011111111

0000000000000100

4

the remaining counts from g

i = h0 + h8

0000000000001001

9

the final answer of the 16-bit word

Here, the operations are as in C programming language, so X >> Y means to shift X right by Y bits, X & Y means the bitwise AND of X and Y, and + is ordinary addition. The best algorithms known for this problem are based on the concept illustrated above and are given here:[1]

//types and constants used in the functions below//uint64_t is an unsigned 64-bit integer variable type (defined in C99 version of C language)constuint64_tm1=0x5555555555555555;//binary: 0101...constuint64_tm2=0x3333333333333333;//binary: 00110011..constuint64_tm4=0x0f0f0f0f0f0f0f0f;//binary: 4 zeros, 4 ones ...constuint64_tm8=0x00ff00ff00ff00ff;//binary: 8 zeros, 8 ones ...constuint64_tm16=0x0000ffff0000ffff;//binary: 16 zeros, 16 ones ...constuint64_tm32=0x00000000ffffffff;//binary: 32 zeros, 32 onesconstuint64_thff=0xffffffffffffffff;//binary: all onesconstuint64_th01=0x0101010101010101;//the sum of 256 to the power of 0,1,2,3...//This is a naive implementation, shown for comparison,//and to help in understanding the better functions.//This algorithm uses 24 arithmetic operations (shift, add, and).intpopcount64a(uint64_tx){x=(x&m1)+((x>>1)&m1);//put count of each 2 bits into those 2 bits x=(x&m2)+((x>>2)&m2);//put count of each 4 bits into those 4 bits x=(x&m4)+((x>>4)&m4);//put count of each 8 bits into those 8 bits x=(x&m8)+((x>>8)&m8);//put count of each 16 bits into those 16 bits x=(x&m16)+((x>>16)&m16);//put count of each 32 bits into those 32 bits x=(x&m32)+((x>>32)&m32);//put count of each 64 bits into those 64 bits returnx;}//This uses fewer arithmetic operations than any other known //implementation on machines with slow multiplication.//This algorithm uses 17 arithmetic operations.intpopcount64b(uint64_tx){x-=(x>>1)&m1;//put count of each 2 bits into those 2 bitsx=(x&m2)+((x>>2)&m2);//put count of each 4 bits into those 4 bits x=(x+(x>>4))&m4;//put count of each 8 bits into those 8 bits x+=x>>8;//put count of each 16 bits into their lowest 8 bitsx+=x>>16;//put count of each 32 bits into their lowest 8 bitsx+=x>>32;//put count of each 64 bits into their lowest 8 bitsreturnx&0x7f;}//This uses fewer arithmetic operations than any other known //implementation on machines with fast multiplication.//This algorithm uses 12 arithmetic operations, one of which is a multiply.intpopcount64c(uint64_tx){x-=(x>>1)&m1;//put count of each 2 bits into those 2 bitsx=(x&m2)+((x>>2)&m2);//put count of each 4 bits into those 4 bits x=(x+(x>>4))&m4;//put count of each 8 bits into those 8 bits return(x*h01)>>56;//returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... }

The above implementations have the best worst-case behavior of any known algorithm. However, when a value is expected to have few nonzero bits, it may instead be more efficient to use algorithms that count these bits one at a time. As Wegner (1960) described,[10] the bitwise and of x with x − 1 differs from x only in zeroing out the least significant nonzero bit: subtracting 1 changes the rightmost string of 0s to 1s, and changes the rightmost 1 to a 0. If x originally had n bits that were 1, then after only n iterations of this operation, x will be reduced to zero. The following implementation is based on this principle.

//This is better when most bits in x are 0//This is algorithm works the same for all data sizes.//This algorithm uses 3 arithmetic operations and 1 comparison/branch per "1" bit in x.intpopcount64d(uint64_tx){intcount;for(count=0;x;count++)x&=x-1;returncount;}

If we are allowed greater memory usage, we can calculate the Hamming weight faster than the above methods. With unlimited memory, we could simply create a large lookup table of the Hamming weight of every 64 bit integer. If we can store a lookup table of the hamming function of every 16 bit integer, we can do the following to compute the Hamming weight of every 32 bit integer.

//Optionally, the wordbits[] table could be filled using this functionintpopcount32e_init(void){uint32_ti;uint16_tx;intcount;for(i=0;i<=0xFFFF;i++){x=i;for(count=0;x;count++)// borrowed from popcount64d() abovex&=x-1;wordbits[i]=count;}}

Muła et al. [11] have shown that a vectorized version of popcount64b can run faster than dedicated instructions (e.g., popcnt on ×64 processors).

Some C compilers provide intrinsic functions that provide bit counting facilities. For example, GCC (since version 3.4 in April 2004) includes a builtin function __builtin_popcount that will use a processor instruction if available or an efficient library implementation otherwise.[12]LLVM-GCC has included this function since version 1.5 in June 2005.[13]

In C++ STL, the bit-array data structure bitset has a count() method that counts the number of bits that are set.

In Common Lisp, the function logcount, given a non-negative integer, returns the number of 1 bits. (For negative integers it returns the number of 0 bits in 2's complement notation.) In either case the integer can be a BIGNUM.

Starting in GHC 7.4, the Haskell base package has a popCount function available on all types that are instances of the Bits class (available from the Data.Bits module).[14]

MySQL version of SQL language provides BIT_COUNT() as a standard function.[15]

Fortran 2008 has the standard, intrinsic, elemental function popcnt returning the number of nonzero bits within an integer (or integer array).[16]