bit_utils 0.1.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3a43f5b1fa5a368f668333525bfbe4e26c81936
+  data.tar.gz: 74a634a4e4d5f2ed55ad6f5d0885b4485520345f
+SHA512:
+  metadata.gz: 03ae269c996d32a8ab0577a285a47ea4a57118a30192ed8d234714d8cdec581b4332efe14da2ae69f11a5518fbbd03aebafb59f020bb36e89db371a5f67fd981
+  data.tar.gz: 78079e83d9f89c0a2c98443559368db1a3ecfc64088a76c3365f3d72889bc44871cd8b77be997cbc456ae9a8d32322a41d45e19ea4f12c23fabceb2c5a6a9a76

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.6
+  - 2.2.4
+  - 2.3.1
+  - jruby-1.7.20
+  - jruby-9.0.4.0
+  - jruby-9.1.0.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_utils.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,78 @@
+# BitUtils
+
+[![Build Status](https://travis-ci.org/jkr2255/bit_utils.svg?branch=master)](https://travis-ci.org/jkr2255/bit_utils)
+
+Utility methods for bit-wise operations of `Integer`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bit_utils'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bit_utils
+
+## Usage
+
+Module `BitUtils` appears after `require 'bit_utils'`.
+
+Currently `BitUtils` offers three functionalities.
+
+### `BitUtils.#popcount(num)`
+Returns popcount (Hamming weight) of the `num`; i.e. equal to `num.to_s(2).count('1')` for non-negative numbers.
+
+#### 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, `popcount` for negative number counts *0* bits and negates the result. (distinguishing with positive version) Same in Ruby:
+```rb
+return -popcount(~num) if num < 0
+```
+
+Note that both `popcount(0)` and `popcount(-1)` still return 0.
+
+### `BitUtils.#trailing_zeros(num)`
+Returns the number of 0 bits continuing from least significant bit. If `num == 0`, it returns -1.
+
+### `BitUtils.#each_bit(num, &block)`
+Iterate over 1-bit positions in `Integer`. If block is not given, it returns `Enumerator`.
+
+The yielding order is *unspecified*; may change by platform/version.
+
+If negative `num` is given, it raises `RangeError`
+
+### common to all functionalities
+All of the module functions raise `TypeError` unless the parameter is `Integer`.
+
+All module functions have `.#xxx_fixnum` and `.#xxx_bignum` (specific for `Fixnum` and `Bignum`), but these are not intended for direct use.
+
+
+## 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).
+
+### 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.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jkr2255/bit_utils.
+
+
+## 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_utils") do |ext|
+    ext.lib_dir = "lib/bit_utils"
+  end
+
+  task :default => [:clobber, :compile, :spec]
+end

data/benchmark/count.rb

@@ -0,0 +1,45 @@
+require 'bit_utils'
+require 'benchmark'
+
+puts 'Fixnum'
+value = 0x1234_5678
+times = 1_000_000
+Benchmark.bm 10 do |r|
+  r.report "Pure Ruby" do
+    times.times do
+      BitUtils::PureRuby.count_fixnum value
+    end
+  end
+  r.report "Optimized" do
+    times.times do
+      BitUtils.count value
+    end
+  end
+end
+puts
+
+patterns = [
+    {value: (2**128) - (2**32), repeat: 1_000_000, title: '128-bit Bignum' },
+    {value: (2**999) + (2**32), repeat: 100_000, title: '1000-bit Bignum' },
+]
+
+
+patterns.each do |h|
+  puts h[:title]
+  value = h[:value]
+  times =
+  Benchmark.bm 10 do |r|
+    r.report "Pure Ruby" do
+      h[:repeat].times do
+        BitUtils::PureRuby.count_bignum value
+      end
+    end
+    r.report "Optimized" do
+      h[:repeat].times do
+        BitUtils.count value
+      end
+    end
+  end
+  puts
+end
+

data/benchmark/each_bit.rb

@@ -0,0 +1,47 @@
+require 'bit_utils'
+require 'benchmark'
+
+puts 'Fixnum'
+value = 0x1F3C_0A27
+times = 1_000_000
+Benchmark.bm 10 do |r|
+  r.report "Pure Ruby" do
+    times.times do
+      BitUtils::PureRuby.each_bit_fixnum(value).to_a
+    end
+  end
+  r.report "Optimized" do
+    times.times do
+      BitUtils.each_bit(value).to_a
+    end
+  end
+end
+
+puts
+
+patterns = [
+    {value: (2**128) - (2**32), repeat: 100_000, title: '128-bit Bignum' },
+    {value: (2**999) + (2**32), repeat: 100_000, title: '1000-bit Bignum (sparse)' },
+    {value: (2**1000) - (2**40), repeat: 10_000, title: '1000-bit Bignum' },
+]
+
+
+patterns.each do |h|
+  puts h[:title]
+  value = h[:value]
+  times =
+  Benchmark.bm 10 do |r|
+    r.report "Pure Ruby" do
+      h[:repeat].times do
+        BitUtils::PureRuby.each_bit_bignum(value).to_a
+      end
+    end
+    r.report "Optimized" do
+      h[:repeat].times do
+        BitUtils.each_bit(value).to_a
+      end
+    end
+  end
+  puts
+end
+

data/benchmark/trailing_zeros.rb

@@ -0,0 +1,45 @@
+require 'bit_utils'
+require 'benchmark'
+
+puts 'Fixnum'
+value = 0x1000_0000
+times = 1_000_000
+Benchmark.bm 10 do |r|
+  r.report "Pure Ruby" do
+    times.times do
+      BitUtils::PureRuby.trailing_zeros_fixnum value
+    end
+  end
+  r.report "Optimized" do
+    times.times do
+      BitUtils.trailing_zeros value
+    end
+  end
+end
+puts
+
+patterns = [
+    {value: (2**128) - (2**32), repeat: 1_000_000, title: '128-bit Bignum' },
+    {value: (2**999) + (2**32), repeat: 100_000, title: '1000-bit Bignum' },
+]
+
+
+patterns.each do |h|
+  puts h[:title]
+  value = h[:value]
+  times =
+  Benchmark.bm 10 do |r|
+    r.report "Pure Ruby" do
+      h[:repeat].times do
+        BitUtils::PureRuby.trailing_zeros_bignum value
+      end
+    end
+    r.report "Optimized" do
+      h[:repeat].times do
+        BitUtils.trailing_zeros value
+      end
+    end
+  end
+  puts
+end
+

data/bin/console

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

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bit_utils/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bit_utils'
+  spec.version       = BitUtils::VERSION
+  spec.authors       = %w[Jkr2255]
+  spec.email         = %w[magnesium.oxide.play@gmail.com]
+
+  spec.summary       = 'Utility methods for manipulating bits within Integer.'
+  spec.homepage      = 'https://github.com/jkr2255/bit_utils'
+  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 = %w[lib]
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_dependency 'function_module', '>= 0.1.1'
+
+if RUBY_PLATFORM =~ /java/
+  spec.platform      = 'java'
+else
+  spec.extensions    = %w[ext/bit_utils/extconf.rb]
+  spec.add_dependency 'backports', '>= 3.6.6'
+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_utils/bit_utils.h

@@ -0,0 +1,10 @@
+#ifndef BIT_UTILS_H
+#define BIT_UTILS_H 1
+
+#include "ruby.h"
+#include "count.h"
+#include "trailing_zeros.h"
+#include "funcs.h"
+#include "each_bit.h"
+
+#endif /* BIT_UTILS_H */

data/ext/bit_utils/count.c

@@ -0,0 +1,178 @@
+#include "count.h"
+
+static VALUE bitutils_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_POPCNT_GCC_ASM
+static VALUE bitutils_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 LONG2FIX(val);
+}
+#define ASM_POPCOUNT 1
+#else
+static VALUE bitutils_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 bitutils_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 bitutils_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_GCC_ASM) && defined(HAVE_POPCNT_LL_GCC_ASM) && (SIZEOF_LONG_LONG == SIZEOF_LONG * 2)
+/* for Windows */
+union ull_punning{
+    unsigned long long ull;
+    unsigned long ul[2];
+};
+
+static VALUE bitutils_cimpl_count_bignum_asm(VALUE self, VALUE num){
+    int negated = 0;
+    unsigned long * packed;
+    union ull_punning * ull_packed;
+    unsigned long long ull_o = 0, ull_o2 = 0;
+    unsigned long long ull_i, ull_i2;
+    VALUE abs_num;
+    size_t words, i, ull_dwords;
+    LONG_LONG ret = 0, ret2 = 0;
+    if(FIXNUM_P(num)){
+        return bitutils_cimpl_count_fixnum_asm(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_dwords = words / 4;
+    ull_packed = (union ull_punning *) packed;
+    for(i = 0; i < ull_dwords * 2; i += 2){
+        ull_i = ull_packed[i].ull;
+        ull_i2 = ull_packed[i+1].ull;
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ull_o): "r"(ull_i) : );
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ull_o2): "r"(ull_i2) : );
+        ret += ull_o;
+        ret2 += ull_o2;
+    }
+    ret += ret2;
+    for(i *= 2; i < words; ++i){
+        unsigned long ul_out = 0;
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ul_out): "r"(packed[i]) : );
+        ret += ul_out;
+    }
+    if(negated) ret = -ret;
+    if(words >= ALLOCA_THRESHOLD) xfree(packed);
+    return LL2NUM(ret);
+}
+
+#elif defined(HAVE_POPCNT_GCC_ASM)
+static VALUE bitutils_cimpl_count_bignum_asm(VALUE self, VALUE num){
+    int negated = 0;
+    unsigned long * packed;
+    unsigned long ul_i, ul_o = 0;
+    unsigned long ul_i2, ul_o2 = 0;
+    VALUE abs_num;
+    size_t words, dwords, i;
+    LONG_LONG ret = 0, ret2 = 0;
+    if(FIXNUM_P(num)){
+        return bitutils_cimpl_count_fixnum_asm(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);
+    dwords = words / 2;
+    for(i = 0; i < dwords * 2; i += 2){
+        ul_i = packed[i];
+        ul_i2 = packed[i+1];
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ul_o): "r"(ul_i) : );
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ul_o2): "r"(ul_i2) : );
+        ret += ul_o;
+        ret2 += ul_o2;
+    }
+    ret += ret2;
+    if(words & 1){
+        __asm__ volatile ("POPCNT %1, %0;": "=r"(ul_o): "r"(packed[i]) : );
+        ret += ul_o;
+    }
+    if(negated) ret = -ret;
+    if(words >= ALLOCA_THRESHOLD) xfree(packed);
+    return LL2NUM(ret);
+}
+#else
+static VALUE bitutils_cimpl_count_bignum_asm(VALUE self, VALUE num){
+    /* dummy function for C compiler, never called from Ruby */
+    return Qnil;
+}
+
+#endif
+
+
+void register_count(VALUE mod){
+    VALUE have_cpu_popcnt;
+    have_cpu_popcnt = my_popcnt_p(mod);
+    if(ASM_POPCOUNT && have_cpu_popcnt){
+        rb_define_module_function(mod, "popcount_fixnum", bitutils_cimpl_count_fixnum_asm, 1);
+        rb_define_module_function(mod, "popcount_bignum", bitutils_cimpl_count_bignum_asm, 1);
+        rb_define_module_function(mod, "popcount", bitutils_cimpl_count_bignum_asm, 1);
+    }else{
+        rb_define_module_function(mod, "popcount_fixnum", bitutils_cimpl_count_fixnum, 1);
+        rb_define_module_function(mod, "popcount_bignum", bitutils_cimpl_count_bignum, 1);
+        rb_define_module_function(mod, "popcount", bitutils_cimpl_count_bignum, 1);
+    }
+}

