rejuicer 0.0.3 → 0.0.4

data/Manifest.txt

@@ -4,5 +4,10 @@ README.rdoc
 Rakefile
 lib/rejuicer.rb
 ext/extconf.rb
-ext/rejuicer_set.h
-ext/rejuicer_set.c
+ext/rejuicer_set/rejuicer_set.h
+ext/rejuicer_set/main.c
+ext/rejuicer_set/init.c
+ext/rejuicer_set/index.c
+ext/rejuicer_set/and.c
+ext/rejuicer_set/or.c
+ext/rejuicer_set/util.c

data/README.rdoc

@@ -14,6 +14,13 @@
 
  index.set(mother)
 
+=== Add to Index
+  num = 20000
+  inst = work.new(num, num % 2 == 0, num % 3, num % 5)
+  index.add(inst)
+=== Remove from Index
+  index.delete(inst)
+
 == Search
  index.search(:odd_flag => false) #=> [1,3,5,7,9...,9997,9999]
  index.search(:remainder_3 => 2, :remainder_5 => 4) #=> [14,29,44,59,...,9974,9989]

data/ext/extconf.rb

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

data/ext/rejuicer_set/and.c

@@ -0,0 +1,97 @@
+//************************************
+//         rejuicer.c
+//
+//       Tsukasa OISHI
+//
+//         2010/03/17
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "rejuicer_set.h"
+
+//
+// intersection
+//
+void intersection(root_node ret_set, root_node set0, root_node set1)
+{
+    int i, count;
+    root_node base, other;
+
+    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 < ROOT_NODE_SIZE || count < base->children_size; i++) {
+        if (base->index[i]) {
+            count++;
+            if (other->index[i]) {
+                ret_set->index[i] = (branch_node)init_and_intersection_branch_node(ret_set, (branch_node)base->index[i], (branch_node)other->index[i]);
+            }
+        }
+    }
+}
+
+void intersection_branch_node(root_node root, branch_node ret_set, branch_node base, branch_node other)
+{
+    if (ret_set->level == LAST_BRANCH_LEVEL) {
+        last_intersection_branch_node(root, ret_set, base, other);
+    } else {
+        middel_intersection_branch_node(root, ret_set, base, other);
+    }
+}
+
+void middel_intersection_branch_node(root_node root, branch_node ret_set, branch_node base, branch_node other)
+{
+    int i, count;
+
+    for (i = 0, count = 0; i < BRANCH_NODE_SIZE || count < base->children_size; i++) {
+        if (base->index[i]) {
+            count++;
+            if (other->index[i]) {
+                ret_set->index[i] = (branch_node)init_and_intersection_branch_node(root, (branch_node)base->index[i], (branch_node)other->index[i]);
+            }
+        }
+    }
+}
+
+void last_intersection_branch_node(root_node root, branch_node ret_set, branch_node base, branch_node other)
+{
+    int i, count;
+
+    for (i = 0, count = 0; i < BRANCH_NODE_SIZE || count < base->children_size; i++) {
+        if (base->index[i]) {
+            count++;
+            if (other->index[i]) {
+                ret_set->index[i] = init_leaf_node2(((leaf_node)base->index[i])->num);
+                intersection_leaf_node(root, (leaf_node)ret_set->index[i], (leaf_node)base->index[i], (leaf_node)other->index[i]);
+            }
+        }
+    }
+}
+
+
+void intersection_leaf_node(root_node root, leaf_node ret_set, leaf_node base, leaf_node other)
+{
+    ret_set->data = base->data & other->data;
+    root->size += bit_count(ret_set->data);
+}
+
+
+void *init_and_intersection_branch_node(root_node root, branch_node base, branch_node other)
+{
+    branch_node ret;
+
+    ret = init_branch_node2(base->level, base->num);
+    intersection_branch_node(root, ret, base, other);
+
+    return ret;
+}

data/ext/rejuicer_set/index.c

