ingramj-bitarray 0.5.0 → 0.5.1

data/README

@@ -15,8 +15,7 @@ Example usage:
     bm.clear_bit 0
 
 
-The test/ directory has a unit test file. It also has a benchmark utility for
-comparison with Peter Cooper's pure Ruby BitField class.
+The test/ directory has a unit test file, and benchmarking utility.
 
 The examples/ directory has bloom filter dictionary-lookup demonstration.
 
@@ -43,9 +42,8 @@ See the LICENSE file for copyright and license information.
 
 Some inspiration was taken from Peter Cooper's BitField class, and various Open
 Source bitarray implementations found online, but this implementation contains
-only original code, except for test/bitfield.rb, which is Peter Cooper's
-BitField class, and test/test.rb, which was modified from the BitField test
-code.
+only original code, except for some parts for test.rb, which were modified from
+BitField's unit test file.
 
 BitField: http://snippets.dzone.com/posts/show/4234
 

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/bitarray.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bitarray}
-  s.version = "0.5.0"
+  s.version = "0.5.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-06-01}
+  s.date = %q{2009-06-02}
   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"]
@@ -26,7 +26,6 @@ Gem::Specification.new do |s|
      "examples/boolnet.rb",
      "ext/bitarray.c",
      "ext/extconf.rb",
-     "test/bitfield.rb",
      "test/bm.rb",
      "test/test.rb"
   ]