data/ext/bit_utils/count.h

@@ -0,0 +1,24 @@
+#ifndef COUNT_H_INCLUDED
+#define COUNT_H_INCLUDED 1
+
+#include "ruby.h"
+#include "funcs.h"
+
+#ifdef HAVE___BUILTIN_POPCOUNTL
+#define POPCOUNTL(x) __builtin_popcountl(x)
+#else
+int my_popcountl(unsigned long x);
+#define POPCOUNTL(x) my_popcountl(x)
+#endif
+
+#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 (1024 / sizeof(unsigned long))
+
+void register_count(VALUE mod);
+
+#endif

data/ext/bit_utils/each_bit.c

@@ -0,0 +1,82 @@
+#include "each_bit.h"
+
+static const char * mes = "Negative value is not accepted";
+
+static VALUE bitutils_cimpl_each_bit_fixnum(VALUE self, VALUE num){
+    long l_num = NUM2LONG(num);
+    unsigned long ul_num = (unsigned long) l_num;
+    int shifted = 0, pos;
+
+    if(l_num < 0){
+        rb_raise(rb_eRangeError, mes);
+    }
+
+    RETURN_ENUMERATOR(self, 1, &num);
+
+    while(ul_num){
+        pos = CTZL(ul_num);
+        rb_yield(INT2FIX(pos + shifted));
+        ++pos;
+        ul_num >>= pos;
+        shifted += pos;
+    }
+    return Qnil;
+}
+
+static VALUE bitutils_cimpl_each_bit_bignum(VALUE self, VALUE num){
+    unsigned long * packed;
+    long long_num = 0;
+    unsigned long line, one_line;
+    int is_fixnum = 0;
+    size_t words, i;
+    VALUE tmp_buf = Qnil;
+    if(FIXNUM_P(num)){
+        is_fixnum = 1;
+        long_num = FIX2LONG(num);
+    }else{
+        Check_Type(num, T_BIGNUM);
+    }
+
+    if(long_num < 0 || (is_fixnum == 0 && RBIGNUM_NEGATIVE_P(num))){
+        rb_raise(rb_eRangeError, mes);
+    }
+
+    RETURN_ENUMERATOR(self, 1, &num);
+
+    if(is_fixnum){
+        one_line = (unsigned long) long_num;
+        packed = &one_line;
+        words = 1;
+    }else{
+        words = BIGNUM_IN_ULONG(num);
+        if(words < ALLOCA_THRESHOLD){
+            packed = ALLOCA_N(unsigned long, words);
+        }else{
+            packed = rb_alloc_tmp_buffer(&tmp_buf, sizeof(unsigned long) * words);
+        }
+        BIG_PACK(num, packed, words);
+    }
+
+    for(i = 0; i < words; ++i){
+        int shifted = 0, pos;
+        line = packed[i];
+        while(line){
+            pos = CTZL(line);
+            rb_yield(INT2FIX(pos + shifted + i * sizeof(unsigned long) * CHAR_BIT));
+            ++pos;
+            line >>= pos;
+            shifted += pos;
+        }
+    }
+
+    if(tmp_buf != Qnil){
+        rb_free_tmp_buffer(&tmp_buf);
+    }
+    return Qnil;
+}
+
+void register_each_bit(VALUE mod){
+    rb_define_module_function(mod, "each_bit_fixnum", bitutils_cimpl_each_bit_fixnum, 1);
+    rb_define_module_function(mod, "each_bit_bignum", bitutils_cimpl_each_bit_bignum, 1);
+    rb_define_module_function(mod, "each_bit", bitutils_cimpl_each_bit_bignum, 1);
+}

