ingramj-bitarray 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.o
+*.so
+Makefile
+pkg

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2009 James E. Ingram
+
+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

@@ -0,0 +1,28 @@
+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.
+
+The test/ directory has a unit test file. It also has a benchmark utility for
+comparison with Peter Cooper's pure Ruby BitField class.
+
+This extension has only been tested with Ruby 1.9.1 on Ubuntu, and probably
+won't compile for Ruby 1.8. Compatibility with Ruby 1.8 is planned.
+
+This library is available as a gem. Install it with
+
+sudo gem install ingramj-bitarray -s http://gems.github.com
+
+Alternately, you can clone the repository and build things manually.
+
+See the TODO file for current limitations and plans.
+
+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.
+
+BitField: http://snippets.dzone.com/posts/show/4234
+

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "bitarray"
+    gem.summary = "A bitarray class for Ruby, implemented as a C extension."
+    gem.description = <<EOF
+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.
+EOF
+    gem.email = "ingramj@gmail.com"
+    gem.homepage = "http://github.com/ingramj/bitarray"
+    gem.authors = ["James E. Ingram"]
+    gem.require_paths = ["ext"]
+    gem.extensions = ["ext/extconf.rb"]
+    gem.required_ruby_version = ">= 1.9.1"
+    gem.rdoc_options << '--exclude' << 'ext/Makefile' << '--title' << ' BitArray Documentation'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/TODO

