bit_counter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5bc1b5aaafc6fa30829b05e4968696aad08cf8a0
+  data.tar.gz: fb66250600e1af2c144b2295ee18936d4fde64b4
+SHA512:
+  metadata.gz: 6ed9f143cb926c71d5ae1ffda8d52a8aa72f30c41d266ee1c7fe23ed5ecc144c04a413fad34dcdfd11dd9811456fcca893176a029426ba385bc10b06ff6ed552
+  data.tar.gz: 9cb5f2ce80ccbcb7250cf75413bf814908e32390794a0cd548268e63359f1c090470ba703e6f498843ccf03e90bffc4fb371141d4dfda65141193647d036c97e

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/vendor/
+/ext/bit_counter/Makefile

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.6
+  - 2.2.4
+  - 2.3.0
+  - jruby-9.0.4.0
+  - rbx-3.27
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bit_counter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jkr2255
+
+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,100 @@
+# BitCounter
+
+Counting bits (popcount, Hamming weight) in integer, made faster.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bit_counter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bit_counter
+
+## Usage
+
+Module `BitCounter` appears after `require 'bit_counter'`.
+
+`BitCounter.count(num)` returns bit count of `num`. (`num` must be `Integer` (`Fixnum` or `Bignum`); otherwise raises `TypeError`)
+
+`BitCounter.count_fixnum(num)` and `BitCounter.count_bignum(num)` are provided, but directly using these are not recommended.
+
+To use `Integer#bit_count`, `require 'bit_counter/core_ext'`. (This feature is not default behavior)
+
+### for negative numbers
+Theoretically, Ruby treats negative integers as if *infinite* 1-bits are leaded (`printf '%x', -1` gives `..f` ),
+so counting 1 bits for negative numbers is meaningless.
+
+In this implementation, `bit_count` for negative number counts *0* bits and negates the result. (distinguishing with positive version) Same in Ruby:
+```rb
+return -bit_count(~num) if num < 0
+```
+
+Note that both `bit_count(0)` and `bit_count(-1)` still return 0.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Implementations
+
+### JRuby
+Java offers `Long.bitCount`, so simply calling this for `Fixnum`.
+
+JRuby uses [`java.lang.BigInteger`](https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html) for Ruby's `Bignum`, which also has `bitCount()` method.
+
+### CRuby & Rubinius
+In C extensions, `Bignum` is converted to array of `long`, and bit is counted using loops.
+Bit counting of `long` is done by using `POPCNT` instruction, if available.
+
+### Limitations
+This gem is mainly developed on x64 GCC environment, so in other environments it may not work or be slow.
+
+Pull requests for other environments are welcome.
+
+## Benchmark
+Compared to `num.to_s(2).count('1')` (popular method for popcount in CRuby), this gem is 5x - 20x faster.
+
+```
+# for fixnum
+                 user     system      total        real
+String       7.770000   0.000000   7.770000 (  7.771210)
+Arithmetic   4.950000   0.000000   4.950000 (  4.953082)
+Loop         9.860000   0.000000   9.860000 (  9.863400)
+Gem          0.610000   0.000000   0.610000 (  0.612627)
+
+# for bignum
+for 280736 bits, 1000 times
+                 user     system      total        real
+String       1.470000   0.030000   1.500000 (  1.491823)
+Pack         8.810000   0.000000   8.810000 (  8.823835)
+Gem          0.040000   0.000000   0.040000 (  0.032927)
+
+for 80 bits, 1000000 times
+                 user     system      total        real
+String       0.820000   0.000000   0.820000 (  0.827302)
+Pack         3.860000   0.000000   3.860000 (  3.869715)
+Gem          0.160000   0.000000   0.160000 (  0.150728)
+
+```
+
+(Done in Core i3 (with POPCNT instruction), Linux x64, Ruby 2.3.0)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jkr2255/bit_counter.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+if RUBY_PLATFORM =~ /java/
+  task :default => [:spec]
+else
+  require "rake/extensiontask"
+
+  task :build => :compile
+
+  Rake::ExtensionTask.new("bit_counter") do |ext|
+    ext.lib_dir = "lib/bit_counter"
+  end
+
+  task :default => [:clobber, :compile, :spec]
+end