@@ -0,0 +1,119 @@
+//************************************
+//         rejuicer.c
+//
+//       Tsukasa OISHI
+//
+//         2010/03/17
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "rejuicer_set.h"
+
+//
+// insert element into set
+//
+void add_num(root_node root, unsigned int value)
+{
+    unsigned int quotient, remainder;
+
+    quotient = value / INDEX_PER_SIZE[0];
+    remainder = value % INDEX_PER_SIZE[0];
+
+    if(!(root->index[quotient])) {
+        root->index[quotient] = init_branch_node(1, quotient);
+        root->children_size++;
+    }
+
+    if (search_and_insert((branch_node)root->index[quotient], 1, remainder, value)) {
+        root->size++;
+    }
+}
+
+int search_and_insert(branch_node branch, int level, unsigned int value, unsigned int original)
+{
+    unsigned int quotient, remainder;
+
+    quotient = value / INDEX_PER_SIZE[level];
+    remainder = value % INDEX_PER_SIZE[level];
+
+    if(!(branch->index[quotient])) {
+        branch->children_size++;
+        if(level == LAST_BRANCH_LEVEL) {
+            branch->index[quotient] = init_leaf_node(original);
+        } else {
+            branch->index[quotient] = init_branch_node(level + 1, original);
+        }
+    }
+
+    if (level == LAST_BRANCH_LEVEL) {
+        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);
+    }
+}
+
+int search_and_insert_at_leaf(leaf_node leaf, unsigned int value)
+{
+    int exist_flag = 0;
+    unsigned int target_bit;
+
+    target_bit = 1 << 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 int value)
+{
+    unsigned int quotient, remainder;
+
+    quotient = value / INDEX_PER_SIZE[0];
+    remainder = value % INDEX_PER_SIZE[0];
+
+    if (!(root->index[quotient])) return;
+
+    if (search_and_remove((branch_node)root->index[quotient], 1, remainder, value)) {
+        root->size--;
+    }
+}
+
+int search_and_remove(branch_node branch, int level, unsigned int value, unsigned int original)
+{
+    unsigned int quotient, remainder, result;
+
+    quotient = value / INDEX_PER_SIZE[level];
+    remainder = value % INDEX_PER_SIZE[level];
+
+    if (!(branch->index[quotient])) return;
+
+    if (level == LAST_BRANCH_LEVEL) {
+        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);
+    }
+}
+
+int search_and_remove_at_leaf(leaf_node leaf, unsigned int value)
+{
+    int exist_flag = 0;
+    unsigned int target_bit;
+
+    target_bit = 1 << value; 
+
+    if ((leaf->data & target_bit)) {
+        leaf->data ^= target_bit;
+        exist_flag = 1;
+    }
+
+    return exist_flag;
+}

data/ext/rejuicer_set/init.c