@@ -38,8 +37,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{A bitarray class for Ruby, implemented as a C extension.}
   s.test_files = [
-    "test/bitfield.rb",
-     "test/test.rb",
+    "test/test.rb",
      "test/bm.rb",
      "examples/bloomfilter.rb",
      "examples/boolnet.rb"

data/ext/bitarray.c

@@ -2,122 +2,135 @@
 #include <limits.h>
 #include <string.h>
 
-/* Bits are stored in an array of unsigned ints. We'll use a couple of defines
- * for getting the size of unsigned ints in bytes and bits.
- */
 #define UINT_BYTES (sizeof(unsigned int))
 #define UINT_BITS (UINT_BYTES * CHAR_BIT)
 
-/* bitmask macro for accessing a particular bit inside an array element. */
-#define bitmask(bit) (1 << (bit % UINT_BITS))
+/* Accessing a particular bit within a word. */
+#define bitmask(bit) (1 << ((bit) % UINT_BITS))
+
+/* Determining how many unsigned ints we need to store a given number of bits.
+ * We check if (bits - 1) is negative because the C standard helpfully
+ * specifies that in an arithmetic expression "... if either operand is
+ * unsigned long int, the other is converted to unsigned long int", causing
+ * large amounts of hilarity when one of the operands is negative.
+ */
+#define uint_array_size(bits) (bits <= 0 ? 0 : (((bits) - 1) / UINT_BITS + 1))
+
+/* Get the number of bits stored in a bitarray. */
+#define bitarray_size(ba) (ba->bits)
 
-/* Bit Array structure. */
-struct bit_array {
-    long bits;         /* Number of bits. */
-    long array_size;   /* Size of the storage array. */
+struct bitarray {
+    long bits;           /* Number of bits. */
+    long array_size;     /* Size of the storage array. */
     unsigned int *array; /* Array of unsigned ints, used for bit storage. */
 };
 
 
-/* Bit Array manipulation functions. */
+/* Low-level bit-manipulation functions.
+ * 
+ * These function are used by the Ruby interface functions to modify
+ * bitarray structures.
+ * 
+ * Functions that take an index will raise an IndexError if it is out of range.
+ * Negative indices count from the end of the array.
+ */
 
-/* Set the specified bit to 1. Return 1 on success, 0 on failure. */
-static inline int
-set_bit(struct bit_array *ba, long bit)
+
+/* This function is used by all of the bit-manipulation functions to check
+ * indices. It handles negative-index conversion and bounds checking.
+ */
+static inline long
+check_index(struct bitarray *ba, long index)
 {
-    if (bit < 0) bit += ba->bits;
-    if (bit >= ba->bits) {
-        return 0;
+    if (index < 0) index += ba->bits;
+    if (index >= ba->bits) {
+        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
     }
 
-    ba->array[bit / UINT_BITS] |= bitmask(bit);
-    return 1;
+    return index;
+}
+
+
+/* Set the specified bit to 1. */
+static inline void
+set_bit(struct bitarray *ba, long index)
+{
+    index = check_index(ba, index);
+    ba->array[index / UINT_BITS] |= bitmask(index);
 }
 
 
 /* Set all bits to 1. */
-static inline int
-set_all_bits(struct bit_array *ba)
+static inline void
+set_all_bits(struct bitarray *ba)
 {
     memset(ba->array, 0xff, (ba->array_size * UINT_BYTES));
-    return 1;
 }
 
 
-/* Clear the specified bit to 0. Return 1 on success, 0 on failure. */
-static inline int
-clear_bit(struct bit_array *ba, long bit)
+/* Clear the specified bit to 0. */
+static inline void
+clear_bit(struct bitarray *ba, long index)
 {
-    if (bit < 0) bit += ba->bits;
-    if (bit >= ba->bits) {
-        return 0;
-    }
-
-    ba->array[bit / UINT_BITS] &= ~bitmask(bit);
-    return 1;
+    index = check_index(ba, index);
+    ba->array[index / UINT_BITS] &= ~bitmask(index);
 }
 
 
 /* Clear all bits to 0. */
-static inline int
-clear_all_bits(struct bit_array *ba)
+static inline void
+clear_all_bits(struct bitarray *ba)
 {
     memset(ba->array, 0x00, (ba->array_size * UINT_BYTES));
-    return 1;
 }
 
 
-/* Toggle the state of the specified bit. Return 1 on success, 0 on failure. */
-static inline int
-toggle_bit(struct bit_array *ba, long bit)
+/* Toggle the state of the specified bit. */
+static inline void
+toggle_bit(struct bitarray *ba, long index)
 {
-    if (bit < 0) bit += ba->bits;
-    if (bit >= ba->bits) {
-        return 0;
-    }
-
-    ba->array[bit / UINT_BITS] ^= bitmask(bit);
-    return 1;
+    index = check_index(ba, index);
+    ba->array[index / UINT_BITS] ^= bitmask(index);
 }
 
 
 /* Toggle the state of all bits. */
-static inline int
-toggle_all_bits(struct bit_array *ba)
+static inline void 
+toggle_all_bits(struct bitarray *ba)
 {
     long 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 inline int
-assign_bit(struct bit_array *ba, long bit, int value)
+/* Assign the specified value to a bit. If the specified value is invalid,
+ * raises an ArgumentError.
+ */ 
+static inline void
+assign_bit(struct bitarray *ba, long index, int value)
 {
     if (value == 0) {
-        return clear_bit(ba, bit);
+        clear_bit(ba, index);
     } else if (value == 1) {
-        return set_bit(ba, bit);
+        set_bit(ba, index);
     } else {
-        return -1;
+        rb_raise(rb_eArgError, "bit value %d out of range", value);
     }
 }
 
 
-/* Get the state of the specified bit. Return -1 on failure. */
+/* Get the state of the specified bit. */
 static inline int
-get_bit(struct bit_array *ba, long bit)
+get_bit(struct bitarray *ba, long index)
 {
-    if (bit < 0) bit += ba->bits;
-    if (bit >= ba->bits) {
-        return -1;
-    }
+    index = check_index(ba, index);
 
-    unsigned int b = (ba->array[bit / UINT_BITS] & bitmask(bit));
+    /* We could shift the bit down, but this is easier. We need an unsigned int
+     * to prevent overflow.
+     */
+    unsigned int b = (ba->array[index / UINT_BITS] & bitmask(index));
     if (b > 0) {
         return 1;
     } else {
@@ -128,7 +141,7 @@ get_bit(struct bit_array *ba, long bit)
 
 /* Return the number of set bits in the array. */
 static inline long
-total_set(struct bit_array *ba)
+total_set(struct bitarray *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
@@ -148,13 +161,110 @@ total_set(struct bit_array *ba)
 }
 
 
-/* Ruby Interface Functions. */
+/* Initialize an already-allocated bitarray structure. The array is initialized
+ * to all zeros.
+ */
+static inline void
+initialize_bitarray(struct bitarray *ba, long size)
+{
+    if (size <= 0) {
+        ba->bits = 0;
+        ba->array_size = 0;
+        ba->array = NULL;
+        return;
+    }
+
+    ba->bits = size;
+    ba->array_size = uint_array_size(size);
+    ba->array = ruby_xcalloc(ba->array_size, UINT_BYTES);
+}
+
+
+/* Initialize an already-allocated bitarray structure as a copy of another
+ * bitarray structure.
+ */
+static inline void
+initialize_bitarray_copy(struct bitarray *new_ba, struct bitarray *orig_ba)
+{
+    new_ba->bits = orig_ba->bits;
+    new_ba->array_size = orig_ba->array_size;
+    new_ba->array = ruby_xmalloc2(new_ba->array_size, UINT_BYTES);
 
+    memcpy(new_ba->array, orig_ba->array, new_ba->array_size * UINT_BYTES);
+}
+
+
+/* Initialize an already-allocated bitarray structure as the concatenation of
+ * two other bitarrays structures.
+ */
+static void
+initialize_bitarray_concat(struct bitarray *new_ba, struct bitarray *x_ba,
+        struct bitarray *y_ba)
+{
+    new_ba->bits = x_ba->bits + y_ba->bits;
+    new_ba->array_size = uint_array_size(new_ba->bits);
+    new_ba->array = ruby_xmalloc2(new_ba->array_size, UINT_BYTES);
+
+
+    /* For each bit set in x_ba and y_ba, set the corresponding bit in new_ba.
+     *
+     * First, copy x_ba->array to the beginning of new_ba->array.
+     */
+    memcpy(new_ba->array, x_ba->array, x_ba->array_size * UINT_BYTES);
+
+    /* Then, if x_ba->bits is a multiple of UINT_BITS, we can just copy
+     * y_ba->array onto the end of new_ba->array.
+     * 
+     * Otherwise, we need to go through y_ba->array bit-by-bit and set the
+     * appropriate bits in new_ba->array.
+     */
+    if ((x_ba->bits % UINT_BITS) == 0) {
+        unsigned int *start = new_ba->array + x_ba->array_size;
+        memcpy(start, y_ba->array, y_ba->array_size * UINT_BYTES);
+    } else {
+        long y_index, new_index;
+        for (y_index = 0, new_index = x_ba->bits;
+                y_index < y_ba->bits;
+                y_index++, new_index++)
+        {
+            if (get_bit(y_ba, y_index) == 1) {
+                set_bit(new_ba, new_index);
+            } else {
+                clear_bit(new_ba, new_index);
+            }
+        }
+    }
+
+}
+
+
+
+/* Ruby Interface Functions.
+ * 
+ * These functions put a Ruby face on top of the lower-level functions. With
+ * very few exceptions, they should not access the bitarray structs' members
+ * directly.
+ *
+ * "bitarray" refers to the C structure. "BitArray" refers to the Ruby class.
+ *
+ * All publicly-accessible functions (those with an rb_define_method call in
+ * Init_bitarray) should have RDoc comment headers.
+ *
+ * When in doubt, see how array.c does things.
+ */
+
+
+/* Our BitArray class. This is initialized in Init_bitarray, but we declare it
+ * here because a few functions need it.
+ */
 static VALUE rb_bitarray_class;
 
 
+/* This gets called when a BitArray is garbage collected. It frees the memory
+ * used by the bitarray struct.
+ */
 static void
-rb_bitarray_free(struct bit_array *ba)
+rb_bitarray_free(struct bitarray *ba)
 {
     if (ba && ba->array) {
         ruby_xfree(ba->array);
@@ -163,33 +273,96 @@ rb_bitarray_free(struct bit_array *ba)
 }
 
 
+/* This function is called by BitArray.new to allocate a new BitArray.
+ * Initialization is done in a seperate function.
+ * 
+ * This function can be called directly with BitArray.allocate, but that is not
+ * very useful.
+ */
 static VALUE
 rb_bitarray_alloc(VALUE klass)
 {
-    struct bit_array *ba;
-    return Data_Make_Struct(rb_bitarray_class, struct bit_array, NULL,
+    struct bitarray *ba;
+    return Data_Make_Struct(rb_bitarray_class, struct bitarray, NULL,
             rb_bitarray_free, ba);
 }
 
 
+/* Initialization helper-function prototypes. These functions are defined after
+ * rb_bitarray_initialize.
+ */
+static VALUE rb_bitarray_from_string(VALUE self, VALUE string);
+static VALUE rb_bitarray_from_array(VALUE self, VALUE array);
+
+
+/* call-seq:
+ *      BitArray.new(size)
+ *      BitArray.new(string)
+ *      BitArray.new(array)
+ *
+ * When called with a size, creates a new BitArray of the specified size, with
+ * all bits cleared. When called with a string or an array, creates a new
+ * BitArray from the argument.
+ *
+ * If a string is given, it should consist of ones and zeroes. If there are
+ * any other characters in the string, the first invalid character and all
+ * following characters will be ignored.
+ *
+ *   b = BitArray.new("10101010")       => 10101010
+ *   b = BitArray.new("1010abcd")       => 1010
+ *   b = BitArray.new("abcd")           => 
+ *
+ * If an array is given, the BitArray is initialized from its elements using
+ * the following rules:
+ *
+ * 1. 0, false, or nil  => 0
+ * 2. anything else     => 1
+ *
+ * Note that the 0 is a number, not a string. "Anything else" means strings,
+ * symbols, non-zero numbers, subarrays, etc.
+ *
+ *   b = BitArray.new([0,0,0,1,1,0])            => 000110
+ *   b = BitArray.new([false, true, false])     => 010
+ *   b = BitArray.new([:a, :b, :c, [:d, :e]])   => 1111
+ */
+static VALUE
+rb_bitarray_initialize(VALUE self, VALUE arg)
+{
+    if (TYPE(arg) == T_FIXNUM || TYPE(arg) == T_BIGNUM) {
+        struct bitarray *ba;
+        Data_Get_Struct(self, struct bitarray, ba);
+
+        initialize_bitarray(ba, NUM2LONG(arg));
+    
+        return self;
+
+    } else if (TYPE(arg) == T_STRING) {
+        return rb_bitarray_from_string(self, arg);
+    } else if (TYPE(arg) == T_ARRAY) { 
+        return rb_bitarray_from_array(self, arg);
+    } else {
+        rb_raise(rb_eArgError, "must be size, string, or array");
+    }
+}
+
+
 /* Create a new BitArray from a string. Called by rb_bitarray_initialize. */
 static VALUE
-rb_bitarray_from_string(VALUE self, VALUE arg)
+rb_bitarray_from_string(VALUE self, VALUE string)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
     /* Extract a C-string from arg. */
-    long str_len = RSTRING_LEN(arg) + 1;
+    long str_len = RSTRING_LEN(string) + 1;
     char cstr[str_len];
-    strncpy(cstr, StringValueCStr(arg), str_len);
+    strncpy(cstr, StringValueCStr(string), str_len);
 
     /* If the string doesn't begin with a '1' or '0', return an empty
      * BitArray.
      */
     if (cstr[0] != '0' && cstr[0] != '1') {
-        ba->bits = 0;
-        ba->array_size = 0;
+        initialize_bitarray(ba, 0);
         return self;
     }
 
@@ -205,9 +378,7 @@ rb_bitarray_from_string(VALUE self, VALUE arg)
     }
 
     /* Setup the BitArray structure. */
-    ba->bits = strlen(cstr);
-    ba->array_size = ((ba->bits - 1) / UINT_BITS) + 1;
-    ba->array = ruby_xmalloc(ba->array_size * UINT_BYTES);
+    initialize_bitarray(ba, strlen(cstr));
 
     /* Initialize the bit array with the string. */
     for (i = 0; i < ba->bits; i++) {
@@ -224,19 +395,18 @@ rb_bitarray_from_string(VALUE self, VALUE arg)
 
 /* Create a new BitArray from an Array. Called by rb_bitarray_initialize */
 static VALUE
-rb_bitarray_from_array(VALUE self, VALUE arg)
+rb_bitarray_from_array(VALUE self, VALUE array)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    ba->bits = RARRAY_LEN(arg);
-    ba->array_size = ((ba->bits - 1) / UINT_BITS) + 1;
-    ba->array = ruby_xmalloc(ba->array_size * UINT_BYTES);
+    long size = RARRAY_LEN(array);
+    initialize_bitarray(ba, size);
 
     VALUE e;
     long i;
-    for (i = 0; i < ba->bits; i++) {
-        e = rb_ary_entry(arg, i);
+    for (i = 0; i < size; i++) {
+        e = rb_ary_entry(array, i);
 
         switch (TYPE(e)) {
             case T_FIXNUM:      /* fixnums and bignums treated the same. */
@@ -256,66 +426,6 @@ rb_bitarray_from_array(VALUE self, VALUE arg)
 }
 
 
-/* call-seq:
- *      BitArray.new(size)
- *      BitArray.new(string)
- *      BitArray.new(array)
- *
- * When called with a size, creates a new BitArray of the specified size, with
- * all bits cleared. When called with a string or an array, creates a new
- * BitArray from the argument.
- *
- * If a string is given, it should consist of ones and zeroes. If there are
- * any other characters in the string, the first invalid character and all
- * following characters will be ignored.
- *
- *   b = BitArray.new("10101010")       => 10101010
- *   b = BitArray.new("1010abcd")       => 1010
- *   b = BitArray.new("abcd")           => 
- *
- * If an array is given, the BitArray is initialized from its elements using
- * the following rules:
- *
- * 1. 0, false, or nil  => 0
- * 2. anything else     => 1
- *
- * Note that the 0 is a number, not a string. "Anything else" means strings,
- * symbols, non-zero numbers, subarrays, etc.
- *
- *   b = BitArray.new([0,0,0,1,1,0])            => 000110
- *   b = BitArray.new([false, true, false])     => 010
- *   b = BitArray.new([:a, :b, :c, [:d, :e]])   => 1111
- */
-static VALUE
-rb_bitarray_initialize(VALUE self, VALUE arg)
-{
-    if (TYPE(arg) == T_FIXNUM || TYPE(arg) == T_BIGNUM) {
-        struct bit_array *ba;
-        Data_Get_Struct(self, struct bit_array, ba);
-
-        long bits = NUM2LONG(arg);
-        if (bits <= 0) {
-            ba->bits = 0;
-            ba->array_size = 0;
-            return self;
-        }
-        
-        ba->bits = bits;
-        ba->array_size = ((bits - 1) / UINT_BITS) + 1;
-        ba->array = ruby_xcalloc(ba->array_size, UINT_BYTES);
-
-        return self;
-
-    } else if (TYPE(arg) == T_STRING) {
-        return rb_bitarray_from_string(self, arg);
-    } else if (TYPE(arg) == T_ARRAY) { 
-        return rb_bitarray_from_array(self, arg);
-    } else {
-        rb_raise(rb_eArgError, "must be size, string, or array");
-    }
-}
-
-
 /* call-seq:
  *      bitarray.clone          -> a_bitarray
  *      bitarray.dup            -> a_bitarray
@@ -325,15 +435,11 @@ rb_bitarray_initialize(VALUE self, VALUE arg)
 static VALUE
 rb_bitarray_initialize_copy(VALUE self, VALUE orig)
 {
-    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);
+    struct bitarray *new_ba, *orig_ba;
+    Data_Get_Struct(self, struct bitarray, new_ba);
+    Data_Get_Struct(orig, struct bitarray, orig_ba);
 
-    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, orig_ba->array, (new_ba->array_size * UINT_BYTES));
+    initialize_bitarray_copy(new_ba, orig_ba);
 
     return self;
 }
@@ -348,40 +454,18 @@ rb_bitarray_initialize_copy(VALUE self, VALUE orig)
 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, 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. 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.
-     */
-    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);
-            }
-        }
-    }
+    /* Get the bitarrays from x and y */
+    struct bitarray *x_ba, *y_ba;
+    Data_Get_Struct(x, struct bitarray, x_ba);
+    Data_Get_Struct(y, struct bitarray, y_ba);
+
+    /* Create a new BitArray, and its bitarray structure*/
+    VALUE z = rb_bitarray_alloc(rb_bitarray_class);
+    struct bitarray *z_ba;
+    Data_Get_Struct(z, struct bitarray, z_ba);
+
+    initialize_bitarray_concat(z_ba, x_ba, y_ba);
+
     return z;
 }
 
@@ -395,10 +479,10 @@ rb_bitarray_concat(VALUE x, VALUE y)
 static VALUE
 rb_bitarray_size(VALUE self)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    return LONG2NUM(ba->bits);
+    return LONG2NUM(bitarray_size(ba));
 }
 
 
@@ -410,11 +494,10 @@ rb_bitarray_size(VALUE self)
 static VALUE
 rb_bitarray_total_set(VALUE self)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    long count = total_set(ba);
-    return LONG2NUM(count);
+    return LONG2NUM(total_set(ba));
 }
 
 
@@ -426,18 +509,13 @@ rb_bitarray_total_set(VALUE self)
  * +IndexError+ is raised.
  */
 static VALUE
-rb_bitarray_set_bit(VALUE self, VALUE bit)
+rb_bitarray_set_bit(VALUE self, VALUE index)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
-
-    long index = NUM2LONG(bit);
-
-    if (set_bit(ba, index)) {
-        return self;
-    } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
-    }
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
+    
+    set_bit(ba, NUM2LONG(index));
+    return self;
 }
 
 
@@ -449,14 +527,11 @@ rb_bitarray_set_bit(VALUE self, VALUE bit)
 static VALUE
 rb_bitarray_set_all_bits(VALUE self)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    if(set_all_bits(ba)) {
-        return self;
-    } else {
-        rb_bug("BitArray#set_all_bits failed. This should not occur.");
-    }
+    set_all_bits(ba);
+    return self;
 }
 
 
