bitvector 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c507e779cafcf95b841c23a00215cd3b1b64480
+  data.tar.gz: 8204d3d2d80258cd2d6fdbe152ae054e8d6de42b
+SHA512:
+  metadata.gz: 78882aa419df48bee5fbedec56163c4fca2942e84b9f24122cbeeee23cb181fac164323f205f649fc215aae4d385f7ed9985bd60581a98d738e439cb07f92b13
+  data.tar.gz: 56b42cd6cd5658b0dcd35132c6e6b08f64966e183821ab2b81e8512e66e9bfc8041eb349ea14dcba9f61efeb0cea045dea3e8f0d8aca4119a3deb2adbc11287c

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+pkg

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Juan Azambuja
+
+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,54 @@
+# BitVector
+
+Small gem to manage integer fields as bit vectors of size 32.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bitvector'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bitvector
+
+## Usage
+
+### Rails Example:
+
+You want to represent your data as a bit vector, for example, lets say you want to represent days of the
+week and store them as a bit vector (assuming days_of_week is an int attribute):
+
+```
+class Schedule < ActiveRecord::Base
+  serialize days_of_week, BitVector::BitVector
+end
+
+schedule = Schedule.new
+vector = schedule.days_of_week # => This is a BitVector!
+
+# Mark monday as true
+vector[0] = 1
+
+puts vector # => '00000000000000000000000000000001'
+
+```
+
+If you save a schedule instance, the value will be persisted as integer.
+
+```
+schedule.days_of_week = BitVector::BitVector.new(1).
+schedule.save # => days_of_week fields is serialized as 1 in database.
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/juanazam/bitvector/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = true
+end
+
+task :default => :spec
+task :test    => :spec

data/bench.rb

@@ -0,0 +1,53 @@
+require "benchmark"
+require "bundler/setup"
+require "bitvector"
+
+N = 100_000
+
+def sample
+  @sample ||= BitVector::BitVector.new
+end
+
+Benchmark.bmbm do |x|
+  x.report "Initialize vector" do
+    N.times do
+      BitVector::BitVector.new
+    end
+  end
+
+  x.report "Load from number" do
+    N.times do
+      BitVector::BitVector.load 123
+    end
+  end
+
+  x.report "Load from string" do
+    N.times do
+      BitVector::BitVector.load "123"
+    end
+  end
+
+  x.report "Dump vector" do
+    N.times do
+      BitVector::BitVector.dump sample
+    end
+  end
+
+  x.report "Set at index" do
+    N.times do
+      sample[16] = 1
+    end
+  end
+
+  x.report "Clear at index" do
+    N.times do
+      sample[16] = 0
+    end
+  end
+
+  x.report "Get at index" do
+    N.times do
+      sample[16]
+    end
+  end
+end

data/bitvector.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "bitvector"
+
+Gem::Specification.new do |spec|
+  spec.name          = "bitvector"
+  spec.version       = BitVector::VERSION
+  spec.authors       = ["Juan Azambuja"]
+  spec.email         = ["juan@wyeworks.com"]
+  spec.summary       = %q{Bit Vector representation and managing of integer fields.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/bit_vector.rb

@@ -0,0 +1,96 @@
+require "bit_vector/version"
+
+module BitVector
+  # Provides a class to represent a bit vector using a number and size.
+  class BitVector
+    DEFAULT_SIZE = 32
+
+    attr_reader :number, :size
+
+    # Returns new bit vector initialized to optional number and size.
+    def initialize(number = 0, size = DEFAULT_SIZE)
+      @number, @size = number, size
+      raise ArgumentError, "number must be =< #{max_number}" if number > max_number
+    end
+
+    # Returns a string representation.
+    def to_s
+      "%0#{size}b" % number
+    end
+
+    # Returns an integer representation.
+    alias_method :to_i, :number
+
+    # Sets or clears the bit at index.
+    def []=(index, value)
+      raise ArgumentError, "index must be < #{size}" if index >= size
+      mask = 1 << index
+      @number = value && value != 0 ? number | mask : number & ~mask
+    end
+
+    # Returns the bit at index.
+    def [](index)
+      raise ArgumentError, "index must be < #{size}" if index >= size
+      number[index]
+    end
+
+    # Returns true if equal to other vector. Two vectors are considered equal if
+    # their numbers and sizes are equal.
+    def ==(other)
+      number == other.number && size == other.size
+    end
+
+    # Returns true if equal to other vector and of the same class.
+    def eql?(other)
+      other.is_a?(self.class) && self == other
+    end
+
+    # Returns a new vector containing the combined bits of both vectors.
+    def |(other)
+      raise ArgumentError, "size mismatch" unless other.size == size
+      self.class.new number | other.number, size
+    end
+    alias_method :+, :|
+
+    # Returns a new vector containing the common bits with other vector.
+    def &(other)
+      raise ArgumentError, "size mismatch" unless other.size == size
+      self.class.new number & other.number, size
+    end
+    alias_method :-, :&
+
+    # Returns true if all the bits at indexes are set, false otherwise.
+    def include?(indexes)
+      indexes.all? { |index| self[index] == 1 }
+    end
+
+    # Returns true if all the bits at indexes are unset, false otherwise.
+    def exclude?(indexes)
+      indexes.all? { |index| self[index] == 0 }
+    end
+
+    # This should be good for now.
+    alias_method :hash, :number
+
+    # Loads vector from value.
+    def self.load(value)
+      new value.to_i
+    end
+
+    # Dumps vector to value.
+    def self.dump(vector)
+      vector.to_i
+    end
+
+    # Creates a new vector with bits at indexes set.
+    def self.from_indexes(indexes, size = DEFAULT_SIZE)
+      new indexes.inject(0) { |number, index| number |= 1 << index; number }, size
+    end
+
+    private
+
+    def max_number
+      2 ** size - 1
+    end
+  end
+end

data/lib/bit_vector/version.rb

@@ -0,0 +1,3 @@
+module BitVector
+  VERSION = "1.0.0"
+end

data/lib/bitvector.rb

@@ -0,0 +1 @@
+require "bit_vector"

data/spec/bit_vector_spec.rb

@@ -0,0 +1,418 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'bitvector'
+
+module BitVector
+  describe BitVector do
+    let(:number) { 0 }
+    let(:bit_vector) { BitVector.new number }
+
+    describe "#to_s" do
+      subject { bit_vector.to_s }
+
+      describe "for an empty vector" do
+        let(:bit_vector) { BitVector.new }
+
+        it "returns all zeros" do
+          subject.must_equal("00000000000000000000000000000000")
+        end
+      end
+
+      describe "with a known number" do
+        let(:number) { 0b101 }
+
+        it "returns a formatted string" do
+          subject.must_equal("00000000000000000000000000000101")
+        end
+      end
+    end
+
+    describe '#[]=' do
+      describe "with a too large index" do
+        let(:index) { bit_vector.size + 1 }
+
+        it "raises" do
+          lambda { bit_vector[index] = 1 }.must_raise(ArgumentError)
+        end
+      end
+
+      describe "with a bit set" do
+        let(:number) { 0b100 }
+
+        subject { bit_vector[2] }
+
+        describe "when set to 0" do
+          before do
+            bit_vector[2] = 0
+          end
+
+          it "clears bit" do
+            subject.must_equal 0
+          end
+        end
+
+        describe "when set to false" do
+          before do
+            bit_vector[2] = false
+          end
+
+          it "clears bit" do
+            subject.must_equal 0
+          end
+        end
+      end
+
+      describe "with no bits set" do
+        let(:number) { 0b0 }
+
+        subject { bit_vector[0] }
+
+        describe "when set to 1" do
+          before do
+            bit_vector[0] = 1
+          end
+
+          it "sets bit" do
+            subject.must_equal 1
+          end
+        end
+
+        describe "when set to true" do
+          before do
+            bit_vector[0] = true
+          end
+
+          it "sets bit" do
+            subject.must_equal 1
+          end
+        end
+      end
+    end
+
+    describe '[]' do
+      let(:number) { 0b011 }
+
+      it "returns values at given positions" do
+        bit_vector[0].must_equal 1
+        bit_vector[1].must_equal 1
+        bit_vector[2].must_equal 0
+      end
+
+      describe "with a too large index" do
+        let(:index) { bit_vector.size + 1 }
+
+        it "raises" do
+          lambda { bit_vector[index] }.must_raise(ArgumentError)
+        end
+      end
+    end
+
+    describe '#to_i' do
+      subject { bit_vector.to_i }
+
+      before do
+        bit_vector[2] = 1
+      end
+
+      it 'returns integer representation of vector' do
+        subject.must_equal(4)
+      end
+    end
+
+    describe "#size" do
+      subject { bit_vector.size }
+
+      it "returns the default size" do
+        subject.must_equal 32
+      end
+    end
+
+    describe "#==" do
+      let(:other_number) { bit_vector.number }
+      let(:other_size) { bit_vector.size }
+      let(:other) { BitVector.new other_number, other_size }
+
+      subject { bit_vector == other }
+
+      describe "with same number and size" do
+        it "returns true" do
+          assert subject
+        end
+      end
+
+      describe "with different number and same size" do
+        let(:other_number) { bit_vector.number + 1 }
+
+        it "returns false" do
+          refute subject
+        end
+      end
+
+      describe "with same number and different size" do
+        let(:other_size) { bit_vector.size + 1 }
+
+        it "returns false" do
+          refute subject
+        end
+      end
+
+      describe "with different number and different size" do
+        let(:other_number) { bit_vector.number + 1 }
+        let(:other_size) { bit_vector.size + 1 }
+
+        it "returns false" do
+          refute subject
+        end
+      end
+    end
+
+    describe "with a size argument" do
+      let(:size) { 48 }
+      let(:bit_vector) { BitVector.new(number, size) }
+
+      describe "#initialize" do
+        describe "with a too large number" do
+          let(:number) { 2 ** size }
+
+          it "raises" do
+            lambda { bit_vector }.must_raise(ArgumentError)
+          end
+        end
+      end
+
+      describe "#size" do
+        subject { bit_vector.size }
+
+        it "return the size" do
+          subject.must_equal size
+        end
+      end
+
+      describe "#to_s" do
+        subject { bit_vector.to_s }
+
+        it "returns a formatted string" do
+          subject.must_equal "000000000000000000000000000000000000000000000000"
+        end
+      end
+    end
+
+    describe "#+" do
+      let(:other_size) { bit_vector.size }
+      let(:other) { BitVector.new other_number, other_size }
+
+      subject { bit_vector + other }
+
+      describe "with known numbers" do
+        let(:number) { 0b101 }
+        let(:other_number) { 0b110 }
+
+        it "returns the or'ed number" do
+          subject.number.must_equal 0b111
+        end
+      end
+    end
+
+    describe "#-" do
+      let(:other_size) { bit_vector.size }
+      let(:other) { BitVector.new other_number, other_size }
+
+      subject { bit_vector - other }
+
+      describe "with known numbers" do
+        let(:number) { 0b101 }
+        let(:other_number) { 0b110 }
+
+        it "returns the and'ed number" do
+          subject.number.must_equal 0b100
+        end
+      end
+    end
+
+    describe "#include?" do
+      let(:number) { 0b111 }
+
+      subject { bit_vector.include? indexes }
+
+      describe "with included indexes" do
+        let(:indexes) { [0, 1] }
+
+        it "returns true" do
+          assert subject
+        end
+      end
+
+      describe "with partially included indexes" do
+        let(:indexes) { [0, 1, 3] }
+
+        it "returns false" do
+          refute subject
+        end
+      end
+
+      describe "with excluded indexes" do
+        let(:indexes) { [3, 4] }
+
+        it "returns false" do
+          refute subject
+        end
+      end
+
+      describe "with no indexes" do
+        let(:indexes) { [] }
+
+        it "returns true" do
+          assert subject
+        end
+      end
+    end
+
+    describe "#exclude?" do
+      let(:number) { 0b111 }
+
+      subject { bit_vector.exclude? indexes }
+
+      describe "with excluded indexes" do
+        let(:indexes) { [3, 4] }
+
+        it "returns true" do
+          assert subject
+        end
+      end
+
+      describe "with partially excluded indexes" do
+        let(:indexes) { [3, 4, 0] }
+
+        it "returns false" do
+          refute subject
+        end
+      end
+
+      describe "with included indexes" do
+        let(:indexes) { [0, 1] }
+
+        it "returns false" do
+          refute subject
+        end
+      end
+
+      describe "with no indexes" do
+        let(:indexes) { [] }
+
+        it "returns true" do
+          assert subject
+        end
+      end
+    end
+
+    describe "#hash" do
+      let(:other) { BitVector.new other_number }
+
+      subject { bit_vector.hash }
+
+      describe "with the same number" do
+        let(:other_number) { number }
+
+        it "is equal" do
+          subject.must_equal other.hash
+        end
+      end
+
+      describe "with a different number" do
+        let(:other_number) { number + 1 }
+
+        it "is not equal" do
+          subject.wont_equal other.hash
+        end
+      end
+
+      describe "when used with a hash and known values" do
+        let(:hash) do
+          {
+            BitVector.new(0b100) => 1,
+            BitVector.new(0b100) => 2,
+            BitVector.new(0b101) => 3
+          }
+        end
+
+        it "has the right size" do
+          hash.size.must_equal 2
+        end
+      end
+    end
+
+    describe ".from_indexes" do
+      subject { BitVector.from_indexes indexes }
+
+      describe "with no indexes" do
+        let(:indexes) { [] }
+
+        it "returns the zero vector" do
+          subject.must_equal BitVector.new(0)
+        end
+      end
+
+      describe "with known indexes" do
+        let(:indexes) { [1, 2] }
+
+        it "returns the expected vector" do
+          subject.must_equal BitVector.new(0b110)
+        end
+      end
+
+      describe "with known, sparse and repeted indexes" do
+        let(:indexes) { [0, 2, 4, 4] }
+
+        it "returns the expected vector" do
+          subject.must_equal BitVector.new(0b10101)
+        end
+      end
+
+      describe "with a too large index" do
+        let(:indexes) { [1, 2, 48] }
+
+        it "raises" do
+          lambda { subject }.must_raise(ArgumentError)
+        end
+      end
+    end
+
+    describe '.load' do
+      subject { BitVector.load(value) }
+
+      describe 'when value is nil' do
+        let(:value) { nil }
+
+        it 'initializes array with all elements as FALSE' do
+          subject.must_equal(BitVector.new(0))
+        end
+      end
+
+      describe "when value is blank" do
+        let(:value) { "" }
+
+        it "initializes vector to 0" do
+          subject.must_equal(BitVector.new(0))
+        end
+      end
+
+      describe 'when value is int (4)' do
+        let(:value) { 4 }
+
+        it 'initializes array representing 4 in binary' do
+          subject.must_equal(BitVector.new(4))
+        end
+      end
+    end
+
+    describe '.dump' do
+      let(:number) { 5 }
+
+      subject { BitVector.dump(bit_vector) }
+
+      it 'dumps de parameter bit vector in its integer form' do
+        subject.must_equal(5)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: bitvector
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Juan Azambuja
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+description: 
+email:
+- juan@wyeworks.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bench.rb
+- bitvector.gemspec
+- lib/bit_vector.rb
+- lib/bit_vector/version.rb
+- lib/bitvector.rb
+- spec/bit_vector_spec.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Bit Vector representation and managing of integer fields.
+test_files:
+- spec/bit_vector_spec.rb