bitcount 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00044fb7d9178864fb0805b0ca619c0e52aca752f2300114cc31b49535bb8c50
+  data.tar.gz: 6edadce559de31f3620cb84c15129462fb4e7657d48dd7350a4ec822467ead89
+SHA512:
+  metadata.gz: 71ffad74ea1e03ced6f59c74086f2682c6f034f339bfcc1f12f27c308f46e6485902221902255a75a07c230cdc485ddc1bc4101ac201cdfe7a727e44c2a8087f
+  data.tar.gz: f351d06612197586fdd763ef2a843d581176342e8091025f5107a31f4e4fae42c1cf39e677843f806e9900785dceda7f15cf6ddaabff0925658a758ab0007e80

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/ext/Makefile
+/lib/bitcount_ext
+Gemfile.lock
+*.gem
+
+# rspec failure tracking
+.rspec_status
+/nbproject

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,32 @@
+---
+language: ruby
+cache: bundler
+
+script: bundle exec rake test
+
+rvm:
+  - 2.3
+  - 2.7
+  - jruby-9.2.9.0
+  - truffleruby
+  - ruby-head
+  - jruby-head
+  
+matrix:
+  include:
+    - name: benchmark-ruby
+      rvm: 2.7
+      script:
+        - bundle exec rake compile:bitcount_ext
+        - bundle exec ruby -S benchmark-driver benchmark/bitcount.yml
+    - name: benchmark-jruby
+      rvm: jruby-head
+      script:
+        - bundle exec rake compile:bitcount_ext
+        - bundle exec ruby -S benchmark-driver benchmark/bitcount.yml
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: truffleruby
+    - name: benchmark-ruby
+    - name: benchmark-jruby

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. For info on how to format all future additions to this file please reference [Keep A Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [0.1.1] - Unreleased
+
+## [0.1.0] - 2020-02-09
+### Added
+- init

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in bitcount.gemspec
+gemspec
+
+gem "rake"
+gem "rspec"
+gem "benchmark_driver"
+gem "rake-compiler"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Pavel Rosický
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Bitcount
+
+__builtin_popcount - Returns the number of 1 bits
+```ruby
+         1 => 00000000000000000000000000000001 => 1
+2147483648 => 10000000000000000000000000000000 => 1
+2147500033 => 10000000000000000100000000000001 => 3
+```
+
+__builtin_clz - Returns leading zeros
+
+```ruby
+         1 => 00000000000000000000000000000001 => 31
+2147483648 => 10000000000000000000000000000000 => 0
+2147500033 => 10000000000000000100000000000001 => 0
+```
+
+__builtin_ctz - Returns trailing zeros
+
+```ruby
+         1 => 00000000000000000000000000000001 => 0
+2147483648 => 10000000000000000000000000000000 => 31
+2147500033 => 10000000000000000100000000000001 => 0
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bitcount'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install bitcount
+
+## Usage
+```ruby
+require 'bitcount'
+Bitcount.popcount(1)
+=> 1
+
+Bitcount.nlz(1)
+=> 63
+
+Bitcount.ntz(1)
+=> 0
+```
+
+or
+
+```ruby
+require 'bitcount/integer'
+1.popcount
+=> 1
+
+1.nlz
+=> 63
+
+1.ntz
+=> 0
+```
+
+you can specify a different layout, but if the layout doesn't match your platform a slower version will be used
+```ruby
+1.nlz(32)
+=> 31
+
+Bitcount::Native.layout_size
+=> 64
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ahorek/bitcount.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'rake/extensiontask'
+
+gem_spec = Gem::Specification.load("bitcount.gemspec")
+
+module FixRequiredRubyVersion
+  def required_ruby_version=(*); end
+end
+Gem::Specification.send(:prepend, FixRequiredRubyVersion)
+
+Rake::ExtensionTask.new('bitcount_ext', gem_spec) do |ext|
+  ext.name = 'bitcount_ext'
+  ext.ext_dir = 'ext'
+  ext.lib_dir = 'lib/bitcount_ext'
+end
+
+CLEAN.include 'lib/bitcount_ext/bitcount_ext.{so,bundle,dll}',
+              'ext/*.{o,so,bundle,dll}', 'ext/Makefile', 'tmp'
+
+RSpec::Core::RakeTask.new(:spec)
+task test: 'compile:bitcount_ext' do
+  Rake::Task['spec'].invoke
+end
+task default: :test

data/benchmark/bitcount.yml

@@ -0,0 +1,8 @@
+prelude: require 'bitcount'
+benchmark:
+  native_popcount: Bitcount::Native.popcount(122)
+  native_nlz: Bitcount::Native.nlz(122)
+  native_ntz: Bitcount::Native.ntz(122)
+  ruby_popcount: Bitcount::Pure.popcount(122)
+  ruby_nlz: Bitcount::Pure.nlz(122)
+  ruby_ntz: Bitcount::Pure.ntz(122)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bitcount"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bitcount.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/bitcount/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bitcount"
+  spec.version       = Bitcount::VERSION
+  spec.authors       = ["Pavel Rosický"]
+  spec.email         = ["pdahorek@seznam.cz"]
+
+  spec.summary       = %q{Bitcount helper methods.}
+  spec.homepage      = "https://github.com/ahorek/bitcount"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+
+  spec.platform      = Gem::Platform::RUBY
+  spec.extensions    = ["ext/extconf.rb"]
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
+  end
+  spec.require_paths = ["lib", "lib/bitcount"]
+
+  spec.add_runtime_dependency 'ffi'
+end

data/ext/bitcount_ext/include/bitcount_ext.h

@@ -0,0 +1,28 @@
+#include <limits.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#ifndef GCC_VERSION_SINCE
+# if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__)
+#  define GCC_VERSION_SINCE(major, minor, patchlevel) \
+    ((__GNUC__ > (major)) ||  \
+     ((__GNUC__ == (major) && \
+       ((__GNUC_MINOR__ > (minor)) || \
+        (__GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))))
+# else
+#  define GCC_VERSION_SINCE(major, minor, patchlevel) 0
+# endif
+#endif
+
+#ifndef __has_builtin
+  #if GCC_VERSION_SINCE(4, 8, 0)
+    # define __has_builtin(x) 1
+  # else
+    # define __has_builtin(x) 0
+  #endif
+#endif
+
+size_t ext_layout();
+size_t ext_popcount(size_t x);
+size_t ext_nlz(size_t x);
+size_t ext_ntz(size_t x);

data/ext/bitcount_ext/src/bitcount_ext.c

@@ -0,0 +1,46 @@
+#include "bitcount_ext.h"
+#include "helpers.c"
+
+size_t ext_layout()
+{
+    return sizeof(size_t) * CHAR_BIT;
+}
+
+size_t ext_popcount(size_t x)
+{
+    if (sizeof(size_t) * CHAR_BIT == 64) {
+        return ext_popcount64((uint64_t)x);
+    }
+    else if (sizeof(size_t) * CHAR_BIT == 32) {
+        return ext_popcount32((uint32_t)x);
+    }
+    else {
+        __builtin_unreachable();
+    }
+}
+
+size_t ext_nlz(size_t x)
+{
+    if (sizeof(size_t) * CHAR_BIT == 32) {
+        return nlz_int32((uint32_t)x);
+    }
+    else if (sizeof(size_t) * CHAR_BIT == 64) {
+        return nlz_int64((uint64_t)x);
+    }
+    else {
+        __builtin_unreachable();
+    }
+}
+
+size_t ext_ntz(size_t x)
+{
+    if (sizeof(size_t) * CHAR_BIT == 64) {
+        return ntz_int64((uint64_t)x);
+    }
+    else if (sizeof(size_t) * CHAR_BIT == 32) {
+        return ntz_int32((uint32_t)x);
+    }
+    else {
+        __builtin_unreachable();
+    }
+}

data/ext/bitcount_ext/src/helpers.c

@@ -0,0 +1,114 @@
+unsigned int ext_popcount64(uint64_t x)
+{
+#if __has_builtin(__builtin_popcount)
+    if (sizeof(long) * CHAR_BIT == 64) {
+        return (unsigned int)__builtin_popcountl((unsigned long)x);
+    }
+    else if (sizeof(long long) * CHAR_BIT == 64) {
+        return (unsigned int)__builtin_popcountll((unsigned long long)x);
+    }
+    else {
+        __builtin_unreachable();
+    }
+#else
+    x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
+    x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
+    x = (x & 0x0707070707070707) + (x >> 4 & 0x0707070707070707);
+    x = (x & 0x001f001f001f001f) + (x >> 8 & 0x001f001f001f001f);
+    x = (x & 0x0000003f0000003f) + (x >>16 & 0x0000003f0000003f);
+    x = (x & 0x000000000000007f) + (x >>32 & 0x000000000000007f);
+    return (unsigned int)x;
+
+#endif
+}
+
+unsigned int ext_popcount32(uint32_t x)
+{
+#if __has_builtin(__builtin_popcount)
+    return (unsigned int)__builtin_popcount(x);
+
+#else
+    x = (x & 0x55555555) + (x >> 1 & 0x55555555);
+    x = (x & 0x33333333) + (x >> 2 & 0x33333333);
+    x = (x & 0x0f0f0f0f) + (x >> 4 & 0x0f0f0f0f);
+    x = (x & 0x001f001f) + (x >> 8 & 0x001f001f);
+    x = (x & 0x0000003f) + (x >>16 & 0x0000003f);
+    return (unsigned int)x;
+#endif
+}
+
+unsigned int nlz_int32(uint32_t x)
+{
+#if __has_builtin(__builtin_clz)
+    return (unsigned int)__builtin_clz(x);
+
+#else
+    uint32_t y;
+    unsigned n = 32;
+    y = x >> 16; if (y) {n -= 16; x = y;}
+    y = x >>  8; if (y) {n -=  8; x = y;}
+    y = x >>  4; if (y) {n -=  4; x = y;}
+    y = x >>  2; if (y) {n -=  2; x = y;}
+    y = x >>  1; if (y) {return n - 2;}
+    return (unsigned int)(n - x);
+#endif
+}
+
+unsigned int nlz_int64(uint64_t x)
+{
+#if __has_builtin(__builtin_clzl)
+    if (x == 0) {
+        return 64;
+    }
+    else if (sizeof(long) * CHAR_BIT == 64) {
+        return (unsigned int)__builtin_clzl((unsigned long)x);
+    }
+    else if (sizeof(long long) * CHAR_BIT == 64) {
+        return (unsigned int)__builtin_clzll((unsigned long long)x);
+    }
+    else {
+        __builtin_unreachable();
+    }
+
+#else
+    uint64_t y;
+    unsigned int n = 64;
+    y = x >> 32; if (y) {n -= 32; x = y;}
+    y = x >> 16; if (y) {n -= 16; x = y;}
+    y = x >>  8; if (y) {n -=  8; x = y;}
+    y = x >>  4; if (y) {n -=  4; x = y;}
+    y = x >>  2; if (y) {n -=  2; x = y;}
+    y = x >>  1; if (y) {return n - 2;}
+    return (unsigned int)(n - x);
+
+#endif
+}
+
+unsigned int ntz_int32(uint32_t x)
+{
+#if __has_builtin(__builtin_ctz)
+    return (unsigned)__builtin_ctz(x);
+#else
+    return ext_popcount32((~x) & (x-1));
+#endif
+}
+
+unsigned int ntz_int64(uint64_t x)
+{
+#if __has_builtin(__builtin_ctzl)
+    if (x == 0) {
+        return 64;
+    }
+    else if (sizeof(long) * CHAR_BIT == 64) {
+        return (unsigned)__builtin_ctzl((unsigned long)x);
+    }
+    else if (sizeof(long long) * CHAR_BIT == 64) {
+        return (unsigned)__builtin_ctzll((unsigned long long)x);
+    }
+    else {
+        __builtin_unreachable();
+    }
+#else
+    return ext_popcount64((~x) & (x-1));
+#endif
+}

data/ext/depend

@@ -0,0 +1 @@
+$(OBJS): $(HDRS)

data/ext/extconf.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+$CFLAGS << ' -std=c99'
+
+if enable_config('march-tune-native', false)
+  $CFLAGS << ' -march=native -mtune=native'
+end
+
+if enable_config('lto', false)
+  $CFLAGS << ' -flto'
+  $LDFLAGS << ' -flto'
+end
+
+$warnflags = ''
+$CFLAGS.gsub!(/[\s+](-ansi|-std=[^\s]+)/, '')
+
+dir_config 'bitcount_ext'
+
+$INCFLAGS << " -I$(srcdir)/bitcount_ext/include"
+$VPATH << "$(srcdir)/bitcount_ext/src"
+Dir.chdir(__dir__) do
+  $VPATH += Dir['bitcount_ext/src/*/'].map { |p| "$(srcdir)/#{p}" }
+  $srcs = Dir['bitcount_ext/src/bitcount_ext.c']
+end
+
+$LIBRUBYARG = nil
+MakeMakefile::LINK_SO << "\nstrip -x $@"
+
+MakeMakefile.send(:remove_const, :EXPORT_PREFIX)
+MakeMakefile::EXPORT_PREFIX = nil
+
+create_makefile 'bitcount/bitcount_ext'

data/lib/bitcount.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "bitcount/version"
+require "bitcount/pure"
+begin
+  require "bitcount/native"
+rescue LoadError
+  puts 'bitcount_ext not loaded'
+end
+
+module Bitcount
+  class << self
+    def popcount(n)
+      type_error unless n.is_a?(Integer)
+      negative_error if n < 0
+      implementation.popcount(n)
+    end
+    
+    def ntz(n, size = nil)
+      type_error unless n.is_a?(Integer)
+      negative_error if n < 0
+      implementation.ntz(n, size)
+    end
+    
+    def nlz(n, size = nil)
+      type_error unless n.is_a?(Integer)
+      negative_error if n < 0
+      implementation.nlz(n, size)
+    end
+    
+    private
+    
+    def implementation
+      defined?(:"Bitcount::Native") ? Bitcount::Native : Bitcount::Pure
+    end
+    
+    def type_error
+      raise TypeError, 'not a number'
+    end
+
+    def negative_error
+      raise ArgumentError, 'number is negative'
+    end
+  end
+end

data/lib/bitcount/integer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bitcount"
+
+class Integer
+  def popcount
+    Bitcount.popcount(self)
+  end
+
+  def ntz(size = nil)
+    Bitcount.ntz(self, size)
+  end
+
+  def nlz(size = nil)
+    Bitcount.nlz(self, size)
+  end
+end

data/lib/bitcount/native.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Bitcount
+  module Native
+    class << self
+      extend FFI::Library
+
+      dl_ext = RbConfig::MAKEFILE_CONFIG['DLEXT']
+      begin
+        ffi_lib File.expand_path("../bitcount_ext/bitcount_ext.#{dl_ext}", __dir__)
+      rescue LoadError
+        ffi_lib File.expand_path("bitcount_ext.#{dl_ext}", "#{__dir__}/../../ext")
+      end
+
+      attach_function :ext_layout, [], :size_t
+      attach_function :ext_popcount, [:size_t], :size_t
+      attach_function :ext_nlz, [:size_t], :size_t
+      attach_function :ext_ntz, [:size_t], :size_t
+
+      def layout_size
+        ext_layout
+      rescue
+        64
+      end
+
+      def popcount(n)
+        return Bitcount::Pure.popcount(n) if defined?(JRUBY_VERSION) && n > max_value
+        begin
+          ext_popcount(n)
+        rescue
+          Bitcount::Pure.popcount(n)
+        end
+      end
+
+      def ntz(n, size = nil)
+        size ||= layout_size
+        return Bitcount::Pure.ntz(n, size) if layout_size != size || (defined?(JRUBY_VERSION) && n > max_value)
+        begin
+          ext_ntz(n)
+        rescue
+          Bitcount::Pure.ntz(n, size)
+        end
+      end
+
+      def nlz(n, size = nil)
+        size ||= layout_size
+        return Bitcount::Pure.nlz(n, size) if layout_size != size || (defined?(JRUBY_VERSION) && n > max_value)
+        begin
+          ext_nlz(n)
+        rescue
+          Bitcount::Pure.nlz(n, size)
+        end
+      end
+
+      private
+
+      def max_value
+        (2 ** layout_size) - 1
+      end
+
+      def layout_error
+        raise RangeError, 'number is too large'
+      end
+    end
+  end
+end

data/lib/bitcount/pure.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Bitcount
+  module Pure
+    class << self
+      def layout_size
+        64
+      end
+
+      def popcount(n)
+        n.to_s(2).count("1")
+      end
+
+      def ntz(n, size = nil)
+        size ||= layout_size
+        count = 0
+        bits = n.to_s(2)
+        layout_error if bits.size > size
+        bits.rjust(size, "0").reverse.each_char do |b|
+          (b == '0') ? count += 1 : break
+        end
+        count
+      end
+
+      def nlz(n, size = nil)
+        size ||= layout_size
+        count = 0
+        bits = n.to_s(2)
+        layout_error if bits.size > size
+        bits.rjust(size, "0").each_char do |b|
+          (b == '0') ? count += 1 : break
+        end
+        count
+      end
+
+      private
+
+      def layout_error
+        raise RangeError, 'number is too large'
+      end
+    end
+  end
+end

data/lib/bitcount/version.rb

@@ -0,0 +1,3 @@
+module Bitcount
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: bitcount
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pavel Rosický
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- pdahorek@seznam.cz
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/bitcount.yml
+- bin/console
+- bin/setup
+- bitcount.gemspec
+- ext/bitcount_ext/include/bitcount_ext.h
+- ext/bitcount_ext/src/bitcount_ext.c
+- ext/bitcount_ext/src/helpers.c
+- ext/depend
+- ext/extconf.rb
+- lib/bitcount.rb
+- lib/bitcount/integer.rb
+- lib/bitcount/native.rb
+- lib/bitcount/pure.rb
+- lib/bitcount/version.rb
+homepage: https://github.com/ahorek/bitcount
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ahorek/bitcount
+  source_code_uri: https://github.com/ahorek/bitcount
+  changelog_uri: https://github.com/ahorek/bitcount/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/bitcount
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Bitcount helper methods.
+test_files: []