bitset_bm 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTlmMTRmMmFiYjI4NGJlY2RjZWJlMzA1MTYzZGRiZTg4MDQ3NjQxOA==
+  data.tar.gz: !binary |-
+    NDMxOTEyNzgxODUwYjA5ZTMxY2MwYzIwMzMwZmFkNzgzOWI5ODUyNg==
+SHA512:
+  metadata.gz: !binary |-
+    ZWI3Mzc4ZjM0MGZjMTE3ZjUyNzI5NWIyYTMyNmQxYWZmMGZjYWZkYjU3MDYz
+    ZmU4MmIzMTU2NDA4MTM2MzFlMjc5YTE2MjE4MDQxNWZhMjhhMjNmMTFlMzQ3
+    ODQzNTA1MDlkMjM4OGFiN2EyOTliNzExMTk4MWY1ODdmYTk0YmU=
+  data.tar.gz: !binary |-
+    NDNjZjJlMzFlMmE4MWEyNDZkYWNiMzhiNTZiZmE3OTlkNDU1Mjg1MzE3N2U1
+    NTU0YzI5YWFjMzE2MjYxZmE3MTc2MTlhNTAzNjJiOGRiNWMxNDkwN2NlOGY2
+    NzliOWQwY2Y1MTAwYjk3YWY4ZGZmZTU3ZTU1YzRiM2E1YjRiMWE=

data/.gitignore

