ingramj-bitarray 0.2.0 → 0.3.1

data/Rakefile

@@ -14,7 +14,7 @@ EOF
     gem.require_paths = ["ext"]
     gem.extensions = ["ext/extconf.rb"]
     gem.required_ruby_version = ">= 1.9.1"
-    gem.rdoc_options << '--exclude' << 'ext/Makefile' << '--title' << ' BitArray Documentation'
+    gem.rdoc_options << '--exclude' << 'ext/Makefile' << '--title' << 'BitArray Documentation'
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.1

data/bitarray.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bitarray}
-  s.version = "0.2.0"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["James E. Ingram"]
-  s.date = %q{2009-05-23}
+  s.date = %q{2009-05-24}
   s.description = %q{A bit array class for Ruby, implemented as a C extension. Includes methods for setting and clearing individual bits, and all bits at once. Also has the standard array access methods, [] and []=, and it mixes in Enumerable.}
   s.email = %q{ingramj@gmail.com}
   s.extensions = ["ext/extconf.rb"]
@@ -30,7 +30,7 @@ Gem::Specification.new do |s|
   ]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/ingramj/bitarray}
-  s.rdoc_options = ["--charset=UTF-8", "--exclude", "ext/Makefile", "--title", " BitArray Documentation"]
+  s.rdoc_options = ["--charset=UTF-8", "--exclude", "ext/Makefile", "--title", "BitArray Documentation"]
   s.require_paths = ["ext"]
   s.required_ruby_version = Gem::Requirement.new(">= 1.9.1")
   s.rubygems_version = %q{1.3.1}

data/ext/bitarray.c

@@ -183,7 +183,12 @@ rb_bitarray_initialize(VALUE self, VALUE size)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    size_t bits = NUM2SIZET(size);
+    ptrdiff_t bits = NUM2SSIZET(size);
+    if (bits <= 0) {
+        ba->bits = 0;
+        ba->array_size = 0;
+        return self;
+    }
     size_t array_size = ((bits - 1) / UINT_BITS) + 1;
 
     ba->bits = bits;
@@ -201,21 +206,62 @@ rb_bitarray_initialize(VALUE self, VALUE size)
  * Produces a copy of _bitarray_.
  */
 static VALUE
-rb_bitarray_clone(VALUE self)
+rb_bitarray_initialize_copy(VALUE self, VALUE orig)
 {
-    struct bit_array *ba, *new_ba;
-    VALUE rb_new_ba;
-    Data_Get_Struct(self, struct bit_array, ba);
-    rb_new_ba = Data_Make_Struct(rb_bitarray_class, struct bit_array, NULL,
-            rb_bitarray_free, new_ba);
+    struct bit_array *new_ba, *orig_ba;
+    Data_Get_Struct(self, struct bit_array, new_ba);
+    Data_Get_Struct(orig, struct bit_array, orig_ba);
 
-    new_ba->bits = ba->bits;
-    new_ba->array_size = ba->array_size;
+    new_ba->bits = orig_ba->bits;
+    new_ba->array_size = orig_ba->array_size;
     new_ba->array = ruby_xcalloc(new_ba->array_size, UINT_BYTES);
 
-    memcpy(new_ba->array, ba->array, (ba->array_size * UINT_BYTES));
+    memcpy(new_ba->array, orig_ba->array, (new_ba->array_size * UINT_BYTES));
 
-    return rb_new_ba;
+    return self;
+}
+
+
+/* call-seq:
+ *      bitarray + other_bitarray       -> a_bitarray
+ *
+ * Concatenation---Return a new BitArray built by concatenating the two
+ * BitArrays.
+ */
+static VALUE
+rb_bitarray_concat(VALUE x, VALUE y)
+{
+    /* Get the bit_arrays from x and y */
+    struct bit_array *x_ba, *y_ba;
+    Data_Get_Struct(x, struct bit_array, x_ba);
+    Data_Get_Struct(y, struct bit_array, y_ba);
+
+    /* Create a new BitArray, and its bit_array */
+    VALUE z;
+    struct bit_array *z_ba;
+    z = rb_bitarray_alloc(rb_bitarray_class);
+    rb_bitarray_initialize(z, SIZET2NUM(x_ba->bits + y_ba->bits));
+    Data_Get_Struct(z, struct bit_array, z_ba);
+
+    /* For each bit set in x and y, set the corresponding bit in z.
+     * 
+     * It might be faster to memcpy x_ba->array to the beginning of
+     * z_ba->array, then set the rest of the bits by looping over y...
+     */
+    size_t z_index = 0;
+    size_t i;
+    for (i = 0; i < x_ba->bits; i++, z_index++) {
+        if (get_bit(x_ba, i) == 1) {
+            set_bit(z_ba, z_index);
+        }
+    }
+    for (i = 0; i < y_ba->bits; i++, z_index++) {
+        if (get_bit(y_ba, i) == 1) {
+            set_bit(z_ba, z_index);
+        }
+    }
+
+    return z;
 }
 
 