data/benchmark/bignum.rb

@@ -0,0 +1,65 @@
+require 'bit_counter'
+require 'benchmark'
+
+def count_string(num)
+  return -count_string(~num) if num < 0
+  num.to_s(2).count '1'
+end
+
+$table = 128.times.map { |i| BitCounter.count(i) }
+
+def count_from_pack(num)
+  return -count_string(~num) if num < 0
+  [num].pack('w').chars.reduce(0) { |cnt, c| cnt + $table[c.ord & 0x7f] }
+end
+
+
+value = 7**100000
+count = 1_000
+
+if value.respond_to?(:bit_length)
+  puts "for #{value.bit_length} bits, #{count} times"
+end
+
+Benchmark.bm 10 do |r|
+  r.report "String" do
+    count.times do
+      count_string(value)
+    end
+  end
+  r.report "Pack" do
+    count.times do
+      count_from_pack(value)
+    end
+  end
+  r.report "C" do
+    count.times do
+      BitCounter.count_bignum(value)
+    end
+  end
+end
+
+value = 2**80 - 6
+count = 1_000_000
+
+if value.respond_to?(:bit_length)
+  puts "for #{value.bit_length} bits, #{count} times"
+end
+
+Benchmark.bm 10 do |r|
+  r.report "String" do
+    count.times do
+      count_string(value)
+    end
+  end
+  r.report "Pack" do
+    count.times do
+      count_from_pack(value)
+    end
+  end
+  r.report "C" do
+    count.times do
+      BitCounter.count_bignum(value)
+    end
+  end
+end

data/benchmark/fixnum.rb

@@ -0,0 +1,55 @@
+require 'bit_counter'
+require 'benchmark'
+
+def count_string(num)
+  return -count_string(~num) if num < 0
+  num.to_s(2).count '1'
+end
+
+def count_arithmetic_32(x)
+  return -count_string(~x) if x < 0
+  m1 = 0x55555555
+  m2 = 0x33333333
+  m4 = 0x0f0f0f0f
+  x -= (x >> 1) & m1
+  x = (x & m2) + ((x >> 2) & m2)
+  x = (x + (x >> 4)) & m4
+  x += x >> 8
+  (x + (x >> 16)) & 0x3f
+end
+
+def count_bit_loop(x)
+  return -count_string(~x) if x < 0
+  ret = 0
+  while x > 0
+    ret += 1
+    x &= x - 1
+  end
+  ret
+end
+
+value = 0x3EDC_BA98
+count = 10_000_000
+
+Benchmark.bm 10 do |r|
+  r.report "String" do
+    count.times do
+      count_string(value)
+    end
+  end
+  r.report "Arithmetic" do
+    count.times do
+      count_arithmetic_32(value)
+    end
+  end
+  r.report "Loop" do
+    count.times do
+      count_bit_loop(value)
+    end
+  end
+  r.report "Native" do
+    count.times do
+      BitCounter.count_fixnum(value)
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bit_counter"
+
+# 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

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/bit_counter.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bit_counter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bit_counter"
+  spec.version       = BitCounter::VERSION
+  spec.authors       = ["Jkr2255"]
+  spec.email         = ["magnesium.oxide.play@gmail.com"]
+
+  spec.summary       = %q{Calculate bit count (popcount, Hamming weight) faster in many environments.}
+  spec.homepage      = "https://github.com/jkr2255/bit_counter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+if RUBY_PLATFORM =~ /java/
+  spec.platform      = 'java'
+else
+  spec.extensions    = ["ext/bit_counter/extconf.rb"]
+end
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/ext/bit_counter/big_pack.h

@@ -0,0 +1,14 @@
+#ifndef BIG_PACK_H
+#define BIG_PACK_H 1
+
+#ifdef HAVE_RB_BIG_PACK
+#define BIG_PACK(val, ptr, cnt) rb_big_pack(val, ptr, cnt)
+#elif defined(HAVE_RB_INTEGER_PACK)
+#define BIG_PACK(val, ptr, cnt) rb_integer_pack(val, ptr, cnt, sizeof(long), 0, \
+            INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER| \
+            INTEGER_PACK_2COMP)
+#else
+#error This Ruby is not supported.
+#endif
+
+#endif

