figure_set 1.0.0 → 1.1.0

data/ext/figure_set/figure_set/init.c

@@ -0,0 +1,177 @@
+//************************************
+//  init.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+static 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++;
+      }
+    }
+  }
+}
+
+//
+// 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;
+}
+
+branch_node
+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] = (branch_node)NULL;
+  }
+
+  branch->children_size = 0;
+  branch->children_type = CT_BRANCH;
+
+  return branch;
+}
+
+leaf_node
+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 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++;
+    }
+  }
+}
+
+branch_node
+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 branch;
+}
+
+leaf_node
+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 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/figure_set/{methods.c → figure_set/methods.c}

@@ -13,10 +13,13 @@
 // Ruby Methods
 // ----------------------------------------------------------
 
+static VALUE rb_cFigureSet;
+
 /**
  * allocate
 **/
-static VALUE t_allocate(VALUE klass)
+static VALUE
+t_allocate(VALUE klass)
 {
     VALUE obj;
     root_node root;
@@ -30,9 +33,10 @@ static VALUE t_allocate(VALUE klass)
 /**
  * initialize
 **/
-static VALUE t_initialize(int argc, VALUE *argv, VALUE self)
+static VALUE
+t_initialize(int argc, VALUE *argv, VALUE self)
 {
-    VALUE num, ary_element;
+    VALUE ary_element;
     root_node root;
     unsigned long i, len;
 
@@ -54,7 +58,8 @@ static VALUE t_initialize(int argc, VALUE *argv, VALUE self)
 /**
  * initialize_copy
 **/
-static VALUE t_initialize_copy(VALUE self, VALUE orig)
+static VALUE
+t_initialize_copy(VALUE self, VALUE orig)
 {
     root_node root, orig_set;
 
@@ -68,7 +73,8 @@ static VALUE t_initialize_copy(VALUE self, VALUE orig)
 /**
  * add
 **/
-static VALUE t_add(VALUE self, VALUE value)
+static VALUE
+t_add(VALUE self, VALUE value)
 {
     root_node root;
 
@@ -84,7 +90,8 @@ static VALUE t_add(VALUE self, VALUE value)
 /**
  * delete
  **/
-static VALUE t_delete(VALUE self, VALUE value)
+static VALUE
+t_delete(VALUE self, VALUE value)
 {
     root_node root;
 
@@ -100,7 +107,8 @@ static VALUE t_delete(VALUE self, VALUE value)
 /**
  * intersection
 **/
-static VALUE t_intersection(VALUE self, VALUE other)
+static VALUE
+t_intersection(VALUE self, VALUE other)
 {
     VALUE obj;
     root_node result_set, set0, set1;
@@ -119,7 +127,8 @@ static VALUE t_intersection(VALUE self, VALUE other)
 /**
  * union
 **/
-static VALUE t_union(VALUE self, VALUE other)
+static VALUE
+t_union(VALUE self, VALUE other)
 {
     VALUE obj;
     root_node result_set, set0, set1;
@@ -138,7 +147,8 @@ static VALUE t_union(VALUE self, VALUE other)
 /**
  * to_a
 **/ 
-static VALUE t_to_a(VALUE self)
+static VALUE
+t_to_a(VALUE self)
 {
     root_node root;
     VALUE array;
@@ -154,7 +164,8 @@ static VALUE t_to_a(VALUE self)
 /**
  * sample
 **/ 
-static VALUE t_sample(int argc, VALUE *argv, VALUE self)
+static VALUE
+t_sample(int argc, VALUE *argv, VALUE self)
 {
     root_node root;
     VALUE array;
@@ -180,7 +191,8 @@ static VALUE t_sample(int argc, VALUE *argv, VALUE self)
 /**
  * size
 **/
-static VALUE t_size(VALUE self)
+static VALUE
+t_size(VALUE self)
 {
     root_node root;
 
@@ -192,7 +204,8 @@ static VALUE t_size(VALUE self)
 /**
  * empty?
 **/
-static VALUE t_empty(VALUE self)
+static VALUE
+t_empty(VALUE self)
 {
     root_node root;
 
@@ -208,7 +221,8 @@ static VALUE t_empty(VALUE self)
 /**
  * cler
 **/
-static VALUE t_clear(VALUE self)
+static VALUE
+t_clear(VALUE self)
 {
     root_node root;
 
@@ -225,7 +239,8 @@ static VALUE t_clear(VALUE self)
 /**
  * define class
 **/
-void Init_figure_set(void) {
+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);

data/ext/figure_set/figure_set/or.c

@@ -0,0 +1,114 @@
+//************************************
+//  or.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+static leaf_node init_and_join_leaf_node(root_node, leaf_node, leaf_node);
+static branch_node init_and_join_brance_node(root_node, branch_node, branch_node);
+static void last_join_branch_node(root_node, branch_node, branch_node, branch_node);
+static void middle_join_branch_node(root_node, branch_node, branch_node, branch_node);
+
+//
+// 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++;
+    }
+  }
+}
+
+static branch_node
+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 branch;
+}
+
+static 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++;
+    }
+  }
+}
+
+static 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++;
+    }
+  }
+}
+
+static leaf_node
+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 leaf;
+}

data/ext/figure_set/figure_set/sample.c

@@ -0,0 +1,90 @@
+//************************************
+//  sample.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+static 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++;
+  }
+}
+
+static 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++;
+    }
+  }
+}
+
+//
+// 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;
+
+  start_sample = (unsigned int)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 ((unsigned int)RARRAY_LEN(array) < sample_count) {
+    sample(root, array, sample_count);
+  }
+
+  rb_funcall(array, rb_intern("uniq!"), 0);
+  if ((unsigned int)RARRAY_LEN(array) < sample_count) {
+    sample(root, array, sample_count);
+  }
+}