data/ext/bit_utils/each_bit.h

@@ -0,0 +1,10 @@
+#ifndef EACH_BIT_H_INCLUDED
+#define EACH_BIT_H_INCLUDED 1
+
+#include "ruby.h"
+#include "funcs.h"
+#include "trailing_zeros.h"
+
+void register_each_bit(VALUE mod);
+
+#endif

data/ext/bit_utils/extconf.rb

@@ -0,0 +1,50 @@
+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
+
+have_func('__builtin_ctzl(1)')
+
+create_makefile("bit_utils/bit_utils")

data/ext/bit_utils/funcs.c

@@ -0,0 +1,57 @@
+#include "funcs.h"
+
+#if SIZEOF_LONG == 8
+int my_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
+int my_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
+
+size_t my_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);
+}
+
+#ifdef HAVE___GET_CPUID
+VALUE my_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
+VALUE my_popcnt_p(VALUE self){
+    return Qfalse;
+}
+#endif

data/ext/bit_utils/funcs.h

@@ -0,0 +1,30 @@
+#ifndef FUNCS_H_INCLUDED
+#define FUNCS_H_INCLUDED 1
+
+#include "ruby.h"
+
+#ifdef HAVE_CPUID_H
+#include <cpuid.h>
+#endif
+
+VALUE my_popcnt_p(VALUE self);
+
+#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
+
+
+#ifdef HAVE_RB_ABSINT_NUMWORDS
+#define BIGNUM_IN_ULONG(v) rb_absint_numwords(v, sizeof(unsigned long), NULL)
+#else
+size_t my_bignum_in_ulong(VALUE v);
+#define BIGNUM_IN_ULONG(v) my_bignum_in_ulong(v)
+#endif
+
+#endif

