figure_set 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e561bc42e983722b42d4633631eebe1cb3d9ef8a7f5429867840657ed0e6ae2
-  data.tar.gz: c81d4e8b25d38e7f4974f1d627d396421a60da2d64fd02f068d88927875f8e16
+  metadata.gz: 68703cf5d7a17b70ea0c0eda48afc85c3b6830902cff9ea5bb4f6aa0056d04fa
+  data.tar.gz: 5d11a68c4f9cff705c533faba0288a3f97031217de241e49efe978597c203ceb
 SHA512:
-  metadata.gz: f02e42c9ea2ca6e993b95d1e6fbd34f927ab862664df1f0259a0e76721e8b6c4d504f5f20efba0c50564849e7d928e384d899da8084d1432e8e5a13ccbf3f071
-  data.tar.gz: c7ff2ea5d1961280b43faf257d766e9af8d64c567c723c3e221ab8265b6609cd714648de3050cf012708e0d2ddf86c57098bb0a4e85139dcfbd8062149b8288e
+  metadata.gz: d3ed337f5e9a5282c6a901f181179230f6bf39f316eac3f200eae741499abcdb0fe7186d7e6172df1fdc68e6ca2b9abb6bec1d60b6f7b893fee003650ace3efc
+  data.tar.gz: abf5fa5906669b40633979657ef3bf4dba93e6f3c841fc8e29e14476b950b6728dbae5a45e3c6a57644ccb95c847e3f7f6ab164507435608b9b3e1ae4be5ae07

data/.travis.yml

@@ -2,14 +2,15 @@ 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
+matrix:
+  fast_finish: true
 bundler_args: --jobs 3 --retry 3

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/and.c

@@ -8,111 +8,118 @@
 #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;
-    }
+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);
 
-    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++;
-                }
-            }
-        }
-    }
+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;
+  }
 }
 
-void *init_and_intersection_branch_node(root_node result_set, branch_node base, branch_node other)
+static leaf_node
+init_and_intersection_leaf_node(root_node result_set, leaf_node base, leaf_node other)
 {
-    branch_node branch;
+  unsigned long data;
+  leaf_node leaf;
 
-    branch = (branch_node)init_branch_node();
+  data = base->data & other->data;
 
-    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 (!data) return (leaf_node)NULL;
 
-    if (branch->children_size) {
-        branch->children_type = base->children_type;
-        return (void*)branch;
-    } else {
-        destroy_branch(branch);
-        return (void*)NULL;
-    }
+  leaf = (leaf_node)init_leaf_node(base->offset);
+  leaf->data = data;
+  result_set->size += BIT_COUNT(leaf->data);
+
+  return leaf;
 }
 
-void middel_intersection_branch_node(root_node result_set, branch_node branch, branch_node base, branch_node other)
+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++;
-                }
-            }
+  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)
+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++;
-                }
-            }
+  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)
+//
+// intersection
+//
+void
+intersection(root_node result_set, root_node set0, root_node set1)
 {
-    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;
+  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/array.c

@@ -8,91 +8,84 @@
 #include <ruby.h>
 #include "figure_set.h"
 
-//
-// output Array object from internal set
-//
-void to_array(root_node root, VALUE array)
+static void
+search_and_get_array_at_leaf(leaf_node leaf, 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++;
-        }
-    }
-}
+  unsigned long i = 0;
+  unsigned long x;
 
-void search_and_get_array(branch_node branch, VALUE array)
-{
-    unsigned int i, count;
+  x = leaf->data;
 
-    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++;
-            }
-        }
-    }
+  while(x) {
+    i = BIT_COUNT((x & (-x))-1);
+    rb_ary_push(array, ULONG2NUM(leaf->offset + i));
+    x = x ^ (1UL << i);
+  }
 }
 
-void search_and_get_array_at_leaf(leaf_node leaf, VALUE array)
+static void
+search_and_get_array(branch_node branch, VALUE array)
 {
-    unsigned long i = 0;
-    unsigned long x;
+  unsigned int i, count;
 
-    x = leaf->data;
-
-    while(x) {
-        i = BIT_COUNT((x & (-x))-1);
-        rb_ary_push(array, ULONG2NUM(leaf->offset + i));
-        x = x ^ (1UL << i);
+  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++;
+      }
     }
-
-
-    /*
-    while(x) {
-        if (x & 1UL) {
-            rb_ary_push(array, ULONG2NUM(leaf->offset + i));
-        }
-        x = x >> 1UL;
-        i++;
+  } 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)
+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;
+  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)
+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)
 {
-    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;
+  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.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);
-