bit_vector 0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f6f928647cf7bd7886a1205e7714ed15f0320bf
+  data.tar.gz: 83942ae3820c64df059a0dfffb1dbf8d4e54ab6f
+SHA512:
+  metadata.gz: ab7074ab7c7b68ef7668dc9b62d53a350d1c5c2e8825eb84b996e12255d046c284fc94ec28749def0c34d693647d45bab943d245b696d6b33d758c6338578ef7
+  data.tar.gz: c5892e896bdec09a219ece110a2a8dbdcdf7193c2c0bde559b4a24f5c14607109f7412b0717eb9262515df86bd5ee91e7a3854687313c6a83d5248a4a20a0329

data/README.md

@@ -0,0 +1,52 @@
+# bit_vector
+
+An implementation of arbitrarily large Bit Vectors in Ruby using C + inline assembler for speed
+
+This builds heavily on a much earlier Gem 'bitset' authored by 'MoonWolf' on RAA.
+
+# Notes on Bit Vector Lengths
+
+Many bit vector operations are only defined if the lengths of the vectors are the same. By
+considering a bit vector to possess any number of high-order zeros most operations
+can be made to work with differently sized operands. When creating this library
+a couple of different approaches to this were considered:
+
+* Return a result the size of the first operand,
+* Return the smallest result set (not necessarily normalized),
+* Return a normalized result (the length being the position of the high order bit).
+
+Like the original implementor I chose to use the middle strategy.
+
+# Bit Vectors in String Format
+
+The string format of a bit vector represents the bit positions from least significant to
+most significant with the characters '0,-,f,F,N' representing an un-set bit and all other
+characters interpreted as a set bit.
+
+## `from_bytes` and `to_bytes`
+
+These are methods to serialize and de-serialize a bit vector in a platform dependent way.
+They use US-ASCII encoded strings consisting of 8-bit bytes that represents the bit
+vector. It is _not_ the binary representation as a string of 0's and 1's used by `new` and
+`to_s` methods.
+
+# Operators and Methods
+
+Statements that use binary operators of the form `r = a op b` are computed by
+the Ruby call `a.op(b)`
+
+Most operators are obvious, here's some that aren't
+
+## minus
+
+This is defined elementwise as: r = a and not b
+
+## bytesize
+
+This returns the length in bytes required to store this bitvec
+
+## New
+Called with:
+
+* a FixNum to create an empty vector of specified length
+* a String to create a vector from the string in the format described above.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rake/clean'
+
+CLEAN << %w{
+    ext/bit_vector/Makefile
+    ext/bit_vector/bit_vector.o
+    ext/bit_vector/mkmf.log
+}
+
+CLOBBER << %w{
+    ext/bit_vector/bit_vector.so
+    ext/bit_vector/bit_vector.bundle
+    pkg/
+}
+
+# Run the benchmarks with the in-tree gem
+#
+desc "Run the benchmarks using the tree"
+task :benchmark do
+  ruby "-Ilib:ext/bit_vector:#{$:.join(':')} test/benchmark.rb"
+end
+
+# Now we want to test with the in-tree gem, but Bundler doesn't support binary gems
+# with the :path syntax, so we have to do it ourselves.
+#
+Rake::TestTask.new('test:unit') do |t|
+  t.pattern = 'test/test*.rb'
+  t.libs << 'ext/bit_vector'
+  t.libs << 'lib'
+end
+
+Rake::TestTask.new('test:spec') do |t|
+  t.test_files = ['test/spec.rb']
+  t.libs << 'ext/bit_vector'
+  t.libs << 'lib'
+end
+
+# Now although we have put the gem in the Gemfile with a :path
+# bundler won't actually compile the extensions, so make it happen...
+#
+desc "Compile the C extensions so we can use in-tree"
+task :compile do
+  cd "ext/bit_vector" do
+    ruby "extconf.rb"
+    sh "make"
+  end
+end
+task 'test:unit' => :compile
+task 'test:spec' => :compile
+
+task :test => ['test:unit', 'test:spec']
+task :default => :test
+
+# vim: ft=ruby sts=2 sw=2 ts=8

data/ext/bit_vector/Makefile