@@ -0,0 +1,9 @@
+* Comment code. I'd like for it to be useful as a tutorial for extension
+  writing, especially with regards to implementing new types.
+* Implement some more methods, like Hamming weight, and slice, and in-place
+  enumerator methods (map!, reverse!, etc).
+* Maybe allow resizing.
+* Write more tests
+* Ruby 1.8 compatibility. This will probably involve just changing some of the
+  NUM2x and x2NUM defines.
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bitarray.gemspec

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bitarray}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["James E. Ingram"]
+  s.date = %q{2009-05-23}
+  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"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "bitarray.gemspec",
+     "ext/bitarray.c",
+     "ext/extconf.rb",
+     "test/bitfield.rb",
+     "test/bm.rb",
+     "test/test.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/ingramj/bitarray}
+  s.rdoc_options = ["--charset=UTF-8", "--exclude", "ext/Makefile", "--title", " BitArray Documentation"]
+  s.require_paths = ["ext"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.1")
+  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/bm.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/ext/bitarray.c

@@ -0,0 +1,347 @@
+#include "ruby.h"
+#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))
+
+/* Bit Array structure. */
+struct bit_array {
+    size_t bits;         /* Number of bits. */
+    size_t array_size;   /* Size of the storage array. */
+    unsigned int *array; /* Array of unsigned ints, used for bit storage. */
+};
+
+
+/* Bit Array manipulation functions. */
+
+/* Set the specified bit to 1. Return 1 on success, 0 on failure. */
+static int
+set_bit(struct bit_array *ba, ptrdiff_t bit)
+{
+    if (bit < 0) bit += ba->bits;
+    if (bit >= ba->bits) {
+        return 0;
+    }
+
+    ba->array[bit / UINT_BITS] |= bitmask(bit);
+    return 1;
+}
+
+
+/* Set all bits to 1. */
+static int
+set_all_bits(struct bit_array *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 int
+clear_bit(struct bit_array *ba, ptrdiff_t bit)
+{
+    if (bit < 0) bit += ba->bits;
+    if (bit >= ba->bits) {
+        return 0;
+    }
+
+    ba->array[bit / UINT_BITS] &= ~bitmask(bit);
+    return 1;
+}
+
+
+/* Clear all bits to 0. */
+static int
+clear_all_bits(struct bit_array *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 int
+toggle_bit(struct bit_array *ba, ptrdiff_t bit)
+{
+    if (bit < 0) bit += ba->bits;
+    if (bit >= ba->bits) {
+        return 0;
+    }
+
+    ba->array[bit / UINT_BITS] ^= bitmask(bit);
+    return 1;
+}
+
+
+/* Assign the specified value to a bit. Return 1 on success, 0 on invalid bit
+ * index, and -1 on invalid value. */
+static int
+assign_bit(struct bit_array *ba, ptrdiff_t bit, int value)
+{
+    if (value == 0) {
+        return clear_bit(ba, bit);
+    } else if (value == 1) {
+        return set_bit(ba, bit);
+    } else {
+        return -1;
+    }
+}
+
+
+/* Get the state of the specified bit. Return -1 on failure. */
+static int
+get_bit(struct bit_array *ba, ptrdiff_t bit)
+{
+    if (bit < 0) bit += ba->bits;
+    if (bit >= ba->bits) {
+        return -1;
+    }
+
+    unsigned int b = (ba->array[bit / UINT_BITS] & bitmask(bit));
+    if (b > 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+
+/* Ruby Interface Functions. These aren't documented yet. */
+
+static VALUE rb_bitarray_class;
+
+
+static void
+rb_bitarray_free(struct bit_array *ba)
+{
+    if (ba && ba->array) {
+        ruby_xfree(ba->array);
+    }
+    ruby_xfree(ba);
+}
+
+
+static VALUE
+rb_bitarray_alloc(VALUE klass)
+{
+    struct bit_array *ba;
+    return Data_Make_Struct(rb_bitarray_class, struct bit_array, NULL,
+            rb_bitarray_free, ba);
+}
+
+
+static VALUE
+rb_bitarray_initialize(VALUE self, VALUE size)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    size_t bits = NUM2SIZET(size);
+    size_t array_size = ((bits - 1) / UINT_BITS) + 1;
+
+    ba->bits = bits;
+    ba->array_size = array_size;
+    ba->array = ruby_xcalloc(array_size, UINT_BYTES);
+
+    return self;
+}
+
+
+static VALUE
+rb_bitarray_clone(VALUE self)
+{
+    struct bit_array *ba, *new_ba;
+    VALUE rb_new_ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+    rb_new_ba = Data_Make_Struct(rb_bitarray_class, struct bit_array, NULL,
+            rb_bitarray_free, new_ba);
+
+    new_ba->bits = ba->bits;
+    new_ba->array_size = ba->array_size;
+    new_ba->array = ruby_xcalloc(new_ba->array_size, UINT_BYTES);
+
+    memcpy(new_ba->array, ba->array, (ba->array_size * UINT_BYTES));
+
+    return rb_new_ba;
+}
+
+
+static VALUE
+rb_bitarray_size(VALUE self)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    return SIZET2NUM(ba->bits);
+}
+
+
+static VALUE
+rb_bitarray_set_bit(VALUE self, VALUE bit)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    ptrdiff_t index = NUM2SSIZET(bit);
+
+    if (set_bit(ba, index)) {
+        return self;
+    } else {
+        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+    }
+}
+
+
+static VALUE
+rb_bitarray_set_all_bits(VALUE self)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    if(set_all_bits(ba)) {
+        return self;
+    } else {
+        rb_bug("BitArray#set_all_bits failed. This should not occur.");
+    }
+}
+
+
+static VALUE
+rb_bitarray_clear_bit(VALUE self, VALUE bit)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    ptrdiff_t index = NUM2SSIZET(bit);
+
+    if (clear_bit(ba, index)) {
+        return self;
+    } else {
+        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+    }
+}
+
+
+static VALUE
+rb_bitarray_clear_all_bits(VALUE self)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    if(clear_all_bits(ba)) {
+        return self;
+    } else {
+        rb_bug("BitArray#clear_all_bits failed. This should not occur.");
+    }
+}
+
+
+static VALUE
+rb_bitarray_get_bit(VALUE self, VALUE bit)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    ptrdiff_t index = NUM2SSIZET(bit);
+
+    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", (long)index);
+    }
+}
+
+
+static VALUE
+rb_bitarray_assign_bit(VALUE self, VALUE bit, VALUE value)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    ptrdiff_t index = NUM2SSIZET(bit);
+    int bit_value = NUM2INT(value);
+
+    int result = assign_bit(ba, index, bit_value);
+    if (result == 1) {
+        return self;
+    } else if (result == 0) {
+        rb_raise(rb_eIndexError, "index %ld out of bit array", (long)index);
+    } else {
+        rb_raise(rb_eRuntimeError, "bit value %d out of range", bit_value);
+    }
+}
+
+
+static VALUE
+rb_bitarray_inspect(VALUE self)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    size_t cstr_size = ba->bits + 1;
+    char cstr[cstr_size];
+    
+    size_t i;
+    for (i = 0; i < ba->bits; i++) {
+        cstr[i] = get_bit(ba, i) + '0';
+    }
+    cstr[ba->bits] = '\0';
+
+    VALUE str = rb_str_new2(cstr);
+    return str;
+}
+
+
+static VALUE
+rb_bitarray_each(VALUE self)
+{
+    struct bit_array *ba;
+    Data_Get_Struct(self, struct bit_array, ba);
+
+    size_t i;
+
+    RETURN_ENUMERATOR(self, 0, 0);
+    for (i = 0; i < ba->bits; i++) {
+        int bit_value = get_bit(ba, i);
+        rb_yield(INT2NUM(bit_value));
+    }
+    return self;
+}
+
+
+void
+Init_bitarray()
+{
+    rb_bitarray_class = rb_define_class("BitArray", rb_cObject);
+    rb_define_alloc_func(rb_bitarray_class, rb_bitarray_alloc);
+
+    rb_define_method(rb_bitarray_class, "initialize",
+            rb_bitarray_initialize, 1);
+    rb_define_method(rb_bitarray_class, "clone", rb_bitarray_clone, 0);
+    rb_define_method(rb_bitarray_class, "size", rb_bitarray_size, 0);
+    rb_define_alias(rb_bitarray_class, "length", "size");
+    rb_define_method(rb_bitarray_class, "set_bit", rb_bitarray_set_bit, 1);
+    rb_define_method(rb_bitarray_class, "set_all_bits",
+            rb_bitarray_set_all_bits, 0);
+    rb_define_method(rb_bitarray_class, "clear_bit", rb_bitarray_clear_bit, 1);
+    rb_define_method(rb_bitarray_class, "clear_all_bits",
+            rb_bitarray_clear_all_bits, 0);
+    rb_define_method(rb_bitarray_class, "[]", rb_bitarray_get_bit, 1);
+    rb_define_method(rb_bitarray_class, "[]=", rb_bitarray_assign_bit, 2);
+    rb_define_method(rb_bitarray_class, "inspect", rb_bitarray_inspect, 0);
+    rb_define_alias(rb_bitarray_class, "to_s", "inspect");
+    rb_define_method(rb_bitarray_class, "each", rb_bitarray_each, 0);
+
+    rb_include_module(rb_bitarray_class, rb_mEnumerable);
+}
+

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('bitarray');