@@ -468,18 +543,13 @@ rb_bitarray_set_all_bits(VALUE self)
  * +IndexError+ is raised.
  */
 static VALUE
-rb_bitarray_clear_bit(VALUE self, VALUE bit)
+rb_bitarray_clear_bit(VALUE self, VALUE index)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    long index = NUM2LONG(bit);
-
-    if (clear_bit(ba, index)) {
-        return self;
-    } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
-    }
+    clear_bit(ba, NUM2LONG(index));
+    return self;
 }
 
 
@@ -491,14 +561,11 @@ rb_bitarray_clear_bit(VALUE self, VALUE bit)
 static VALUE
 rb_bitarray_clear_all_bits(VALUE self)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    if(clear_all_bits(ba)) {
-        return self;
-    } else {
-        rb_bug("BitArray#clear_all_bits failed. This should not occur.");
-    }
+    clear_all_bits(ba);
+    return self;
 }
 
 
@@ -510,18 +577,13 @@ rb_bitarray_clear_all_bits(VALUE self)
  * +IndexError+ is raised.
  */
 static VALUE
-rb_bitarray_toggle_bit(VALUE self, VALUE bit)
+rb_bitarray_toggle_bit(VALUE self, VALUE index)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
-
-    long index = NUM2LONG(bit);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    if (toggle_bit(ba, index)) {
-        return self;
-    } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
-    }
+    toggle_bit(ba, NUM2LONG(index));
+    return self;
 }
 
 
