bitwise 0.1.2 → 0.2.0

data/README.md

@@ -38,32 +38,70 @@ b.to_bits
  => "00001000"
 ```
 
-Index assignment and retrieval:
+String-based assignment and retrieval:
 
 ```ruby
 b = Bitwise.new
-b.indexes = [1, 10, 100]
+b.value = "abc"
 
-b.to_bits
- => "01000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000"
-
-b.cardinality
+b.size
  => 3
+b.to_bits
+ => "011000010110001001100011"
+b.value.unpack('C*')
+ => [97, 98, 99]
+```
 
-b.size
- => 13
+Index-based assignment and retrieval:
 
-b.set_at(20)
+```ruby
+b = Bitwise.new
+b.indexes = [1, 2, 4, 8, 16]
 
 b.to_bits
- => "01000000001000000000100000000000000000000000000000000000000000000000000000000000000000000000000000001000"
+ => "011010001000000010000000"
+b.indexes
+ => [1, 2, 4, 8, 16]
+b.cardinality
+ => 5
 
-b.value.unpack('C*')
- => [64, 32, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]
+b.set_at(10)
 
+b.to_bits
+ => "011010001010000010000000"
+b.indexes
+ => [1, 2, 4, 8, 10, 16]
 b.cardinality
- => 4
+ => 6
+```
 
-b.indexes
- => [1, 10, 20, 100]
+NOT, OR, AND and XOR:
+
+```ruby
+b1 = Bitwise.new
+b2 = Bitwise.new
+b1.indexes = [1, 2, 3, 5, 6]
+b2.indexes = [1, 2, 4, 8, 16]
+
+(~b1).indexes
+ => [0, 4, 7]
+(b1 | b2).indexes
+ => [1, 2, 3, 4, 5, 6, 8, 16]
+(b1 & b2).indexes
+ => [1, 2]
+(b1 ^ b2).indexes
+ => [3, 4, 5, 6, 8, 16]
+```
+
+As a bonus, `Bitwise#string_not`, `Bitwise#string_union`, `Bitwise#string_intersect`, and `Bitwise#string_xor` can be used as a standalone method to work with any binary string.
+
+```ruby
+Bitwise.string_not "\xF0"
+ => "\x0F"
+Bitwise.string_union "\xF0","\xFF"
+ => "\xFF"
+Bitwise.string_intersect "\xF0","\xFF"
+ => "\xF0"
+Bitwise.string_xor "\xF0","\xFF"
+ => "\x0F"
 ```

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/bitwise.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "bitwise"
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kenn Ejima"]

data/ext/bitwise/bitwise.c

@@ -1,8 +1,8 @@
-#include "ruby.h"
+#include <ruby.h>
 
 VALUE BitwiseClass;
 
