figure_set 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e561bc42e983722b42d4633631eebe1cb3d9ef8a7f5429867840657ed0e6ae2
-  data.tar.gz: c81d4e8b25d38e7f4974f1d627d396421a60da2d64fd02f068d88927875f8e16
+  metadata.gz: 607f5983d462888fdae0e4b02ef8c2b35ce817b18497be4e0e9ab368f53e4517
+  data.tar.gz: 7dff01e4b5bdfd6695cc9c65d0199a94079a92e2bd751bdddf875da40c7aff5c
 SHA512:
-  metadata.gz: f02e42c9ea2ca6e993b95d1e6fbd34f927ab862664df1f0259a0e76721e8b6c4d504f5f20efba0c50564849e7d928e384d899da8084d1432e8e5a13ccbf3f071
-  data.tar.gz: c7ff2ea5d1961280b43faf257d766e9af8d64c567c723c3e221ab8265b6609cd714648de3050cf012708e0d2ddf86c57098bb0a4e85139dcfbd8062149b8288e
+  metadata.gz: 32c5187a40d3f61a7846981142bd4c28c9584730039256c7476be3de84e5fe4194e971189c8e3b8414d7a383c572befea3ada6afdc9c69a3a3a5dde6479f4682
+  data.tar.gz: 5732976db72898325f0965e521b8ce158723a88188d05bed982d508adc43defd9d6eaf4eb3b0a186dd6ebace9489f7b04ca49995c06ee7e586c53e431e93ac59

data/.travis.yml

@@ -1,15 +1,14 @@
 language: ruby
-before_install:
-  - gem install bundler
 before_script:
-  - bundle update
-  - "bundle exec rake compile"
+  - "bin/setup"
 script:
-  - "bundle exec rake test"
+  - "bin/test"
 cache: bundler
 rvm:
-  - 2.2.9
-  - 2.3.6
-  - 2.4.3
-  - 2.5.0
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+  - 2.6.0
+matrix:
+  fast_finish: true
 bundler_args: --jobs 3 --retry 3

data/Manifest.txt

@@ -1,14 +1,25 @@
+.gitignore
+.travis.yml
+CODE_OF_CONDUCT.md
+Gemfile
 History.txt
+LICENSE.txt
 Manifest.txt
 README.rdoc
 Rakefile
+benchmark/sample_benchmark.rb
+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
-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
+lib/figure_set/version.rb

data/Rakefile

@@ -5,6 +5,7 @@ require 'rake/testtask'
 # compile
 gemspec = eval(File.read(File.expand_path('../figure_set.gemspec', __FILE__)))
 Rake::ExtensionTask.new("figure_set", gemspec) do |ext|
+  ext.ext_dir = "ext/figure_set/figure_set"
   ext.lib_dir = "lib/figure_set"
 end
 
@@ -12,3 +13,13 @@ end
 Rake::TestTask.new do |t|
   t.test_files = FileList['test/**/test_*.rb']
 end
+
+desc 'generate Manifest.txt'
+task :manifest do |t|
+  File.open(File.expand_path("../Manifest.txt", __FILE__), "w") do |out|
+    gemspec.files.sort.each do |f|
+      out.puts(f) if File.file?(f)
+    end
+  end
+  puts "Generate Manifest.txt"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "figure_set"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install --path .bundle
+bundle exec rake compile
+
+# Do any other automated setup that you need to do here

data/bin/test

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle exec rake test
+
+# Do any other automated setup that you need to do here

data/ext/figure_set/figure_set/and.c

@@ -0,0 +1,125 @@
+//************************************
+//  and.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+static void middel_intersection_branch_node(root_node, branch_node, branch_node, branch_node);
+static void last_intersection_branch_node(root_node, branch_node, branch_node, branch_node);
+
+static branch_node
+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 branch;
+  } else {
+    destroy_branch(branch);
+    return (branch_node)NULL;
+  }
+}
+
+static leaf_node
+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 (leaf_node)NULL;
+
+  leaf = (leaf_node)init_leaf_node(base->offset);
+  leaf->data = data;
+  result_set->size += BIT_COUNT(leaf->data);
+
+  return leaf;
+}
+
+static 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++;
+        }
+      }
+    }
+  }
+}
+
+static 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++;
+        }
+      }
+    }
+  }
+}
+
+//
+// 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++;
+        }
+      }
+    }
+  }
+}

data/ext/figure_set/figure_set/array.c

@@ -0,0 +1,91 @@
+//************************************
+//  array.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+static 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);
+  }
+}
+
+static 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++;
+      }
+    }
+  }
+}
+
+//
+// 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;
+}
+
+//
+// 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++;
+    }
+  }
+}

data/ext/figure_set/figure_set/extconf.rb

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

data/ext/figure_set/{figure_set.h → figure_set/figure_set.h}

@@ -7,18 +7,6 @@
 
 #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
@@ -43,9 +31,6 @@ static unsigned long OFFSET_SCALE[] = {0x20000000, 0x2000000, 0x200000, 0x20000,
 #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) 
@@ -68,78 +53,44 @@ typedef struct _branch_node {
 } *branch_node;
 
 typedef struct _root_node {
-    unsigned char children_size;     
+    unsigned char children_size;
     unsigned long size;              // number of elements in set
     void *index[MAX_CHILDREN_SIZE_OF_ROOT_NODE];    // children pointer
 } *root_node;
 
+// bit count
+unsigned long bit32_count(unsigned long);
+unsigned long bit64_count(unsigned long);
+
 // initialize
 void init_root_node(root_node);
-void *init_branch_node();
-void *init_leaf_node(unsigned long);
+branch_node init_branch_node();
+leaf_node 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);
+branch_node init_and_copy_brance_node(root_node, branch_node);
+leaf_node init_and_copy_leaf_node(root_node, leaf_node);
+
+// memory free
+void destroy_all(root_node);
+void destroy_all_branches(root_node);
+void destroy_branch(branch_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/figure_set/figure_set/index.c

@@ -0,0 +1,130 @@
+//************************************
+//  index.c
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "figure_set.h"
+
+static unsigned int search_and_insert(branch_node, unsigned long, unsigned long, unsigned long);
+static unsigned int search_and_insert_at_leaf(leaf_node, unsigned long);
+static unsigned int search_and_remove(branch_node, unsigned long, unsigned long, unsigned long);
+static unsigned int search_and_remove_at_leaf(leaf_node, unsigned long);
+
+
+static 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);
+  }
+}
+
+static 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;
+}
+
+static 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);
+  }
+}
+
+static 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;
+}
+
+//
+// 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++;
+  }
+}
+
+//
+// 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--;
+  }
+}