data/ext/bit_utils/init.c

@@ -0,0 +1,14 @@
+#include "bit_utils.h"
+
+VALUE rb_mBitUtils;
+
+void
+Init_bit_utils(void)
+{
+  VALUE rb_mCImpl;
+  rb_mBitUtils = rb_define_module("BitUtils");
+  rb_mCImpl = rb_define_module_under(rb_mBitUtils, "CImpl");
+  register_count(rb_mCImpl);
+  register_trailing_zeros(rb_mCImpl);
+  register_each_bit(rb_mCImpl);
+}

data/ext/bit_utils/trailing_zeros.c

@@ -0,0 +1,39 @@
+#include "trailing_zeros.h"
+
+#define VAL_CTZL(n) INT2FIX((n) ? CTZL(n) : -1)
+
+static VALUE bitutils_cimpl_trailing_zeros_fixnum(VALUE self, VALUE num){
+    // using only bit pattern
+    unsigned long ul_num = (unsigned long) NUM2LONG(num);
+    return VAL_CTZL(ul_num);
+}
+
+static VALUE bitutils_cimpl_trailing_zeros_bignum(VALUE self, VALUE num){
+    unsigned long * packed;
+    size_t words, i, ret;
+    if(FIXNUM_P(num)){
+        unsigned long ul_num = (unsigned long) FIX2LONG(num);
+        return VAL_CTZL(ul_num);
+    }
+    Check_Type(num, T_BIGNUM);
+    if(rb_big_cmp(num, INT2FIX(0)) == 0) return INT2FIX(-1);
+    words = BIGNUM_IN_ULONG(num);
+    if(words < ALLOCA_THRESHOLD){
+        packed = ALLOCA_N(unsigned long, words);
+    }else{
+        packed = ALLOC_N(unsigned long, words);
+    }
+    BIG_PACK(num, packed, words);
+    for( i= 0; !packed[i] ;++i){
+        /* do nothing */
+    }
+    ret = i * sizeof(long) * CHAR_BIT + CTZL(packed[i]);
+    if(words >= ALLOCA_THRESHOLD) xfree(packed);
+    return SIZET2NUM(ret);
+}
+
+void register_trailing_zeros(VALUE mod){
+    rb_define_module_function(mod, "trailing_zeros_fixnum", bitutils_cimpl_trailing_zeros_fixnum, 1);
+    rb_define_module_function(mod, "trailing_zeros_bignum", bitutils_cimpl_trailing_zeros_bignum, 1);
+    rb_define_module_function(mod, "trailing_zeros", bitutils_cimpl_trailing_zeros_bignum, 1);
+}

