bitarray 0.0.1 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c79a60a3580af853940651ca520abd24f359fc97
+  data.tar.gz: 96cb2ffe5551ac793e33f3eb06563aadcc6cfd1d
+SHA512:
+  metadata.gz: bcd93a192a22cf477b45cd582028a3cd60c090dd9cdfbfd5b507a86f4c996a1dede387926d34f0495441cb90b0d899c96d5bb9a34dc8b16b5e933794f0e89bf1
+  data.tar.gz: cb2b120ce2abe9242bfc07ac9f1dff0bff7aab271daabaaafca53f39a06be8ce690946575bc6c423e8258fbf99c284ab783301327c0495bb37477798a0def376

data/Gemfile

@@ -1,4 +1,2 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in bitarray.gemspec
+source "https://rubygems.org"
 gemspec

data/README.md

@@ -1,23 +1,65 @@
-# BitArray: A simple bit array/bit field library in pure Ruby
+# BitArray: A simple bit-array/bitfield library in pure Ruby
 
-Basic, pure Ruby bit field. Pretty fast (for what it is) and memory efficient. Works well for Bloom filters (the reason I wrote it).
+Basic, pure Ruby bit field. Works well for Bloom filters (the use case for which I originally wrote it).
 
-Written in 2007 and not updated since then, just bringing it on to GitHub by user request. It used to be called Bitfield and was hosted at http://snippets.dzone.com/posts/show/4234
+Originally written in 2007 and left without significant update until 2017, it has now been updated to work within a typical, modern Ruby environment while maintaining the same API.
+
+## Installation
+
+```ruby
+gem install bitarray
+```
 
 ## Examples
 