data/test/bitfield.rb

@@ -0,0 +1,67 @@
+#        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

data/test/bm.rb

@@ -0,0 +1,38 @@
+require 'bitfield'
+require 'bitarray'
+require 'benchmark'
+
+Benchmark.bm(24) { |bm|
+  puts "------------------------ Object instantiation."
+  bm.report("BitField initialize") { 10000.times { BitField.new(256) } }
+  bm.report("BitArray initialize") { 10000.times { BitArray.new(256) } }
+
+  bf = BitField.new(256)
+  ba = BitArray.new(256)
+  
+  puts "------------------------ Element Reading"
+  bm.report("BitField []")         { 10000.times { bf[rand(256)] } }
+  bm.report("BitArray []")         { 10000.times { ba[rand(256)] } }
+
+  puts "------------------------ Element Writing"
+  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"
+  bm.report("BitField each")       { 10000.times { bf.each {|b| b } } }
+  bm.report("BitArray each")       { 10000.times { ba.each {|b| b } } }
+
+  puts "------------------------ To String"
+  bm.report("BitField to_s")       { 10000.times { bf.to_s } }
+  bm.report("BitArray to_s")       { 10000.times { ba.to_s } }
+
+  puts "------------------------ Set All"
+  bm.report("BitArray set_all_bits")    { 10000.times { ba.set_all_bits} }
+
+  puts "------------------------ Clear All"
+  bm.report("BitArray clear_all_bits")  { 10000.times { ba.clear_all_bits } }
+  
+  puts "------------------------ Clone"
+  bm.report("BitArray clone")           { 10000.times { ba.clone } }
+}
+