data/ext/bit_utils/trailing_zeros.h

@@ -0,0 +1,18 @@
+#ifndef TRAILING_ZEROS_H
+#define TRAILING_ZEROS_H 1
+
+#include "ruby.h"
+#include "count.h"
+#include "funcs.h"
+
+void register_trailing_zeros(VALUE mod);
+
+#ifdef HAVE___BUILTIN_CTZL
+#  define CTZL(val) __builtin_ctzl(val)
+#else
+  static inline int CTZL(unsigned long val){
+    return POPCOUNTL((val & (-val)) - 1);
+  }
+#endif
+
+#endif

data/lib/bit_utils.rb

@@ -0,0 +1,13 @@
+require 'bit_utils/version'
+require 'function_module'
+
+require 'bit_utils/pure_ruby'
+
+if RUBY_PLATFORM =~ /java/
+  require 'bit_utils/jruby_bit_length'
+  require 'bit_utils/jruby'
+else
+  require 'backports/2.1.0/fixnum/bit_length'
+  require 'backports/2.1.0/bignum/bit_length'
+  require 'bit_utils/cruby'
+end

data/lib/bit_utils/core_ext.rb

@@ -0,0 +1,3 @@
+require 'bit_utils/core_ext/popcount'
+require 'bit_utils/core_ext/each_bit'
+require 'bit_utils/core_ext/trailing_zeros'