@@ -0,0 +1,238 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@:)
+ECHO = $(ECHO1:0=@echo)
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /System/Library/Frameworks/Ruby.framework/Versions/2.0/usr/include/ruby-2.0.0
+hdrdir = $(topdir)
+arch_hdrdir = /System/Library/Frameworks/Ruby.framework/Versions/2.0/usr/include/ruby-2.0.0/universal-darwin14
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = /System/Library/Frameworks/Ruby.framework/Versions/2.0/usr
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(DESTDIR)/Library/Ruby/Site
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(DESTDIR)/usr/share/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(DESTDIR)/usr/share/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = /usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(DESTDIR)/Library/Ruby/Site
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = xcrun clang
+CXX = xcrun clang++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+optflags = 
+debugflags = -g
+warnflags = 
+CCDLFLAGS = 
+CFLAGS   = $(CCDLFLAGS) -std=c99 -Wall -Wextra -O0 -ggdb3 $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(ARCH_FLAG) -g -Os -pipe  $(ARCH_FLAG)
+ldflags  = -L. -L/usr/local/lib
+dldflags = -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress 
+ARCH_FLAG = -arch x86_64
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby.2.0.0
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = universal-darwin14
+sitearch = $(arch)
+ruby_version = 2.0.0
+ruby = $(bindir)/ruby
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lobjc 
+ORIG_SRCS = bit_vector.c
+SRCS = $(ORIG_SRCS) 
+OBJS = bit_vector.o
+HDRS = 
+TARGET = bit_vector
+TARGET_NAME = bit_vector
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(DESTDIR)$(bindir)
+RUBYCOMMONDIR = $(DESTDIR)$(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(DESTDIR)$(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(DESTDIR)$(sitearchdir)$(target_prefix)
+HDRDIR        = $(DESTDIR)$(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(DESTDIR)$(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) ./.RUBYARCHDIR.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default:
+	$(ECHO) installing default bit_vector libraries
+./.RUBYARCHDIR.time:
+	$(Q) $(MAKEDIRS) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .C .o
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	$(ECHO) linking shared-object $(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+	$(Q) test -z '$(RUBY_CODESIGN)' || codesign -s '$(RUBY_CODESIGN)' -f $@
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/ext/bit_vector/bit_vector.c

@@ -0,0 +1,1019 @@
+/* Taken from an original by 'MoonWolf' on RAA
+ * Largely rewritten to use 64 bit allocations and inline assembly for speed
+ * by Nick Townsend 2014
+ */
+#include "ruby.h"
+#include "string.h"
+
+#define BITCOUNTS(s,len) (s->bit_len = len, s->qws_len = (len+63)/64, s->last_bit = len % 64 )
+
+static VALUE cBitVector;
+static ID id_new, id_first, id_end;
+
+struct BitVector {
+  int64_t   bit_len;  /* in bits */
+  int64_t   qws_len;  /* number of uint64 elements */
+  int       last_bit; /* number bits used in final element (0 = all) */
+  uint64_t *ptr;
+};
+
+void bs_resize(struct BitVector *bits, int64_t bit_len) {
+
+  int64_t qws_len   = (bit_len + 63) / 64;
+  int     last_bit  = bit_len % 64;
+
+  if (bits->bit_len == bit_len) {
+    return;
+  }
+  else if (bits->bit_len > bit_len) {
+    bits->ptr = REALLOC_N(bits->ptr, uint64_t, qws_len);
+    if (last_bit > 0) {
+      bits->ptr[qws_len-1] &= (1<<last_bit)-1;
+    }
+  }
+  else if (bits->bit_len < bit_len) {
+    bits->ptr = REALLOC_N(bits->ptr, uint64_t, qws_len);
+    memset(bits->ptr+bits->qws_len, 0, qws_len - bits->qws_len);
+  }
+  bits->bit_len = bit_len;
+  bits->qws_len = qws_len;
+  bits->last_bit = last_bit;
+}
+
+int64_t bs_bytesize(struct BitVector *bits) {
+  int64_t byte_len = bits->qws_len*8;
+  if (bits->last_bit > 0) {
+    byte_len -= 8;
+    byte_len += (bits->last_bit+7)/8;
+  }
+  return byte_len;
+}
+
+int bs_get(struct BitVector *bits, int64_t index) {
+  int bit;
+
+  if (index >= bits->bit_len) {
+    bit = 0;
+  } else {
+    __asm ( "mov %2, %%r8 \n"
+          "shr $6, %%r8 \n"
+          "mov %2, %%r9 \n"
+          "and $63, %%r9 \n"
+          "mov $0, %0 \n"
+          "bt %%r9, (%1, %%r8, 8) \n"
+          "jnc get_exit \n"
+          "mov $1, %0 \n"
+          "get_exit: \n"
+        : "=r"(bit) : "r"(bits->ptr), "r"(index) : "cc"
+    );
+  }
+  return bit;
+}
+
+void bs_set(struct BitVector *bits, int64_t index, int bit) {
+
+  if (index >= bits->bit_len) {
+    bs_resize(bits, index+1);
+  }
+
+  __asm volatile (
+      "mov %1, %%r8 \n"
+      "shr $6, %%r8 \n"
+      "mov %1, %%r9 \n"
+      "and $63, %%r9 \n"
+      "cmp $0, %2 \n"
+      "je bs_set_zero \n"
+      "bts %%r9, (%0,%%r8,8) \n"
+      "jmp bs_set_exit \n"
+      "bs_set_zero: \n"
+      "btr %%r9, (%0,%%r8,8) \n"
+      "bs_set_exit: \n"
+      : : "r"(bits->ptr), "r"(index), "r"(bit) : "%r8", "%r9", "cc", "memory"
+  );
+
+}
+
+void bs_sets(struct BitVector *bits, int64_t first, int64_t last, int bit) {
+  int64_t first_offset;
+  int64_t last_offset;
+  int64_t first_bit;
+  int64_t last_bit;
+  int64_t qws;
+  int64_t i;
+  uint64_t c;
+
+  if (bits->bit_len < last) {
+    bs_resize(bits, last);
+  }
+
+  first_offset = first / 64;
+  first_bit    = first % 64;
+  last_offset  = last  / 64;
+  last_bit     = last  % 64;
+  qws = last_offset - first_offset + 1;
+
+  if (first_bit==0 && last_bit==63) {
+    memset(&bits->ptr[first_offset], bit ? 0xffffffffffffffff : 0x0, qws);
+    return;
+  }
+
+  if (last-first < 63) {
+    for(i=first; i<=last; i++) {
+      bs_set(bits, i, bit);
+    }
+    return;
+  }
+
+  if (first_bit != 0) {
+    c = bits->ptr[first_offset];
+    if (bit) {
+      c |= ~((1 << first_bit) - 1);
+    } else {
+      c &= ((1 << first_bit) - 1);
+    }
+    bits->ptr[first_offset] = c;
+    first_offset++;
+    qws--;
+  }
+
+  if (last_bit != 63) {
+    c = bits->ptr[last_offset];
+    if (bit) {
+      c |= ((2 << last_bit) - 1);
+    } else {
+      c &= ~((2 << last_bit) - 1);
+    }
+    bits->ptr[last_offset] = c;
+    qws--;
+  }
+
+  if (qws>0) {
+    memset(&bits->ptr[first_offset], bit ? 0xffffffffffffffff : 0x00, qws);
+  }
+
+  return;
+}
+
+
+void bs_fill(VALUE obj, struct BitVector *bits, int fill) {
+  int i;
+  VALUE vfirst, vend;
+  int64_t first, end;
+  switch(TYPE(obj)) {
+  case T_FIXNUM:
+    bs_set(bits, FIX2LONG(obj), fill);
+    break;
+  case T_ARRAY:
+    for(i=0; i< (RARRAY_LEN(obj)); i++) {
+      bs_fill( (RARRAY_PTR(obj)[i]), bits, fill);
+    }
+    break;
+  default:
+    if (rb_class_of(obj)==rb_cRange) {
+      vfirst = rb_funcall(obj, id_first, 0);
+      vend   = rb_funcall(obj, id_end, 0);
+      Check_Type(vfirst, T_FIXNUM);
+      Check_Type(vend, T_FIXNUM);
+      first = FIX2LONG(vfirst);
+      end   = FIX2LONG(vend);
+      if (rb_funcall(obj, rb_intern("exclude_end?"), 0) == Qtrue) {
+        end--;
+      }
+      if (first>end || first<0 || end<0) {
+        rb_raise(rb_eRangeError, "not valid range");
+      }
+      bs_sets(bits, first, end, fill);
+    } else {
+      rb_raise(rb_eTypeError, "not valid index");
+    }
+  }
+}
+
+void bs_or(struct BitVector *bits, struct BitVector *x) {
+  uint64_t *ptr, *xptr;
+  int64_t i;
+
+  if (bits->bit_len < x->bit_len) {
+    bs_resize(bits, x->bit_len);
+  }
+
+  ptr   = bits->ptr;
+  xptr  = x->ptr;
+  for(i=0; i<bits->qws_len; i++) {
+    *ptr++ |= *xptr++;
+  }
+
+}
+
+void bs_not(struct BitVector *bits) {
+  uint64_t *ptr;
+  uint64_t qw;
+  int64_t i;
+
+  ptr   = bits->ptr;
+  for(i=0; i < bits->qws_len; i++) {
+    qw = *ptr;
+    *ptr++ = ~qw;
+  }
+  if (bits->last_bit>0) {
+    qw = *--ptr;
+    *ptr = qw & ((1<<bits->last_bit)-1);
+  }
+}
+
+/* Returned bit_vector is the size of the first operand. See README.md */
+
+void bs_and(struct BitVector *rbits, struct BitVector *xbits, struct BitVector *ybits) {
+  uint64_t *rptr, *xptr, *yptr;
+
+  *rbits = *xbits;
+  rbits->ptr = ALLOC_N(uint64_t, rbits->qws_len);
+
+  rptr = rbits->ptr;
+  xptr = xbits->ptr;
+  yptr = ybits->ptr;
+
+  for (int64_t ix = 0; ix < rbits->qws_len; ix++) {
+    *rptr++ = *xptr++ & *yptr++;
+  }
+  if (rbits->last_bit > 0) {
+      *(--rptr) &= (1<<rbits->last_bit)-1;
+  }
+}
+
+void bs_xor(struct BitVector *bits, struct BitVector *x) {
+  uint64_t *ptr, *xptr;
+  int64_t i;
+
+  if (bits->bit_len < x->bit_len) {
+    bs_resize(bits, x->bit_len);
+  }
+
+  ptr   = bits->ptr;
+  xptr  = x->ptr;
+  for(i=0; i<bits->qws_len; i++) {
+    *ptr++ ^= *xptr++;
+  }
+
+}
+
+int64_t bs_max(struct BitVector *bits) {
+  int64_t qws;
+  int64_t pos;
+
+  for (qws = bits->qws_len - 1; qws >= 0; qws -= 1) {
+    __asm (
+          "bsr %1, %0 \n"
+          "jnz bs_max_found \n"
+          "mov $64, %0 \n"
+          "bs_max_found: \n"
+        : "=r"(pos) : "m"(bits->ptr[qws]) : "cc", "memory"
+    );
+    if (pos < 64) {
+      return (qws * 64) + pos;
+    }
+  }
+  return -1;
+}
+
+int64_t bs_min(struct BitVector *bits) {
+  int64_t index;
+  int pos;
+  uint64_t *ptr, qw;
+
+  ptr   = bits->ptr;
+  for(index = 0; index < bits->bit_len; index += 64) {
+    qw = *ptr++;
+    __asm (
+          "bsf %1, %0 \n"
+          "jnz bs_min_found \n"
+          "mov $64, %0 \n"
+          "bs_min_found: \n"
+        : "=r"(pos) : "m"(qw) : "cc"
+    );
+    if (pos < 64) {
+      return index + pos;
+    }
+  }
+  return -1;
+}
+
+int64_t bs_index(struct BitVector *bits, int bit, int64_t off) {
+  int64_t pos;
+
+  __asm (
+      "mov %3, %%r9 \n"
+      "shr $6, %%r9 \n" /* r9: loop counter stepping up in qw */
+      "mov %2, %%r11 \n"
+      "shr $6, %%r11 \n" /* r11: end marker in qw */
+      "mov $18446744073709551615, %%r8 \n"
+      "mov %3, %%rcx \n"
+      "and $63, %%rcx \n" /* rcx: bit offset in first qw */
+      "shl %%cl, %%r8 \n"
+      "and (%1, %%r9, 8), %%r8 \n"
+      "loop: \n"
+      "  bsf %%r8, %%rax \n"
+      "  jnz found \n"
+      "  inc %%r9 \n"
+      "  cmp %%r11, %%r9 \n"
+      "  jl next \n"
+      "  movq $-1, %0 \n"
+      "  jmp exit \n"
+      "next: \n"
+      "  mov (%1, %%r9, 8), %%r8 \n"
+      "  jmp loop \n"
+      "found: \n"
+      "  salq $6, %%r9 \n"
+      "  add %%rax, %%r9 \n"
+      "  movq %%r9, %0 \n"
+      "exit: \n"
+      : "=r"(pos) : "r"(bits->ptr), "r"(bits->bit_len), "r"(off), "m"(bit) : "%rax", "%rcx", "%r8", "%r9", "%r11", "cc", "memory"
+  );
+
+  return pos;
+}
+int to_bit(VALUE obj) {
+  int bit;
+
+  switch(TYPE(obj)) {
+  case T_NIL:
+  case T_FALSE:
+    bit = 0;
+    break;
+  case T_FIXNUM:
+    if (FIX2INT(obj)==0) {
+      bit = 0;
+    } else {
+      bit = 1;
+    }
+    break;
+  default:
+    bit = 1;
+  }
+
+  return bit;
+}
+
+void bits_free(struct BitVector *bits) {
+  ruby_xfree(bits->ptr);
+}
+
+static VALUE bits_s_new(int argc, VALUE *argv, VALUE self) {
+  struct BitVector *bits;
+  VALUE arg;
+  VALUE obj;
+  int   bitcnt;
+  int64_t   len;
+  uint64_t  qw, *bptr;
+  unsigned char *ptr;
+
+  obj = Data_Make_Struct(self, struct BitVector, NULL, bits_free, bits);
+
+  switch(argc) {
+    case 0:
+      arg = INT2FIX(1);
+      break;
+    case 1:
+      arg = argv[0];
+      break;
+    default:
+      arg = INT2FIX(0);
+      rb_raise(rb_eArgError, "Too many args");
+  }
+
+  switch(TYPE(arg)) {
+
+  case T_FIXNUM:
+
+    BITCOUNTS(bits, FIX2LONG(arg));
+    if (bits->bit_len < 1) {
+      rb_raise(rb_eArgError, "May not be less than one");
+    }
+    bits->ptr = ALLOC_N(uint64_t, bits->qws_len);
+    memset(bits->ptr, 0, bits->qws_len*8);
+    break;
+
+  case T_STRING:
+
+    len = RSTRING_LEN(arg);
+    BITCOUNTS(bits,len);
+    bits->ptr = ALLOC_N(uint64_t, bits->qws_len);
+    memset(bits->ptr, 0, bits->qws_len*8);
+
+    qw = 0;
+    bitcnt = 0;
+    ptr = (unsigned char *)RSTRING_PTR(arg);
+    bptr = bits->ptr;
+    while(len--) {
+      switch(*ptr++) {
+      case '0':
+      case '-':
+      case 'f':
+      case 'F':
+      case 'N':
+        break;
+      default:
+        __asm ( "bts %1, %0" : "=g"(qw) : "r"(bitcnt) : "cc","memory");
+      }
+      bitcnt++;
+      if (bitcnt == 64) {
+        *bptr++ = qw;
+        qw = 0;
+        bitcnt = 0;
+      }
+    }
+    if (bitcnt) {
+      *bptr++ = qw;
+    }
+    break;
+
+  default:
+    rb_raise(rb_eArgError, "not valid value");
+  }
+
+  return obj;
+}
+
+static VALUE bits_s_from_bytes(VALUE self, VALUE arg) {
+  struct BitVector *bits;
+  VALUE retobj;
+  int64_t len;
+
+  Check_Type(arg, T_STRING);
+
+  len = RSTRING_LEN(arg);
+  if (len<1) {
+    rb_raise(rb_eArgError, "array size");
+  }
+
+  retobj = Data_Make_Struct(self, struct BitVector, NULL, bits_free, bits);
+  BITCOUNTS(bits, len*8);
+  bits->ptr = ALLOC_N(uint64_t, bits->qws_len);
+
+  memcpy(bits->ptr, RSTRING_PTR(arg), len);
+
+  return retobj;
+}
+
+
+static VALUE bits_length(VALUE self) {
+  struct BitVector *bits;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  return LONG2FIX(bits->bit_len);
+}
+
+static VALUE bits_bytesize(VALUE self) {
+  struct BitVector *bits;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  return LONG2FIX(bs_bytesize(bits));
+}
+
+static VALUE bits_resize(VALUE self, VALUE obj) {
+  struct BitVector *bits;
+  int64_t len;
+
+  Check_Type(obj, T_FIXNUM);
+  len = FIX2LONG(obj);
+  if (len<1) {
+    rb_raise(rb_eArgError, "array size");
+  }
+
+  Data_Get_Struct(self, struct BitVector, bits);
+  bs_resize(bits, len);
+
+  return self;
+}
+
+static VALUE bits_to_s(VALUE self) {
+  struct BitVector *bits;
+  unsigned char *ptr;
+  int64_t i;
+  VALUE str;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+  str = rb_str_new(0, bits->bit_len);
+
+  ptr = (unsigned char *)RSTRING_PTR(str);
+  for(i=0; i<bits->bit_len; i++) {
+    *ptr++ = bs_get(bits, i) ? '1' : '0';
+  }
+
+  return str;
+}
+
+static VALUE bits_dup(VALUE self) {
+  struct BitVector *orig;
+  struct BitVector *dups;
+  VALUE obj;
+
+  Data_Get_Struct(self, struct BitVector, orig);
+
+  obj = Data_Make_Struct(CLASS_OF(self), struct BitVector, NULL, bits_free, dups);
+  *dups = *orig;
+  dups->ptr = ALLOC_N(uint64_t, dups->qws_len);
+  memcpy(dups->ptr, orig->ptr, dups->qws_len*8);
+
+  return obj;
+}
+
+static VALUE bits_clear(VALUE self) {
+  struct BitVector *bits;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+  memset(bits->ptr, 0, bits->qws_len*8);
+
+  return self;
+}
+
+static VALUE bits_get(VALUE self, VALUE vidx) {
+  struct BitVector *bits;
+  int64_t index;
+  int bit;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  Check_Type(vidx, T_FIXNUM);
+
+  index = FIX2LONG(vidx);
+  if (index<0) {
+    rb_raise(rb_eRangeError, "index range");
+  }
+
+  bit = bs_get(bits, index);
+
+  return INT2FIX(bit);
+}
+
+
+static VALUE bits_set(VALUE self, VALUE vidx, VALUE vobj) {
+  struct BitVector *bits;
+  int64_t index;
+  int bit;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  Check_Type(vidx, T_FIXNUM);
+
+  index = FIX2LONG(vidx);
+  if (index<0) {
+    rb_raise(rb_eRangeError, "index range");
+  }
+
+  bit = to_bit(vobj);
+
+  bs_set(bits, index, bit);
+
+  return self;
+}
+
+/* This method returns the index of the first bit set to the given value */
+
+static VALUE bits_index(VALUE self, VALUE vobj, VALUE voff) {
+  struct BitVector *bits;
+  int64_t       pos, off;
+  int           bit;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+  bit = to_bit(vobj);
+  Check_Type(voff, T_FIXNUM);
+  off = FIX2LONG(voff);
+
+  pos = bs_index(bits, bit, off);
+
+  return (pos == -1) ? Qnil : LONG2FIX(pos);
+}
+/* This method extracts a subset of the bit_vector */
+
+static VALUE bits_slice(VALUE self, VALUE vidx) {
+  struct BitVector *bits;
+  struct BitVector *slis;
+  VALUE obj;
+  VALUE vfirst, vend;
+  int64_t first = 0, end = 0;
+  int64_t ix, ox;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  /* Validate the range and extract start and end */
+
+  if (rb_class_of(vidx)==rb_cRange) {
+    vfirst = rb_funcall(vidx, id_first, 0);
+    vend   = rb_funcall(vidx, id_end, 0);
+    Check_Type(vfirst, T_FIXNUM);
+    Check_Type(vend, T_FIXNUM);
+    first = FIX2LONG(vfirst);
+    end   = FIX2LONG(vend);
+    if (rb_funcall(vidx, rb_intern("exclude_end?"), 0) == Qtrue) {
+      end--;
+    }
+    if (first>end || first<0 || end<0) {
+      rb_raise(rb_eRangeError, "not valid range");
+    }
+  } else {
+    rb_raise(rb_eTypeError, "not valid index");
+  }
+
+  obj = Data_Make_Struct(CLASS_OF(self), struct BitVector, NULL, bits_free, slis);
+  slis->bit_len = end - first + 1;
+  slis->qws_len = (slis->bit_len+63)/64;
+  slis->last_bit = slis->bit_len % 64;
+  slis->ptr = ALLOC_N(uint64_t, slis->qws_len);
+
+  /* Now copy the bits TBD use __asm */
+
+  for (ix = first, ox = 0; ix <= end; ix++,ox++) {
+    bs_set(slis, ox, bs_get(bits, ix));
+  }
+  return obj;
+}
+
+static VALUE bits_on(int argc, VALUE *argv, VALUE self) {
+  struct BitVector *bits;
+  int i;
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  for(i=0; i<argc; i++) {
+    bs_fill(argv[i], bits, 1);
+  }
+
+  return self;
+}
+
+static VALUE bits_off(int argc, VALUE *argv, VALUE self) {
+  struct BitVector *bits;
+  int i;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  for(i=0; i<argc; i++) {
+    bs_fill(argv[i], bits, 0);
+  }
+
+  return self;
+}
+
+static VALUE bits_or(VALUE self, VALUE other) {
+  VALUE obj;
+  struct BitVector *bits, *rbits, *xbits;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  obj = Data_Make_Struct(CLASS_OF(self), struct BitVector, NULL, bits_free, rbits);
+  *rbits = *bits;
+  rbits->ptr = ALLOC_N(uint64_t, rbits->qws_len);
+  memcpy(rbits->ptr, bits->ptr, rbits->qws_len*8);
+
+  Data_Get_Struct(other, struct BitVector, xbits);
+  bs_or(rbits, xbits);
+
+  return obj;
+}
+
+static VALUE bits_not(VALUE self) {
+  VALUE obj;
+  struct BitVector *bits, *rbits;
+
+  Data_Get_Struct(self,  struct BitVector, bits);
+
+  obj = Data_Make_Struct(CLASS_OF(self), struct BitVector, NULL, bits_free, rbits);
+  *rbits = *bits;
+  rbits->ptr = ALLOC_N(uint64_t, rbits->qws_len);
+  memcpy(rbits->ptr, bits->ptr, rbits->qws_len*8);
+
+  bs_not(rbits);
+
+  return obj;
+}
+
+static VALUE bits_and(VALUE self, VALUE other) {
+  VALUE r;
+  struct BitVector *rbits, *xbits, *ybits;
+
+  Data_Get_Struct(self,  struct BitVector, xbits);
+  Data_Get_Struct(other, struct BitVector, ybits);
+
+  r = Data_Make_Struct(CLASS_OF(self), struct BitVector, NULL, bits_free, rbits);
+
+  bs_and(rbits, xbits, ybits);
+
+  return r;
+}
+
+static VALUE bits_xor(VALUE self, VALUE other) {
+  VALUE obj;
+  struct BitVector *bits, *rbits, *xbits;
+
+  Data_Get_Struct(self,  struct BitVector, bits);
+
+  obj = Data_Make_Struct(CLASS_OF(self), struct BitVector, NULL, bits_free, rbits);
+  *rbits = *bits;
+  rbits->ptr = ALLOC_N(uint64_t, rbits->qws_len);
+  memcpy(rbits->ptr, bits->ptr, rbits->qws_len*8);
+
+  Data_Get_Struct(other, struct BitVector, xbits);
+  bs_xor(rbits, xbits);
+
+  return obj;
+}
+
+/* r = a and ~b */
+static VALUE bits_minus(VALUE self, VALUE other) {
+  VALUE r;
+  struct BitVector i;
+  struct BitVector *rbits, *xbits, *ybits, *ibits;
+
+  Data_Get_Struct(self,  struct BitVector, xbits);
+  Data_Get_Struct(other, struct BitVector, ybits);
+  r = Data_Make_Struct(CLASS_OF(self), struct BitVector, NULL, bits_free, rbits);
+
+  ibits = &i;
+  *ibits = *ybits;
+  ibits->ptr = ALLOC_N(uint64_t, ibits->qws_len);
+  memcpy(ibits->ptr, ybits->ptr, ibits->qws_len*8);
+
+  if (xbits->bit_len > ybits->bit_len) bs_resize(ibits, xbits->bit_len);
+  bs_not(ibits);
+  bs_and(rbits, xbits, ibits);
+
+  return r;
+}
+
+static VALUE bits_cmp(VALUE self, VALUE other) {
+  struct BitVector *sbits, *obits;
+  int64_t smax,omax,qws;
+  uint64_t *sptr,*optr, sqw, oqw;
+
+  Data_Get_Struct(self,  struct BitVector, sbits);
+  Data_Get_Struct(other, struct BitVector, obits);
+
+  smax = bs_max(sbits);
+  omax = bs_max(obits);
+  if (smax < omax) {
+    return INT2FIX(-1);
+  } else if (smax > omax) {
+    return INT2FIX(1);
+  }
+
+  if (smax < 0) {
+    return INT2FIX(0);
+  }
+
+  qws = (smax+63)/64;
+  sptr = sbits->ptr + qws - 1;
+  optr = obits->ptr + qws - 1;
+  while(qws--) {
+    sqw = *sptr--;
+    oqw = *optr--;
+    if (sqw < oqw) {
+      return INT2FIX(-1);
+    } else if (sqw > oqw) {
+      return INT2FIX(1);
+    }
+  }
+
+  return INT2FIX(0);
+}
+
+
+static VALUE bits_zero(VALUE self) {
+  struct BitVector *bits;
+  uint64_t *ptr;
+  int64_t i;
+
+  Data_Get_Struct(self,  struct BitVector, bits);
+
+  ptr = bits->ptr;
+  for(i=0 ; i<bits->qws_len; i++) {
+    if (*ptr++ != 0) {
+      return Qfalse;
+    }
+  }
+
+  return Qtrue;
+}
+
+static VALUE bits_nonzero(VALUE self) {
+  struct BitVector *bits;
+  uint64_t *ptr;
+  int64_t i;
+
+  Data_Get_Struct(self,  struct BitVector, bits);
+
+  ptr = bits->ptr;
+  for(i=0 ; i<bits->qws_len; i++) {
+    if (*ptr++ != 0) {
+      return Qtrue;
+    }
+  }
+
+  return Qfalse;
+}
+
+static VALUE bits_max(VALUE self) {
+  struct BitVector *bits;
+  int64_t index;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  index = bs_max(bits);
+
+  if (index >= 0) {
+    return LONG2FIX(index);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE bits_min(VALUE self) {
+  struct BitVector *bits;
+  int64_t index;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  index = bs_min(bits);
+
+  if (index >= 0) {
+    return LONG2FIX(index);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE bits_norm(VALUE self) {
+  VALUE obj;
+  struct BitVector *bits;
+  int64_t index;
+
+  obj = bits_dup(self);
+  Data_Get_Struct(obj, struct BitVector, bits);
+
+  index = bs_max(bits);
+  if (index < 0) {
+    index = 1;
+  } else {
+    index = index + 1;
+  }
+  bs_resize(bits, index);
+
+  return obj;
+}
+
+static VALUE bits_normx(VALUE self) {
+  struct BitVector *bits;
+  int64_t index;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  index = bs_max(bits);
+
+  if (index < 0) {
+    index = 1;
+  } else {
+    index = index + 1;
+  }
+  bs_resize(bits, index);
+
+  return self;
+}
+
+static VALUE bits_to_ary(VALUE self) {
+  VALUE ary;
+  struct BitVector *bits;
+  int64_t from, to, index;
+
+  Data_Get_Struct(self,  struct BitVector, bits);
+
+  ary = rb_ary_new();
+
+  for (index = 0; index != -1;) {
+      index = bs_index(bits, 1, index);
+      if (index < 0) break;
+      from = index;
+      to = from;
+      do {
+          index = bs_index(bits, 1, index+1);
+          if (index == -1) break;
+          if (index == to + 1) to = index;
+      } while (index == to);
+
+      if (from==to) {
+        rb_ary_push(ary, LONG2FIX(from));
+      } else {
+        rb_ary_push(ary, rb_funcall(rb_cRange, id_new, 2, LONG2FIX(from), LONG2FIX(to)));
+      }
+  }
+  return ary;
+}
+
+static VALUE bits_to_bytes(VALUE self) {
+  struct BitVector *bits;
+  VALUE rs;
+
+  Data_Get_Struct(self, struct BitVector, bits);
+
+  int64_t len = bs_bytesize(bits);
+
+  rs = rb_str_new(0, len);
+
+  memcpy(RSTRING_PTR(rs), bits->ptr, len);
+
+  return rs;
+}
+
+static VALUE bits_each(VALUE self) {
+  struct BitVector *bits;
+  int64_t idx;
+
+  Data_Get_Struct(self,  struct BitVector, bits);
+
+  for(idx=0; idx < bits->bit_len; idx++) {
+    if (bs_get(bits, idx)) {
+      rb_yield(LONG2FIX(idx));
+    }
+  }
+
+  return self;
+}
+
+static VALUE bits_count(VALUE self) {
+  struct BitVector *bits;
+  uint64_t *ptr, qw;
+  int64_t count;
+  int64_t i;
+
+  Data_Get_Struct(self,  struct BitVector, bits);
+
+  count = 0;
+  ptr = bits->ptr;
+  for(i = 0 ; i < bits->qws_len; i++) {
+    qw = *ptr++;
+    __asm ( "mov %1, %%r8 \n"
+          "bs_count: \n"
+          "bsf %%r8, %%r11 \n"
+          "jz bs_count_exit \n"
+          "inc %0 \n"
+          "btr %%r11, %%r8 \n"
+          "jmp bs_count \n"
+          "bs_count_exit: \n"
+        : "=&r"(count) : "r"(qw) : "%r8", "cc", "memory"
+    );
+  }
+
+  return LONG2FIX(count);
+}
+
+void Init_bit_vector() {
+  cBitVector =  rb_define_class("BitVector", rb_cObject);
+  rb_include_module(cBitVector, rb_mComparable);
+
+  rb_define_singleton_method(cBitVector, "new", bits_s_new, -1 );
+  rb_define_singleton_method(cBitVector, "from_bytes", bits_s_from_bytes, 1 );
+
+  rb_define_method(cBitVector, "size",       bits_length,    0);
+  rb_define_method(cBitVector, "size=",      bits_resize,    1);
+  rb_define_method(cBitVector, "length",     bits_length,    0);
+  rb_define_method(cBitVector, "bytesize",   bits_bytesize,  0);
+  rb_define_method(cBitVector, "to_s",       bits_to_s,      0);
+  rb_define_method(cBitVector, "dup",        bits_dup,       0);
+  rb_define_method(cBitVector, "clone",      bits_dup,       0);
+  rb_define_method(cBitVector, "slice",      bits_slice,     1);
+  rb_define_method(cBitVector, "index",      bits_index,     2);
+  rb_define_method(cBitVector, "clear",      bits_clear,     0);
+  rb_define_method(cBitVector, "get",        bits_get,       1);
+  rb_define_method(cBitVector, "[]",         bits_get,       1);
+  rb_define_method(cBitVector, "set",        bits_set,       2);
+  rb_define_method(cBitVector, "[]=",        bits_set,       2);
+  rb_define_method(cBitVector, "on",         bits_on,       -1);
+  rb_define_method(cBitVector, "off",        bits_off,      -1);
+
+  rb_define_method(cBitVector, "|",          bits_or,        1);
+  rb_define_method(cBitVector, "~",          bits_not,       0);
+  rb_define_method(cBitVector, "&",          bits_and,       1);
+  rb_define_method(cBitVector, "^",          bits_xor,       1);
+  rb_define_method(cBitVector, "+",          bits_or,        1);
+  rb_define_method(cBitVector, "-",          bits_minus,     1);
+  rb_define_method(cBitVector, "*",          bits_and,       1);
+  rb_define_method(cBitVector, "<=>",        bits_cmp,       1);
+
+  rb_define_method(cBitVector, "zero?",      bits_zero,      0);
+  rb_define_method(cBitVector, "nonzero?",   bits_nonzero,   0);
+  rb_define_method(cBitVector, "max",        bits_max,       0);
+  rb_define_method(cBitVector, "min",        bits_min,       0);
+  rb_define_method(cBitVector, "normalize",  bits_norm,      0);
+  rb_define_method(cBitVector, "normalize!", bits_normx,     0);
+
+  rb_define_method(cBitVector, "to_ary",     bits_to_ary,    0);
+  rb_define_method(cBitVector, "to_bytes",   bits_to_bytes,  0);
+  rb_define_method(cBitVector, "count",      bits_count,     0);
+
+  rb_define_method(cBitVector, "each",       bits_each,      0);
+  /* rb_include_module(cBitVector, rb_mEnumerable); */
+
+  id_new   = rb_intern("new");
+  id_first = rb_intern("first");
+  id_end   = rb_intern("end");
+}