data/ext/bit_counter/bignum_in_ulong.h

@@ -0,0 +1,18 @@
+#ifndef BIGNUM_IN_ULONG_H
+#define BIGNUM_IN_ULONG_H 1
+
+#ifdef HAVE_RB_ABSINT_NUMWORDS
+#define BIGNUM_IN_ULONG(v) rb_absint_numwords(v, sizeof(unsigned long), NULL)
+#else
+static size_t BIGNUM_IN_ULONG(VALUE v){
+    static ID size_id = 0;
+    VALUE ret_val;
+    if(!size_id){
+        size_id = rb_intern("size");
+    }
+    ret_val = rb_funcall(v, size_id, 0);
+    return (NUM2SIZET(ret_val) + sizeof(unsigned long) - 1) / sizeof(unsigned long);
+}
+#endif
+
+#endif

data/ext/bit_counter/bit_counter.c

@@ -0,0 +1,172 @@
+#include "bit_counter.h"
+
+VALUE rb_mBitCounter;
+
+static VALUE bitcounter_cimpl_count_fixnum(VALUE self, VALUE num){
+    long l_num = NUM2LONG(num);
+    int val = POPCOUNTL(l_num);
+    if(l_num < 0) val -= sizeof(long) * CHAR_BIT;
+    return INT2FIX(val);
+}
+
+#ifdef HAVE___GET_CPUID
+static VALUE bitcounter_cimpl_cpu_popcnt_p(VALUE self){
+    unsigned int eax, ebx, ecx = 0, edx;
+    __get_cpuid(1, &eax, &ebx, &ecx, &edx);
+    return (ecx & bit_POPCNT) ? Qtrue : Qfalse;
+}
+#else
+static VALUE bitcounter_cimpl_cpu_popcnt_p(VALUE self){
+    return Qfalse;
+}
+#endif
+
+#ifdef HAVE_POPCNT_GCC_ASM
+static VALUE bitcounter_cimpl_count_fixnum_asm(VALUE self, VALUE num){
+    long l_num = NUM2LONG(num);
+    long val;
+    __asm__ volatile ("POPCNT %1, %0;": "=r"(val): "r"(l_num) : );
+    if(l_num < 0) val -= sizeof(long) * CHAR_BIT;
+    return INT2FIX(val);
+}
+#define ASM_POPCOUNT 1
+#else
+static VALUE bitcounter_cimpl_count_fixnum_asm(VALUE self, VALUE num){
+    /* dummy function for C compiler, never called from Ruby */
+    return Qnil;
+}
+#define ASM_POPCOUNT 0
+#endif
+
+/*  for bignum */
+static VALUE bitcounter_cimpl_count_bignum(VALUE self, VALUE num){
+    int negated = 0;
+    unsigned long * packed;
+    VALUE abs_num;
+    size_t words, i;
+    LONG_LONG ret = 0;
+    if(FIXNUM_P(num)){
+        return bitcounter_cimpl_count_fixnum(self, num);
+    }
+    Check_Type(num, T_BIGNUM);
+    if(RBIGNUM_NEGATIVE_P(num)){
+        negated = 1;
+        abs_num = BIG_NEG(num);
+    }else{
+        abs_num = num;
+    }
+    words = BIGNUM_IN_ULONG(abs_num);
+    if(words < ALLOCA_THRESHOLD){
+        packed = ALLOCA_N(unsigned long, words);
+    }else{
+        packed = ALLOC_N(unsigned long, words);
+    }
+    BIG_PACK(abs_num, packed, words);
+    for(i = 0; i < words; ++i){
+        ret += POPCOUNTL(packed[i]);
+    }
+    if(negated) ret = -ret;
+    if(words >= ALLOCA_THRESHOLD) xfree(packed);
+    return LL2NUM(ret);
+}
+
+#if defined(HAVE_POPCNT_LL_GCC_ASM) && (SIZEOF_LONG_LONG == SIZEOF_LONG * 2)
+/* for Windows */
+static VALUE bitcounter_cimpl_count_bignum_asm(VALUE self, VALUE num){
+    int negated = 0;
+    unsigned long * packed;
+    unsigned long long * ull_packed;
+    unsigned long long ull_i, ull_o = 0;
+    VALUE abs_num;
+    size_t words, i, ull_words;
+    LONG_LONG ret = 0;
+    if(FIXNUM_P(num)){
+        return bitcounter_cimpl_count_fixnum(self, num);
+    }
+    Check_Type(num, T_BIGNUM);
+    if(RBIGNUM_NEGATIVE_P(num)){
+        negated = 1;
+        abs_num = BIG_NEG(num);
+    }else{
+        abs_num = num;
+    }
+    words = BIGNUM_IN_ULONG(abs_num);
+    if(words < ALLOCA_THRESHOLD){
+        packed = ALLOCA_N(unsigned long, words);
+    }else{
+        packed = ALLOC_N(unsigned long, words);
+    }
+    BIG_PACK(abs_num, packed, words);
+    ull_words = words / 2;
+    ull_packed = (unsigned long long *) packed;
+    for(i = 0; i < ull_words; ++i){
+        ull_i = ull_packed[i];
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ull_o): "r"(ull_i) : );
+        ret += ull_o;
+    }
+    if(words & 1) ret += POPCOUNTL(packed[words-1]);
+    if(negated) ret = -ret;
+    if(words >= ALLOCA_THRESHOLD) xfree(packed);
+    return LL2NUM(ret);
+}
+
+#elif defined(HAVE_POPCNT_GCC_ASM)
+static VALUE bitcounter_cimpl_count_bignum_asm(VALUE self, VALUE num){
+    int negated = 0;
+    unsigned long * packed;
+    unsigned long ul_i, ul_o = 0;
+    VALUE abs_num;
+    size_t words, i;
+    LONG_LONG ret = 0;
+    if(FIXNUM_P(num)){
+        return bitcounter_cimpl_count_fixnum(self, num);
+    }
+    Check_Type(num, T_BIGNUM);
+    if(RBIGNUM_NEGATIVE_P(num)){
+        negated = 1;
+        abs_num = BIG_NEG(num);
+    }else{
+        abs_num = num;
+    }
+    words = BIGNUM_IN_ULONG(abs_num);
+    if(words < ALLOCA_THRESHOLD){
+        packed = ALLOCA_N(unsigned long, words);
+    }else{
+        packed = ALLOC_N(unsigned long, words);
+    }
+    BIG_PACK(abs_num, packed, words);
+    for(i = 0; i < words; ++i){
+        ul_i = packed[i];
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ul_o): "r"(ul_i) : );
+        ret += ul_o;
+    }
+    if(negated) ret = -ret;
+    if(words >= ALLOCA_THRESHOLD) xfree(packed);
+    return LL2NUM(ret);
+}
+#else
+static VALUE bitcounter_cimpl_count_bignum_asm(VALUE self, VALUE num){
+    /* dummy function for C compiler, never called from Ruby */
+    return Qnil;
+}
+
+#endif
+
+
+void
+Init_bit_counter(void)
+{
+  VALUE rb_mCImpl;
+  VALUE have_cpu_popcnt;
+  rb_mBitCounter = rb_define_module("BitCounter");
+  rb_mCImpl = rb_define_module_under(rb_mBitCounter, "CImpl");
+  have_cpu_popcnt = bitcounter_cimpl_cpu_popcnt_p(rb_mCImpl);
+  rb_define_module_function(rb_mCImpl, "cpu_popcnt?", bitcounter_cimpl_cpu_popcnt_p, 0);
+  if(ASM_POPCOUNT && have_cpu_popcnt){
+      rb_define_method(rb_mCImpl, "count_fixnum", bitcounter_cimpl_count_fixnum_asm, 1);
+      rb_define_method(rb_mCImpl, "count_bignum", bitcounter_cimpl_count_bignum_asm, 1);
+  }else{
+      rb_define_method(rb_mCImpl, "count_fixnum", bitcounter_cimpl_count_fixnum, 1);
+      rb_define_method(rb_mCImpl, "count_bignum", bitcounter_cimpl_count_bignum, 1);
+  }
+}

