bitset 0.1.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 67a16f9ffaa21475905ca59bde6734954735e3c7
+  data.tar.gz: c734af4e2b220c01b760f1e93fd05940ca79569d
+SHA512:
+  metadata.gz: 6603741fd0c7f3a5e348e3db792695fdfc5926062567d401e49b2c66f8ae7e44dc8e1eed66fc8d69859305dc265a3abe2377dad5486ee234da872fa427a9119b
+  data.tar.gz: 50f4c82523b31f15d176d7dc26a47be1610135bd4b826f2633abe960394c3fea407d67b7b624dc27148004374f1035968880fb007753c7efd2e440166d429431

data/README.markdown

@@ -0,0 +1,158 @@
+Bitset
+======
+
+A fast Bitset implementation for Ruby. Available as the 'bitset' gem.
+
+
+Installation
+------------
+
+Usually you want to do this:
+
+    gem install bitset
+
+But if you want the latest patches or want to work on it yourself, you may want
+to do this:
+
+    git clone git://github.com/ericboesch/bitset.git
+    cd bitset
+    rake build
+    gem install pkg/bitset-<version>.gem
+
+
+Usage
+-----
+
+You create a bitset like this:
+
+    >> Bitset.new(8)
+    => 00000000
+
+Here we created an 8-bit bitset. All bits are initialized to 0.
+
+We can also create a bitset based on a string of ones and zeros.
+
+    >> Bitset.from_s('00010001')
+    => 00010001
+
+Obviously you can also set and clear bits...
+
+    >> bitset = Bitset.new(8)
+    => 00000000
+    
+    >> bitset[3] = true
+    => 00010000
+    
+    >> bitset[3] = false
+    => 00000000
+    
+    >> bitset.set(1, 3, 5, 7)
+    => 01010101
+    
+    >> bitset.clear(1, 5)
+    => 00010001
+
+The point of a bitset is to be, effectively, an array of single bits. It should
+support basic set and bitwise operations. So, let's look at a few of those.
+
+    >> a = Bitset.from_s('00001111')
+    => 00001111
+    
+    >> b = Bitset.from_s('01010101')
+    => 01010101
+    
+    >> a & b
+    => 00000101
+    
+    >> a | b
+    => 01011111
+    
+    >> b - a
+    => 01010000
+    
+    >> a ^ b
+    => 01011010
+    
+    >> ~a
+    => 11110000
+    
+    >> a.hamming(b)
+    => 4
+    
+    >> a.cardinality
+    => 4
+    
+    >> a.reverse
+    => 11110000
+
+    # Tell whether all of the given bit numbers are set
+    >> a.set? 6
+    => true
+
+    # Return a new Bitset composed of bits #1, #3, #5, #4, and #1 again
+    >> a.select_bits [1,3,5,4,1]
+    => 00110
+
+    # Tell whether all of the given bit numbers are clear
+    >> a.clear? 1,3,5
+    => false
+
+    # Tell whether all bits are clear
+    >> a.empty?
+    => false
+
+    # Pass all bits to the block
+    >> b.each { |v| puts v }
+    => false
+       true
+       false
+       ...
+
+    # Pass the positions of all set bits to the block
+    >> b.each_set { |bit| puts bit }
+    => 1
+       3
+       5
+       7
+
+    # Return an array of the positions of all set bits
+    >> b.each_set
+    => [1, 3, 5, 7]
+
+    # The following methods modify a Bitset in place very quickly:
+    >> a.intersect!(b)      #  like a &= b
+    >> a.union!(b)          #  like a |= b
+    >> a.difference!(b)     #  like a -= b
+    >> a.xor!(b)            #  alias a.symmetric_difference!(b), like a ^= b
+    >> a.reset!
+
+    # Above, "like" does not mean "identical to." a |= b creates a new
+    # Bitset object. a.union!(b) changes an existing object which
+    # affects all variables that point to the same object.
+
+    # Attempting to apply bitwise binary operators or their in-place
+    # equivalents between bitsets of different sizes will raise an
+    # ArgumentError.
+
+    # b.dup and b.clone are also available.
+
+    # Marshal.dump and Marshal.load are also supported. If you want to
+    # save a few bytes and don't need Marshal.load to work, you can
+    # use #pack and Bitset.unpack instead.
+
+Contributing
+------------
+
+The best way to contribute is to fork the project on GitHub, make your changes,
+and send a pull request. This is always much appreciated. If you want to mess
+around with the version numbers, gemspec, or anything like that feel free... But
+do it in separate commits so I can easily ignore them.
+
+
+License
+-------
+
+See LICENSE.txt.
+
+
+### Thanks for using Bitset!

data/Rakefile

@@ -12,17 +12,17 @@ task :default => :spec
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   gem.name = "bitset"
-  gem.homepage = "http://github.com/tyler/bitset"
+  gem.homepage = "http://github.com/ericboesch/bitset"
   gem.license = "MIT"
   gem.summary = 'Bitset implementation.'
   gem.description = 'A fast C-based Bitset. It supports the standard set operations as well as operations you may expect on bit arrays. (popcount, for instance)'
