nbitarray 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2, :cli => "--color" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Yusuke Mito
+
+MIT License
+
+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,37 @@
+# NBitArray
+
+This is bitarray implementation which can assign arbitrary bit size per item.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'nbitarray'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nbitarray
+
+## Usage
+
+```ruby
+bitarray = NBitArray.new(3) # 3-bit array
+bitarray[0] = 7
+puts bitarray[0] #=> 7
+bitarray[3] = 1
+bitarray.size #=> 4
+
+bitarray[1] = 8 #=> raise error
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/nbitarray/version.rb

@@ -0,0 +1,3 @@
+class NBitArray
+  VERSION = "0.0.1"
+end

data/lib/nbitarray.rb

@@ -0,0 +1,98 @@
+require 'nbitarray/version'
+require 'pry'
+
+class NBitArray
+  MARSHAL_SPLIT_SIZE = 512
+  attr_reader :bit
+  include Enumerable
+
+  def initialize(bit)
+    @bit = bit
+    @bit_array = 0
+    @mask = (1 << @bit) - 1
+  end
+
+  def size
+    if @bit_array == 0
+      1
+    else
+      num_of_bits = Math.log2(@bit_array)
+      if num_of_bits == Float::INFINITY
+        # FIXME: this algorithm is too slow
+        count = 1
+        value = @bit_array
+        while (value = value >> 1) != 0
+          count += 1
+        end
+        num_of_bits = count
+      else
+        num_of_bits = num_of_bits.floor + 1
+      end
+      (num_of_bits - 1) / @bit + 1
+    end
+  end
+  alias length size
+
+  def each(&block)
+    size.times {|index| yield self[index] }
+  end
+
+  def []=(index, value)
+    raise ArgumentError, 'too large value' if value >= 1 << @bit
+    raise ArgumentError, 'value must be positive' if value < 0
+    bit_index = index * @bit
+
+    # 00 00 00 10 << 4 shift
+    # 00 10 00 00
+    assign_value = value << bit_index
+
+    # 00 00 00 11 mask
+    # 00 11 00 00 move to masking position
+    # 11 00 11 11 reverse mask
+    reverse_mask = ~(@mask << bit_index)
+
+    # 10 01 11 00 & 11 00 11 11 erase current value by reverse mask
+    # 10 00 11 00 | 00 10 00 00 assign new value
+    # 10 10 11 00
+    @bit_array = (@bit_array & reverse_mask) | assign_value
+    value
+  end
+
+  def [](index)
+    bit_index = index * @bit
+
+    # 10 10 11 00 >> 4          shift
+    # 00 00 10 10 | 00 00 00 11 mask
+    # 00 00 00 10               value
+    (@bit_array >> bit_index) & @mask
+  end
+
+  def marshal_dump
+    [@bit, @mask, splitted_bit_array(@bit_array, MARSHAL_SPLIT_SIZE), MARSHAL_SPLIT_SIZE]
+  end
+
+  def marshal_load(array)
+    @bit, @mask, splitted_array, split_size = array
+    @bit_array = joined_bit_array(splitted_array, split_size)
+  end
+
+  def splitted_bit_array(bit_array, split_size = 32)
+    mask = (1 << split_size) - 1
+    array = []
+    while bit_array > 0
+      array << (bit_array & mask)
+      bit_array = bit_array >> split_size
+    end
+    array
+  end
+  private :splitted_bit_array
+
+  def joined_bit_array(splitted_array, split_size)
+    value = 0
+    splitted_array.each_with_index do |splitted_value, index|
+      value += splitted_value << (split_size * index)
+    end
+    value
+  end
+  private :joined_bit_array
+end

data/nbitarray.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nbitarray/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Yusuke Mito"]
+  gem.email         = ["y310.1984@gmail.com"]
+  gem.description   = %q{Pure Ruby n-bit array implementation.}
+  gem.summary       = %q{Pure Ruby n-bit array implementation.}
+  gem.homepage      = "https://github.com/y310/nbitarray"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "nbitarray"
+  gem.require_paths = ["lib"]
+  gem.version       = NBitArray::VERSION
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'pry-debugger'
+end

data/spec/lib/nbitarray_spec.rb

@@ -0,0 +1,192 @@
+require 'nbitarray'
+
+describe NBitArray do
+  describe '#new' do
+    it 'should initialized by bit' do
+      array = NBitArray.new(8)
+      expect { array[1] = 1 }.to change { array.size }.from(1).to(2)
+      array = NBitArray.new(33)
+      expect { array[1] = 1 }.to change { array.size }.from(1).to(2)
+    end
+  end
+
+  describe '#size' do
+    shared_examples_for 'return correct array size for any bit' do
+      let(:bit_array) { NBitArray.new(bit) }
+
+      it 'should return correct size' do
+        expect { bit_array[1] = 1 }.to change { bit_array.size }.from(1).to(2)
+        expect { bit_array[10] = 1 }.to change { bit_array.size }.from(2).to(11)
+        expect { bit_array[100] = 1 }.to change { bit_array.size }.from(11).to(101)
+      end
+    end
+
+    it 'can be called by #length' do
+      expect { NBitArray.new(1).length }.to_not raise_error
+    end
+
+    context 'small bit' do
+      let(:bit) { 1 }
+      it_should_behave_like 'return correct array size for any bit'
+    end
+
+    context 'large bit' do
+      let(:bit) { 100 }
+      it_should_behave_like 'return correct array size for any bit'
+    end
+  end
+
+  describe '#each' do
+    let(:bit_array) { NBitArray.new(3) }
+    let(:assign_values) { [0, 1, 2, 3, 4, 5, 6, 7] }
+
+    before do
+      assign_values.each_with_index do |v, i|
+        bit_array[i] = v
+      end
+    end
+
+    it 'should iterate all items' do
+      bit_array.each do |v|
+        v.should eq assign_values.shift
+      end
+    end
+
+    it 'can use Enumerablue method' do
+      bit_array.map{|v| v * 2}.inject(0) {|v, sum| sum += v}.should eq 56
+    end
+  end
+
+  describe '#[]=, #[]' do
+    shared_examples_for 'manage value correctly for any bit' do
+      let(:bit_array) { NBitArray.new(bit) }
+      let(:max_value) { (1 << bit) - 1 }
+
+      it 'should assign value' do
+        expect { bit_array[0] = 0 }.to change { bit_array[0] }.by(0)
+        expect { bit_array[1] = max_value }.to change { bit_array[1] }.from(0).to(max_value)
+      end
+
+      it 'should raise error' do
+        expect { bit_array[0] = 1 << bit }.to raise_error(ArgumentError)
+        expect { bit_array[0] = -1 }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'under 32bit array' do
+      let(:bit) { 1 }
+      it_should_behave_like 'manage value correctly for any bit'
+    end
+
+    context 'over 32bit array' do
+      let(:bit) { 34 }
+      it_should_behave_like 'manage value correctly for any bit'
+    end
+
+    context 'too large bit array' do
+      let(:bit) { 100  }
+      it_should_behave_like 'manage value correctly for any bit'
+    end
+  end
+
+  describe 'marshaling' do
+    let(:bit_array) { NBitArray.new(8) }
+    it 'can marshal' do
+      bit_array[0] = 1
+      bit_array[1] = 2
+      restored_bit_array = Marshal.load(Marshal.dump(bit_array))
+      restored_bit_array.bit.should eql bit_array.bit
+      restored_bit_array[0].should eql bit_array[0]
+      restored_bit_array[1].should eql bit_array[1]
+    end
+  end
+
+  describe 'marshaling benchmark' do
+    shared_examples_for 'benchmark bit array with array' do
+      let(:max_value) { (1 << bit) - 1 }
+      let(:bit_array) { NBitArray.new(bit) }
+      let(:array) { Array.new }
+      let(:bit_array_size) { Marshal.dump(bit_array).size }
+      let(:array_size) { Marshal.dump(array).size }
+
+      it 'sparse array' do
+        index = 100
+        bit_array[index] = 1
+        array[index] = 1
+        (bit_array_size < array_size).should == sparse_won
+      end
+
+      it 'filled array' do
+        1000.times do |i|
+          value = rand(max_value)
+          bit_array[i] = value
+          array[i] = value
+        end
+        (bit_array_size < array_size).should == filled_won
+      end
+    end
+
+    context '1 bit' do
+      let(:bit) { 1 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '4 bit' do
+      let(:bit) { 4 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '8 bit' do
+      let(:bit) { 8 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '12 bit' do
+      let(:bit) { 12 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '16 bit' do
+      let(:bit) { 16 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '24 bit' do
+      let(:bit) { 24 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '32 bit' do
+      let(:bit) { 32 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '64 bit' do
+      let(:bit) { 64 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+
+    context '128 bit' do
+      let(:bit) { 128 }
+      let(:sparse_won) { true }
+      let(:filled_won) { true }
+      it_should_behave_like 'benchmark bit array with array'
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: nbitarray
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Yusuke Mito
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70151155133100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70151155133100
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70151155132240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70151155132240
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  requirement: &70151155131800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70151155131800
+description: Pure Ruby n-bit array implementation.
+email:
+- y310.1984@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/nbitarray.rb
+- lib/nbitarray/version.rb
+- nbitarray.gemspec
+- spec/lib/nbitarray_spec.rb
+homepage: https://github.com/y310/nbitarray
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Pure Ruby n-bit array implementation.
+test_files:
+- spec/lib/nbitarray_spec.rb