ingramj-bitarray 0.3.1 → 0.4.0

data/README

@@ -2,13 +2,29 @@ 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.
 
+Example usage:
+
+    require 'bitarray'
+    bm = BitArray.new(16)
+    bm[5] = 1
+    bm.toggle_all_bits
+    puts bm
+
+
 The test/ directory has a unit test file. It also has a benchmark utility for
 comparison with Peter Cooper's pure Ruby BitField class.
 
-This extension has only been tested with Ruby 1.9.1 on Ubuntu, and probably
-won't compile for Ruby 1.8. Compatibility with Ruby 1.8 is planned.
+This library has been compiled and tested on:
+    
+    ruby 1.9.1p129 (2009-05-12 revision 23412) [i686-linux]
+    ruby 1.8.7 (2008-08-11 patchlevel 72) [alpha-netbsd]
+
+If you have success using it on any other version/platform combinations, I'd
+like to know. Or if you have problems, I'd like to know that too. Report bugs
+at http://github.com/ingramj/bitarray/issues
+
 
-This library is available as a gem. Install it with
+BitArray is available as a gem. Install it with
 
 sudo gem install ingramj-bitarray -s http://gems.github.com
 

data/Rakefile

@@ -13,7 +13,7 @@ EOF
     gem.authors = ["James E. Ingram"]
     gem.require_paths = ["ext"]
     gem.extensions = ["ext/extconf.rb"]
-    gem.required_ruby_version = ">= 1.9.1"
+    gem.required_ruby_version = ">= 1.8.6"
     gem.rdoc_options << '--exclude' << 'ext/Makefile' << '--title' << 'BitArray Documentation'
   end
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/bitarray.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bitarray}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   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-24}
+  s.date = %q{2009-05-25}
   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"]