@@ -533,82 +595,19 @@ rb_bitarray_toggle_bit(VALUE self, VALUE bit)
 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.");
-    }
-}
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-/* Return an individual bit. */
-static VALUE
-rb_bitarray_get_bit(VALUE self, long index)
-{
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
-
-    int bit_value = get_bit(ba, index);
-
-    if (bit_value >= 0) {
-        return INT2NUM(bit_value);
-    } else {
-        rb_raise(rb_eIndexError, "index %ld out of bit array", index);
-    }
+    toggle_all_bits(ba);
+    return self;
 }
 
 
-/* Create a new BitArray from a subsequence of x. */
-static VALUE
-rb_bitarray_subseq(VALUE x, long beg, long 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, LONG2NUM(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. */
-    long 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;
-}
+/* Bit-reference helper-function prototypes. These are defined after
+ * rb_bitarray_bitref.
+ */
+static inline VALUE rb_bitarray_get_bit(VALUE self, long index);
+static VALUE rb_bitarray_subseq(VALUE self, long beg, long len);
 
 
 /* call-seq:
@@ -622,7 +621,6 @@ rb_bitarray_subseq(VALUE x, long beg, long len)
  * _index_ is greater than the capacity of _bitarray_, an +IndexError+ is
  * raised.
  */
-
 static VALUE
 rb_bitarray_bitref(int argc, VALUE *argv, VALUE self)
 {
@@ -650,8 +648,8 @@ rb_bitarray_bitref(int argc, VALUE *argv, VALUE self)
         return rb_bitarray_get_bit(self, FIX2LONG(arg));
     }
 
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, 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
@@ -671,6 +669,67 @@ rb_bitarray_bitref(int argc, VALUE *argv, VALUE self)
 }
 
 
