figure_set 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2012-11-26
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/figure_set.rb
+ext/extconf.rb
+ext/figure_set.h
+ext/methods.c
+ext/init.c
+ext/index.c
+ext/and.c
+ext/or.c
+ext/array.c
+ext/sample.c

data/README.rdoc

@@ -0,0 +1,61 @@
+= FigureSet
+
+= Description
+ FigureSet is the library which treats set operation.
+ FigureSet is able to treat the set of 32bit integer.(0 .. 2 ** 32 -1)
+
+= How to
+
+== Initialize
+=== an empty set.
+  empty_set = FigureSet.new
+
+=== give array.
+  set = FigureSet.new([0,3,6,7])
+
+== Element operation
+=== add to set.
+  set = FigureSet.new
+  set.add 10
+  set << 100
+  set.to_a #=> [10, 100]
+
+=== remove from set.
+  set = FigureSet.new([1,4,5])
+  set.delete(4)
+  set.to_a #=> [1, 5]
+
+== Set operation
+=== and
+  set1 = FigureSet.new([1,2,3,5])
+  set2 = FigureSet.new([2,4,6])
+  set_and = set1 & set2
+  set_and.to_a #=> [2]
+
+=== or
+  set1 = FigureSet.new([1,2,3,5])
+  set2 = FigureSet.new([2,4,6])
+  set_or = set1 | set2
+  set_or.to_a #=> [1,2,3,4,5,6]
+
+== Other
+=== size
+  set = FigureSet.new([1,2,3])
+  set.size #=> 3
+
+=== empty?
+  set = FigureSet.new
+  set.empty? #=> true
+ 
+=== clear
+  set = FigureSet.new([1,2,3])
+  set.clear
+  set.to_a #=> []
+
+= INSTALL:
+
+sudo gem install figure_set
+
+= LICENSE:
+
+  FigureSet is released under the MIT license.

data/Rakefile

