Issue #20163 has been updated by jhawthorn (John Hawthorn). I tried finding uses in the wild via gem-codesearch. I only looked for `to_s(2).count("1")` which is a pretty inefficient way to `bit_count`, so this would miss any gems which used another technique (a loop or some bit twiddling) to count bits. Still it found a few use cases: **CIDR/netmask** Very common to do some variation of `IPAddr.new(mask).to_i.to_s(2).count("1")` to get the prefix length of the netmask. Done by: sequel, facter, inspec-core, vagrant, and many others Another case (in stdlib!) is `IPAddr#prefix` which uses a shift loop. If `bit_count` is accepted we should change [the loop in `IPAddr#prefix` to use it](https://github.com/ruby/ipaddr/blob/master/lib/ipaddr.rb#L464-L480). **Hamming distance** For example [dhash-vips.rb](https://github.com/nakilon/dhash-vips/blob/master/lib/dhash-vips.rb) doing `to_s(2).count("1")` to get hamming distance for perceptual similarity Also: simhash2, chromaprint, edits, dhash, dhasher, and others Also found in [unicode_plot](https://github.com/red-data-tools/unicode_plot.rb/blob/4c313e47449d894d055cc...) using a different pattern: `(i ^ k).digits(2).sum` **Parity bit** For example in https://github.com/larskanis/pkcs11 `n.to_s(2).count("1").odd?` **sigstore-ruby** I only found sigstore Ruby doing this, something involving proof verification in a Merkle tree (?). It requires both bit_length (which already exists) and bit_count (being proposed here). `(log_index >> inner).to_s(2).count("1")` https://github.com/sigstore/sigstore-ruby/blob/26ffbe0c1d6e16614fb9cd8b2ed40... Note: I believe this was ported from go which has a popcount (`bits.OnesCount64`) method. ---------------------------------------- Feature #20163: Introduce #bit_count method on Integer https://bugs.ruby-lang.org/issues/20163#change-117911 * Author: garrison (Garrison Jensen) * Status: Open ---------------------------------------- This feature request is to implement a method called #bit_count on Integer that returns the number of ones in the binary representation of the absolute value of the integer. ``` n = 19 n.bit_count #=> 3 (-n).bit_count #=> 3 ``` This is often useful when you use an integer as a bitmask and want to count how many bits are set. This would be equivalent to ``` n.to_s(2).count("1") ``` However, this can be outperformed by ``` def bit_count(n) count = 0 while n > 0 n &= n - 1 # Flip the least significant 1 bit to 0 count += 1 end count end ``` I think this would be a useful addition because it would fit alongside the other bit-related methods defined on integer: `#bit_length,` `#allbits?`, `#anybits?`, `#nobits?`. Also, when working with bitmasks, a minor upgrade to performance often results in a significant improvement. Similar methods from other languages: https://docs.python.org/3/library/stdtypes.html#int.bit_count https://doc.rust-lang.org/std/primitive.i32.html#method.count_ones -- https://bugs.ruby-lang.org/