@@ -376,22 +422,13 @@ rb_bitarray_toggle_all_bits(VALUE self)
     }
 }
 
-
-/* call-seq:
- *      bitarray[index]         -> value
- *
- * Bit Reference---Returns the bit at _index_. Negative indices count backwards
- * from the end of _bitarray_. If _index_ is greater than the capacity of
- * _bitarray_, an +IndexError+ is raised.
- */
+/* Return an individual bit. */
 static VALUE
-rb_bitarray_get_bit(VALUE self, VALUE bit)
+rb_bitarray_get_bit(VALUE self, ptrdiff_t index)
 {
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    ptrdiff_t index = NUM2SSIZET(bit);
-
     int bit_value = get_bit(ba, index);
 
     if (bit_value >= 0) {
@@ -402,6 +439,117 @@ rb_bitarray_get_bit(VALUE self, VALUE bit)
 }
 
 
+/* Create a new BitArray from a subsequence of x. */
+static VALUE
+rb_bitarray_subseq(VALUE x, ptrdiff_t beg, ptrdiff_t len)
+{
+
+    struct bit_array *x_ba;
+    Data_Get_Struct(x, struct bit_array, x_ba);
+
+    /* Quick exit - a negative length, or a beginning past the end of the
+     * array returns nil.
+     */
+    if (beg < 0) {
+        beg += x_ba->bits;
+    }
+    if (len < 0 || beg > x_ba->bits) {
+        return Qnil;
+    }
+
+    /* Make sure that we don't try getting more bits than x has. We handle this
+     * the same way as Array; if beg+len is past the end of x, shorten len.
+     */
+    if (x_ba->bits <  len ||  x_ba->bits < (beg + len)) {
+        len = x_ba->bits - beg;
+    }
+
+    /* Create a new BitArray of the appropriate size. */
+    VALUE y;
+    y = rb_bitarray_alloc(rb_bitarray_class);
+    rb_bitarray_initialize(y, SSIZET2NUM(len));
+    /* If our length is 0, we can just return now. */
+    if (len == 0) {
+        return y;
+    }
+    struct bit_array *y_ba;
+    Data_Get_Struct(y, struct bit_array, y_ba);
+
+    /* For each set bit in x[beg..len], set the corresponding bit in y. */
+    size_t x_index, y_index;
+    for (x_index = beg, y_index = 0;
+            x_index < beg + len;
+            x_index++, y_index++)
+    {
+        if (get_bit(x_ba, x_index) == 1) {
+            set_bit(y_ba, y_index);
+        }
+    }
+
+    return y;
+}
+
+
+/* call-seq:
+ *      bitarray[index]         -> value
+ *      bitarray[beg, len]      -> a_bitarray
+ *      bitarray[range]         -> a_bitarray
+ *
+ * Bit Reference---Returns the bit at _index_, or returns a subarray starting
+ * at _beg_, and continuing for _len_ bits, or returns a subarray specified by
+ * _range_.  _Negative indices count backwards from the end of _bitarray_. If
+ * _index_ is greater than the capacity of _bitarray_, an +IndexError+ is
+ * raised.
+ */
+
+static VALUE
+rb_bitarray_bitref(int argc, VALUE *argv, VALUE self)
+{
+    /* We follow a form similar to rb_ary_aref in array.c */
+
+    /* Two arguments means we have a beginning and a  length */
+    if (argc == 2) {
+        ptrdiff_t beg = NUM2SSIZET(argv[0]);
+        ptrdiff_t len = NUM2SSIZET(argv[1]);
+        return rb_bitarray_subseq(self, beg, len);
+    } 
+    
+    /* Make sure we have either 1 or 2 arguments. */
+    if (argc != 1) {
+        rb_scan_args(argc, argv, "11", 0, 0);
+    }
+
+    /* If we have a single argument, it can be either an index, or a range. */
+    VALUE arg = argv[0];
+    
+    /* rb_ary_aref treats a fixnum argument specially, for a speedup in the
+     * most common case. We'll do the same.
+     */
+    if (FIXNUM_P(arg)) {
+        return rb_bitarray_get_bit(self, FIX2LONG(arg));
+    }
+
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+    /* Next we see if arg is a range. rb_range_beg_len is defined in range.c
+     * If arg is not a range, it returns Qfalse. If arg is a range, but it
+     * refers to invalid indices, it returns Qnil. Otherwise, it sets beg and
+     * end to the appropriate values.
+     */
+    long beg, len;
+    switch (rb_range_beg_len(arg, &beg, &len, ba->bits, 0)) {
+        case Qfalse:
+            break;
+        case Qnil:
+            return Qnil;
+        default:
+            return rb_bitarray_subseq(self, beg, len);
+    }
+    
+    return rb_bitarray_get_bit(self, NUM2SSIZET(arg));
+}
+
+
 /* call-seq:
  *      bitarray[index] = value     -> value
  *
@@ -498,15 +646,11 @@ Init_bitarray()
 {
     rb_bitarray_class = rb_define_class("BitArray", rb_cObject);
     rb_define_alloc_func(rb_bitarray_class, rb_bitarray_alloc);
-
     rb_define_method(rb_bitarray_class, "initialize",
             rb_bitarray_initialize, 1);
-    
-    /* TODO: apparently, we need to define an #initialize_copy method instead
-     * of clone.
-     */
-    rb_define_method(rb_bitarray_class, "clone", rb_bitarray_clone, 0);
-    rb_define_alias(rb_bitarray_class, "dup", "clone");
+    rb_define_method(rb_bitarray_class, "initialize_copy",
+            rb_bitarray_initialize_copy, 1);
+    rb_define_method(rb_bitarray_class, "+", rb_bitarray_concat, 1);
     rb_define_method(rb_bitarray_class, "size", rb_bitarray_size, 0);
     rb_define_alias(rb_bitarray_class, "length", "size");
     rb_define_method(rb_bitarray_class, "total_set", rb_bitarray_total_set, 0);
@@ -520,7 +664,8 @@ Init_bitarray()
             rb_bitarray_toggle_bit, 1);
     rb_define_method(rb_bitarray_class, "toggle_all_bits",
             rb_bitarray_toggle_all_bits, 0);