@@ -0,0 +1,28 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/figure_set'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('figure_set', FigureSet.version) do |p|
+  p.developer('Tsukasa OISHI', 'tsukasa.oishi@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name # TODO this is default value
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+
+  pec_extras = {
+    :extensions => ['ext/extconf.rb'],
+  }
+
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/ext/and.c

@@ -0,0 +1,118 @@
+//************************************
+//  and.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+//
+// intersection
+//
+void intersection(root_node result_set, root_node set0, root_node set1)
+{
+    unsigned int i, count;
+    root_node base, other;
+    branch_node branch;
+
+    if (set0->size == 0 || set1->size == 0) {
+        return;
+    } else if (set0->size > set1->size) {
+        base = set1;
+        other = set0;
+    } else {
+        base = set0;
+        other = set1;
+    }
+
+    for (i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE || count < base->children_size; i++) {
+        if (base->index[i]) {
+            count++;
+            if (other->index[i]) {
+                branch = (branch_node)init_and_intersection_branch_node(result_set, (branch_node)base->index[i], (branch_node)other->index[i]);
+                if (branch) {
+                    result_set->index[i] = (void*)branch;
+                    result_set->children_size++;
+                }
+            }
+        }
+    }
+}
+
+void *init_and_intersection_branch_node(root_node result_set, branch_node base, branch_node other)
+{
+    branch_node branch;
+
+    branch = (branch_node)init_branch_node();
+
+    if (base->children_type == CT_LEAF) {
+        last_intersection_branch_node(result_set, branch, base, other);
+    } else {
+        middel_intersection_branch_node(result_set, branch, base, other);
+    }
+
+    if (branch->children_size) {
+        branch->children_type = base->children_type;
+        return (void*)branch;
+    } else {
+        destroy_branch(branch);
+        return (void*)NULL;
+    }
+}
+
+void middel_intersection_branch_node(root_node result_set, branch_node branch, branch_node base, branch_node other)
+{
+    unsigned int i, count;
+    branch_node middle_branch;
+
+    for (i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < base->children_size; i++) {
+        if (base->index[i]) {
+            count++;
+            if (other->index[i]) {
+                middle_branch = (branch_node)init_and_intersection_branch_node(result_set, (branch_node)base->index[i], (branch_node)other->index[i]);
+                if (middle_branch) {
+                    branch->index[i] = (void*)middle_branch;
+                    branch->children_size++;
+                }
+            }
+        }
+    }
+}
+
+void last_intersection_branch_node(root_node result_set, branch_node branch, branch_node base, branch_node other)
+{
+    unsigned int i, count;
+    leaf_node leaf;
+
+    for (i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < base->children_size; i++) {
+        if (base->index[i]) {
+            count++;
+            if (other->index[i]) {
+                leaf = (leaf_node)init_and_intersection_leaf_node(result_set, (leaf_node)base->index[i], (leaf_node)other->index[i]);
+                if (leaf) {
+                    branch->index[i] = (void*)leaf;
+                    branch->children_size++;
+                }
+            }
+        }
+    }
+}
+
+
+void *init_and_intersection_leaf_node(root_node result_set, leaf_node base, leaf_node other)
+{
+    unsigned long data;
+    leaf_node leaf;
+    
+    data = base->data & other->data;
+
+    if (!data) return (void*)NULL;
+
+    leaf = (leaf_node)init_leaf_node(base->offset);
+    leaf->data = data;
+    result_set->size += BIT_COUNT(leaf->data);
+
+    return (void*)leaf;
+}

data/ext/array.c

@@ -0,0 +1,98 @@
+//************************************
+//  array.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+//
+// output Array object from internal set
+//
+void to_array(root_node root, VALUE array)
+{
+    unsigned int i, count;
+
+    for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE || count < root->children_size; i++) {
+        if (root->index[i]) {
+            search_and_get_array((branch_node)root->index[i], array);
+            count++;
+        }
+    }
+}
+
+void search_and_get_array(branch_node branch, VALUE array)
+{
+    unsigned int i, count;
+
+    if (branch->children_type == CT_LEAF) {
+        for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < branch->children_size; i++) {
+            if (branch->index[i]) {
+                search_and_get_array_at_leaf((leaf_node)branch->index[i], array);
+                count++;
+            }
+        }
+    } else {
+        for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < branch->children_size; i++) {
+            if (branch->index[i]) {
+                search_and_get_array((branch_node)branch->index[i], array);
+                count++;
+            }
+        }
+    }
+}
+
+void search_and_get_array_at_leaf(leaf_node leaf, VALUE array)
+{
+    unsigned long i = 0;
+    unsigned long x;
+
+    x = leaf->data;
+
+    while(x) {
+        i = BIT_COUNT((x & (-x))-1);
+        rb_ary_push(array, ULONG2NUM(leaf->offset + i));
+        x = x ^ (1UL << i);
+    }
+
+
+    /*
+    while(x) {
+        if (x & 1UL) {
+            rb_ary_push(array, ULONG2NUM(leaf->offset + i));
+        }
+        x = x >> 1UL;
+        i++;
+    }
+    */
+}
+
+
+//
+// bit count
+//
+
+// 32 bit
+unsigned long bit32_count(unsigned long x)
+{
+    x = x - ((x >> 1UL) & 0x55555555UL);
+    x = (x & 0x33333333UL) + ((x >> 2UL) & 0x33333333UL);
+    x = (x + (x >> 4UL)) & 0x0f0f0f0fUL;
+    x = x + (x >> 8UL);
+    x = x + (x >> 16UL);
+    return x & 0x0000003FUL;
+}
+
+// 64 bit
+unsigned long bit64_count(unsigned long x)
+{
+    x = x - ((x >> 1UL) & 0x5555555555555555UL);
+    x = (x & 0x3333333333333333UL) + ((x >> 2UL) & 0x3333333333333333UL);
+    x = (x & 0x0f0f0f0f0f0f0f0fUL) + ((x >> 4UL) & 0x0f0f0f0f0f0f0f0fUL);
+    x = (x + (x >> 8UL)) & 0x00ff00ff00ff00ffUL;
+    x = x + (x >> 16UL);
+    x = x + (x >> 32UL);
+    return x & 0x000000000000007FUL;
+}

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require "mkmf"
+create_makefile("figure_set")

data/ext/figure_set.h