+/* Return an individual bit. */
+static inline VALUE
+rb_bitarray_get_bit(VALUE self, long index)
+{
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
+
+    return INT2NUM(get_bit(ba, index));
+}
+
+
+/* Create a new BitArray from a subsequence of x. */
+static VALUE
+rb_bitarray_subseq(VALUE x, long beg, long len)
+{
+
+    struct bitarray *x_ba;
+    Data_Get_Struct(x, struct bitarray, x_ba);
+
+    /* Quick exit - a negative length, or a beginning past the end of the
+     * array returns nil.
+     */
+    if (beg < 0) {
+        beg += bitarray_size(x_ba);
+    }
+    if (len < 0 || beg > bitarray_size(x_ba)) {
+        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 (bitarray_size(x_ba) <  len ||  bitarray_size(x_ba) < (beg + len)) {
+        len = bitarray_size(x_ba) - beg;
+    }
+
+    /* Create a new BitArray of the appropriate size. */
+    VALUE y = rb_bitarray_alloc(rb_bitarray_class);
+    rb_bitarray_initialize(y, LONG2NUM(len));
+    /* If our length is 0, we can just return now. */
+    if (len == 0) {
+        return y;
+    }
+    struct bitarray *y_ba;
+    Data_Get_Struct(y, struct bitarray, y_ba);
+
+    /* For each set bit in x[beg..len], set the corresponding bit in y. */
+    long 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     -> value
  *
@@ -682,22 +741,13 @@ rb_bitarray_bitref(int argc, VALUE *argv, VALUE self)
  * raised.
  */
 static VALUE
-rb_bitarray_assign_bit(VALUE self, VALUE bit, VALUE value)
+rb_bitarray_assign_bit(VALUE self, VALUE index, VALUE value)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
-
-    long index = NUM2LONG(bit);
-    int bit_value = NUM2INT(value);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    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", index);
-    } else {
-        rb_raise(rb_eRuntimeError, "bit value %d out of range", bit_value);
-    }
+    assign_bit(ba, NUM2LONG(index), NUM2INT(value));
+    return value; 
 }
 
 