data/ext/bit_counter/bit_counter.h

@@ -0,0 +1,24 @@
+#ifndef BIT_COUNTER_H
+#define BIT_COUNTER_H 1
+
+#include "ruby.h"
+
+#include <limits.h>
+
+#ifdef HAVE_CPUID_H
+#include <cpuid.h>
+#endif
+
+#include "popcountl.h"
+#include "bignum_in_ulong.h"
+#include "big_pack.h"
+
+#ifdef HAVE_RB_BIG_XOR
+#define BIG_NEG(val) rb_big_xor(val, INT2FIX(-1))
+#else
+#define BIG_NEG(val) rb_funcall(val, rb_intern("~"), 0)
+#endif
+
+#define ALLOCA_THRESHOLD (8192 / sizeof(unsigned long))
+
+#endif /* BIT_COUNTER_H */

data/ext/bit_counter/extconf.rb

@@ -0,0 +1,48 @@
+require "mkmf"
+
+have_func('__builtin_popcountl(1)')
+have_func('rb_absint_numwords')
+have_func('rb_big_pack')
+have_func('rb_integer_pack')
+have_func('rb_big_xor')
+have_header('cpuid.h') && have_func('__get_cpuid', 'cpuid.h')
+check_sizeof('long')
+check_sizeof('long long')
+message 'checking for usability of POPCNT in GCC-style inline assembler... '
+gcc_popcount = try_compile <<SRC
+int main(){
+  long a=1, b=2;
+  __asm__ volatile ("POPCNT %1, %0;"
+                    :"=r"(b)
+                    :"r"(a)
+                    :
+                   );
+  return 0;
+}
+SRC
+if gcc_popcount
+  message "yes\n"
+  $defs << '-DHAVE_POPCNT_GCC_ASM'
+  message 'checking for usability of POPCNT for long long in GCC-style inline assembler... '
+  gcc_ll_popcount = try_compile <<SRC
+int main(){
+  long long a=1, b=2;
+  __asm__ volatile ("POPCNT %1, %0;"
+                    :"=r"(b)
+                    :"r"(a)
+                    :
+                   );
+  return 0;
+}
+SRC
+  if gcc_ll_popcount
+    message "yes\n"
+    $defs << '-DHAVE_POPCNT_LL_GCC_ASM'
+  else
+    message "no\n"
+  end
+else
+  message "no\n"
+end
+
+create_makefile("bit_counter/bit_counter")