@@ -32,7 +32,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/ingramj/bitarray}
   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.required_ruby_version = Gem::Requirement.new(">= 1.8.6")
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{A bitarray class for Ruby, implemented as a C extension.}
   s.test_files = [

data/ext/bitarray.c

@@ -13,8 +13,8 @@
 
 /* Bit Array structure. */
 struct bit_array {
-    size_t bits;         /* Number of bits. */
-    size_t array_size;   /* Size of the storage array. */
+    long bits;         /* Number of bits. */
+    long array_size;   /* Size of the storage array. */
     unsigned int *array; /* Array of unsigned ints, used for bit storage. */
 };
 
@@ -23,7 +23,7 @@ struct bit_array {
 
 /* Set the specified bit to 1. Return 1 on success, 0 on failure. */
 static int
-set_bit(struct bit_array *ba, ptrdiff_t bit)
+set_bit(struct bit_array *ba, long bit)
 {
     if (bit < 0) bit += ba->bits;
     if (bit >= ba->bits) {
@@ -46,7 +46,7 @@ set_all_bits(struct bit_array *ba)
 
 /* Clear the specified bit to 0. Return 1 on success, 0 on failure. */
 static int
-clear_bit(struct bit_array *ba, ptrdiff_t bit)
+clear_bit(struct bit_array *ba, long bit)
 {
     if (bit < 0) bit += ba->bits;
     if (bit >= ba->bits) {
@@ -69,7 +69,7 @@ clear_all_bits(struct bit_array *ba)
 
 /* Toggle the state of the specified bit. Return 1 on success, 0 on failure. */
 static int
-toggle_bit(struct bit_array *ba, ptrdiff_t bit)
+toggle_bit(struct bit_array *ba, long bit)
 {
     if (bit < 0) bit += ba->bits;
     if (bit >= ba->bits) {
@@ -85,7 +85,7 @@ toggle_bit(struct bit_array *ba, ptrdiff_t bit)
 static int
 toggle_all_bits(struct bit_array *ba)
 {
-    int i;
+    long i;
     for(i = 0; i < ba->array_size; i++) {
         ba->array[i] ^= ~0ul;     /* ~0 = all bits set. */
     }
@@ -96,7 +96,7 @@ toggle_all_bits(struct bit_array *ba)
 /* Assign the specified value to a bit. Return 1 on success, 0 on invalid bit
  * index, and -1 on invalid value. */
 static int
-assign_bit(struct bit_array *ba, ptrdiff_t bit, int value)
+assign_bit(struct bit_array *ba, long bit, int value)
 {
     if (value == 0) {
         return clear_bit(ba, bit);
@@ -110,7 +110,7 @@ assign_bit(struct bit_array *ba, ptrdiff_t bit, int value)
 
 /* Get the state of the specified bit. Return -1 on failure. */
 static int
-get_bit(struct bit_array *ba, ptrdiff_t bit)
+get_bit(struct bit_array *ba, long bit)
 {
     if (bit < 0) bit += ba->bits;
     if (bit >= ba->bits) {
@@ -127,15 +127,15 @@ get_bit(struct bit_array *ba, ptrdiff_t bit)
 
 
 /* Return the number of set bits in the array. */
-static size_t
+static long
 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;
+    long count = 0;
+    long i;
     unsigned x;
     for (i = 0; i < ba->array_size; i++) {
         x = ba->array[i];
@@ -183,13 +183,13 @@ rb_bitarray_initialize(VALUE self, VALUE size)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    ptrdiff_t bits = NUM2SSIZET(size);
+    long bits = NUM2LONG(size);
     if (bits <= 0) {
         ba->bits = 0;
         ba->array_size = 0;
         return self;
     }
-    size_t array_size = ((bits - 1) / UINT_BITS) + 1;
+    long array_size = ((bits - 1) / UINT_BITS) + 1;
 
     ba->bits = bits;
     ba->array_size = array_size;
@@ -240,27 +240,31 @@ rb_bitarray_concat(VALUE x, VALUE y)
     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));
+    rb_bitarray_initialize(z, LONG2NUM(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...
+    /* For each bit set in x and y, set the corresponding bit in z. First, copy
+     * x to the beginning of z. Then, if x->bits is a multiple of UINT_BITS, we
+     * can just copy y onto the end of z. Otherwise, we need to go through y
+     * bit-by-bit and set the appropriate bits in z.
      */
-    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);
+    memcpy(z_ba->array, x_ba->array, (x_ba->array_size * UINT_BYTES));
+    if ((x_ba->bits % UINT_BITS) == 0) {
+        unsigned int *start = z_ba->array + x_ba->array_size;
+        memcpy(start, y_ba->array, (y_ba->array_size * UINT_BYTES));
+    } else {
+        long y_index, z_index;
+        for (y_index = 0, z_index = x_ba->bits;
+                y_index < y_ba->bits;
+                y_index++, z_index++)
+        {
+            if (get_bit(y_ba, y_index) == 1) {
+                set_bit(z_ba, z_index);
+            } else {
+                clear_bit(z_ba, z_index);
+            }
         }
     }
-
     return z;
 }
 
@@ -277,7 +281,7 @@ rb_bitarray_size(VALUE self)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    return SIZET2NUM(ba->bits);
+    return LONG2NUM(ba->bits);
 }
 
 
@@ -292,8 +296,8 @@ 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);
+    long count = total_set(ba);
+    return LONG2NUM(count);
 }
 
 
@@ -310,12 +314,12 @@ rb_bitarray_set_bit(VALUE self, VALUE bit)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    ptrdiff_t index = NUM2SSIZET(bit);
+    long index = NUM2LONG(bit);
 
     if (set_bit(ba, index)) {
         return self;
     } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
     }
 }
 
@@ -352,12 +356,12 @@ rb_bitarray_clear_bit(VALUE self, VALUE bit)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    ptrdiff_t index = NUM2SSIZET(bit);
+    long index = NUM2LONG(bit);
 
     if (clear_bit(ba, index)) {
         return self;
     } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
     }
 }
 
@@ -394,12 +398,12 @@ 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);
+    long index = NUM2LONG(bit);
 
     if (toggle_bit(ba, index)) {
         return self;
     } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
     }
 }
 
@@ -424,7 +428,7 @@ rb_bitarray_toggle_all_bits(VALUE self)
 
 /* Return an individual bit. */
 static VALUE
-rb_bitarray_get_bit(VALUE self, ptrdiff_t index)
+rb_bitarray_get_bit(VALUE self, long index)
 {
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
@@ -434,14 +438,14 @@ rb_bitarray_get_bit(VALUE self, ptrdiff_t index)
     if (bit_value >= 0) {
         return INT2NUM(bit_value);
     } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
     }
 }
 
 
 /* Create a new BitArray from a subsequence of x. */
 static VALUE
-rb_bitarray_subseq(VALUE x, ptrdiff_t beg, ptrdiff_t len)
+rb_bitarray_subseq(VALUE x, long beg, long len)
 {
 
     struct bit_array *x_ba;
@@ -467,7 +471,7 @@ rb_bitarray_subseq(VALUE x, ptrdiff_t beg, ptrdiff_t len)
     /* Create a new BitArray of the appropriate size. */
     VALUE y;
     y = rb_bitarray_alloc(rb_bitarray_class);
-    rb_bitarray_initialize(y, SSIZET2NUM(len));
+    rb_bitarray_initialize(y, LONG2NUM(len));
     /* If our length is 0, we can just return now. */
     if (len == 0) {
         return y;
@@ -476,7 +480,7 @@ rb_bitarray_subseq(VALUE x, ptrdiff_t beg, ptrdiff_t len)
     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;
+    long x_index, y_index;
     for (x_index = beg, y_index = 0;
             x_index < beg + len;
             x_index++, y_index++)
@@ -509,8 +513,8 @@ rb_bitarray_bitref(int argc, VALUE *argv, VALUE self)
 
     /* 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]);
+        long beg = NUM2LONG(argv[0]);
+        long len = NUM2LONG(argv[1]);
         return rb_bitarray_subseq(self, beg, len);
     } 
     
@@ -546,7 +550,7 @@ rb_bitarray_bitref(int argc, VALUE *argv, VALUE self)
             return rb_bitarray_subseq(self, beg, len);
     }
     
-    return rb_bitarray_get_bit(self, NUM2SSIZET(arg));
+    return rb_bitarray_get_bit(self, NUM2LONG(arg));
 }
 
 
@@ -566,14 +570,14 @@ rb_bitarray_assign_bit(VALUE self, VALUE bit, VALUE value)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    ptrdiff_t index = NUM2SSIZET(bit);
+    long index = NUM2LONG(bit);
     int bit_value = NUM2INT(value);
 
     int result = assign_bit(ba, index, bit_value);
     if (result == 1) {
         return value;
     } else if (result == 0) {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
     } else {
         rb_raise(rb_eRuntimeError, "bit value %d out of range", bit_value);
     }
@@ -592,10 +596,10 @@ rb_bitarray_inspect(VALUE self)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    size_t cstr_size = ba->bits + 1;
+    long cstr_size = ba->bits + 1;
     char cstr[cstr_size];
     
-    size_t i;
+    long i;
     for (i = 0; i < ba->bits; i++) {
         cstr[i] = get_bit(ba, i) + '0';
     }
@@ -625,7 +629,7 @@ rb_bitarray_each(VALUE self)
     struct bit_array *ba;
     Data_Get_Struct(self, struct bit_array, ba);
 
-    size_t i;
+    long i;
 
     RETURN_ENUMERATOR(self, 0, 0);
     for (i = 0; i < ba->bits; i++) {

data/test/bm.rb

@@ -44,6 +44,10 @@ Benchmark.bm(28) { |bm|
   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 } }
+  ba.set_all_bits
+  bm.report("BitArray + (256, all set)") { 100000.times { ba + ba } }
+  ba2 = BitArray.new(240)
+  ba2.set_all_bits
+  bm.report("BitArray + (240, all set)") { 100000.times { ba2 + ba2 } }
 }
 

data/test/test.rb

@@ -120,6 +120,18 @@ class TestLibraryFileName < Test::Unit::TestCase
     ba2.set_all_bits
     ba3 = ba1 + ba2
     assert_equal "0000011111", ba3.to_s
+    ba3 = ba2 + ba1
+    assert_equal "1111100000", ba3.to_s
+  end
+
+  def test_concatenation2
+    ba1 = BitArray.new(32)
+    ba2 = BitArray.new(7)
+    ba2.set_all_bits
+    ba3 = ba1 + ba2
+    assert_equal "000000000000000000000000000000001111111", ba3.to_s
+    ba3 = ba2 + ba1
+    assert_equal "111111100000000000000000000000000000000", ba3.to_s
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ingramj-bitarray
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - James E. Ingram
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-24 00:00:00 -07:00
+date: 2009-05-25 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -50,7 +50,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.9.1
+      version: 1.8.6
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: