figure_set 1.0.0 → 1.1.0

data/ext/figure_set/and.c

@@ -1,118 +0,0 @@
-//************************************
-//  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/figure_set/array.c

@@ -1,98 +0,0 @@
-//************************************
-//  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/figure_set/extconf.rb

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

data/ext/figure_set/index.c

@@ -1,118 +0,0 @@
-//************************************
-//  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/figure_set/init.c

@@ -1,167 +0,0 @@
-//************************************
-//  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/figure_set/or.c

@@ -1,105 +0,0 @@
-//************************************
-//  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/figure_set/sample.c

@@ -1,87 +0,0 @@
-//************************************
-//  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;
-
-    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++;
-    }
-}