@@ -0,0 +1,145 @@
+//************************************
+//  figure_set.h
+//
+//  Tsukasa OISHI
+//  http://www.kaeruspoon.net
+//************************************
+
+#include <math.h>
+
+#ifndef RUBY_19
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(v) (RARRAY(v)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(v) (RARRAY(v)->ptr)
+#endif
+#endif
+
+// max children size of branch
+#define MAX_CHILDREN_SIZE_OF_BRANCH (unsigned long)16
+#define LAST_BRANCH_LEVEL (unsigned long)6
+
+#if ULLONG_MAX == 0xffffffffffffffff
+#define ULONG_BIT_COUNT (unsigned long)64
+#define MAX_CHILDREN_SIZE_OF_ROOT_NODE (unsigned long)4
+#define BIT_COUNT(x) bit64_count(x)
+static unsigned long OFFSET_SCALE[] = {0x40000000, 0x4000000, 0x400000, 0x40000, 0x4000, 0x400, 0x40};
+#else
+#define ULONG_BIT_COUNT (unsigned long)32
+#define MAX_CHILDREN_SIZE_OF_ROOT_NODE (unsigned long)8
+#define BIT_COUNT(x) bit32_count(x)
+static unsigned long OFFSET_SCALE[] = {0x20000000, 0x2000000, 0x200000, 0x20000, 0x2000, 0x200, 0x20};
+#endif
+
+// branch node children type
+#define CT_BRANCH 0
+#define CT_LEAF 1
+
+// valid valie range
+#define VALID_MIN_VALUE UINT2NUM(0)
+#define VALID_MAX_VALUE UINT2NUM(0xffffffff)
+
+// FigureSet class object
+static VALUE rb_cFigureSet;
+
+// leaf node
+// example:
+//   data = 5  # (bit is 0...0101) exist bit numbers is (2, 0) 
+//   offset = 640
+// 
+// set is
+//  [offset + 2, offset + 0]
+//   = [642, 640]
+//  
+typedef struct _leaf_node {
+    unsigned long offset;   // offset number
+    unsigned long data;  // each bit is exist flag(1:exist 0:none) of member
+} *leaf_node;
+
+// branch node
+typedef struct _branch_node {
+    unsigned char children_type; // children type
+    unsigned char children_size;
+    void *index[MAX_CHILDREN_SIZE_OF_BRANCH];  // children pointer
+} *branch_node;
+
+typedef struct _root_node {
+    unsigned char children_size;     
+    unsigned long size;              // number of elements in set
+    void *index[MAX_CHILDREN_SIZE_OF_ROOT_NODE];    // children pointer
+} *root_node;
+
+// initialize
+void init_root_node(root_node);
+void *init_branch_node();
+void *init_leaf_node(unsigned long);
+
+// init_copy
+void copy_root_node(root_node, root_node);
+void copy_branch_node(root_node, branch_node, branch_node);
+void *init_and_copy_brance_node(root_node, branch_node);
+void *init_and_copy_leaf_node(root_node, leaf_node);
+
+// insert element into set
+void add_num(root_node, unsigned long);
+unsigned int search_and_insert(branch_node, unsigned long, unsigned long, unsigned long);
+unsigned int search_and_insert_at_leaf(leaf_node, unsigned long);
+
+// remove element from set
+void delete_num(root_node, unsigned long);
+unsigned int search_and_remove(branch_node, unsigned long, unsigned long, unsigned long);
+unsigned int search_and_remove_at_leaf(leaf_node, unsigned long);
+
+// output Array object from internal set
+void to_array(root_node, VALUE);
+void search_and_get_array(branch_node, VALUE);
+void search_and_get_array_at_leaf(leaf_node, VALUE);
+
+// join
+void join(root_node, root_node, root_node);
+void middle_join_branch_node(root_node, branch_node, branch_node, branch_node);
+void last_join_branch_node(root_node, branch_node, branch_node, branch_node);
+void *init_and_join_brance_node(root_node, branch_node, branch_node);
+void *init_and_join_leaf_node(root_node, leaf_node, leaf_node);
+
+// intersection
+void intersection(root_node, root_node, root_node);
+void middel_intersection_branch_node(root_node, branch_node, branch_node, branch_node);
+void last_intersection_branch_node(root_node, branch_node, branch_node, branch_node);
+void *init_and_intersection_leaf_node(root_node, leaf_node, leaf_node);
+void *init_and_intersection_branch_node(root_node, branch_node, branch_node);
+unsigned long bit32_count(unsigned long);
+unsigned long bit64_count(unsigned long);
+
+// sample
+void sample(root_node, VALUE, unsigned long);
+void search_and_sample_array(branch_node, VALUE);
+void search_and_sample_array_at_leaf(leaf_node, VALUE);
+
+// memory free
+void destroy_all(root_node);
+void destroy_all_branches(root_node);
+void destroy_branch(branch_node);
+
+//-----------------------------------------------------------
+// Ruby Methods
+// ----------------------------------------------------------
+
+static VALUE t_allocate(VALUE);
+static VALUE t_initialize(int, VALUE *, VALUE);
+static VALUE t_initialize_copy(VALUE, VALUE);
+static VALUE t_add(VALUE, VALUE);
+static VALUE t_delete(VALUE, VALUE);
+static VALUE t_intersection(VALUE, VALUE);
+static VALUE t_union(VALUE, VALUE);
+static VALUE t_to_a(VALUE);
+static VALUE t_sample(int, VALUE *, VALUE);
+static VALUE t_size(VALUE);
+static VALUE t_empty(VALUE);
+static VALUE t_clear(VALUE);
+void Init_figure_set(void);
+

data/ext/index.c

@@ -0,0 +1,118 @@
+//************************************
+//  index.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+//
+// insert element into set
+//
+void add_num(root_node root, unsigned long value)
+{
+    unsigned long quotient, remainder;
+
+    quotient = value / OFFSET_SCALE[0];
+    remainder = value % OFFSET_SCALE[0];
+
+    if(!(root->index[quotient])) {
+        root->index[quotient] = init_branch_node();
+        root->children_size++;
+    }
+
+    if (search_and_insert((branch_node)root->index[quotient], 1, remainder, value)) {
+        root->size++;
+    }
+}
+
+unsigned int search_and_insert(branch_node branch, unsigned long level, unsigned long value, unsigned long original)
+{
+    unsigned long quotient, remainder;
+
+    quotient = value / OFFSET_SCALE[level];
+    remainder = value % OFFSET_SCALE[level];
+
+    if(!(branch->index[quotient])) {
+        if(branch->children_type == CT_LEAF) {
+            branch->index[quotient] = init_leaf_node((unsigned long)(original / ULONG_BIT_COUNT) * ULONG_BIT_COUNT);
+        } else {
+            branch->index[quotient] = init_branch_node();
+            if ((level + 1) == LAST_BRANCH_LEVEL) {
+                ((branch_node)(branch->index[quotient]))->children_type = CT_LEAF;
+            }
+        }
+        branch->children_size++;
+    }
+
+    if (branch->children_type == CT_LEAF) {
+        return search_and_insert_at_leaf((leaf_node)branch->index[quotient], remainder);
+    } else {
+        return search_and_insert((branch_node)branch->index[quotient], level + 1, remainder, original);
+    }
+}
+
+unsigned int search_and_insert_at_leaf(leaf_node leaf, unsigned long value)
+{
+    unsigned int exist_flag = 0;
+    unsigned long target_bit;
+
+    target_bit = 1UL << value; 
+
+    if (!(leaf->data & target_bit)) {
+        leaf->data |= target_bit;
+        exist_flag = 1;
+    }
+
+    return exist_flag;
+}
+
+//
+// remove element from set
+//
+void delete_num(root_node root, unsigned long value)
+{
+    unsigned long quotient, remainder;
+
+    quotient = value / OFFSET_SCALE[0];
+    remainder = value % OFFSET_SCALE[0];
+
+    if (!(root->index[quotient])) return;
+
+    if (search_and_remove((branch_node)root->index[quotient], 1, remainder, value)) {
+        root->size--;
+    }
+}
+
+unsigned int search_and_remove(branch_node branch, unsigned long level, unsigned long value, unsigned long original)
+{
+    unsigned long quotient, remainder;
+
+    quotient = value / OFFSET_SCALE[level];
+    remainder = value % OFFSET_SCALE[level];
+
+    if (!(branch->index[quotient])) return 0;
+
+    if (branch->children_type == CT_LEAF) {
+        return search_and_remove_at_leaf((leaf_node)branch->index[quotient], remainder);
+    } else {
+        return search_and_remove((branch_node)branch->index[quotient], level + 1, remainder, original);
+    }
+}
+
+unsigned int search_and_remove_at_leaf(leaf_node leaf, unsigned long value)
+{
+    unsigned int exist_flag = 0;
+    unsigned long target_bit;
+
+    target_bit = 1UL << value; 
+
+    if ((leaf->data & target_bit)) {
+        leaf->data ^= target_bit;
+        exist_flag = 1;
+    }
+
+    return exist_flag;
+}

data/ext/init.c

@@ -0,0 +1,167 @@
+//************************************
+//  init.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+//
+// initialize
+//
+void init_root_node(root_node root)
+{
+    unsigned int i;
+
+    for(i = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE; i++) {
+        root->index[i] = (void*)NULL;
+    }
+    root->size = 0;
+    root->children_size = 0;
+}
+
+void *init_branch_node()
+{
+    unsigned int i;
+    branch_node branch;
+
+    if (!(branch = (branch_node)malloc(sizeof(struct _branch_node)))) {
+        rb_raise(rb_eStandardError, "memory is not enough");
+    }
+
+    for(i = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH; i++) {
+        branch->index[i] = (void*)NULL;
+    }
+
+    branch->children_size = 0;
+    branch->children_type = CT_BRANCH;
+
+    return (void*)branch;
+}
+
+void *init_leaf_node(unsigned long offset)
+{
+    leaf_node leaf;
+
+    if(!(leaf = (leaf_node)malloc(sizeof(struct _leaf_node)))) {
+        rb_raise(rb_eStandardError, "memory is not enough");
+    }
+
+    leaf->offset = offset;
+    leaf->data = 0;
+
+    return (void*)leaf;
+}
+
+//
+// initialize copy
+//
+void copy_root_node(root_node root, root_node orig)
+{
+    unsigned int i, count;
+
+    root->children_size = orig->children_size;
+
+    for (i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE || count < orig->children_size; i++) {
+        if (orig->index[i]) {
+            root->index[i] = init_and_copy_brance_node(root, (branch_node)orig->index[i]);
+            count++;
+        }
+    }
+}
+
+void copy_branch_node(root_node root, branch_node branch, branch_node orig)
+{
+    unsigned int i, count;
+
+    branch->children_type = orig->children_type;
+    branch->children_size = orig->children_size;
+
+    if (orig->children_type == CT_LEAF) {
+        for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < orig->children_size; i++) {
+            if (orig->index[i]) {
+                branch->index[i] = init_and_copy_leaf_node(root, (leaf_node)orig->index[i]);
+                count++;
+            }
+        }
+    } else {
+        for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < orig->children_size; i++) {
+            if (orig->index[i]) {
+                branch->index[i] = init_and_copy_brance_node(root, (branch_node)orig->index[i]);
+                count++;
+            }
+        }
+    }
+}
+
+void *init_and_copy_brance_node(root_node root, branch_node orig)
+{
+    branch_node branch;
+
+    branch = (branch_node)init_branch_node();
+    copy_branch_node(root, branch, orig);
+
+    return (void*)branch;
+}
+
+void *init_and_copy_leaf_node(root_node root, leaf_node orig)
+{
+    leaf_node leaf;
+
+    leaf = (leaf_node)init_leaf_node(orig->offset);
+    leaf->data = orig->data;
+    root->size += BIT_COUNT(leaf->data);
+
+    return (void*)leaf;
+}
+
+//
+// memory free
+//
+void destroy_all(root_node root)
+{
+    destroy_all_branches(root);
+    free(root);
+}
+
+void destroy_all_branches(root_node root)
+{
+    unsigned int i, count;
+    
+    for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE || count < root->children_size; i++) {
+        if (root->index[i]) {
+            destroy_branch((branch_node)root->index[i]);
+            root->index[i] = (void*)NULL;
+            count++;
+        }
+    }
+
+    root->size = 0;
+    root->children_size = 0;
+}
+
+void destroy_branch(branch_node branch)
+{
+    unsigned int i, count;
+
+    if (branch->children_type == CT_LEAF) {
+        for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < branch->children_size; i++) {
+            if (branch->index[i]) {
+                free((leaf_node)branch->index[i]);
+                branch->index[i] = (void*)NULL;
+                count++;
+            }
+        }
+    } else {
+        for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < branch->children_size; i++) {
+            if (branch->index[i]) {
+                destroy_branch((branch_node)branch->index[i]);
+                branch->index[i] = (void*)NULL;
+                count++;
+            }
+        }
+    }
+    free(branch);
+}