@@ -0,0 +1,46 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# Rubymine
+.idea
+
+# Compiler artifacts
+tmp
+lib/bitset.bundle
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+#*~
+#\#*
+#.\#*
+#
+# For vim:
+#*.swp

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.1"

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    bitset_bm (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.3.2)
+    rake-compiler (0.9.2)
+      rake
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.1)
+    rspec-expectations (2.99.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.99.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bitset_bm!
+  rake (~> 10.1)
+  rake-compiler (~> 0.9, >= 0.9.2)
+  rspec (~> 2.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tyler McMullen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,108 @@
+Bitset [![Build Status](https://travis-ci.org/brendon9x/bitset.svg?branch=master)](https://travis-ci.org/brendon9x/bitset)
+======
+
+A fast Bitset implementation for Ruby. Available as the 'bitset' gem.  This is a fork of tyler/bitset which adds the
+following functionality:
+
+* Switch to Bundler's Gemspec defaults
+* Bug fix for a 64 bit cardinality bug
+* Adds a to_a method which returns on positions
+* Adds a to_binary_array which returns fixnum 1s and 0s
+* Other fixes and features are merged upstream
+
+
+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/brendon9x/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
+
+
+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

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'rake/extensiontask'
+
+gemspec = Gem::Specification.load('bitset.gemspec')
+Rake::ExtensionTask.new do |ext|
+  ext.name = 'bitset'
+  ext.source_pattern = "*.{c}"
+  ext.ext_dir = 'ext/bitset'
+  ext.gem_spec = gemspec
+end
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+task :default => [:compile, :spec]

data/VERSION

@@ -0,0 +1 @@
+0.1.3

data/bitset.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'bitset/version'
+
+Gem::Specification.new do |s|
+  s.name = "bitset_bm"
+  s.version = BitsetVersion::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tyler McMullen", "Brendon McLean"]
+  s.date = %q{2011-10-06}
+  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.extensions = ["ext/bitset/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.homepage = %q{http://github.com/brendon9x/bitset}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Bitset implementation.}
+
+  s.add_development_dependency "rspec", "~> 2.0"
+  s.add_development_dependency "rake", "~> 10.1"
+  s.add_development_dependency 'rake-compiler', '~> 0.9', '>= 0.9.2'
+end
+

data/ext/bitset/bitset.c

@@ -0,0 +1,396 @@
+#include "ruby.h"
+
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+VALUE cBitset;
+
+typedef struct {
+    int len;
+    uint64_t * data;
+} Bitset;
+
+#define BYTES(_bs) (((_bs->len-1) >> 3) + 1)
+#define INTS(_bs) (((_bs->len-1) >> 6) + 1)
+
+Bitset * bitset_new() {
+    return (Bitset *) malloc(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
+}
+
+void bitset_free(Bitset * bs) {
+    if(bs->data)
+        free(bs->data);
+    free(bs);
+}
+
+
+Bitset * get_bitset(VALUE obj) {
+    Bitset * bs;
+    Data_Get_Struct(obj, Bitset, bs);
+    return bs;
+}
+
+static VALUE rb_bitset_alloc(VALUE klass) {
+    VALUE obj;
+    obj = Data_Wrap_Struct(klass, 0, bitset_free, bitset_new());
+    return obj;
+}
+
+static VALUE rb_bitset_initialize(VALUE self, VALUE len) {
+    Bitset * bs = get_bitset(self);
+    bitset_setup(bs, NUM2INT(len));
+    return self;
+}
+
+static VALUE rb_bitset_size(VALUE self, VALUE len) {
+    Bitset * bs = get_bitset(self);
+    return INT2NUM(bs->len);
+}
+
+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))
+
+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);
+}
+
+void assign_bit(Bitset * bs, int idx, VALUE value) {
+    if(NIL_P(value) || value == Qfalse)
+        clear_bit(bs, idx);
+    else
+        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;
+}
+
+static VALUE rb_bitset_aset(VALUE self, VALUE index, VALUE value) {
+    Bitset * bs = get_bitset(self);
+    int idx = NUM2INT(index);
+    validate_index(bs, idx);
+    assign_bit(bs, idx, value);
+    return Qtrue;
+}
+
+static VALUE rb_bitset_set(int argc, VALUE * argv, VALUE self) {
+    int i;
+    Bitset * bs = get_bitset(self);
+    for(i = 0; i < argc; i++) {
+        VALUE index = argv[i];
+        int idx = NUM2INT(index);
+        validate_index(bs, idx);
+        set_bit(bs, idx);
+    }
+    return Qtrue;
+}
+
+static VALUE rb_bitset_clear(int argc, VALUE * argv, VALUE self) {
+    int i;
+    Bitset * bs = get_bitset(self);
+    for(i = 0; i < argc; i++) {
+        VALUE index = argv[i];
+        int idx = NUM2INT(index);
+        validate_index(bs, idx);
+        clear_bit(bs, idx);
+    }
+    return Qtrue;
+}
+
+static VALUE rb_bitset_clear_p(int argc, VALUE * argv, VALUE self) {
+    int i;
+    Bitset * bs = get_bitset(self);
+    for(i = 0; i < argc; i++) {
+        VALUE index = argv[i];
+        int idx = NUM2INT(index);
+        validate_index(bs, idx);
+        if(get_bit(bs, idx) > 0)
+            return Qfalse;
+    }
+    return Qtrue;
+}
+
+static VALUE rb_bitset_set_p(int argc, VALUE * argv, VALUE self) {
+    int i;
+    Bitset * bs = get_bitset(self);
+    for(i = 0; i < argc; i++) {
+        VALUE index = argv[i];
+        int idx = NUM2INT(index);
+        validate_index(bs, idx);
+        if(get_bit(bs, idx) == 0)
+            return Qfalse;
+    }
+    return Qtrue;
+}
+
+static VALUE rb_bitset_cardinality(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    int i;
+    int max = ((bs->len-1) >> 6) + 1;
+    int count = 0;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        if(i+1 == max && (bs->len & 0x3F))
+            segment &= ((((uint64_t) 1) << (bs->len & 0x3F)) - 1);
+        count += __builtin_popcountll(segment);
+    }
+    return INT2NUM(count);
+}
+
+static VALUE rb_bitset_intersect(VALUE self, VALUE other) {
+    Bitset * bs = get_bitset(self);
+    Bitset * other_bs = get_bitset(other);
+
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, bs->len);
+
+    int max = ((bs->len-1) >> 6) + 1;
+    int i;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        uint64_t other_segment = other_bs->data[i];
+        new_bs->data[i] = segment & other_segment;
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+static VALUE rb_bitset_union(VALUE self, VALUE other) {
+    Bitset * bs = get_bitset(self);
+    Bitset * other_bs = get_bitset(other);
+
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, bs->len);
+
+    int max = ((bs->len-1) >> 6) + 1;
+    int i;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        uint64_t other_segment = other_bs->data[i];
+        new_bs->data[i] = segment | other_segment;
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+static VALUE rb_bitset_difference(VALUE self, VALUE other) {
+    Bitset * bs = get_bitset(self);
+    Bitset * other_bs = get_bitset(other);
+
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, bs->len);
+
+    int max = ((bs->len-1) >> 6) + 1;
+    int i;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        uint64_t other_segment = other_bs->data[i];
+        new_bs->data[i] = segment & ~other_segment;
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+static VALUE rb_bitset_xor(VALUE self, VALUE other) {
+    Bitset * bs = get_bitset(self);
+    Bitset * other_bs = get_bitset(other);
+
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, bs->len);
+
+    int max = ((bs->len-1) >> 6) + 1;
+    int i;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        uint64_t other_segment = other_bs->data[i];
+        new_bs->data[i] = segment ^ other_segment;
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+static VALUE rb_bitset_not(VALUE self) {
+    Bitset * bs = get_bitset(self);
+
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, bs->len);
+
+    int max = ((bs->len-1) >> 6) + 1;
+    int i;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        new_bs->data[i] = ~segment;
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+static VALUE rb_bitset_to_s(VALUE self) {
+    Bitset * bs = get_bitset(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[bs->len] = 0;
+
+    return rb_str_new2(data);
+}
+
+static VALUE rb_bitset_from_s(VALUE self, VALUE s) {
+    int length = RSTRING_LEN(s);
+    char* data = StringValuePtr(s);
+
+    Bitset * new_bs = bitset_new();
+    bitset_setup(new_bs, length);
+
+    int i;
+    for (i = 0; i < length; i++) {
+        if (data[i] == '1') {
+            set_bit(new_bs, i);
+        }
+    }
+
+    return Data_Wrap_Struct(cBitset, 0, bitset_free, new_bs);
+}
+
+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 count = 0;
+    int i;
+    for(i = 0; i < max; i++) {
+        uint64_t segment = bs->data[i];
+        uint64_t other_segment = other_bs->data[i];
+        count += __builtin_popcountll(segment ^ other_segment);
+    }
+
+    return INT2NUM(count);
+}
+
+static VALUE rb_bitset_each(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    int i;
+
+    for(i = 0; i < bs->len; i++) {
+        rb_yield(get_bit(bs, i) > 0 ? Qtrue : Qfalse);
+    }
+
+    return self;
+}
+
+static VALUE rb_bitset_marshall_dump(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    VALUE hash = rb_hash_new();
+    VALUE data = rb_str_new(bs->data, BYTES(bs));
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("len")), UINT2NUM(bs->len));
+    rb_hash_aset(hash, ID2SYM(rb_intern("data")), data);
+
+    return hash;
+}
+
+static VALUE rb_bitset_marshall_load(VALUE self, VALUE hash) {
+    Bitset * bs = get_bitset(self);
+    int len = NUM2INT(rb_hash_aref(hash, ID2SYM(rb_intern("len"))));
+
+    VALUE data = rb_hash_aref(hash, ID2SYM(rb_intern("data")));
+
+    bitset_setup(bs, len);
+
+    bs->data = (uint64_t *) calloc(INTS(bs), sizeof(uint64_t));
+    memcpy(bs->data, RSTRING_PTR(data), BYTES(bs));
+
+    return Qnil;
+}
+
+static VALUE rb_bitset_to_a(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    int i;
+
+    VALUE array = rb_ary_new2(bs->len / 2);
+    for(i = 0; i < bs->len; i++) {
+        if (get_bit(bs, i) > 0) {
+            rb_ary_push(array, INT2NUM(i));
+        }
+    }
+
+    return array;
+}
+
+static VALUE rb_bitset_to_binary_array(VALUE self) {
+    Bitset * bs = get_bitset(self);
+    int i;
+
+    VALUE array = rb_ary_new2(bs->len / 2);
+    for(i = 0; i < bs->len; i++) {
+        rb_ary_push(array, INT2NUM(get_bit(bs, i) > 0 ? 1 : 0));
+    }
+
+    return array;
+}
+
+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, "size", rb_bitset_size, 0);
+    rb_define_method(cBitset, "[]", rb_bitset_aref, 1);
+    rb_define_method(cBitset, "[]=", rb_bitset_aset, 2);
+    rb_define_method(cBitset, "set", rb_bitset_set, -1);
+    rb_define_method(cBitset, "clear", rb_bitset_clear, -1);
+    rb_define_method(cBitset, "set?", rb_bitset_set_p, -1);
+    rb_define_method(cBitset, "clear?", rb_bitset_clear_p, -1);
+    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_method(cBitset, "union", rb_bitset_union, 1);
+    rb_define_alias(cBitset, "|", "union");
+    rb_define_method(cBitset, "difference", rb_bitset_difference, 1);
+    rb_define_alias(cBitset, "-", "difference");
+    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, "not", rb_bitset_not, 0);
+    rb_define_alias(cBitset, "~", "not");
+    rb_define_method(cBitset, "hamming", rb_bitset_hamming, 1);
+    rb_define_method(cBitset, "each", rb_bitset_each, 0);
+    rb_define_method(cBitset, "to_s", rb_bitset_to_s, 0);
+    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, "to_a", rb_bitset_to_a, 0);
+    rb_define_method(cBitset, "to_binary_array", rb_bitset_to_binary_array, 0);
+}