data/ext/bit_counter/popcountl.h

@@ -0,0 +1,48 @@
+/* header for long popcount (without CPU-native) */
+
+#ifndef POPCOUNTL_H
+#define POPCOUNTL_H 1
+
+#ifdef HAVE___BUILTIN_POPCOUNTL
+#define POPCOUNTL(x) __builtin_popcountl(x)
+#elif SIZEOF_LONG == 8
+static inline int POPCOUNTL(unsigned long x){
+    x = ((x & 0xaaaaaaaaaaaaaaaaUL) >> 1)
+      +  (x & 0x5555555555555555UL);
+    x = ((x & 0xccccccccccccccccUL) >> 2)
+      +  (x & 0x3333333333333333UL);
+    x = ((x & 0xf0f0f0f0f0f0f0f0UL) >> 4)
+      +  (x & 0x0f0f0f0f0f0f0f0fUL);
+    x = ((x & 0xff00ff00ff00ff00UL) >> 8)
+      +  (x & 0x00ff00ff00ff00ffUL);
+    x = ((x & 0xffff0000ffff0000UL) >> 16)
+      +  (x & 0x0000ffff0000ffffUL);
+    x = ((x & 0xffffffff00000000UL) >> 32)
+      +  (x & 0x00000000ffffffffUL);
+    return (int) x;
+}
+#elif SIZEOF_LONG == 4
+static inline int POPCOUNTL(unsigned long x){
+    x = ((x & 0xaaaaaaaaUL) >> 1)
+      +  (x & 0x55555555UL);
+    x = ((x & 0xccccccccUL) >> 2)
+      +  (x & 0x33333333UL);
+    x = ((x & 0xf0f0f0f0UL) >> 4)
+      +  (x & 0x0f0f0f0fUL);
+    x = ((x & 0xff00ff00UL) >> 8)
+      +  (x & 0x00ff00ffUL);
+    x = ((x & 0xffff0000UL) >> 16)
+      +  (x & 0x0000ffffUL);
+    return (int) x;
+}
+#else
+#error Unsupported architecture
+#endif
+
+#if SIZEOF_LONG == 8
+#define BER_MASK 0x7f7f7f7f7f7f7f7fUL
+#elif SIZEOF_LONG == 4
+#define BER_MASK 0x7f7f7f7fUL
+#endif
+
+#endif