data/lib/bit_utils/core_ext/each_bit.rb

@@ -0,0 +1,15 @@
+require 'bit_utils'
+
+# Core Extension for Fixnum
+class Fixnum
+  def each_bit(&block)
+    BitUtils.each_bit_fixnum self, &block
+  end
+end
+
+# Core Extension for Bignum
+class Bignum
+  def each_bit(&block)
+    BitUtils.each_bit_bignum self, &block
+  end
+end

data/lib/bit_utils/core_ext/popcount.rb

@@ -0,0 +1,15 @@
+require 'bit_utils'
+
+# Core Extension for Fixnum
+class Fixnum
+  def popcount
+    BitUtils.popcount_fixnum self
+  end
+end
+
+# Core Extension for Bignum
+class Bignum
+  def popcount
+    BitUtils.popcount_bignum self
+  end
+end

data/lib/bit_utils/core_ext/trailing_zeros.rb

@@ -0,0 +1,15 @@
+require 'bit_utils'
+
+# Core Extension for Fixnum
+class Fixnum
+  def trailing_zeros
+    BitUtils.trailing_zeros_fixnum self
+  end
+end
+
+# Core Extension for Bignum
+class Bignum
+  def trailing_zeros
+    BitUtils.trailing_zeros_bignum self
+  end
+end

data/lib/bit_utils/cruby.rb

@@ -0,0 +1,6 @@
+require 'bit_utils/bit_utils'
+require 'function_module'
+
+module BitUtils
+  include_module_functions CImpl
+end

data/lib/bit_utils/jruby.rb

@@ -0,0 +1,66 @@
+require 'java'
+require 'function_module'
+
+#
+# module for bit utilities
+#
+module BitUtils
+
+  #
+  # module for Java-specific codes of BitUtils.
+  # @note not intended for direct use.
+  #
+  module JavaImpl
+
+    module_function
+
+    def popcount(num)
+      case num
+      when Fixnum
+        popcount_fixnum num
+      when Bignum
+        popcount_bignum num
+      else
+        raise TypeError
+      end
+    end
+
+    def popcount_fixnum(num)
+      raise TypeError unless num.is_a?(::Fixnum)
+      count = Java::JavaLang::Long.bitCount(num)
+      num >= 0 ? count : count - 64
+    end
+
+    def popcount_bignum(num)
+      raise TypeError unless num.is_a?(::Bignum)
+      count = num.to_java.bitCount
+      num >= 0 ? count : -count
+    end
+
+    def trailing_zeros(num)
+      case num
+      when Fixnum
+        trailing_zeros_fixnum num
+      when Bignum
+        trailing_zeros_bignum num
+      else
+        raise TypeError
+      end
+    end
+
+
+    def trailing_zeros_fixnum(num)
+      raise TypeError unless num.is_a?(::Fixnum)
+      return -1 if num == 0
+      Java::JavaLang::Long.numberOfTrailingZeros(num)
+    end
+
+    def trailing_zeros_bignum(num)
+      raise TypeError unless num.is_a?(::Bignum)
+      num.to_java.getLowestSetBit
+    end
+  end
+
+  include_module_functions JavaImpl
+
+end