data/ext/bitset/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'bitset'

data/lib/bitset/version.rb

@@ -0,0 +1,3 @@
+module BitsetVersion
+  VERSION = "1.0.0"
+end

data/spec/bitset_spec.rb

@@ -0,0 +1,290 @@
+require 'bitset'
+
+describe Bitset do
+  it 'can be initialized' do
+    Bitset.new(64)
+  end
+
+  describe :size do
+    it 'returns the correct size' do
+      Bitset.new(64).size.should == 64
+      Bitset.new(73).size.should == 73
+    end
+  end
+
+  describe :[] do
+    it 'returns True for set bits' do
+      bs = Bitset.new(8)
+      bs[0] = true
+      bs[0].should == true
+    end
+
+    it 'returns False for unset bits' do
+      bs = Bitset.new(8)
+      bs[0].should == false
+    end
+
+    it 'raises an error when accessing out of bound indexes' do
+      bs = Bitset.new(8)
+      expect { bs[8] }.to raise_error(IndexError)
+    end
+  end
+
+  describe :[]= do
+    it 'sets True for truthy values' do
+      bs = Bitset.new(8)
+
+      bs[0] = true
+      bs[0].should == true
+
+      bs[1] = 123
+      bs[1].should == true
+
+      bs[2] = "woo"
+      bs[2].should == true
+    end
+
+    it 'sets False for falsey values' do
+      bs = Bitset.new(8)
+
+      bs[0] = false
+      bs[0].should == false
+
+      bs[1] = nil
+      bs[1].should == false
+    end
+
+    it 'raises an error when setting out of bound indexes' do
+      bs = Bitset.new(8)
+      expect { bs[8] = true }.to raise_error(IndexError)
+    end
+  end
+
+  describe :set do
+    it 'sets True for all given indexes' do
+      bs = Bitset.new(8)
+      bs.set 1,2,3
+
+      bs[1].should == true
+      bs[2].should == true
+      bs[3].should == true
+    end
+  end
+
+  describe :clear do
+    it 'sets False for all given indexes' do
+      bs = Bitset.new(8)
+      bs.set 1,2,3
+      bs.clear 1,3
+
+      bs[1].should == false
+      bs[2].should == true
+      bs[3].should == false
+    end
+  end
+
+  describe :set? 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
+    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
+    end
+  end
+
+  describe :clear? 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
+    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
+    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
+    end
+  end
+
+  describe :cardinality do
+    it 'returns the number of bits set' do
+      bs = Bitset.new(8)
+      bs.cardinality.should == 0
+
+      bs[0] = true
+      bs.cardinality.should == 1
+
+      bs[1] = true
+      bs.cardinality.should == 2
+
+      bs[2] = true
+      bs.cardinality.should == 3
+
+      bs = Bitset.new(64)
+      bs[0] = 1
+
+      bs.cardinality.should == 1
+    end
+
+    it '... even for large numbers of bits' do
+      bs = Bitset.new(10_000)
+      bs.set(*(0...5000).to_a)
+      bs.cardinality.should == 5000
+
+      bs = Bitset.from_s "01001101000000000000000000000011000010100100000000000000010000101000000000000000100000000100000000000010100100010000000010000100000100000001001000110000000000100010000000010100000000000000110000000000000000000000000100000000100010010000000000000000000001000000000000000000000000000001000000000000000000000000000100000000010010000000000000000000100100000000000000001000000010000001000000000000001000001100010001000000000000001000001000001000000000000001100010000010010001000000010000100000000000110000"
+      bs.cardinality.should == 63
+    end
+  end
+
+  describe :& do
+    it 'returns a new Bitset which is the intersection of two Bitsets' do
+      bs1 = Bitset.new(8)
+      bs1.set 1, 4, 7
+
+      bs2 = Bitset.new(8)
+      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
+    end
+  end
+
+  describe :| do
+    it 'returns a new Bitset which is the union of two Bitsets' do
+      bs1 = Bitset.new(8)
+      bs1.set 1, 4, 7
+
+      bs2 = Bitset.new(8)
+      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
+    end
+  end
+
+  describe :- do
+    it 'returns a new Bitset which is the difference of two Bitsets' do
+      bs1 = Bitset.new(8)
+      bs1.set 1, 4, 7
+
+      bs2 = Bitset.new(8)
+      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
+    end
+  end
+
+  describe :^ do
+    it 'returns a new Bitset which is the xor of two Bitsets' do
+      bs1 = Bitset.new(8)
+      bs1.set 1, 4, 7
+
+      bs2 = Bitset.new(8)
+      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
+    end
+  end
+
+  describe :not do
+    it "returns a new Bitset with 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
+    end
+  end
+
+  describe :hamming do
+    it 'returns the hamming distance of two Bitsets' do
+      bs1 = Bitset.new(8)
+      bs1.set 1, 4, 7
+
+      bs2 = Bitset.new(8)
+      bs2.set 1, 2, 4, 6
+
+      bs1.hamming(bs2).should == 3
+    end
+  end
+
+  describe :each do
+    it 'iterates over the bits in the Bitset' do
+      bs = Bitset.new(4)
+      bs.set 0, 2
+
+      i = 0
+      bs.each do |bit|
+        bit.should == bs[i]
+        i += 1
+      end
+      i.should == 4
+    end
+  end
+
+  describe :to_s do
+    it 'correctly prints out a binary string' do
+      bs = Bitset.new(4)
+      bs.set 0, 2
+      bs.to_s.should == "1010"
+
+      bs = Bitset.new(68)
+      bs.set 0, 2, 66
+      bs.to_s.should == "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
+    end
+  end
+
+  describe :marshalling do
+    it 'can marshal and load' do
+      bs = Bitset.new(68)
+      bs.set 1, 65
+
+      serialized = Marshal.load(Marshal.dump(bs))
+      serialized.set?(1, 65).should == true
+      serialized.cardinality.should == 2
+    end
+  end
+
+  describe :to_a do
+    it "can convert to an array of set positions" do
+      bs = Bitset.new(68)
+      bs.set 1, 64, 65
+
+      bs.to_a.should == [1, 64, 65]
+    end
+  end
+
+  describe :to_binary_array do
+    it "can convert to an array of 1s and 0s" do
+      bs = Bitset.new(68)
+      bs.set 1, 64, 65
+
+      bs.to_binary_array.values_at(1, 64, 65, 66).should == [1, 1, 1, 0]
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: bitset_bm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tyler McMullen
+- Brendon McLean
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+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
+executables: []
+extensions:
+- ext/bitset/extconf.rb
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- bitset.gemspec
+- ext/bitset/bitset.c
+- ext/bitset/extconf.rb
+- lib/bitset/version.rb
+- spec/bitset_spec.rb
+homepage: http://github.com/brendon9x/bitset
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Bitset implementation.
+test_files:
+- spec/bitset_spec.rb