-  gem.email = "tbmcmullen@gmail.com"
+  gem.email = "eric.boesch@nist.gov"
   gem.authors = ["Tyler McMullen"]
 end
 Jeweler::RubygemsDotOrgTasks.new
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 
   rdoc.rdoc_dir = 'rdoc'

data/VERSION

@@ -1 +1 @@
-0.1.0
+1.0.0

data/bitset.gemspec

@@ -5,13 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bitset}
-  s.version = "0.1.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Tyler McMullen"]
-  s.date = %q{2011-03-03}
+  s.authors = ["Tyler McMullen", "Eric Boesch"]
+  s.date = %q{2016-02-22}
   s.description = %q{A fast C-based Bitset. It supports the standard set operations as well as operations you may expect on bit arrays. (popcount, for instance)}
-  s.email = %q{tbmcmullen@gmail.com}
+  s.email = %q{ericboesch@gmail.com}
   s.extensions = ["ext/bitset/extconf.rb"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -25,9 +25,10 @@ Gem::Specification.new do |s|
     "bitset.gemspec",
     "ext/bitset/bitset.c",
     "ext/bitset/extconf.rb",
+    "lib/bitset/bitset.rb",
     "spec/bitset_spec.rb"
   ]
-  s.homepage = %q{http://github.com/tyler/bitset}
+  s.homepage = %q{http://github.com/ericboesch/bitset}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}

data/ext/bitset/bitset.c

@@ -11,16 +11,18 @@ typedef struct {
     uint64_t * data;
 } Bitset;
 
-#define BYTES(_bs) (((_bs->len-1) >> 3) + 1)
-#define INTS(_bs) (((_bs->len-1) >> 6) + 1)
+// Avoid using (len-1), just in case len == 0.
+#define BYTES(_bs) (((_bs)->len+7) >> 3)
+#define INTS(_bs) (((_bs)->len+63) >> 6)
+ // 2^6=64
 
 Bitset * bitset_new() {
-    return (Bitset *) malloc(sizeof(Bitset));
+    return (Bitset *) calloc(1, sizeof(Bitset));
 }
 
 void bitset_setup(Bitset * bs, int len) {
     bs->len = len;
-    bs->data = (uint64_t *) calloc((((bs->len-1) >> 6) + 1), sizeof(uint64_t)); // 2^6=64
+    bs->data = (uint64_t *) calloc(INTS(bs), sizeof(uint64_t));
 }
 
 void bitset_free(Bitset * bs) {
@@ -30,7 +32,7 @@ void bitset_free(Bitset * bs) {
 }
 
 
-Bitset * get_bitset(VALUE obj) {
+static Bitset * get_bitset(VALUE obj) {
     Bitset * bs;
     Data_Get_Struct(obj, Bitset, bs);
     return bs;
@@ -53,44 +55,43 @@ static VALUE rb_bitset_size(VALUE self, VALUE len) {
     return INT2NUM(bs->len);
 }
 
-void raise_index_error() {
+static void raise_index_error() {
     VALUE rb_eIndexError = rb_const_get(rb_cObject, rb_intern("IndexError"));
     rb_raise(rb_eIndexError, "Index out of bounds");
 }
 
-#define _bit_segment(bit) ((bit) >> 6UL)
-#define _bit_mask(bit) (((uint64_t) 1) << ((bit) & 0x3f))
+#define _bit_no(bit) ((bit) & 0x3f)
+#define _bit_segment(bit) ((bit) >> 6)
+#define _bit_mask(bit) (((uint64_t) 1) << _bit_no(bit))
+#define _seg_no_to_bit_no(seg_no) ((seg_no) << 6)
+#define _get_bit(bs, idx) ((bs)->data[_bit_segment(idx)] & _bit_mask(idx))
+#define _set_bit(bs, idx) ((bs)->data[_bit_segment(idx)] |= _bit_mask(idx))
+#define _clear_bit(bs, idx) ((bs)->data[_bit_segment(idx)] &= ~_bit_mask(idx))
 
-void validate_index(Bitset * bs, int idx) {
+static void validate_index(Bitset * bs, int idx) {
     if(idx < 0 || idx >= bs->len)
         raise_index_error();
 }
 
-uint64_t get_bit(Bitset * bs, int idx) {
-    uint64_t segment = bs->data[_bit_segment(idx)];
-    return segment & _bit_mask(idx);
-}
-
-void set_bit(Bitset * bs, int idx) {
-    bs->data[_bit_segment(idx)] |= _bit_mask(idx);
-}
-
-void clear_bit(Bitset * bs, int idx) {
-    bs->data[_bit_segment(idx)] &= ~_bit_mask(idx);
+static void verify_equal_size(Bitset * bs1, Bitset * bs2) {
+   if (bs1->len != bs2->len) {
+       VALUE rb_eArgumentError = rb_const_get(rb_cObject, rb_intern("ArgumentError"));
+       rb_raise(rb_eArgumentError, "Operands size mismatch");
+   }
 }
 
 void assign_bit(Bitset * bs, int idx, VALUE value) {
     if(NIL_P(value) || value == Qfalse)
-        clear_bit(bs, idx);
+        _clear_bit(bs, idx);
     else
-        set_bit(bs, idx);
+        _set_bit(bs, idx);
 }
 
 static VALUE rb_bitset_aref(VALUE self, VALUE index) {
     Bitset * bs = get_bitset(self);
     int idx = NUM2INT(index);
     validate_index(bs, idx);
-    return get_bit(bs, idx) > 0 ? Qtrue : Qfalse;
+    return _get_bit(bs, idx) > 0 ? Qtrue : Qfalse;
 }
 
 static VALUE rb_bitset_aset(VALUE self, VALUE index, VALUE value) {
@@ -108,7 +109,7 @@ static VALUE rb_bitset_set(int argc, VALUE * argv, VALUE self) {
         VALUE index = argv[i];
         int idx = NUM2INT(index);
         validate_index(bs, idx);
-        set_bit(bs, idx);
+        _set_bit(bs, idx);
     }
     return Qtrue;
 }
@@ -120,7 +121,7 @@ static VALUE rb_bitset_clear(int argc, VALUE * argv, VALUE self) {
         VALUE index = argv[i];
         int idx = NUM2INT(index);
         validate_index(bs, idx);
-        clear_bit(bs, idx);
+        _clear_bit(bs, idx);
     }
     return Qtrue;
 }
@@ -132,7 +133,7 @@ static VALUE rb_bitset_clear_p(int argc, VALUE * argv, VALUE self) {
         VALUE index = argv[i];
         int idx = NUM2INT(index);
         validate_index(bs, idx);
-        if(get_bit(bs, idx) > 0)
+        if(_get_bit(bs, idx) > 0)
             return Qfalse;
     }
     return Qtrue;
@@ -145,7 +146,7 @@ static VALUE rb_bitset_set_p(int argc, VALUE * argv, VALUE self) {
         VALUE index = argv[i];
         int idx = NUM2INT(index);
         validate_index(bs, idx);
-        if(get_bit(bs, idx) == 0)
+        if(_get_bit(bs, idx) == 0)
             return Qfalse;
     }
     return Qtrue;
@@ -154,13 +155,10 @@ static VALUE rb_bitset_set_p(int argc, VALUE * argv, VALUE self) {
 static VALUE rb_bitset_cardinality(VALUE self) {
     Bitset * bs = get_bitset(self);
     int i;
-    int max = ((bs->len-1) >> 6) + 1;
+    int max = INTS(bs);
     int count = 0;
     for(i = 0; i < max; i++) {
-        uint64_t segment = bs->data[i];
-        if(i+1 == max)
-            segment &= ((((uint64_t) 1) << (bs->len & 0x3F)) - 1);
-        count += __builtin_popcountll(segment);
+        count += __builtin_popcountll(bs->data[i]);
     }
     return INT2NUM(count);
 }
@@ -168,11 +166,12 @@ static VALUE rb_bitset_cardinality(VALUE self) {
 static VALUE rb_bitset_intersect(VALUE self, VALUE other) {
     Bitset * bs = get_bitset(self);
     Bitset * other_bs = get_bitset(other);
+    verify_equal_size(bs, other_bs);
 
     Bitset * new_bs = bitset_new();
     bitset_setup(new_bs, bs->len);
 
-    int max = ((bs->len-1) >> 6) + 1;
+    int max = INTS(bs);
     int i;
     for(i = 0; i < max; i++) {
         uint64_t segment = bs->data[i];
@@ -186,11 +185,12 @@ static VALUE rb_bitset_intersect(VALUE self, VALUE other) {
 static VALUE rb_bitset_union(VALUE self, VALUE other) {
     Bitset * bs = get_bitset(self);
     Bitset * other_bs = get_bitset(other);
+    verify_equal_size(bs, other_bs);
 
     Bitset * new_bs = bitset_new();
     bitset_setup(new_bs, bs->len);
 
-    int max = ((bs->len-1) >> 6) + 1;
+    int max = INTS(bs);
     int i;
     for(i = 0; i < max; i++) {
         uint64_t segment = bs->data[i];
@@ -204,11 +204,12 @@ static VALUE rb_bitset_union(VALUE self, VALUE other) {
 static VALUE rb_bitset_difference(VALUE self, VALUE other) {
     Bitset * bs = get_bitset(self);
     Bitset * other_bs = get_bitset(other);
+    verify_equal_size(bs, other_bs);
 
     Bitset * new_bs = bitset_new();
     bitset_setup(new_bs, bs->len);
 
-    int max = ((bs->len-1) >> 6) + 1;
+    int max = INTS(bs);
     int i;
     for(i = 0; i < max; i++) {
         uint64_t segment = bs->data[i];
@@ -222,11 +223,12 @@ static VALUE rb_bitset_difference(VALUE self, VALUE other) {
 static VALUE rb_bitset_xor(VALUE self, VALUE other) {
     Bitset * bs = get_bitset(self);
     Bitset * other_bs = get_bitset(other);
+    verify_equal_size(bs, other_bs);
 
     Bitset * new_bs = bitset_new();
     bitset_setup(new_bs, bs->len);
 
-    int max = ((bs->len-1) >> 6) + 1;
+    int max = INTS(bs);
     int i;
     for(i = 0; i < max; i++) {
         uint64_t segment = bs->data[i];
@@ -243,12 +245,15 @@ static VALUE rb_bitset_not(VALUE self) {
     Bitset * new_bs = bitset_new();
     bitset_setup(new_bs, bs->len);
 
-    int max = ((bs->len-1) >> 6) + 1;
+    int max = INTS(bs);
+
     int i;
     for(i = 0; i < max; i++) {
         uint64_t segment = bs->data[i];
         new_bs->data[i] = ~segment;
     }
+    if(_bit_no(bs->len) != 0)
+        new_bs->data[max-1] &= _bit_mask(bs->len) - 1;
 
     return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
 }
@@ -259,7 +264,7 @@ static VALUE rb_bitset_to_s(VALUE self) {
     int i;
     char * data = malloc(bs->len + 1);
     for(i = 0; i < bs->len; i++) {
-        data[i] = get_bit(bs, i)  ? '1' : '0';
+        data[i] = _get_bit(bs, i)  ? '1' : '0';
     }
     data[bs->len] = 0;
 
@@ -276,7 +281,7 @@ static VALUE rb_bitset_from_s(VALUE self, VALUE s) {
     int i;
     for (i = 0; i < length; i++) {
         if (data[i] == '1') {
-            set_bit(new_bs, i);
+            _set_bit(new_bs, i);
         }
     }
 
@@ -287,7 +292,7 @@ static VALUE rb_bitset_hamming(VALUE self, VALUE other) {
     Bitset * bs = get_bitset(self);
     Bitset * other_bs = get_bitset(other);
 
-    int max = ((bs->len-1) >> 6) + 1;
+    int max = INTS(bs);
     int count = 0;
     int i;
     for(i = 0; i < max; i++) {
@@ -304,7 +309,7 @@ static VALUE rb_bitset_each(VALUE self) {
     int i;
 
     for(i = 0; i < bs->len; i++) {
-        rb_yield(get_bit(bs, i) > 0 ? Qtrue : Qfalse);
+        rb_yield(_get_bit(bs, i) ? Qtrue : Qfalse);
     }
 
     return self;
@@ -335,11 +340,171 @@ static VALUE rb_bitset_marshall_load(VALUE self, VALUE hash) {
     return Qnil;
 }
 
+static VALUE rb_bitset_dup(VALUE self) {
+    Bitset * bs = get_bitset(self);
+
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, bs->len);
+
+    int max = INTS(bs);
+    memcpy(new_bs->data, bs->data, max * sizeof(bs->data[0]));
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+/* Yield the bit numbers of each set bit in sequence to a block. If
+   there is no block, return an array of those numbers. */
+static VALUE rb_bitset_each_set(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    int seg_no;
+    int max = INTS(bs);
+    uint64_t* seg_ptr = bs->data;
+    int block_p = rb_block_given_p();
+    VALUE ary = Qnil;
+
+    if (!block_p) {
+       ary = rb_ary_new();
+    }
+
+    for (seg_no = 0; seg_no < max; ++seg_no, ++seg_ptr) {
+       uint64_t segment = *seg_ptr;
+       int bit_position = 0;
+       while (segment) {
+          VALUE v;
+
+          if (!(segment & 1)) {
+             int shift = __builtin_ctzll(segment);
+             bit_position += shift;
+             segment >>= shift;
+          }
+          v = INT2NUM(_seg_no_to_bit_no(seg_no) + bit_position);
+          if (block_p) {
+             rb_yield(v);
+          } else {
+             rb_ary_push(ary, v);
+          }
+          ++bit_position;
+          segment >>= 1;
+       }
+    }
+
+    return block_p ? self : ary;
+}
+
+static VALUE rb_bitset_empty_p(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    int seg_no;
+    int max = INTS(bs);
+    uint64_t* seg_ptr = bs->data;
+
+    for (seg_no = 0; seg_no < max; ++seg_no, ++seg_ptr) {
+       if (*seg_ptr) {
+          return Qfalse;
+       }
+    }
+    return Qtrue;
+}
+
+static VALUE rb_bitset_select_bits(VALUE self, VALUE index_array) {
+    int i;
+    Bitset * bs = get_bitset(self);
+    struct RArray *arr = RARRAY(index_array);
+    int blen = bs->len;
+    int alen = RARRAY_LEN(index_array);
+    VALUE *ptr = RARRAY_PTR(index_array);
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, alen);
+    for (i = 0; i < alen; ++i) {
+       int idx = NUM2INT(ptr[i]);
+       if (idx >= 0 && idx < blen && _get_bit(bs, idx)) {
+          _set_bit(new_bs, i);
+       }
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+/** This could run a bit faster if you worked at it. */
+static VALUE rb_bitset_reverse(VALUE self, VALUE index_array) {
+    int i;
+    Bitset * bs = get_bitset(self);
+    int len = bs->len;
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, len);
+    for (i = 0; i < len; ++i) {
+       if (_get_bit(bs, i)) {
+          _set_bit(new_bs, len - i - 1);
+       }
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+static VALUE rb_bitset_equal(VALUE self, VALUE other) {
+    int i;
+    Bitset * bs = get_bitset(self);
+    Bitset * other_bs = get_bitset(other);
+
+    if (bs->len != other_bs->len)
+       return Qfalse;
+    int max = INTS(bs);
+    for(i = 0; i < max; i++) {
+       if (bs->data[i] != other_bs->data[i]) {
+          return Qfalse;
+       }
+    }
+    return Qtrue;
+}
+
+typedef uint64_t (*bitwise_op)(uint64_t, uint64_t);
+inline uint64_t and(uint64_t a, uint64_t b) { return a & b; }
+inline uint64_t or(uint64_t a, uint64_t b) { return a | b; }
+inline uint64_t xor(uint64_t a, uint64_t b) { return a ^ b; }
+inline uint64_t difference(uint64_t a, uint64_t b) { return a & ~b; }
+
+static VALUE mutable(VALUE self, VALUE other, bitwise_op operator) {
+    Bitset * bs = get_bitset(self);
+    Bitset * other_bs = get_bitset(other);
+    verify_equal_size(bs, other_bs);
+
+    int max = INTS(bs);
+    int i;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        uint64_t other_segment = other_bs->data[i];
+        bs->data[i] = operator(segment, other_segment);
+    }
+
+    return self;
+}
+
+static VALUE rb_bitset_union_mutable(VALUE self, VALUE other) {
+    return mutable(self, other, &or);
+}
+
+static VALUE rb_bitset_intersect_mutable(VALUE self, VALUE other) {
+    return mutable(self, other, &and);
+}
+
+static VALUE rb_bitset_xor_mutable(VALUE self, VALUE other) {
+    return mutable(self, other, &xor);
+}
+
+static VALUE rb_bitset_difference_mutable(VALUE self, VALUE other) {
+    return mutable(self, other, &difference);
+}
+
+static VALUE rb_bitset_reset(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    memset(bs->data, 0, (INTS(bs) * sizeof(uint64_t)) );
+    return self;
+}
+
 void Init_bitset() {
     cBitset = rb_define_class("Bitset", rb_cObject);
     rb_include_module(cBitset, rb_mEnumerable);
     rb_define_alloc_func(cBitset, rb_bitset_alloc);
     rb_define_method(cBitset, "initialize", rb_bitset_initialize, 1);
+    rb_define_method(cBitset, "reset!", rb_bitset_reset, 0);
     rb_define_method(cBitset, "size", rb_bitset_size, 0);
     rb_define_method(cBitset, "[]", rb_bitset_aref, 1);
     rb_define_method(cBitset, "[]=", rb_bitset_aset, 2);
@@ -350,13 +515,22 @@ void Init_bitset() {
     rb_define_method(cBitset, "cardinality", rb_bitset_cardinality, 0);
     rb_define_method(cBitset, "intersect", rb_bitset_intersect, 1);
     rb_define_alias(cBitset, "&", "intersect");
+    rb_define_alias(cBitset, "and", "intersect");
+    rb_define_method(cBitset, "intersect!", rb_bitset_intersect_mutable, 1);
+    rb_define_alias(cBitset, "and!", "intersect!");
     rb_define_method(cBitset, "union", rb_bitset_union, 1);
     rb_define_alias(cBitset, "|", "union");
+    rb_define_alias(cBitset, "or", "union");
+    rb_define_method(cBitset, "union!", rb_bitset_union_mutable, 1);
+    rb_define_alias(cBitset, "or!", "union!");
     rb_define_method(cBitset, "difference", rb_bitset_difference, 1);
     rb_define_alias(cBitset, "-", "difference");
+    rb_define_method(cBitset, "difference!", rb_bitset_difference_mutable, 1);
     rb_define_method(cBitset, "xor", rb_bitset_xor, 1);
     rb_define_alias(cBitset, "^", "xor");
     rb_define_alias(cBitset, "symmetric_difference", "xor");
+    rb_define_method(cBitset, "xor!", rb_bitset_xor_mutable, 1);
+    rb_define_alias(cBitset, "symmetric_difference!", "xor!");
     rb_define_method(cBitset, "not", rb_bitset_not, 0);
     rb_define_alias(cBitset, "~", "not");
     rb_define_method(cBitset, "hamming", rb_bitset_hamming, 1);
@@ -365,4 +539,11 @@ void Init_bitset() {
     rb_define_singleton_method(cBitset, "from_s", rb_bitset_from_s, 1);
     rb_define_method(cBitset, "marshal_dump", rb_bitset_marshall_dump, 0);
     rb_define_method(cBitset, "marshal_load", rb_bitset_marshall_load, 1);
+    rb_define_method(cBitset, "dup", rb_bitset_dup, 0);
+    rb_define_alias(cBitset, "clone", "dup");
+    rb_define_method(cBitset, "each_set", rb_bitset_each_set, 0);
+    rb_define_method(cBitset, "empty?", rb_bitset_empty_p, 0);
+    rb_define_method(cBitset, "select_bits", rb_bitset_select_bits, 1);
+    rb_define_method(cBitset, "reverse", rb_bitset_reverse, 0);
+    rb_define_method(cBitset, "==", rb_bitset_equal, 1);
 }

data/lib/bitset/bitset.rb

@@ -0,0 +1,23 @@
+class Bitset
+
+  # Return a string that represents this bitset packed into 8-bit
+  # characters. The first 3 bits represent the number of padding bits
+  # in the final byte of the string.
+
+  # You could make a good case that this is redundant with
+  # Marshal.dump and Marshal.load, but it does save a few bytes.
+  def pack
+    # Number of bits of zero padding in this representation.
+    padding_bits = (size+3) & 7
+    padding_bits = (padding_bits == 0) ? 0 : (8 - padding_bits)
+    [("%03b" % padding_bits) + self.to_s].pack("b*")
+  end
+
+  # Convert a string created using the pack method back into a bitset.
+  def self.unpack str
+    bits = str.unpack("b*")[0]
+    padding_bits = bits[0...3].to_i(2)
+    from_s(bits[3 .. -1 - padding_bits])
+  end
+
+end

data/spec/bitset_spec.rb

@@ -5,10 +5,14 @@ describe Bitset do
     Bitset.new(64)
   end
 
+  it 'raises ArgumentError wihen initialized with no argument' do
+    expect { Bitset.new }.to raise_error(ArgumentError)
+  end
+
   describe :size do
     it 'returns the correct size' do
-      Bitset.new(64).size.should == 64
-      Bitset.new(73).size.should == 73
+      expect(Bitset.new(64).size).to eq(64)
+      expect(Bitset.new(73).size).to eq(73)
     end
   end
 
@@ -16,17 +20,18 @@ describe Bitset do
     it 'returns True for set bits' do
       bs = Bitset.new(8)
       bs[0] = true
-      bs[0].should == true
+      expect(bs[0]).to be true
     end
 
     it 'returns False for unset bits' do
       bs = Bitset.new(8)
-      bs[0].should == false
+      expect(bs[0]).to be false
     end
 
     it 'raises an error when accessing out of bound indexes' do
       bs = Bitset.new(8)
       expect { bs[8] }.to raise_error(IndexError)
+      expect { bs[-1] }.to raise_error(IndexError)
     end
   end
 
@@ -35,23 +40,23 @@ describe Bitset do
       bs = Bitset.new(8)
 
       bs[0] = true
-      bs[0].should == true
+      expect(bs[0]).to be true
 
       bs[1] = 123
-      bs[1].should == true
+      expect(bs[1]).to be true
 
       bs[2] = "woo"
-      bs[2].should == true
+      expect(bs[2]).to be true
     end
 
     it 'sets False for falsey values' do
       bs = Bitset.new(8)
 
       bs[0] = false
-      bs[0].should == false
+      expect(bs[0]).to be false
 
       bs[1] = nil
-      bs[1].should == false
+      expect(bs[1]).to be false
     end
 
     it 'raises an error when setting out of bound indexes' do
@@ -65,9 +70,10 @@ describe Bitset do
       bs = Bitset.new(8)
       bs.set 1,2,3
 
-      bs[1].should == true
-      bs[2].should == true
-      bs[3].should == true
+      expect(bs[1]).to be true
+      expect(bs[0]).to be false
+      expect(bs[4]).to be false
+      expect(bs[3]).to be true
     end
   end
 
@@ -77,9 +83,9 @@ describe Bitset do
       bs.set 1,2,3
       bs.clear 1,3
 
-      bs[1].should == false
-      bs[2].should == true
-      bs[3].should == false
+      expect(bs[1]).to be false
+      expect(bs[2]).to be true
+      expect(bs[3]).to be false
     end
   end
 
@@ -87,13 +93,13 @@ describe Bitset do
     it 'returns True if all bits indexed are set' do
       bs = Bitset.new(8)
       bs.set 1, 4, 5
-      bs.set?(1,4,5).should == true
+      expect(bs.set?(1,4,5)).to be true
     end
 
     it 'returns False if not all bits indexed are set' do
       bs = Bitset.new(8)
       bs.set 1, 4
-      bs.set?(1,4,5).should == false
+      expect(bs.set?(1,4,5)).to be false
     end
   end
 
@@ -101,44 +107,48 @@ describe Bitset do
     it 'returns True if all bits indexed are clear' do
       bs = Bitset.new(8)
       bs.set 1, 4, 5
-      bs.clear?(0,2,3,6).should == true
+      expect(bs.clear?(0,2,3,6)).to be true
     end
 
     it 'returns works with the full range of 64 bit values'  do
       bs = Bitset.new(68)
       bs.set 0, 2, 66
-      bs.clear?(32, 33, 34).should == true
+      expect(bs.clear?(32, 33, 34)).to be true
     end
 
     it 'returns False if not all bits indexed are clear' do
       bs = Bitset.new(8)
       bs.set 1, 4
-      bs.clear?(1,2,6).should == false
+      expect(bs.clear?(1,2,6)).to be false
     end
   end
 
   describe :cardinality do
     it 'returns the number of bits set' do
-      bs = Bitset.new(8)
-      bs.cardinality.should == 0
+      bs = Bitset.new(64)
+      expect(bs.cardinality).to eq(0)
 
       bs[0] = true
-      bs.cardinality.should == 1
+      expect(bs.cardinality).to eq(1)
 
       bs[1] = true
-      bs.cardinality.should == 2
+      expect(bs.cardinality).to eq(2)
 
       bs[2] = true
-      bs.cardinality.should == 3
+      expect(bs.cardinality).to eq(3)
+
+      expect(bs.not.cardinality).to eq(bs.size - bs.cardinality)
     end
 
     it '... even for large numbers of bits' do
       bs = Bitset.new(10_000)
-      bs.set(*(0...5000).to_a)
-      bs.cardinality.should == 5000
+      size = 5000
+      bs.set(*(0...size).to_a)
+      expect(bs.cardinality).to eq(size)
 
       bs = Bitset.from_s "01001101000000000000000000000011000010100100000000000000010000101000000000000000100000000100000000000010100100010000000010000100000100000001001000110000000000100010000000010100000000000000110000000000000000000000000100000000100010010000000000000000000001000000000000000000000000000001000000000000000000000000000100000000010010000000000000000000100100000000000000001000000010000001000000000000001000001100010001000000000000001000001000001000000000000001100010000010010001000000010000100000000000110000"
-      bs.cardinality.should == 63
+      expect(bs.cardinality).to eq(63)
+      expect(bs.not.cardinality).to eq(bs.size - bs.cardinality)
     end
   end
 
@@ -151,8 +161,8 @@ describe Bitset do
       bs2.set 1, 2, 4, 6
 
       bs3 = bs1 & bs2
-      bs3.set?(1,4).should == true
-      bs3.clear?(0,2,3,5,6,7).should == true
+      expect(bs3.set?(1,4)).to be true
+      expect(bs3.clear?(0,2,3,5,6,7)).to be true
     end
   end
 
@@ -165,8 +175,11 @@ describe Bitset do
       bs2.set 1, 2, 4, 6
 
       bs3 = bs1 | bs2
-      bs3.set?(1,2,4,6,7).should == true
-      bs3.clear?(0,3,5).should == true
+      expect(bs3.set?(1,2,4,6,7)).to be true
+      expect(bs3.clear?(0,3,5)).to be true
+    end
+    it 'throws if size mismatch' do
+      expect { Bitset.new(3) | Bitset.new(7) }.to raise_error(ArgumentError)
     end
   end
 
@@ -179,8 +192,11 @@ describe Bitset do
       bs2.set 1, 2, 4, 6
 
       bs3 = bs1 - bs2
-      bs3.set?(7).should == true
-      bs3.clear?(0,1,2,3,4,5,6).should == true
+      expect(bs3.set?(7)).to be true
+      expect(bs3.clear?(0,1,2,3,4,5,6)).to be true
+    end
+    it 'throws if size mismatch' do
+      expect { Bitset.new(3) - Bitset.new(7) }.to raise_error(ArgumentError)
     end
   end
 
@@ -193,19 +209,23 @@ describe Bitset do
       bs2.set 1, 2, 4, 6
 
       bs3 = bs1 ^ bs2
-      bs3.set?(2,6,7).should == true
-      bs3.clear?(0,1,3,4,5).should == true
+      expect(bs3.set?(2,6,7)).to be true
+      expect(bs3.clear?(0,1,3,4,5)).to be true
+    end
+
+    it 'throws if size mismatch' do
+      expect { Bitset.new(3) ^ Bitset.new(7) }.to raise_error(ArgumentError)
     end
   end
 
   describe :not do
-    it "returns a new Bitset with is the not of one Bitset" do
+    it "returns a new Bitset which is the not of one Bitset" do
       bs1 = Bitset.new(8)
       bs1.set 1, 4, 7
 
       bs2 = bs1.not
-      bs2.set?(0, 2, 3, 5, 6).should == true
-      bs2.clear?(1, 4, 7).should == true
+      expect(bs2.set?(0, 2, 3, 5, 6)).to be true
+      expect(bs2.clear?(1, 4, 7)).to be true
     end
   end
 
@@ -217,7 +237,7 @@ describe Bitset do
       bs2 = Bitset.new(8)
       bs2.set 1, 2, 4, 6
 
-      bs1.hamming(bs2).should == 3
+      expect(bs1.hamming(bs2)).to eq(3)
     end
   end
 
@@ -228,10 +248,50 @@ describe Bitset do
 
       i = 0
       bs.each do |bit|
-        bit.should == bs[i]
+        expect(bit).to be bs[i]
         i += 1
       end
-      i.should == 4
+      expect(i).to eq(4)
+    end
+  end
+
+  describe :each_set do
+    it 'iterates over each set bit in the Bitset' do
+      bs = Bitset.new(4)
+      sets = [0,3]
+      bs.set(*sets)
+      sets2 = []
+      bs.each_set { |bit| sets2 << bit }
+      expect(sets2).to eq(sets)
+    end
+
+    it 'without a block, it returns an array of set bits' do
+      bs = Bitset.new(4)
+      sets = [0,3]
+      bs.set(*sets)
+      expect(bs.each_set).to eq(sets)
+    end
+  end
+
+  describe :empty? do
+    it 'returns empty only if all zeroes' do
+      expect(Bitset.new(225).tap { |bs| bs[133] = true }.empty?).to be false
+      expect(Bitset.new(0).empty?).to be true
+      expect(Bitset.new(225).empty?).to be true
+    end
+  end
+
+  describe :dup do
+    it "returns a duplicate" do
+      bs = Bitset.from_s("11011")
+      expect(bs.dup.tap { |bs| bs.clear 1,3 }.to_s).to eq("10001")
+      expect(bs.to_s).to eq("11011")
+    end
+  end
+
+  describe :clone do
+    it "works" do
+      expect(Bitset.new(0).clone.to_s).to eq("")
     end
   end
 
@@ -239,18 +299,18 @@ describe Bitset do
     it 'correctly prints out a binary string' do
       bs = Bitset.new(4)
       bs.set 0, 2
-      bs.to_s.should == "1010"
+      expect(bs.to_s).to eq("1010")
 
       bs = Bitset.new(68)
       bs.set 0, 2, 66
-      bs.to_s.should == "101" + ("0" * 63) + "10"
+      expect(bs.to_s).to eq("101" + ("0" * 63) + "10")
     end
   end
 
   describe :from_s do
     it 'correctly creates a bitmap from a binary string' do
       bs = Bitset.from_s("10101")
-      bs.set?(0, 2, 4).should == true
+      expect(bs.set?(0, 2, 4)).to be true
     end
   end
 
@@ -260,8 +320,65 @@ describe Bitset do
       bs.set 1, 65
 
       serialized = Marshal.load(Marshal.dump(bs))
-      serialized.set?(1, 65).should == true
-      serialized.cardinality.should == 2
+      expect(serialized.set?(1, 65)).to be true
+      expect(serialized.cardinality).to eq(2)
+    end
+  end
+
+  describe :union! do
+    it 'acts like |=' do
+      bs = Bitset.from_s "11011"
+      bs2 = Bitset.from_s "01111"
+      bs3 = bs.dup
+      bs.union!(bs2)
+      expect(bs).to eq(bs3 | bs2)
+    end
+
+    it 'throws if size mismatch' do
+      expect { Bitset.new(3).union!(Bitset.new(7)) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe :intersect! do
+    it 'acts like &=' do
+      bs = Bitset.from_s "11011"
+      bs2 = Bitset.from_s "01111"
+      bs3 = bs.dup
+      bs.intersect!(bs2)
+      expect(bs).to eq(bs3 & bs2)
+    end
+  end
+
+  describe :xor! do
+    it 'acts like ^=' do
+      bs = Bitset.from_s "11011"
+      bs2 = Bitset.from_s "01111"
+      bs3 = bs.dup
+      bs.xor!(bs2)
+      expect(bs).to eq(bs3 ^ bs2)
+    end
+
+    it 'throws if size mismatch' do
+      expect { Bitset.new(3).xor!(Bitset.new(7)) }.to raise_error(ArgumentError)
     end
   end
+
+  describe :difference! do
+    it 'acts like -=' do
+      bs = Bitset.from_s "11011"
+      bs2 = Bitset.from_s "01111"
+      bs3 = bs.dup
+      bs.difference!(bs2)
+      expect(bs).to eq(bs3 - bs2)
+    end
+  end
+
+  describe :reset! do
+    it 'causes empty? to become true' do
+      bs = Bitset.from_s "11011"
+      bs.reset!
+      expect(bs.empty?).to be true
+    end
+  end
+
 end

metadata

@@ -1,72 +1,56 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: bitset
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
+authors:
 - Tyler McMullen
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-03 00:00:00 -08:00
-default_executable: 
+date: 2017-05-15 00:00:00.000000000 Z
 dependencies: []
-
-description: A fast C-based Bitset. It supports the standard set operations as well as operations you may expect on bit arrays. (popcount, for instance)
-email: tbmcmullen@gmail.com
+description: A fast C-based Bitset. It supports the standard set operations as well
+  as operations you may expect on bit arrays. (popcount, for instance)
+email: eric.boesch@nist.gov
 executables: []
-
-extensions: 
+extensions:
 - ext/bitset/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
-files: 
+- README.markdown
+files:
 - LICENSE.txt
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
 - bitset.gemspec
 - ext/bitset/bitset.c
 - ext/bitset/extconf.rb
+- lib/bitset/bitset.rb
 - spec/bitset_spec.rb
-has_rdoc: true
-homepage: http://github.com/tyler/bitset
-licenses: 
+homepage: http://github.com/ericboesch/bitset
+licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.6.12
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Bitset implementation.
-test_files: 
-- spec/bitset_spec.rb
+test_files: []

data/README.rdoc

@@ -1,3 +0,0 @@
-= Bitset
-
-A fast Bitset implementation for Ruby. Available as the 'bitset' gem.