data/lib/bit_counter/core_ext.rb

@@ -0,0 +1,21 @@
+require 'bit_counter'
+
+# :nodoc:
+class Fixnum
+  #
+  # calling BitCounter.#count with self
+  #
+  def bit_count
+    BitCounter.count_fixnum(self)
+  end
+end
+
+# :nodoc:
+class Bignum
+  #
+  # calling BitCounter.#count with self
+  #
+  def bit_count
+    BitCounter.count_bignum(self)
+  end
+end

data/lib/bit_counter/cruby.rb

@@ -0,0 +1,8 @@
+#
+# module for bit counting
+#
+module BitCounter
+
+  extend CImpl
+
+end

data/lib/bit_counter/jruby.rb

@@ -0,0 +1,28 @@
+require 'java'
+
+#
+# module for bit counting
+#
+module BitCounter
+
+  #
+  # module for Java-specific codes of BitCounter.
+  # @note not intended for direct use.
+  #
+  module JavaImpl
+    def count_fixnum(num)
+      raise TypeError unless num.is_a?(::Fixnum)
+      count = Java::JavaLang::Long.bitCount(num)
+      num >= 0 ? count : count - 64
+    end
+
+    def count_bignum(num)
+      raise TypeError unless num.is_a?(::Bignum)
+      count = num.to_java.bitCount
+      num >= 0 ? count : -count
+    end
+  end
+
+  extend JavaImpl
+
+end

data/lib/bit_counter/version.rb

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

data/lib/bit_counter.rb

@@ -0,0 +1,34 @@
+require "bit_counter/version"
+
+if RUBY_PLATFORM =~ /java/
+  require 'bit_counter/jruby'
+else
+  require "bit_counter/bit_counter"
+  require 'bit_counter/cruby'
+end
+
+#
+# module for bit counting
+#
+module BitCounter
+
+  module_function
+
+  #
+  # counts bits in Integer.
+  # @return [Integer] num the number of bits.
+  #   if positive number is given, count 1 bits.
+  #   if negative number is given, count 0 bits and -(count) is returned.
+  # @raise [TypeError] when non-Integer was given.
+  #
+  def count(num)
+    case num
+    when Fixnum
+      count_fixnum(num)
+    when Bignum
+      count_bignum(num)
+    else
+      raise TypeError
+    end
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: bit_counter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jkr2255
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- magnesium.oxide.play@gmail.com
+executables: []
+extensions:
+- ext/bit_counter/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/bignum.rb
+- benchmark/fixnum.rb
+- bin/console
+- bin/setup
+- bit_counter.gemspec
+- ext/bit_counter/big_pack.h
+- ext/bit_counter/bignum_in_ulong.h
+- ext/bit_counter/bit_counter.c
+- ext/bit_counter/bit_counter.h
+- ext/bit_counter/extconf.rb
+- ext/bit_counter/popcountl.h
+- lib/bit_counter.rb
+- lib/bit_counter/core_ext.rb
+- lib/bit_counter/cruby.rb
+- lib/bit_counter/jruby.rb
+- lib/bit_counter/version.rb
+homepage: https://github.com/jkr2255/bit_counter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Calculate bit count (popcount, Hamming weight) faster in many environments.
+test_files: []