bitset 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c14192c25ee30542e0317d9866aae505540db2d
-  data.tar.gz: 3ca3e7cdd173f8f45785f80925afc31960236200
+  metadata.gz: 0f092c73af4ffc1b72421acc789fd93e5ad55560
+  data.tar.gz: 7049663c15cbda4765a9f85e60854450418ae078
 SHA512:
-  metadata.gz: 0c811e6e8fc572c7efd0338e4b249189542be2c8e533cc672166cd22e2113b4d1ed10c28a5ea1587492c38d26787700dd45fa3d705badf6273014ecde1fa64b8
-  data.tar.gz: 5f602be6047488f9f1ba99f168b98050f3479fba816032bdeb7a4873786f9e8de9fd6b076c0ad29d3ac39c5818a7977a72209c19f2acdad637a735e5c7f966a7
+  metadata.gz: c1b6a3553fb32e640d0fe66da0c5dd7b6b0339a4ac3b3b89c853f72bcfa4cdd0da20788ccf09af1fb057158bb314489620fdd7b6c273b50ab7f0c4175dccc03d
+  data.tar.gz: 35a517b590357d9940786448605fa124f33d4e4d55abd447e5793f2572b27c2a2a1df31c51113cb6ef8070ff0518ecb0da6f5f7420cec20837d45591f00d3442

data/README.markdown

@@ -35,6 +35,17 @@ We can also create a bitset based on a string of ones and zeros.
     >> Bitset.from_s('00010001')
     => 00010001
 
+or from an array. Falsey values (false and nil) are converted to
+zeroes; all other values, including 0 and "", are converted to ones.
+
+    >> Bitset.new [false, nil, 3, 0]
+    => 0011
+
+To input an array of ones and zeroes:
+
+    >> Bitset.new([0,1,1,0].map(&:positive?))
+    => 0110
+
 Obviously you can also set and clear bits...
 
     >> bitset = Bitset.new(8)
@@ -52,7 +63,7 @@ Obviously you can also set and clear bits...
     >> bitset.clear(1, 5)
     => 00010001
 
-Arrays of ints can also be passed to #clear and #set (c/o brendon9x).
+Arrays of Integers can also be passed to #clear and #set (c/o brendon9x).
 
 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.

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.0

data/bitset.gemspec

@@ -2,17 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: bitset 1.1.0 ruby lib
+# stub: bitset 1.2.0 ruby lib
 # stub: ext/bitset/extconf.rb
 
 Gem::Specification.new do |s|
   s.name = "bitset".freeze
-  s.version = "1.1.0"
+  s.version = "1.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Tyler McMullen".freeze]
-  s.date = "2018-01-06"
+  s.date = "2018-05-01"
   s.description = "A fast C-based Bitset. It supports the standard set operations as well as operations you may expect on bit arrays,such as popcount.".freeze
   s.email = "eric.boesch@nist.gov".freeze
   s.extensions = ["ext/bitset/extconf.rb".freeze]

data/ext/bitset/bitset.c

@@ -19,6 +19,14 @@ typedef struct {
 #define INTS(_bs) (((_bs)->len+63) >> 6)
  // 2^6=64
 
+#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))
+
 Bitset * bitset_new() {
     return (Bitset *) calloc(1, sizeof(Bitset));
 }
@@ -47,9 +55,23 @@ static VALUE rb_bitset_alloc(VALUE klass) {
     return obj;
 }
 
-static VALUE rb_bitset_initialize(VALUE self, VALUE len) {
+static VALUE rb_bitset_initialize(VALUE self, VALUE ary) {
     Bitset * bs = get_bitset(self);
-    bitset_setup(bs, NUM2INT(len));
+    if (RB_TYPE_P(ary, T_ARRAY)) {
+        int i;
+        int len = (int) RARRAY_LEN(ary);
+        bitset_setup(bs, len);
+        for (i = 0; i < len; ++i) {
+            // This could be more efficient, but if you're converting
+            // from a Ruby array of bits, you're not looking
+            // at blazing speed anyhow.
+            if (RTEST(rb_ary_entry(ary, i))) {
+                _set_bit(bs, i);
+            }
+        }
+    } else {
+        bitset_setup(bs, NUM2INT(ary));
+    }
     return self;
 }
 
@@ -63,14 +85,6 @@ static void raise_index_error() {
     rb_raise(rb_eIndexError, "Index out of bounds");
 }
 
-#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))
-
 static void validate_index(Bitset * bs, int idx) {
     if(idx < 0 || idx >= bs->len)
         raise_index_error();

data/lib/bitset.rb

@@ -1,13 +1,13 @@
 require "bitset/bitset"
 
 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.
+  # @return [String] This bitset packed into bytes.
+  #
+  # The first 3 bits represent the number of padding bits in the final
+  # byte of the string.
+  #
+  # This is somewhat 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
@@ -15,11 +15,16 @@ class Bitset
     [("%03b" % padding_bits) + self.to_s].pack("b*")
   end
 
-  # Convert a string created using the pack method back into a bitset.
+  def inspect
+    "#{self.class.name}:#{to_s}"
+  end
+
+  # @param [String] Output from {#pack}
+  #
+  # @return [Bitset] A duplicate of the input to {#pack}
   def self.unpack str
-    bits = str.unpack("b*")[0]
+    bits = str.unpack("b*").first
     padding_bits = bits[0...3].to_i(2)
     from_s(bits[3 .. -1 - padding_bits])
   end
-
 end

data/spec/bitset_spec.rb

@@ -1,10 +1,14 @@
 require 'bitset'
 
 describe Bitset do
-  it 'can be initialized' do
+  it 'can be initialized by size' do
     Bitset.new(64)
   end
 
+  it 'can be initialized by array' do
+    Bitset.new([false, nil, 3, 0]).to_s == "0011"
+  end
+
   it 'raises ArgumentError wihen initialized with no argument' do
     expect { Bitset.new }.to raise_error(ArgumentError)
   end
@@ -110,13 +114,13 @@ describe Bitset do
       expect(bs.clear?(0,2,3,6)).to be true
     end
 
-    it 'returns works with the full range of 64 bit values'  do
+    it 'works with the full range of 64 bit values'  do
       bs = Bitset.new(68)
       bs.set 0, 2, 66
       expect(bs.clear?(32, 33, 34)).to be true
     end
 
-    it 'returns False if not all bits indexed are clear' do
+    it 'returns false if not all bits indexed are clear' do
       bs = Bitset.new(8)
       bs.set 1, 4
       expect(bs.clear?(1,2,6)).to be false
@@ -416,5 +420,10 @@ describe Bitset do
       end
     end
   end
-
+  
+  describe :inspect do
+    it "returns expected output" do
+      expect(Bitset.from_s("1011").inspect).to eq("Bitset:1011")
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitset
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Tyler McMullen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-06 00:00:00.000000000 Z
+date: 2018-05-01 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,such as popcount.