@@ -710,17 +760,17 @@ rb_bitarray_assign_bit(VALUE self, VALUE bit, VALUE value)
 static VALUE
 rb_bitarray_inspect(VALUE self)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    long cstr_size = ba->bits + 1;
+    long cstr_size = bitarray_size(ba) + 1;
     char cstr[cstr_size];
     
     long i;
-    for (i = 0; i < ba->bits; i++) {
+    for (i = 0; i < bitarray_size(ba); i++) {
         cstr[i] = get_bit(ba, i) + '0';
     }
-    cstr[ba->bits] = '\0';
+    cstr[cstr_size - 1] = '\0';
 
     VALUE str = rb_str_new2(cstr);
     return str;
@@ -735,10 +785,10 @@ rb_bitarray_inspect(VALUE self)
 static VALUE
 rb_bitarray_to_a(VALUE self)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
-    long array_size = ba->bits;
+    long array_size = bitarray_size(ba);
     VALUE c_array[array_size];
     
     int i;
@@ -766,13 +816,13 @@ rb_bitarray_to_a(VALUE self)
 static VALUE
 rb_bitarray_each(VALUE self)
 {
-    struct bit_array *ba;
-    Data_Get_Struct(self, struct bit_array, ba);
+    struct bitarray *ba;
+    Data_Get_Struct(self, struct bitarray, ba);
 
     long i;
 
     RETURN_ENUMERATOR(self, 0, 0);
-    for (i = 0; i < ba->bits; i++) {
+    for (i = 0; i < bitarray_size(ba); i++) {
         int bit_value = get_bit(ba, i);
         rb_yield(INT2NUM(bit_value));
     }

data/test/bm.rb

@@ -1,61 +1,37 @@
-require 'bitfield'
 require 'bitarray'
 require 'benchmark'
 
 Benchmark.bm(28) { |bm|
-  puts "---------------------------- Object instantiation (10,000 iterations)"
-  bm.report("BitField initialize") { 10000.times { BitField.new(256) } }
   bm.report("BitArray initialize") { 10000.times { BitArray.new(256) } }
   s = "0"*256
   bm.report("BitArray init from string") { 10000.times { BitArray.new(s) } }
   a = [0]*256
   bm.report("BitArray init from array")  { 10000.times { BitArray.new(a) } }
 
-  bf = BitField.new(256)
   ba = BitArray.new(256)
   
-  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 (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 (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 (10,000 iterations)"
-  bm.report("BitField to_s")       { 10000.times { bf.to_s } }
   bm.report("BitArray to_s")       { 10000.times { ba.to_s } }
-
-  puts "---------------------------- To Array (10,000 iterations)"
-  bm.report("BitField to_a")       { 10000.times { bf.to_a } }
   bm.report("BitArray to_a")       { 10000.times { ba.to_a } }
-
-  puts "---------------------------- Total Set (100,000 iterations)"
-  bf = BitField.new(256)
+  
   ba = BitArray.new(256)
-  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}
+  bm.report("BitArray total_set (none)") { 10000.times { ba.total_set } }
   ba.set_all_bits
-  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 total_set (all)")  { 10000.times { ba.total_set } }
+
+  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("BitArray slice (beg,len)") { 10000.times { ba[17, 230] } }
+  bm.report("BitArray slice (range)")   { 10000.times { ba[17..247] } }
   ba.set_all_bits
-  bm.report("BitArray + (256, all set)") { 100000.times { ba + ba } }
+  bm.report("BitArray + (256, all set)") { 10000.times { ba + ba } }
   ba2 = BitArray.new(240)
   ba2.set_all_bits
-  bm.report("BitArray + (240, all set)") { 100000.times { ba2 + ba2 } }
+  bm.report("BitArray + (240, all set)") { 10000.times { ba2 + ba2 } }
 }
 

data/test/test.rb

@@ -33,14 +33,16 @@ class TestLibraryFileName < Test::Unit::TestCase
   
   def test_multiple_setting
     1.upto(999) do |pos|
-      2.times { @public_ba[pos] = 1 }
+      @public_ba[pos] = 1 
+      @public_ba[pos] = 1
       assert_equal 1, @public_ba[pos]
     end
   end
 
   def test_multiple_unsetting
     1.upto(999) do |pos|
-      2.times { @public_ba[pos] = 0 }
+      @public_ba[pos] = 0
+      @public_ba[pos] = 0
       assert_equal 0, @public_ba[pos]
     end
   end
@@ -135,6 +137,13 @@ class TestLibraryFileName < Test::Unit::TestCase
     assert_equal "111111100000000000000000000000000000000", ba3.to_s
   end
 
+  def test_concatenation3
+    ba1 = BitArray.new(0)
+    ba2 = BitArray.new(0)
+    ba3 = ba1 + ba2
+    assert_equal "", ba3.to_s
+  end
+
   def test_to_a
     ba = BitArray.new(16)
     ba[1] = 1
@@ -149,6 +158,8 @@ class TestLibraryFileName < Test::Unit::TestCase
     assert_equal "00011", ba.to_s
     ba = BitArray.new("abcd0101")
     assert_equal "", ba.to_s
+    ba = BitArray.new("")
+    assert_equal "", ba.to_s
   end
 
 
@@ -159,6 +170,8 @@ class TestLibraryFileName < Test::Unit::TestCase
     assert_equal "11001", ba.to_s
     ba = BitArray.new([nil, nil, :a, nil, [:b, :c]])
     assert_equal "00101", ba.to_s
+    ba = BitArray.new([])
+    assert_equal "", ba.to_s
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ingramj-bitarray
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - James E. Ingram
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-01 00:00:00 -07:00
+date: 2009-06-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -34,7 +34,6 @@ files:
 - examples/boolnet.rb
 - ext/bitarray.c
 - ext/extconf.rb
-- test/bitfield.rb
 - test/bm.rb
 - test/test.rb
 has_rdoc: true
@@ -68,7 +67,6 @@ signing_key:
 specification_version: 2
 summary: A bitarray class for Ruby, implemented as a C extension.
 test_files: 
-- test/bitfield.rb
 - test/test.rb
 - test/bm.rb
 - examples/bloomfilter.rb

data/test/bitfield.rb

@@ -1,67 +0,0 @@
-#        NAME: BitField
-#      AUTHOR: Peter Cooper
-#     LICENSE: MIT ( http://www.opensource.org/licenses/mit-license.php )
-#   COPYRIGHT: (c) 2007 Peter Cooper (http://www.petercooper.co.uk/)
-#     VERSION: v4
-#     HISTORY: 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)
-#
-# DESCRIPTION: Basic, pure Ruby bit field. Pretty fast (for what it is) and memory efficient.
-#              I've written a pretty intensive test suite for it and it passes great. 
-#              Works well for Bloom filters (the reason I wrote it).
-#
-#              Create a bit field 1000 bits wide
-#                bf = BitField.new(1000)
-#
-#              Setting and reading bits
-#                bf[100] = 1
-#                bf[100]    .. => 1
-#                bf[100] = 0
-#
-#              More
-#                bf.to_s = "10101000101010101"  (example)
-#                bf.total_set         .. => 10  (example - 10 bits are set to "1")
-
-class BitField
-  attr_reader :size
-  include Enumerable
-  
-  ELEMENT_WIDTH = 32
-  
-  def initialize(size)
-    @size = size
-    @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
-    inject("") { |a, b| a + b.to_s }
-  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