data/ext/methods.c

@@ -0,0 +1,245 @@
+//************************************
+// method.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+//-----------------------------------------------------------
+// Ruby Methods
+// ----------------------------------------------------------
+
+/**
+ * allocate
+**/
+static VALUE t_allocate(VALUE klass)
+{
+    VALUE obj;
+    root_node root;
+
+    obj = Data_Make_Struct(klass, struct _root_node, NULL, destroy_all, root);
+    init_root_node(root);
+
+    return obj;
+}
+
+/**
+ * initialize
+**/
+static VALUE t_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE num, ary_element;
+    root_node root;
+    unsigned long i, len;
+
+    Data_Get_Struct(self, struct _root_node, root);
+
+    if (argc == 1 && TYPE(argv[0]) == T_ARRAY) {
+        len = RARRAY_LEN(argv[0]);
+        for(i = 0; i < len; i++) {
+            ary_element = rb_ary_entry(argv[0], i);
+            if ((TYPE(ary_element) == T_FIXNUM) && VALID_MIN_VALUE <= ary_element && VALID_MAX_VALUE >= ary_element) {
+                add_num(root, NUM2ULONG(ary_element));
+            }
+        }
+    }
+
+    return self;
+}
+
+/**
+ * initialize_copy
+**/
+static VALUE t_initialize_copy(VALUE self, VALUE orig)
+{
+    root_node root, orig_set;
+
+    Data_Get_Struct(self, struct _root_node, root);
+    Data_Get_Struct(orig, struct _root_node, orig_set);
+    copy_root_node(root, orig_set);
+
+    return self;
+}
+
+/**
+ * add
+**/
+static VALUE t_add(VALUE self, VALUE value)
+{
+    root_node root;
+
+    if (TYPE(value) != T_FIXNUM) return;
+    if (VALID_MIN_VALUE > value || VALID_MAX_VALUE < value) return;
+
+    Data_Get_Struct(self, struct _root_node, root);
+    add_num(root, NUM2ULONG(value));
+
+    return self;
+}
+
+/**
+ * delete
+ **/
+static VALUE t_delete(VALUE self, VALUE value)
+{
+    root_node root;
+
+    if (TYPE(value) != T_FIXNUM) return;
+    if (VALID_MIN_VALUE > value || VALID_MAX_VALUE < value) return;
+
+    Data_Get_Struct(self, struct _root_node, root);
+    delete_num(root, NUM2ULONG(value));
+
+    return self;
+}
+
+/**
+ * intersection
+**/
+static VALUE t_intersection(VALUE self, VALUE other)
+{
+    VALUE obj;
+    root_node result_set, set0, set1;
+
+    obj = Data_Make_Struct(rb_cFigureSet, struct _root_node, NULL, destroy_all, result_set);
+    init_root_node(result_set);
+
+    Data_Get_Struct(self, struct _root_node, set0);
+    Data_Get_Struct(other, struct _root_node, set1);
+
+    intersection(result_set, set0, set1);
+
+    return obj;
+}
+
+/**
+ * union
+**/
+static VALUE t_union(VALUE self, VALUE other)
+{
+    VALUE obj;
+    root_node result_set, set0, set1;
+
+    obj = Data_Make_Struct(rb_cFigureSet, struct _root_node, NULL, destroy_all, result_set);
+    init_root_node(result_set);
+
+    Data_Get_Struct(self, struct _root_node, set0);
+    Data_Get_Struct(other, struct _root_node, set1);
+
+    join(result_set, set0, set1);
+
+    return obj;
+}
+
+/**
+ * to_a
+**/ 
+static VALUE t_to_a(VALUE self)
+{
+    root_node root;
+    VALUE array;
+
+    Data_Get_Struct(self, struct _root_node, root);
+    array = rb_ary_new2(root->size);
+
+    to_array(root, array);
+
+    return array;
+}
+
+/**
+ * sample
+**/ 
+static VALUE t_sample(int argc, VALUE *argv, VALUE self)
+{
+    root_node root;
+    VALUE array;
+    unsigned long sample_count = 1UL;
+
+    Data_Get_Struct(self, struct _root_node, root);
+
+    if (argc == 1 && TYPE(argv[0]) == T_FIXNUM) {
+        sample_count = NUM2ULONG(argv[0]);
+        if (sample_count < 1UL || sample_count > root->size) sample_count = 1UL;
+    }
+
+    array = rb_ary_new2(sample_count);
+    if (sample_count == root->size) {
+        to_array(root, array);
+    } else {
+        sample(root, array, sample_count);
+    }
+
+    return array;
+}
+
+/**
+ * size
+**/
+static VALUE t_size(VALUE self)
+{
+    root_node root;
+
+    Data_Get_Struct(self, struct _root_node, root);
+
+    return ULONG2NUM(root->size);
+}
+
+/**
+ * empty?
+**/
+static VALUE t_empty(VALUE self)
+{
+    root_node root;
+
+    Data_Get_Struct(self, struct _root_node, root);
+
+    if (root->size == 0) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * cler
+**/
+static VALUE t_clear(VALUE self)
+{
+    root_node root;
+
+    Data_Get_Struct(self, struct _root_node, root);
+
+    if (root->size) {
+        destroy_all_branches(root);
+    }
+
+    return self;
+}
+
+
+/**
+ * define class
+**/
+void Init_figure_set(void) {
+    rb_cFigureSet = rb_define_class("FigureSet", rb_cObject);
+    rb_define_alloc_func(rb_cFigureSet, t_allocate);
+    rb_define_private_method(rb_cFigureSet, "initialize", t_initialize, -1);
+    rb_define_method(rb_cFigureSet, "initialize_copy", t_initialize_copy, 1);
+    rb_define_method(rb_cFigureSet, "add", t_add, 1);
+    rb_define_method(rb_cFigureSet, "delete", t_delete, 1);
+    rb_define_method(rb_cFigureSet, "intersection", t_intersection, 1);
+    rb_define_method(rb_cFigureSet, "union", t_union, 1);
+    rb_define_method(rb_cFigureSet, "to_a", t_to_a, 0);
+    rb_define_method(rb_cFigureSet, "sample", t_sample, -1);
+    rb_define_method(rb_cFigureSet, "size", t_size, 0);
+    rb_define_method(rb_cFigureSet, "empty?", t_empty, 0);
+    rb_define_method(rb_cFigureSet, "clear", t_clear, 0);
+    rb_define_alias(rb_cFigureSet, "<<", "add");
+    rb_define_alias(rb_cFigureSet, "&", "intersection");
+    rb_define_alias(rb_cFigureSet, "|", "union");
+    rb_define_alias(rb_cFigureSet, "length", "size");
+}

data/ext/or.c

@@ -0,0 +1,105 @@
+//************************************
+//  or.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+//
+// join
+//
+void join(root_node result_set, root_node set0, root_node set1)
+{
+    unsigned int i;
+
+    if (set0->size == 0 && set1->size == 0) {
+        return;
+    } else if (set0->size == 0) {
+        copy_root_node(result_set, set1);
+        return;
+    } else if (set1->size == 0) {
+        copy_root_node(result_set, set0);
+        return;
+    }
+
+    for (i = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE; i++) {
+        if (set0->index[i] && set1->index[i]) {
+            result_set->index[i] = init_and_join_brance_node(result_set, (branch_node)set0->index[i], (branch_node)set1->index[i]);
+            result_set->children_size++;
+        } else if(set0->index[i]) {
+            result_set->index[i] = init_and_copy_brance_node(result_set, (branch_node)set0->index[i]);
+            result_set->children_size++;
+        } else if (set1->index[i]) {
+            result_set->index[i] = init_and_copy_brance_node(result_set, (branch_node)set1->index[i]);
+            result_set->children_size++;
+        }
+    }
+}
+
+
+void *init_and_join_brance_node(root_node result_set, branch_node set0, branch_node set1)
+{
+    branch_node branch;
+
+    branch = (branch_node)init_branch_node();
+
+    if (set0->children_type == CT_LEAF) {
+        branch->children_type = CT_LEAF;
+        last_join_branch_node(result_set, branch, set0, set1);
+    } else {
+        middle_join_branch_node(result_set, branch, set0, set1);
+    }
+
+    return (void*)branch;
+}
+
+void middle_join_branch_node(root_node result_set, branch_node branch, branch_node set0, branch_node set1)
+{
+    unsigned int i;
+
+    for (i = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH; i++) {
+        if (set0->index[i] && set1->index[i]) {
+            branch->index[i] = init_and_join_brance_node(result_set, (branch_node)set0->index[i], (branch_node)set1->index[i]);
+            branch->children_size++;
+        } else if (set0->index[i]) {
+            branch->index[i] = init_and_copy_brance_node(result_set, (branch_node)set0->index[i]);
+            branch->children_size++;
+        } else if (set1->index[i]) {
+            branch->index[i] = init_and_copy_brance_node(result_set, (branch_node)set1->index[i]);
+            branch->children_size++;
+        }
+    }
+}
+
+void last_join_branch_node(root_node result_set, branch_node branch, branch_node set0, branch_node set1)
+{
+    unsigned int i;
+
+    for (i = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH; i++) {
+        if (set0->index[i] && set1->index[i]) {
+            branch->index[i] = init_and_join_leaf_node(result_set, (leaf_node)set0->index[i], (leaf_node)set1->index[i]);
+            branch->children_size++;
+        } else if (set0->index[i]) {
+            branch->index[i] = init_and_copy_leaf_node(result_set, (leaf_node)set0->index[i]);
+            branch->children_size++;
+        } else if (set1->index[i]) {
+            branch->index[i] = init_and_copy_leaf_node(result_set, (leaf_node)set1->index[i]);
+            branch->children_size++;
+        }
+    }
+}
+
+void *init_and_join_leaf_node(root_node result_set, leaf_node set0, leaf_node set1)
+{
+    leaf_node leaf;
+
+    leaf = (leaf_node)init_leaf_node(set0->offset);
+
+    leaf->data = set0->data | set1->data;
+    result_set->size += BIT_COUNT(leaf->data);
+
+    return (void*)leaf;
+}

data/ext/sample.c

@@ -0,0 +1,89 @@
+//************************************
+//  sample.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+//
+// output Array object from sample set
+//
+void sample(root_node root, VALUE array, unsigned long sample_count)
+{
+    unsigned int start_sample, sample_now, i, count, target_point;
+
+    srand((unsigned) time(NULL));
+
+    start_sample = RARRAY_LEN(array);
+
+    for(sample_now = start_sample; sample_now < sample_count; sample_now++) {
+        target_point = rand() % root->children_size;
+        for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE || count < root->children_size; i++) {
+            if (root->index[i]) {
+                if (count == target_point) {
+                    search_and_sample_array((branch_node)root->index[i], array);
+                }
+                count++;
+            }
+        }
+    }
+
+    if (RARRAY_LEN(array) < sample_count) {
+        sample(root, array, sample_count);
+    }
+
+    rb_funcall(array, rb_intern("uniq!"), 0);
+    if (RARRAY_LEN(array) < sample_count) {
+        sample(root, array, sample_count);
+    }
+}
+
+void search_and_sample_array(branch_node branch, VALUE array)
+{
+    unsigned int i, count, target_point;
+
+    if (!branch->children_size) return;
+
+    target_point = rand() % branch->children_size;
+
+    for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < branch->children_size; i++) {
+        if (branch->index[i]) {
+            if (count == target_point) {
+                if (branch->children_type == CT_LEAF) {
+                    search_and_sample_array_at_leaf((leaf_node)branch->index[i], array);
+                } else {
+                    search_and_sample_array((branch_node)branch->index[i], array);
+                }
+            }
+            count++;
+        }
+    }
+}
+
+void search_and_sample_array_at_leaf(leaf_node leaf, VALUE array)
+{
+    unsigned long i = 0, hit_count = 0;
+    unsigned long bit_count, target_point;
+    unsigned long x;
+
+    x = leaf->data;
+    bit_count = BIT_COUNT(leaf->data);
+    if (!bit_count) return;
+
+    target_point = rand() % bit_count;
+
+    while(x) {
+        if (x & 1UL) {
+            if (hit_count == target_point) {
+                rb_ary_push(array, ULONG2NUM(leaf->offset + i));
+            }
+            hit_count++;
+        }
+        x = x >> 1UL;
+        i++;
+    }
+}

data/lib/figure_set.rb

@@ -0,0 +1,11 @@
+require 'figure_set.so'
+
+class FigureSet
+  VERSION = "0.0.1"
+
+  class << self
+    def version
+      VERSION
+    end
+  end 
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: figure_set
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tsukasa OISHI
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-26 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 1
+        - 2
+        - 3
+        version: 1.2.3
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 1
+        - 8
+        - 0
+        version: 1.8.0
+  type: :development
+  version_requirements: *id002
+description: FigureSet.
+email: 
+- tsukasa.oishi@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/figure_set.rb
+- ext/extconf.rb
+- ext/figure_set.h
+- ext/methods.c
+- ext/init.c
+- ext/index.c
+- ext/and.c
+- ext/or.c
+- ext/array.c
+- ext/sample.c
+has_rdoc: true
+homepage: http://www.kaeruspoon.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: figure_set
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 2
+summary: FigureSet.
+test_files: []
+