-int COUNT_TABLE[] = {
+static int COUNT_TABLE[] = {
   0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
   1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
   1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
@@ -21,20 +21,39 @@ int COUNT_TABLE[] = {
   4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
 };
 
+static VALUE bw_population_count(VALUE self, VALUE str) {
+  int count, i;
+  unsigned char *buffer = RSTRING_PTR(str);
+  count = 0;
+  for (i = 0; i < RSTRING_LEN(str); i++) {
+    count += COUNT_TABLE[buffer[i]];
+  }
+  return INT2NUM(count);
+}
+
+static VALUE bw_string_not(VALUE self, VALUE str)
+{
+  VALUE result = rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str));
+  int i;
+  for (i = 0; i < RSTRING_LEN(str); i++) {
+    RSTRING_PTR(result)[i] = ~RSTRING_PTR(str)[i];
+  }
+  return result;
+}
+
 static VALUE bw_string_union(VALUE self, VALUE max, VALUE min)
 {
-  VALUE result = rb_str_new(RSTRING_PTR(max), RSTRING_LEN(max)); 
+  VALUE result = rb_str_new(RSTRING_PTR(max), RSTRING_LEN(max));
   int i;
-  int min_len = RSTRING_LEN(min);
-  for (i = 0; i < RSTRING_LEN(max); i++) {
-    RSTRING_PTR(result)[i] |= ((i < min_len) ? RSTRING_PTR(min)[i] : 0);
+  for (i = 0; i < RSTRING_LEN(min); i++) {
+    RSTRING_PTR(result)[i] |= RSTRING_PTR(min)[i];
   }
   return result;
 }
 
 static VALUE bw_string_intersect(VALUE self, VALUE max, VALUE min)
 {
-  VALUE result = rb_str_new(RSTRING_PTR(min), RSTRING_LEN(min)); 
+  VALUE result = rb_str_new(RSTRING_PTR(min), RSTRING_LEN(min));
   int i;
   for (i = 0; i < RSTRING_LEN(min); i++) {
     RSTRING_PTR(result)[i] &= RSTRING_PTR(max)[i];
@@ -42,20 +61,23 @@ static VALUE bw_string_intersect(VALUE self, VALUE max, VALUE min)
   return result;
 }
 
-static VALUE bw_population_count(VALUE self, VALUE str) {
-  int count, i;
-  unsigned char *buffer = RSTRING_PTR(str);
-  count = 0;
-  for (i = 0; i < RSTRING_LEN(str); i++) {
-    count += COUNT_TABLE[buffer[i]];
+static VALUE bw_string_xor(VALUE self, VALUE max, VALUE min)
+{
+  VALUE result = rb_str_new(RSTRING_PTR(max), RSTRING_LEN(max));
+  int i;
+  int min_len = RSTRING_LEN(min);
+  for (i = 0; i < RSTRING_LEN(max); i++) {
+    RSTRING_PTR(result)[i] ^= ((i < min_len) ? RSTRING_PTR(min)[i] : 0);
   }
-  return INT2NUM(count);
+  return result;
 }
 
 void Init_bitwise()
 {
   BitwiseClass = rb_define_class("Bitwise", rb_cObject);
+  rb_define_singleton_method(BitwiseClass, "population_count", bw_population_count, 1);
+  rb_define_singleton_method(BitwiseClass, "string_not", bw_string_not, 1);
   rb_define_singleton_method(BitwiseClass, "string_union", bw_string_union, 2);
   rb_define_singleton_method(BitwiseClass, "string_intersect", bw_string_intersect, 2);
-  rb_define_singleton_method(BitwiseClass, "population_count", bw_population_count, 1);
+  rb_define_singleton_method(BitwiseClass, "string_xor", bw_string_xor, 2);
 }

data/lib/bitwise.rb

@@ -50,6 +50,13 @@ class Bitwise
     @byte = @value.getbyte(@div)
   end
 
+  def not
+    result = Bitwise.new
+    result.value = Bitwise.string_not(self.value)
+    result
+  end
+  alias :~ :not
+
   def intersect(other)
     min, max = [ self.value, other.value ].sort_by{|i| i.bytesize }
     result = Bitwise.new
@@ -66,6 +73,14 @@ class Bitwise
   end
   alias :| :union
 
+  def xor(other)
+    min, max = [ self.value, other.value ].sort_by{|i| i.bytesize }
+    result = Bitwise.new
+    result.value = Bitwise.string_xor(max, min)
+    result
+  end
+  alias :^ :xor
+
   def value=(string)
     @value = string.force_encoding(Encoding::ASCII_8BIT)
     @value.bytesize

data/spec/bitwise_spec.rb

@@ -1,3 +1,5 @@
+# coding: ascii-8bit
+
 require 'bitwise'
 require 'set'
 
@@ -6,27 +8,81 @@ describe Bitwise do
     @bitwise = Bitwise.new(1)
   end
 
-  it "should set and clear" do
-    @bitwise.to_bits.should == '00000000'
+  describe "assignment and retrieval" do
+    it "bit-based" do
+      @bitwise.to_bits.should == '00000000'
+
+      @bitwise.set_at 1
+      @bitwise.set_at 4
+      @bitwise.to_bits.should == '01001000'
+      @bitwise.cardinality.should == 2
 
-    @bitwise.set_at 1
-    @bitwise.set_at 2
-    @bitwise.set_at 3
-    @bitwise.set_at 5
-    @bitwise.to_bits.should == '01110100'
-    @bitwise.cardinality.should == 4
+      @bitwise.clear_at(1)
+      @bitwise.to_bits.should == '00001000'
+      @bitwise.cardinality.should == 1
+    end
 
-    @bitwise.clear_at(1)
-    @bitwise.clear_at(3)
-    @bitwise.to_bits.should == '00100100'
-    @bitwise.cardinality.should == 2
+    it "string-based" do
+      @bitwise.value = 'abc'
+      @bitwise.size.should == 3
+      @bitwise.to_bits.should == '011000010110001001100011'
+      @bitwise.cardinality.should == 10
+    end
+
+    it "index-based" do
+      @bitwise.indexes = [1, 2, 4, 8, 16]
+      @bitwise.to_bits.should == '011010001000000010000000'
+      @bitwise.indexes.should == [1, 2, 4, 8, 16]
+      @bitwise.cardinality.should == 5
+      @bitwise.set_at 10
+      @bitwise.to_bits.should == '011010001010000010000000'
+      @bitwise.indexes.should == [1, 2, 4, 8, 10, 16]
+      @bitwise.cardinality.should == 6
+    end
   end
 
-  it "should set by indexes" do
-    @bitwise.indexes = [1,10]
-    @bitwise.indexes.should == [1,10]
-    @bitwise.to_bits.should == '0100000000100000'
-    @bitwise.cardinality.should == 2
+  describe "operators" do
+    before do
+      @b1 = Bitwise.new
+      @b2 = Bitwise.new
+      @b1.indexes = [1, 2, 3, 5, 6]
+      @b2.indexes = [1, 2, 4, 8, 16]
+    end
+
+    it "NOT" do
+      @b1.not.indexes.should == [0, 4, 7]
+    end
+
+    it "OR" do
+      @b1.union(@b2).indexes.should == [1, 2, 3, 4, 5, 6, 8, 16]
+    end
+
+    it "AND" do
+      @b1.intersect(@b2).indexes.should == [1, 2]
+    end
+
+    it "XOR" do
+      @b1.xor(@b2).indexes.should == [3, 4, 5, 6, 8, 16]
+    end
+  end
+
+  describe "standalone" do
+    it "NOT" do
+      Bitwise.string_not("\xF0").should == "\x0F"
+    end
+
+    it "OR" do
+      Bitwise.string_union("\xF0","\xFF").should == "\xFF"
+    end
+
+    it "AND" do
+      Bitwise.string_intersect("\xF0","\xFF").should == "\xF0"
+    end
+
+    it "XOR" do
+      Bitwise.string_xor("\xF0","\xFF").should == "\x0F"
+    end
+
   end
 
   describe "benchmark" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitwise
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2156349640 !ruby/object:Gem::Requirement
+  requirement: &2159343420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156349640
+  version_requirements: *2159343420
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2156102560 !ruby/object:Gem::Requirement
+  requirement: &2159341700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156102560
+  version_requirements: *2159341700
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2156099600 !ruby/object:Gem::Requirement
+  requirement: &2159340960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156099600
+  version_requirements: *2159340960
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &2156095000 !ruby/object:Gem::Requirement
+  requirement: &2159340120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156095000
+  version_requirements: *2159340120
 description: Fast, memory efficient bitwise operations on large binary strings
 email: kenn.ejima@gmail.com
 executables: []