-Create a bit field 1000 bits wide
-    bf = BitField.new(1000)
+To use:
+
+```ruby
+require 'bitarray'
+```
+
+Create a bit array 1000 bits wide:
+
+```ruby
+ba = BitArray.new(1000)
+```
+
+Setting and reading bits:
+
+```ruby
+ba[100] = 1
+ba[100]
+#=> 1
+
+ba[100] = 0
+ba[100]
+#=> 0
+```
+
+More:
+
+```ruby
+ba = BitArray.new(20)
+[1,3,5,9,11,13,15].each { |i| ba[i] = 1 }
+ba.to_s
+#=> "01010100010101010000"
+ba.total_set
+#=> 7
+```
+
+## History
+- 1.0 in 2017 (updated for modern Ruby, more efficient storage, and 10th birthday)
+- 0.0.1 in 2012 (original v5 released on GitHub)
+- v5 (added support for flags being on by default, instead of off)
+- v4 (fixed bug where setting 0 bits to 0 caused a set to 1)
+- v3 (supports dynamic bitwidths for array elements.. now doing 32 bit widths default)
+- v2 (now uses 1 << y, rather than 2 ** y .. it's 21.8 times faster!)
+- v1 (first release)
 
-Setting and reading bits
-    bf[100] = 1
-    bf[100]    .. => 1
-    bf[100] = 0
+## Thanks
 
-More
-    bf.to_s = "10101000101010101"  (example)
-    bf.total_set         .. => 10  (example - 10 bits are set to "1")
+Thanks to Michael Slade for encouraging me to update this library on its 10th birthday and for suggesting finally using String's getbyte and setbyte methods now that we're all on 1.9+ compatible implementations.
 
 ## License
 
-MIT licensed. Copyright 2007-2012 Peter Cooper, yada yada.
+MIT licensed. Copyright 2007-2017 Peter Cooper.

data/Rakefile

@@ -1,5 +1,5 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-Rake::TestTask.new      # defaults are fine for now
-task :default => :test
+Rake::TestTask.new
+task :default => :test

data/bitarray.gemspec

@@ -1,19 +1,22 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
 
+require 'bitarray'
+
 Gem::Specification.new do |s|
   s.name        = "bitarray"
-  s.version     = "0.0.1"
+  s.version     = BitArray::VERSION
   s.authors     = ["Peter Cooper"]
   s.email       = ["git@peterc.org"]
   s.homepage    = "https://github.com/peterc/bitarray"
-  s.summary     = %q{A simple, pure Ruby bit array implementation.}
-  s.description = %q{A simple, pure Ruby bit array implementation.}
-
-  s.rubyforge_project = "bitarray"
+  s.summary     = %q{A simple, pure Ruby bit-array / bitfield implementation.}
+  s.description = %q{A simple, pure Ruby bit-array / bitfield implementation.}
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest"
 end

data/lib/bitarray-array.rb

@@ -0,0 +1,43 @@
+class BitArray
+  attr_reader :size
+  attr_reader :field
+  include Enumerable
+
+  VERSION = "1.0.0"
+  ELEMENT_WIDTH = 32
+
+  def initialize(size, field = nil)
+    @size = size
+    @field = field || Array.new(((size - 1) / ELEMENT_WIDTH) + 1, 0)
+  end
+
+  # Set a bit (1/0)
+  def []=(position, value)
+    if value == 1
+      @field[position / ELEMENT_WIDTH] |= 1 << (position % ELEMENT_WIDTH)
+    elsif (@field[position / ELEMENT_WIDTH]) & (1 << (position % ELEMENT_WIDTH)) != 0
+      @field[position / ELEMENT_WIDTH] ^= 1 << (position % ELEMENT_WIDTH)
+    end
+  end
+
+  # Read a bit (1/0)
+  def [](position)
+    @field[position / ELEMENT_WIDTH] & 1 << (position % ELEMENT_WIDTH) > 0 ? 1 : 0
+  end
+
+  # Iterate over each bit
+  def each(&block)
+    @size.times { |position| yield self[position] }
+  end
+
+  # Returns the field as a string like "0101010100111100," etc.
+  def to_s
+    @field.collect{|ea| ("%0#{ELEMENT_WIDTH}b" % ea).reverse}.join[0..@size-1]
+  end
+
+  # Returns the total number of bits that are set
+  # (The technique used here is about 6 times faster than using each or inject direct on the bitfield)
+  def total_set
+    @field.inject(0) { |a, byte| a += byte & 1 and byte >>= 1 until byte == 0; a }
+  end
+end

data/lib/bitarray.rb

@@ -1,41 +1,42 @@
 class BitArray
   attr_reader :size
+  attr_reader :field
   include Enumerable
-  
-  ELEMENT_WIDTH = 32
-  
-  def initialize(size)
+
+  VERSION = "1.0.0"
+
+  def initialize(size, field = nil)
     @size = size
-    @field = Array.new(((size - 1) / ELEMENT_WIDTH) + 1, 0)
+    @field = "\0" * (size / 8 + 1)
   end
-  
+
   # Set a bit (1/0)
   def []=(position, value)
     if value == 1
-      @field[position / ELEMENT_WIDTH] |= 1 << (position % ELEMENT_WIDTH)
-    elsif (@field[position / ELEMENT_WIDTH]) & (1 << (position % ELEMENT_WIDTH)) != 0
-      @field[position / ELEMENT_WIDTH] ^= 1 << (position % ELEMENT_WIDTH)
+      @field.setbyte(position >> 3, @field.getbyte(position >> 3) | (1 << (position % 8)))
+    else
+      @field.setbyte(position >> 3, @field.getbyte(position >> 3) ^ (1 << (position % 8)))
     end
   end
-  
+
   # Read a bit (1/0)
   def [](position)
-    @field[position / ELEMENT_WIDTH] & 1 << (position % ELEMENT_WIDTH) > 0 ? 1 : 0
+    (@field.getbyte(position >> 3) & (1 << (position % 8))) > 0 ? 1 : 0
   end
-  
+
   # Iterate over each bit
   def each(&block)
     @size.times { |position| yield self[position] }
   end
-  
+
   # Returns the field as a string like "0101010100111100," etc.
   def to_s
-    inject("") { |a, b| a + b.to_s }
+    @field.bytes.collect{|ea| ("%08b" % ea).reverse}.join[0, @size]
   end
-  
+
   # Returns the total number of bits that are set
   # (The technique used here is about 6 times faster than using each or inject direct on the bitfield)
   def total_set
-    @field.inject(0) { |a, byte| a += byte & 1 and byte >>= 1 until byte == 0; a }
+    @field.bytes.inject(0) { |a, byte| a += byte & 1 and byte >>= 1 until byte == 0; a }
   end
-end
+end

data/memory-test.rb

@@ -0,0 +1,13 @@
+require_relative 'lib/bitarray'
+require 'memory_profiler'
+
+report = MemoryProfiler.report do
+    ba = BitArray.new(1000000)
+
+    1000000.times do |i|
+      ba[rand(100000)] = 1
+      ba[rand(100000)] = 0
+    end
+end
+
+report.pretty_print

data/test/test_bitarray.rb

@@ -1,62 +1,62 @@
-require "test/unit"
+require "minitest/autorun"
 require "bitarray"
 
-class TestBitArray < Test::Unit::TestCase
+class TestBitArray < Minitest::Test
   def setup
-    @public_bf = BitArray.new(1000)
+    @public_ba = BitArray.new(1000)
   end
-  
+
   def test_basic
     assert_equal 0, BitArray.new(100)[0]
-    assert_equal 0, BitArray.new(100)[1]
+    assert_equal 0, BitArray.new(100)[99]
   end
-  
+
   def test_setting_and_unsetting
-    @public_bf[100] = 1
-    assert_equal 1, @public_bf[100]
-    @public_bf[100] = 0
-    assert_equal 0, @public_bf[100]
+    @public_ba[100] = 1
+    assert_equal 1, @public_ba[100]
+    @public_ba[100] = 0
+    assert_equal 0, @public_ba[100]
   end
 
   def test_random_setting_and_unsetting
     100.times do
       index = rand(1000)
-      @public_bf[index] = 1
-      assert_equal 1, @public_bf[index]
-      @public_bf[index] = 0
-      assert_equal 0, @public_bf[index]
+      @public_ba[index] = 1
+      assert_equal 1, @public_ba[index]
+      @public_ba[index] = 0
+      assert_equal 0, @public_ba[index]
     end
   end
-  
+
   def test_multiple_setting
     1.upto(999) do |pos|
-      2.times { @public_bf[pos] = 1 }
-      assert_equal 1, @public_bf[pos]
+      2.times { @public_ba[pos] = 1 }
+      assert_equal 1, @public_ba[pos]
     end
   end
 
   def test_multiple_unsetting
     1.upto(999) do |pos|
-      2.times { @public_bf[pos] = 0 }
-      assert_equal 0, @public_bf[pos]
+      2.times { @public_ba[pos] = 0 }
+      assert_equal 0, @public_ba[pos]
     end
   end
-  
+
   def test_size
-    assert_equal 1000, @public_bf.size
+    assert_equal 1000, @public_ba.size
   end
-  
+
   def test_to_s
-    bf = BitArray.new(10)
-    bf[1] = 1
-    bf[5] = 1
-    assert_equal "0100010000", bf.to_s
+    ba = BitArray.new(35)
+    [1, 5, 6, 7, 10, 16, 33].each{|i|ba[i] = 1}
+    assert_equal "01000111001000001000000000000000010", ba.to_s
   end
-  
+
   def test_total_set
-    bf = BitArray.new(10)
-    bf[1] = 1
-    bf[5] = 1
-    assert_equal 2, bf.total_set
+    ba = BitArray.new(10)
+    ba[1] = 1
+    ba[5] = 1
+    ba[9] = 1
+    assert_equal 3, ba.total_set
   end
-end
+end

metadata

@@ -1,54 +1,82 @@
 --- !ruby/object:Gem::Specification
 name: bitarray
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Peter Cooper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-18 00:00:00.000000000 Z
-dependencies: []
-description: A simple, pure Ruby bit array implementation.
+date: 2017-01-07 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: A simple, pure Ruby bit-array / bitfield implementation.
 email:
 - git@peterc.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
+- Gemfile.lock
 - README.md
 - Rakefile
 - bitarray.gemspec
+- lib/bitarray-array.rb
 - lib/bitarray.rb
+- memory-test.rb
 - test/test_bitarray.rb
 homepage: https://github.com/peterc/bitarray
 licenses: []
+metadata: {}
 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: bitarray
-rubygems_version: 1.8.10
+rubyforge_project: 
+rubygems_version: 2.6.8
 signing_key: 
-specification_version: 3
-summary: A simple, pure Ruby bit array implementation.
+specification_version: 4
+summary: A simple, pure Ruby bit-array / bitfield implementation.
 test_files:
 - test/test_bitarray.rb
-has_rdoc: