Switched to a getbyte/setbyte approach

Author: peterc

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bitarray (0.0.5)
+    bitarray (1.0.0)
 
 GEM
   remote: https://rubygems.org/

README.md

@@ -1,8 +1,8 @@
-# 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 .. I will review the code and bring the docs up to date in due course.
+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
 
@@ -48,12 +48,18 @@ ba.total_set
 ```
 
 ## 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)
 
+## Thanks
+
+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-2013 Peter Cooper, yada yada.
+MIT licensed. Copyright 2007-2013 Peter Cooper, yada yada.

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

lib/bitarray.rb

@@ -3,26 +3,25 @@ class BitArray
   attr_reader :field
   include Enumerable
 
-  VERSION = "0.0.5"
-  ELEMENT_WIDTH = 32
+  VERSION = "1.0.0"
 
   def initialize(size, field = nil)
     @size = size
-    @field = 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
@@ -32,12 +31,12 @@ def each(&block)
 
   # Returns the field as a string like "0101010100111100," etc.
   def to_s
-    @field.collect{|ea| ("%032b" % ea).reverse}.join[0..@size-1]
+    @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

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

test/test_bitarray.rb

@@ -2,14 +2,13 @@
 require "bitarray"
 
 class TestBitArray < Minitest::Test
-
   def setup
     @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
@@ -57,6 +56,7 @@ def test_total_set
     ba = BitArray.new(10)
     ba[1] = 1
     ba[5] = 1
-    assert_equal 2, ba.total_set
+    ba[9] = 1
+    assert_equal 3, ba.total_set
   end
 end