@@ -0,0 +1,183 @@
+//************************************
+//         rejuicer.c
+//
+//       Tsukasa OISHI
+//
+//         2010/03/17
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "rejuicer_set.h"
+
+//
+// initialize
+//
+void init_root_node(root_node root)
+{
+    int i;
+
+    for(i = 0; i < ROOT_NODE_SIZE; i++) {
+        root->index[i] = (void*)NULL;
+    }
+    root->size = 0;
+    root->children_size = 0;
+}
+
+void *init_branch_node(int level, unsigned int value)
+{
+    return init_branch_node2(level, (value / INDEX_PER_SIZE[level - 1]));
+}
+
+void *init_branch_node2(int level, unsigned int num)
+{
+    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 < BRANCH_NODE_SIZE; i++) {
+        branch->index[i] = (void*)NULL;
+    }
+
+    branch->level = level;
+    branch->num = num;
+    branch->children_size = 0;
+
+    return (void*)branch;
+}
+
+void *init_leaf_node(unsigned int value)
+{
+    return init_leaf_node2(value / INDEX_PER_SIZE[LAST_BRANCH_LEVEL]);
+}
+
+void *init_leaf_node2(unsigned int num)
+{
+    leaf_node leaf;
+
+    if(!(leaf = (leaf_node)malloc(sizeof(struct _leaf_node)))) {
+        rb_raise(rb_eStandardError, "memory is not enough");
+    }
+
+    leaf->num = num;
+    leaf->data = 0;
+
+    return (void*)leaf;
+}
+
+//
+// initialize copy
+//
+void copy_root_node(root_node root, root_node orig)
+{
+    int i, count;
+
+    root->children_size = orig->children_size;
+
+    for (i = 0, count = 0; i < ROOT_NODE_SIZE || count < orig->children_size; i++) {
+        if (orig->index[i]) {
+            root->index[i] = (branch_node)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)
+{
+    int i, count;
+
+    branch->num = orig->num;
+    branch->level = orig->level;
+    branch->children_size = orig->children_size;
+
+    if (orig->level == LAST_BRANCH_LEVEL) {
+        for(i = 0, count = 0; i < BRANCH_NODE_SIZE || count < orig->children_size; i++) {
+            if (orig->index[i]) {
+                branch->index[i] = (leaf_node)init_and_copy_leaf_node(root, (leaf_node)orig->index[i]);
+                count++;
+            }
+        }
+    } else {
+        for(i = 0, count = 0; i < BRANCH_NODE_SIZE || count < orig->children_size; i++) {
+            if (orig->index[i]) {
+                branch->index[i] = (branch_node)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 ret;
+
+    ret = init_branch_node2(orig->level, orig->num);
+    copy_branch_node(root, ret, orig);
+
+    return ret;
+}
+
+void *init_and_copy_leaf_node(root_node root, leaf_node orig)
+{
+    leaf_node ret;
+
+    ret = init_leaf_node2(orig->num);
+    ret->data = orig->data;
+    root->size += bit_count(ret->data);
+
+    return ret;
+}
+
+//
+// memory free
+//
+void destroy_all(root_node root)
+{
+    destroy_all_branches(root);
+    free(root);
+}
+
+void destroy_all_branches(root_node root)
+{
+    int i, count;
+    
+    for(i = 0, count = 0; i < ROOT_NODE_SIZE || count < root->children_size; i++) {
+        if (root->index[i]) {
+            destroy_branch((branch_node)root->index[i]);
+            root->index[i] = NULL;
+            count++;
+        }
+    }
+
+    root->size = 0;
+    root->children_size = 0;
+}
+
+void destroy_branch(branch_node branch)
+{
+    int i, count;
+
+    if (branch->level == LAST_BRANCH_LEVEL) {
+        for(i = 0, count = 0; i < BRANCH_NODE_SIZE || count < branch->children_size; i++) {
+            if (branch->index[i]) {
+                free((leaf_node)branch->index[i]);
+                branch->index[i] = NULL;
+                count++;
+            }
+        }
+    } else {
+        for(i = 0, count = 0; i < BRANCH_NODE_SIZE || count < branch->children_size; i++) {
+            if (branch->index[i]) {
+                destroy_branch((branch_node)branch->index[i]);
+                branch->index[i] = NULL;
+                count++;
+            }
+        }
+    }
+    free(branch);
+}

data/ext/rejuicer_set/main.c

@@ -0,0 +1,213 @@
+//************************************
+//         rejuicer.c
+//
+//       Tsukasa OISHI
+//
+//         2010/03/17
+//************************************
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ruby.h>
+#include "rejuicer_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;
+    root_node root;
+
+    Data_Get_Struct(self, struct _root_node, root);
+    if (argc == 1) {
+        while((num = rb_ary_shift(argv[0])) != Qnil) {
+            add_num(root, NUM2UINT(num));
+        }
+    }
+
+    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;
+    unsigned int num;
+
+    Data_Get_Struct(self, struct _root_node, root);
+    add_num(root, NUM2UINT(value));
+
+    return self;
+}
+
+/**
+ * delete
+ **/
+static VALUE t_delete(VALUE self, VALUE value)
+{
+    root_node root;
+    unsigned int num;
+
+    Data_Get_Struct(self, struct _root_node, root);
+    delete_num(root, NUM2UINT(value));
+
+    return self;
+}
+
+/**
+ * intersection
+**/
+static VALUE t_intersection(VALUE self, VALUE other)
+{
+    root_node set0, set1, ret_set;
+    VALUE ret;
+
+    ret = Data_Make_Struct(rb_cRejuicerSet, struct _root_node, NULL, destroy_all, ret_set);
+    init_root_node(ret_set);
+
+    Data_Get_Struct(self, struct _root_node, set0);
+    Data_Get_Struct(other, struct _root_node, set1);
+
+    intersection(ret_set, set0, set1);
+
+    return ret;
+}
+
+/**
+ * union
+**/
+static VALUE t_union(VALUE self, VALUE other)
+{
+    root_node set0, set1, ret_set;
+    VALUE ret;
+
+    ret = Data_Make_Struct(rb_cRejuicerSet, struct _root_node, NULL, destroy_all, ret_set);
+    init_root_node(ret_set);
+
+    Data_Get_Struct(self, struct _root_node, set0);
+    Data_Get_Struct(other, struct _root_node, set1);
+
+    join(ret_set, set0, set1);
+
+    return ret;
+}
+
+/**
+ * to_a
+**/ 
+static VALUE t_to_a(VALUE self)
+{
+    int i;
+    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;
+}
+
+/**
+ * size
+**/
+static VALUE t_size(VALUE self)
+{
+    root_node root;
+
+    Data_Get_Struct(self, struct _root_node, root);
+
+    return INT2NUM(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_rejuicer_set(void) {
+    rb_cRejuicerSet = rb_define_class("RejuicerSet", rb_cObject);
+    rb_define_alloc_func(rb_cRejuicerSet, t_allocate);
+    rb_define_private_method(rb_cRejuicerSet, "initialize", t_initialize, -1);
+    rb_define_method(rb_cRejuicerSet, "initialize_copy", t_initialize_copy, 1);
+    rb_define_method(rb_cRejuicerSet, "add", t_add, 1);
+    rb_define_method(rb_cRejuicerSet, "delete", t_delete, 1);
+    rb_define_method(rb_cRejuicerSet, "intersection", t_intersection, 1);
+    rb_define_method(rb_cRejuicerSet, "union", t_union, 1);
+    rb_define_method(rb_cRejuicerSet, "to_a", t_to_a, 0);
+    rb_define_method(rb_cRejuicerSet, "size", t_size, 0);
+    rb_define_method(rb_cRejuicerSet, "empty?", t_empty, 0);
+    rb_define_method(rb_cRejuicerSet, "clear", t_clear, 0);
+    rb_define_alias(rb_cRejuicerSet, "<<", "add");
+    rb_define_alias(rb_cRejuicerSet, "&", "intersection");
+    rb_define_alias(rb_cRejuicerSet, "|", "union");
+    rb_define_alias(rb_cRejuicerSet, "length", "size");
+}