data/lib/bit_utils/jruby_bit_length.rb

@@ -0,0 +1,23 @@
+require 'java'
+
+# for Bignum
+
+unless Bignum.method_defined?(:bit_length)
+  class Bignum #:nodoc:
+    def bit_length
+      to_java.bitLength
+    end
+  end
+end
+
+# for Fixnum
+
+unless Fixnum.method_defined?(:bit_length) && -1.bit_length == 0
+  class Fixnum #:nodoc:
+    def bit_length
+      val = self < 0 ? ~self : self
+      64 - Java::JavaLang::Long.numberOfLeadingZeros(val)
+    end
+  end
+end
+

data/lib/bit_utils/pure_ruby.rb

@@ -0,0 +1,54 @@
+require 'function_module'
+
+#
+# module for bit utilities
+#
+module BitUtils
+
+  #
+  # module for pure Ruby code of BitUtils.
+  # @note not intended for direct use.
+  #
+  module PureRuby
+
+    module_function
+
+    def popcount(num)
+      raise TypeError unless num.is_a?(::Integer)
+      return -popcount(~num) if num < 0
+      num.to_s(2).count('1')
+    end
+
+    alias_module_function :popcount_fixnum, :popcount
+    alias_module_function :popcount_bignum, :popcount
+
+    def trailing_zeros(num)
+      raise TypeError unless num.is_a?(::Integer)
+      return -1 if num == 0
+      (num & -num).bit_length - 1
+    end
+
+    alias_module_function :trailing_zeros_fixnum, :trailing_zeros
+    alias_module_function :trailing_zeros_bignum, :trailing_zeros
+
+    def each_bit(num)
+      raise TypeError unless num.is_a?(::Integer)
+      raise RangeError if num < 0
+      return enum_for(__method__, num) { BitUtils.count(num) } unless block_given?
+      shift = 0
+      loop do
+        return if num == 0
+        pos = BitUtils.trailing_zeros num
+        yield shift + pos
+        num >>= pos + 1
+        shift += pos + 1
+      end
+    end
+
+    alias_module_function :each_bit_fixnum, :each_bit
+    alias_module_function :each_bit_bignum, :each_bit
+
+  end
+
+  include_module_functions PureRuby
+end

data/lib/bit_utils/version.rb

@@ -0,0 +1,3 @@
+module BitUtils
+  VERSION = "0.1.1"
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: bit_utils
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: java
+authors:
+- Jkr2255
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2016-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  name: function_module
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake-compiler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description:
+email:
+- magnesium.oxide.play@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/count.rb
+- benchmark/each_bit.rb
+- benchmark/trailing_zeros.rb
+- bin/console
+- bin/setup
+- bit_utils.gemspec
+- ext/bit_utils/bit_utils.h
+- ext/bit_utils/count.c
+- ext/bit_utils/count.h
+- ext/bit_utils/each_bit.c
+- ext/bit_utils/each_bit.h
+- ext/bit_utils/extconf.rb
+- ext/bit_utils/funcs.c
+- ext/bit_utils/funcs.h
+- ext/bit_utils/init.c
+- ext/bit_utils/trailing_zeros.c
+- ext/bit_utils/trailing_zeros.h
+- lib/bit_utils.rb
+- lib/bit_utils/core_ext.rb
+- lib/bit_utils/core_ext/each_bit.rb
+- lib/bit_utils/core_ext/popcount.rb
+- lib/bit_utils/core_ext/trailing_zeros.rb
+- lib/bit_utils/cruby.rb
+- lib/bit_utils/jruby.rb
+- lib/bit_utils/jruby_bit_length.rb
+- lib/bit_utils/pure_ruby.rb
+- lib/bit_utils/version.rb
+homepage: https://github.com/jkr2255/bit_utils
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.6.4
+signing_key:
+specification_version: 4
+summary: Utility methods for manipulating bits within Integer.
+test_files: []