-    rb_define_method(rb_bitarray_class, "[]", rb_bitarray_get_bit, 1);
+    rb_define_method(rb_bitarray_class, "[]", rb_bitarray_bitref, -1);
+    rb_define_alias(rb_bitarray_class, "slice", "[]");
     rb_define_method(rb_bitarray_class, "[]=", rb_bitarray_assign_bit, 2);
     rb_define_method(rb_bitarray_class, "inspect", rb_bitarray_inspect, 0);
     rb_define_alias(rb_bitarray_class, "to_s", "inspect");

data/test/bm.rb

@@ -3,44 +3,47 @@ require 'bitarray'
 require 'benchmark'
 
 Benchmark.bm(28) { |bm|
-  puts "---------------------------- Object instantiation."
+  puts "---------------------------- Object instantiation (10,000 iterations)"
   bm.report("BitField initialize") { 10000.times { BitField.new(256) } }
   bm.report("BitArray initialize") { 10000.times { BitArray.new(256) } }
 
   bf = BitField.new(256)
   ba = BitArray.new(256)
   
-  puts "---------------------------- Element Reading"
+  puts "---------------------------- Element Reading (10,000 iterations)"
   bm.report("BitField []")         { 10000.times { bf[rand(256)] } }
   bm.report("BitArray []")         { 10000.times { ba[rand(256)] } }
 
-  puts "---------------------------- Element Writing"
+  puts "---------------------------- Element Writing (10,000 iterations)"
   bm.report("BitField []=")        { 10000.times { bf[rand(256)] = [0,1][rand(2)] } }
   bm.report("BitArray []=")        { 10000.times { ba[rand(256)] = [0,1][rand(2)] } }
 
-  puts "---------------------------- Element Enumeration"
+  puts "---------------------------- Element Enumeration (10,000 iterations)"
   bm.report("BitField each")       { 10000.times { bf.each {|b| b } } }
   bm.report("BitArray each")       { 10000.times { ba.each {|b| b } } }
 
-  puts "---------------------------- To String"
+  puts "---------------------------- To String (10,000 iterations)"
   bm.report("BitField to_s")       { 10000.times { bf.to_s } }
   bm.report("BitArray to_s")       { 10000.times { ba.to_s } }
 
-  puts "---------------------------- Total Set"
+  puts "---------------------------- Total Set (100,000 iterations)"
   bf = BitField.new(256)
   ba = BitArray.new(256)
-  bm.report("BitField total_set (none)") { 10000.times { bf.total_set } }
-  bm.report("BitArray total_set (none)") { 10000.times { ba.total_set } }
+  bm.report("BitField total_set (none)") { 100000.times { bf.total_set } }
+  bm.report("BitArray total_set (none)") { 100000.times { ba.total_set } }
   bf.each {|b| b = 1}
   ba.set_all_bits
-  bm.report("BitField total_set (all)") { 10000.times { bf.total_set } }
-  bm.report("BitArray total_set (all)") { 10000.times { ba.total_set } }
-
-  puts "---------------------------- BitArray methods"
-  bm.report("BitArray set_all_bits")    { 10000.times { ba.set_all_bits} }
-  bm.report("BitArray clear_all_bits")  { 10000.times { ba.clear_all_bits } }
-  bm.report("BitArray toggle_bit")      { 10000.times { ba.toggle_bit(1) } }
-  bm.report("BitArray toggle_all_bits") { 10000.times { ba.toggle_all_bits } }
-  bm.report("BitArray clone")           { 10000.times { ba.clone } }
+  bm.report("BitField total_set (all)") { 100000.times { bf.total_set } }
+  bm.report("BitArray total_set (all)") { 100000.times { ba.total_set } }
+
+  puts "---------------------------- BitArray methods (100,000 iterations)"
+  bm.report("BitArray set_all_bits")    { 100000.times { ba.set_all_bits} }
+  bm.report("BitArray clear_all_bits")  { 100000.times { ba.clear_all_bits } }
+  bm.report("BitArray toggle_bit")      { 100000.times { ba.toggle_bit(1) } }
+  bm.report("BitArray toggle_all_bits") { 100000.times { ba.toggle_all_bits } }
+  bm.report("BitArray clone")           { 100000.times { ba.clone } }
+  bm.report("BitArray slice (beg,len)") { 100000.times { ba[17, 230] } }
+  bm.report("BitArray slice (range)")   { 100000.times { ba[17..247] } }
+  bm.report("BitArray +")               { 100000.times { ba + ba } }
 }
 

data/test/test.rb

@@ -92,10 +92,34 @@ class TestLibraryFileName < Test::Unit::TestCase
   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
+    assert_equal 2, ba.total_set
+  end
+
+  def test_slice_beg_len
+    ba = BitArray.new(10)
+    ba[1] = 1
+    ba[5] = 1
+    assert_equal "10001", ba[1,5].to_s
+    assert_equal "10000", ba[-5,5].to_s
+  end
+
+  def test_slice_range
+    ba = BitArray.new(10)
+    ba[1] = 1
+    ba[5] = 1
+    assert_equal "10001", ba[1..5].to_s
+    assert_equal "10000", ba[-5..-1].to_s
+  end
+
+  def test_concatenation
+    ba1 = BitArray.new(5)
+    ba2 = BitArray.new(5)
+    ba2.set_all_bits
+    ba3 = ba1 + ba2
+    assert_equal "0000011111", ba3.to_s
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ingramj-bitarray
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - James E. Ingram
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-23 00:00:00 -07:00
+date: 2009-05-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -43,7 +43,7 @@ rdoc_options:
 - --exclude
 - ext/Makefile
 - --title
-- " BitArray Documentation"
+- BitArray Documentation
 require_paths: 
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement