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, popcount, sideways sum, or bit summation.
11101 | 4 | |
11101000 | 4 | |
00000000 | 0 | |
678012340567 | 10 |
The Hamming weight is named after Richard Hamming although he did not originate the notion. The Hamming weight of binary numbers was already used in 1899 by James W. L. Glaisher to give a formula for the number of odd binomial coefficients in a single row of Pascal's triangle. Irving S. Reed introduced a concept, equivalent to Hamming weight in the binary case, in 1954.
Hamming weight is used in several disciplines including information theory, coding theory, and cryptography. Examples of applications of the Hamming weight include:
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 A xor B.
The problem of how to implement it efficiently has been widely studied. A single operation for the calculation, or parallel operations on bit vectors are available on some processors. 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 | Count 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 | Count 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 | Count 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 | Count of 1s in entire 16-bit word |
Here, the operations are as in C programming language, so 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:
//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).int popcount64a(uint64_t x)
//This uses fewer arithmetic operations than any other known //implementation on machines with slow multiplication.//This algorithm uses 17 arithmetic operations.int popcount64b(uint64_t x)
//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.int popcount64c(uint64_t x)
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 described in 1960, 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.
If greater memory usage is allowed, 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.
Muła et al. have shown that a vectorized version of popcount64b can run faster than dedicated instructions (e.g., popcnt on x64 processors).
In error-correcting coding, the minimum Hamming weight, commonly referred to as the minimum weight wmin of a code is the weight of the lowest-weight non-zero code word. The weight w of a code word is the number of 1s in the word. For example, the word 11001010 has a weight of 4.
In a linear block code the minimum weight is also the minimum Hamming distance (dmin) and defines the error correction capability of the code. If wmin = n, then dmin = n and the code will correct up to dmin/2 errors.[1]
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. LLVM-GCC has included this function since version 1.5 in June 2005.
In the C++ Standard Library, the bit-array data structure bitset
has a count
method that counts the number of bits that are set. In C++20, a new header <bit>
was added, containing functions std::popcount
and std::has_single_bit
, taking arguments of unsigned integer types.
In Java, the growable bit-array data structure has a method that counts the number of bits that are set. In addition, there are and functions to count bits in primitive 32-bit and 64-bit integers, respectively. Also, the arbitrary-precision integer class also has a method that counts bits.
In Python, the int
type has a bit_count
method to count the number of bits set. This functionality was introduced in Python 3.10, released in October 2021.[2]
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).
MySQL version of SQL language provides BIT_COUNT
as a standard function.
Fortran 2008 has the standard, intrinsic, elemental function popcnt
returning the number of nonzero bits within an integer (or integer array).
Some programmable scientific pocket calculators feature special commands to calculate the number of set bits, e.g. #B
on the HP-16C and WP 43S, #BITS
or BITSUM
on HP-16C emulators, and nBITS
on the WP 34S.
FreePascal implements popcnt since version 3.0.
CXi
.POPC
instruction, but most implementations do not implement it, requiring it be emulated by the operating system.SADD
instruction since 1999. SADD a,b,c
counts all bits that are 1 in b and 0 in c and writes the result to a.CIX
).ONES
instruction to perform a 32-bit population count.POPCNT
instruction as part of the SSE4a extensions in 2007.POPCNT
instruction with the SSE4.2 instruction set extension, first available in a Nehalem-based Core i7 processor, released in November 2008.VCNT
instruction as part of the Advanced SIMD (NEON) extensions.CPOP
instruction as part of the Bit Manipulation (B) extension.