ingramj-bitarray 0.1.1 → 0.2.0

data/TODO

@@ -1,7 +1,7 @@
 * Comment code. I'd like for it to be useful as a tutorial for extension
   writing, especially with regards to implementing new types.
-* Implement some more methods, like Hamming weight, and slice, and in-place
-  enumerator methods (map!, reverse!, etc).
+* Implement some more methods, like slice, and in-place enumerator methods
+  (map!, reverse!, etc).
 * Maybe allow resizing.
 * Write more tests
 * Ruby 1.8 compatibility. This will probably involve just changing some of the

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/bitarray.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bitarray}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["James E. Ingram"]

data/ext/bitarray.c

@@ -81,6 +81,18 @@ toggle_bit(struct bit_array *ba, ptrdiff_t bit)
 }
 
 
+/* Toggle the state of all bits. */
+static int
+toggle_all_bits(struct bit_array *ba)
+{
+    int i;
+    for(i = 0; i < ba->array_size; i++) {
+        ba->array[i] ^= ~0ul;     /* ~0 = all bits set. */
+    }
+    return 1;
+}
+
+
 /* Assign the specified value to a bit. Return 1 on success, 0 on invalid bit
  * index, and -1 on invalid value. */
 static int
@@ -114,7 +126,29 @@ get_bit(struct bit_array *ba, ptrdiff_t bit)
 }
 
 
-/* Ruby Interface Functions. These aren't documented yet. */
+/* Return the number of set bits in the array. */
+static size_t
+total_set(struct bit_array *ba)
+{
+    /* This is basically the algorithm from K&R, with a running total for all
+     * array elements. There are faster algorithms, but this one is simpler to
+     * implement. The running time is proportionate to the number of set bits.
+     */
+    size_t count = 0;
+    int i;
+    unsigned x;
+    for (i = 0; i < ba->array_size; i++) {
+        x = ba->array[i];
+        while (x) {
+            x &= x - 1;
+            count++;
+        }
+    }
+    return count;
+}
+
+
+/* Ruby Interface Functions. */
 
 static VALUE rb_bitarray_class;
 
@@ -201,6 +235,22 @@ rb_bitarray_size(VALUE self)
 }
 
 
+/* call-seq:
+ *      bitarray.total_set      -> int
+ *
+ * Return the number of set (1) bits in _bitarray_.
+ */
+static VALUE
+rb_bitarray_total_set(VALUE self)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    size_t count = total_set(ba);
+    return SIZET2NUM(count);
+}
+
+
 /* call-seq:
  *      bitarray.set_bit(index)       -> bitarray
  *
@@ -285,6 +335,48 @@ rb_bitarray_clear_all_bits(VALUE self)
 }
 
 
+/* call-seq:
+ *      bitarray.toggle_bit(index)       -> bitarray
+ *
+ * Toggles the bit at _index_ to 0. 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_toggle_bit(VALUE self, VALUE bit)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    ptrdiff_t index = NUM2SSIZET(bit);
+
+    if (toggle_bit(ba, index)) {
+        return self;
+    } else {
+        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+    }
+}
+
+
+/* call-seq:
+ *      bitarray.toggle_all_bits         -> bitarray
+ *
+ * Toggle all bits.
+ */
+static VALUE
+rb_bitarray_toggle_all_bits(VALUE self)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    if(toggle_all_bits(ba)) {
+        return self;
+    } else {
+        rb_bug("BitArray#clear_all_bits failed. This should not occur.");
+    }
+}
+
+
 /* call-seq:
  *      bitarray[index]         -> value
  *
@@ -417,12 +509,17 @@ Init_bitarray()
     rb_define_alias(rb_bitarray_class, "dup", "clone");
     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);
     rb_define_method(rb_bitarray_class, "set_bit", rb_bitarray_set_bit, 1);
     rb_define_method(rb_bitarray_class, "set_all_bits",
             rb_bitarray_set_all_bits, 0);
     rb_define_method(rb_bitarray_class, "clear_bit", rb_bitarray_clear_bit, 1);
     rb_define_method(rb_bitarray_class, "clear_all_bits",
             rb_bitarray_clear_all_bits, 0);
+    rb_define_method(rb_bitarray_class, "toggle_bit",
+            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_assign_bit, 2);
     rb_define_method(rb_bitarray_class, "inspect", rb_bitarray_inspect, 0);

data/test/bm.rb

@@ -2,37 +2,45 @@ require 'bitfield'
 require 'bitarray'
 require 'benchmark'
 
-Benchmark.bm(24) { |bm|
-  puts "------------------------ Object instantiation."
+Benchmark.bm(28) { |bm|
+  puts "---------------------------- Object instantiation."
   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"
   bm.report("BitField []")         { 10000.times { bf[rand(256)] } }
   bm.report("BitArray []")         { 10000.times { ba[rand(256)] } }
 
-  puts "------------------------ Element Writing"
+  puts "---------------------------- Element Writing"
   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"
   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"
   bm.report("BitField to_s")       { 10000.times { bf.to_s } }
   bm.report("BitArray to_s")       { 10000.times { ba.to_s } }
 
-  puts "------------------------ Set All"
+  puts "---------------------------- Total Set"
+  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 } }
+  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} }
-
-  puts "------------------------ Clear All"
   bm.report("BitArray clear_all_bits")  { 10000.times { ba.clear_all_bits } }
-  
-  puts "------------------------ Clone"
+  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 } }
 }
 

data/test/test.rb

@@ -47,7 +47,6 @@ class TestLibraryFileName < Test::Unit::TestCase
   def test_size
     assert_equal 1000, @public_ba.size
   end
-  
 
   def test_to_s
     ba = BitArray.new(10)
@@ -56,7 +55,6 @@ class TestLibraryFileName < Test::Unit::TestCase
     assert_equal "0100010000", ba.to_s
   end
 
-
   def test_set_all_bits
     ba = BitArray.new(10)
     ba.set_all_bits
@@ -78,14 +76,26 @@ class TestLibraryFileName < Test::Unit::TestCase
     ba_clone = ba.clone
     assert_equal ba_clone.to_s, ba.to_s
   end
-  
-  # This method is not implemented yet.
 
-  #def test_total_set
-  #  bf = BitArray.new(10)
-  #  bf[1] = 1
-  #  bf[5] = 1
-  #  assert_equal 2, bf.total_set
-  #end
+  def test_toggle_bit
+    ba = BitArray.new(10)
+    ba.toggle_bit 5
+    assert_equal 1, ba[5] 
+  end
+
+  def test_toggle_all_bits
+    ba = BitArray.new(10)
+    ba[1] = 1
+    ba[5] = 1
+    ba.toggle_all_bits
+    assert_equal "1011101111", ba.to_s
+  end
+
+  def test_total_set
+    bf = BitArray.new(10)
+    bf[1] = 1
+    bf[5] = 1
+    assert_equal 2, bf.total_set
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ingramj-bitarray
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - James E. Ingram