data/figure_set.gemspec

@@ -17,10 +17,8 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib", "ext"]
-  spec.extensions    = ["ext/figure_set/extconf.rb"]
-
-  spec.required_ruby_version = '>= 2.2'
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/figure_set/figure_set/extconf.rb"]
 
   spec.add_development_dependency "bundler", ">= 1.3.0", "< 2.0"
   spec.add_development_dependency "rake", ">= 0.8.7"

data/lib/figure_set/version.rb

@@ -1,5 +1,5 @@
 class FigureSet
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 
   class << self
     def version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: figure_set
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Tsukasa OISHI
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-01-31 00:00:00.000000000 Z
+date: 2023-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,7 +91,7 @@ email:
 - tsukasa.oishi@gmail.com
 executables: []
 extensions:
-- ext/figure_set/extconf.rb
+- ext/figure_set/figure_set/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -104,15 +104,18 @@ files:
 - README.rdoc
 - Rakefile
 - benchmark/sample_benchmark.rb
-- ext/figure_set/and.c
-- ext/figure_set/array.c
-- ext/figure_set/extconf.rb
-- ext/figure_set/figure_set.h
-- ext/figure_set/index.c
-- ext/figure_set/init.c
-- ext/figure_set/methods.c
-- ext/figure_set/or.c
-- ext/figure_set/sample.c
+- bin/console
+- bin/setup
+- bin/test
+- ext/figure_set/figure_set/and.c
+- ext/figure_set/figure_set/array.c
+- ext/figure_set/figure_set/extconf.rb
+- ext/figure_set/figure_set/figure_set.h
+- ext/figure_set/figure_set/index.c
+- ext/figure_set/figure_set/init.c
+- ext/figure_set/figure_set/methods.c
+- ext/figure_set/figure_set/or.c
+- ext/figure_set/figure_set/sample.c
 - figure_set.gemspec
 - lib/figure_set.rb
 - lib/figure_set/version.rb
@@ -120,25 +123,23 @@ homepage: https://github.com/tsukasaoishi/figure_set
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
-- ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: FigureSet is the library which treats set operation.
 test_files: []