data/test/test.rb

@@ -0,0 +1,91 @@
+# Peter Cooper's BitField test file, modified for BitArray.
+# http://snippets.dzone.com/posts/show/4234
+require "test/unit"
+require "bitarray"
+
+class TestLibraryFileName < Test::Unit::TestCase
+  def setup
+    @public_ba = BitArray.new(1000)
+  end
+  
+  def test_basic
+    assert_equal 0, BitArray.new(100)[0]
+    assert_equal 0, BitArray.new(100)[1]
+  end
+  
+  def test_setting_and_unsetting
+    @public_ba[100] = 1
+    assert_equal 1, @public_ba[100]
+    @public_ba[100] = 0
+    assert_equal 0, @public_ba[100]
+  end
+
+  def test_random_setting_and_unsetting
+    100.times do
+      index = rand(1000)
+      @public_ba[index] = 1
+      assert_equal 1, @public_ba[index]
+      @public_ba[index] = 0
+      assert_equal 0, @public_ba[index]
+    end
+  end
+  
+  def test_multiple_setting
+    1.upto(999) do |pos|
+      2.times { @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 }
+      assert_equal 0, @public_ba[pos]
+    end
+  end
+  
+  def test_size
+    assert_equal 1000, @public_ba.size
+  end
+  
+
+  def test_to_s
+    ba = BitArray.new(10)
+    ba[1] = 1
+    ba[5] = 1
+    assert_equal "0100010000", ba.to_s
+  end
+
+
+  def test_set_all_bits
+    ba = BitArray.new(10)
+    ba.set_all_bits
+    assert_equal "1111111111", ba.to_s
+  end
+
+  def test_clear_all_bits
+    ba = BitArray.new(10)
+    ba[1] = 1
+    ba[5] = 1
+    ba.clear_all_bits
+    assert_equal "0000000000", ba.to_s
+  end
+
+  def test_clone
+    ba = BitArray.new(10)
+    ba[1] = 1
+    ba[5] = 1
+    ba_clone = ba.clone
+    assert_equal ba_clone.to_s, ba.to_s
+  end
+  
+  # This method is not implemented yet.
+
+  #def test_total_set
+  #  bf = BitArray.new(10)
+  #  bf[1] = 1
+  #  bf[5] = 1
+  #  assert_equal 2, bf.total_set
+  #end
+end
+

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: ingramj-bitarray
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- James E. Ingram
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-23 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 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.
+email: ingramj@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- .gitignore
+- LICENSE
+- README
+- Rakefile
+- TODO
+- VERSION
+- bitarray.gemspec
+- ext/bitarray.c
+- ext/extconf.rb
+- test/bitfield.rb
+- test/bm.rb
+- test/test.rb
+has_rdoc: true
+homepage: http://github.com/ingramj/bitarray
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+- --exclude
+- ext/Makefile
+- --title
+- " BitArray Documentation"
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.1
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+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