figure_set 1.0.0 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. checksums.yaml +4 -4
  2. data/.travis.yml +4 -3
  3. data/bin/console +14 -0
  4. data/bin/setup +8 -0
  5. data/bin/test +8 -0
  6. data/ext/figure_set/and.c +94 -87
  7. data/ext/figure_set/array.c +59 -66
  8. data/ext/figure_set/figure_set.h +14 -63
  9. data/ext/figure_set/index.c +87 -75
  10. data/ext/figure_set/init.c +114 -104
  11. data/ext/figure_set/methods.c +29 -14
  12. data/ext/figure_set/or.c +78 -69
  13. data/ext/figure_set/sample.c +58 -55
  14. data/lib/figure_set/version.rb +1 -1
  15. metadata +5 -2
data/ext/figure_set/methods.c CHANGED
@@ -13,10 +13,13 @@
13
13
  // Ruby Methods
14
14
  // ----------------------------------------------------------
15
15
 
16
+ static VALUE rb_cFigureSet;
17
+
16
18
  /**
17
19
  * allocate
18
20
  **/
19
- static VALUE t_allocate(VALUE klass)
21
+ static VALUE
22
+ t_allocate(VALUE klass)
20
23
  {
21
24
  VALUE obj;
22
25
  root_node root;
@@ -30,9 +33,10 @@ static VALUE t_allocate(VALUE klass)
30
33
  /**
31
34
  * initialize
32
35
  **/
33
- static VALUE t_initialize(int argc, VALUE *argv, VALUE self)
36
+ static VALUE
37
+ t_initialize(int argc, VALUE *argv, VALUE self)
34
38
  {
35
- VALUE num, ary_element;
39
+ VALUE ary_element;
36
40
  root_node root;
37
41
  unsigned long i, len;
38
42
 
@@ -54,7 +58,8 @@ static VALUE t_initialize(int argc, VALUE *argv, VALUE self)
54
58
  /**
55
59
  * initialize_copy
56
60
  **/
57
- static VALUE t_initialize_copy(VALUE self, VALUE orig)
61
+ static VALUE
62
+ t_initialize_copy(VALUE self, VALUE orig)
58
63
  {
59
64
  root_node root, orig_set;
60
65
 
@@ -68,7 +73,8 @@ static VALUE t_initialize_copy(VALUE self, VALUE orig)
68
73
  /**
69
74
  * add
70
75
  **/
71
- static VALUE t_add(VALUE self, VALUE value)
76
+ static VALUE
77
+ t_add(VALUE self, VALUE value)
72
78
  {
73
79
  root_node root;
74
80
 
@@ -84,7 +90,8 @@ static VALUE t_add(VALUE self, VALUE value)
84
90
  /**
85
91
  * delete
86
92
  **/
87
- static VALUE t_delete(VALUE self, VALUE value)
93
+ static VALUE
94
+ t_delete(VALUE self, VALUE value)
88
95
  {
89
96
  root_node root;
90
97
 
@@ -100,7 +107,8 @@ static VALUE t_delete(VALUE self, VALUE value)
100
107
  /**
101
108
  * intersection
102
109
  **/
103
- static VALUE t_intersection(VALUE self, VALUE other)
110
+ static VALUE
111
+ t_intersection(VALUE self, VALUE other)
104
112
  {
105
113
  VALUE obj;
106
114
  root_node result_set, set0, set1;
@@ -119,7 +127,8 @@ static VALUE t_intersection(VALUE self, VALUE other)
119
127
  /**
120
128
  * union
121
129
  **/
122
- static VALUE t_union(VALUE self, VALUE other)
130
+ static VALUE
131
+ t_union(VALUE self, VALUE other)
123
132
  {
124
133
  VALUE obj;
125
134
  root_node result_set, set0, set1;
@@ -138,7 +147,8 @@ static VALUE t_union(VALUE self, VALUE other)
138
147
  /**
139
148
  * to_a
140
149
  **/
141
- static VALUE t_to_a(VALUE self)
150
+ static VALUE
151
+ t_to_a(VALUE self)
142
152
  {
143
153
  root_node root;
144
154
  VALUE array;
@@ -154,7 +164,8 @@ static VALUE t_to_a(VALUE self)
154
164
  /**
155
165
  * sample
156
166
  **/
157
- static VALUE t_sample(int argc, VALUE *argv, VALUE self)
167
+ static VALUE
168
+ t_sample(int argc, VALUE *argv, VALUE self)
158
169
  {
159
170
  root_node root;
160
171
  VALUE array;
@@ -180,7 +191,8 @@ static VALUE t_sample(int argc, VALUE *argv, VALUE self)
180
191
  /**
181
192
  * size
182
193
  **/
183
- static VALUE t_size(VALUE self)
194
+ static VALUE
195
+ t_size(VALUE self)
184
196
  {
185
197
  root_node root;
186
198
 
@@ -192,7 +204,8 @@ static VALUE t_size(VALUE self)
192
204
  /**
193
205
  * empty?
194
206
  **/
195
- static VALUE t_empty(VALUE self)
207
+ static VALUE
208
+ t_empty(VALUE self)
196
209
  {
197
210
  root_node root;
198
211
 
@@ -208,7 +221,8 @@ static VALUE t_empty(VALUE self)
208
221
  /**
209
222
  * cler
210
223
  **/
211
- static VALUE t_clear(VALUE self)
224
+ static VALUE
225
+ t_clear(VALUE self)
212
226
  {
213
227
  root_node root;
214
228
 
@@ -225,7 +239,8 @@ static VALUE t_clear(VALUE self)
225
239
  /**
226
240
  * define class
227
241
  **/
228
- void Init_figure_set(void) {
242
+ void
243
+ Init_figure_set(void) {
229
244
  rb_cFigureSet = rb_define_class("FigureSet", rb_cObject);
230
245
  rb_define_alloc_func(rb_cFigureSet, t_allocate);
231
246
  rb_define_private_method(rb_cFigureSet, "initialize", t_initialize, -1);
data/ext/figure_set/or.c CHANGED
@@ -8,98 +8,107 @@
8
8
  #include <ruby.h>
9
9
  #include "figure_set.h"
10
10
 
11
+ static leaf_node init_and_join_leaf_node(root_node, leaf_node, leaf_node);
12
+ static branch_node init_and_join_brance_node(root_node, branch_node, branch_node);
13
+ static void last_join_branch_node(root_node, branch_node, branch_node, branch_node);
14
+ static void middle_join_branch_node(root_node, branch_node, branch_node, branch_node);
15
+
11
16
  //
12
17
  // join
13
18
  //
14
- void join(root_node result_set, root_node set0, root_node set1)
19
+ void
20
+ join(root_node result_set, root_node set0, root_node set1)
15
21
  {
16
- unsigned int i;
17
-
18
- if (set0->size == 0 && set1->size == 0) {
19
- return;
20
- } else if (set0->size == 0) {
21
- copy_root_node(result_set, set1);
22
- return;
23
- } else if (set1->size == 0) {
24
- copy_root_node(result_set, set0);
25
- return;
26
- }
27
-
28
- for (i = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE; i++) {
29
- if (set0->index[i] && set1->index[i]) {
30
- result_set->index[i] = init_and_join_brance_node(result_set, (branch_node)set0->index[i], (branch_node)set1->index[i]);
31
- result_set->children_size++;
32
- } else if(set0->index[i]) {
33
- result_set->index[i] = init_and_copy_brance_node(result_set, (branch_node)set0->index[i]);
34
- result_set->children_size++;
35
- } else if (set1->index[i]) {
36
- result_set->index[i] = init_and_copy_brance_node(result_set, (branch_node)set1->index[i]);
37
- result_set->children_size++;
38
- }
22
+ unsigned int i;
23
+
24
+ if (set0->size == 0 && set1->size == 0) {
25
+ return;
26
+ } else if (set0->size == 0) {
27
+ copy_root_node(result_set, set1);
28
+ return;
29
+ } else if (set1->size == 0) {
30
+ copy_root_node(result_set, set0);
31
+ return;
32
+ }
33
+
34
+ for (i = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE; i++) {
35
+ if (set0->index[i] && set1->index[i]) {
36
+ result_set->index[i] = init_and_join_brance_node(result_set, (branch_node)set0->index[i], (branch_node)set1->index[i]);
37
+ result_set->children_size++;
38
+ } else if(set0->index[i]) {
39
+ result_set->index[i] = init_and_copy_brance_node(result_set, (branch_node)set0->index[i]);
40
+ result_set->children_size++;
41
+ } else if (set1->index[i]) {
42
+ result_set->index[i] = init_and_copy_brance_node(result_set, (branch_node)set1->index[i]);
43
+ result_set->children_size++;
39
44
  }
45
+ }
40
46
  }
41
47
 
42
-
43
- void *init_and_join_brance_node(root_node result_set, branch_node set0, branch_node set1)
48
+ static branch_node
49
+ init_and_join_brance_node(root_node result_set, branch_node set0, branch_node set1)
44
50
  {
45
- branch_node branch;
51
+ branch_node branch;
46
52
 
47
- branch = (branch_node)init_branch_node();
53
+ branch = (branch_node)init_branch_node();
48
54
 
49
- if (set0->children_type == CT_LEAF) {
50
- branch->children_type = CT_LEAF;
51
- last_join_branch_node(result_set, branch, set0, set1);
52
- } else {
53
- middle_join_branch_node(result_set, branch, set0, set1);
54
- }
55
+ if (set0->children_type == CT_LEAF) {
56
+ branch->children_type = CT_LEAF;
57
+ last_join_branch_node(result_set, branch, set0, set1);
58
+ } else {
59
+ middle_join_branch_node(result_set, branch, set0, set1);
60
+ }
55
61
 
56
- return (void*)branch;
62
+ return branch;
57
63
  }
58
64
 
59
- void middle_join_branch_node(root_node result_set, branch_node branch, branch_node set0, branch_node set1)
65
+ static void
66
+ middle_join_branch_node(root_node result_set, branch_node branch, branch_node set0, branch_node set1)
60
67
  {
61
- unsigned int i;
62
-
63
- for (i = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH; i++) {
64
- if (set0->index[i] && set1->index[i]) {
65
- branch->index[i] = init_and_join_brance_node(result_set, (branch_node)set0->index[i], (branch_node)set1->index[i]);
66
- branch->children_size++;
67
- } else if (set0->index[i]) {
68
- branch->index[i] = init_and_copy_brance_node(result_set, (branch_node)set0->index[i]);
69
- branch->children_size++;
70
- } else if (set1->index[i]) {
71
- branch->index[i] = init_and_copy_brance_node(result_set, (branch_node)set1->index[i]);
72
- branch->children_size++;
73
- }
68
+ unsigned int i;
69
+
70
+ for (i = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH; i++) {
71
+ if (set0->index[i] && set1->index[i]) {
72
+ branch->index[i] = init_and_join_brance_node(result_set, (branch_node)set0->index[i], (branch_node)set1->index[i]);
73
+ branch->children_size++;
74
+ } else if (set0->index[i]) {
75
+ branch->index[i] = init_and_copy_brance_node(result_set, (branch_node)set0->index[i]);
76
+ branch->children_size++;
77
+ } else if (set1->index[i]) {
78
+ branch->index[i] = init_and_copy_brance_node(result_set, (branch_node)set1->index[i]);
79
+ branch->children_size++;
74
80
  }
81
+ }
75
82
  }
76
83
 
77
- void last_join_branch_node(root_node result_set, branch_node branch, branch_node set0, branch_node set1)
84
+ static void
85
+ last_join_branch_node(root_node result_set, branch_node branch, branch_node set0, branch_node set1)
78
86
  {
79
- unsigned int i;
80
-
81
- for (i = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH; i++) {
82
- if (set0->index[i] && set1->index[i]) {
83
- branch->index[i] = init_and_join_leaf_node(result_set, (leaf_node)set0->index[i], (leaf_node)set1->index[i]);
84
- branch->children_size++;
85
- } else if (set0->index[i]) {
86
- branch->index[i] = init_and_copy_leaf_node(result_set, (leaf_node)set0->index[i]);
87
- branch->children_size++;
88
- } else if (set1->index[i]) {
89
- branch->index[i] = init_and_copy_leaf_node(result_set, (leaf_node)set1->index[i]);
90
- branch->children_size++;
91
- }
87
+ unsigned int i;
88
+
89
+ for (i = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH; i++) {
90
+ if (set0->index[i] && set1->index[i]) {
91
+ branch->index[i] = init_and_join_leaf_node(result_set, (leaf_node)set0->index[i], (leaf_node)set1->index[i]);
92
+ branch->children_size++;
93
+ } else if (set0->index[i]) {
94
+ branch->index[i] = init_and_copy_leaf_node(result_set, (leaf_node)set0->index[i]);
95
+ branch->children_size++;
96
+ } else if (set1->index[i]) {
97
+ branch->index[i] = init_and_copy_leaf_node(result_set, (leaf_node)set1->index[i]);
98
+ branch->children_size++;
92
99
  }
100
+ }
93
101
  }
94
102
 
95
- void *init_and_join_leaf_node(root_node result_set, leaf_node set0, leaf_node set1)
103
+ static leaf_node
104
+ init_and_join_leaf_node(root_node result_set, leaf_node set0, leaf_node set1)
96
105
  {
97
- leaf_node leaf;
106
+ leaf_node leaf;
98
107
 
99
- leaf = (leaf_node)init_leaf_node(set0->offset);
108
+ leaf = (leaf_node)init_leaf_node(set0->offset);
100
109
 
101
- leaf->data = set0->data | set1->data;
102
- result_set->size += BIT_COUNT(leaf->data);
110
+ leaf->data = set0->data | set1->data;
111
+ result_set->size += BIT_COUNT(leaf->data);
103
112
 
104
- return (void*)leaf;
113
+ return leaf;
105
114
  }
data/ext/figure_set/sample.c CHANGED
@@ -9,79 +9,82 @@
9
9
  #include <ruby.h>
10
10
  #include "figure_set.h"
11
11
 
12
- //
13
- // output Array object from sample set
14
- //
15
- void sample(root_node root, VALUE array, unsigned long sample_count)
12
+ static void
13
+ search_and_sample_array_at_leaf(leaf_node leaf, VALUE array)
16
14
  {
17
- unsigned int start_sample, sample_now, i, count, target_point;
15
+ unsigned long i = 0, hit_count = 0;
16
+ unsigned long bit_count, target_point;
17
+ unsigned long x;
18
18
 
19
- start_sample = RARRAY_LEN(array);
19
+ x = leaf->data;
20
+ bit_count = BIT_COUNT(leaf->data);
21
+ if (!bit_count) return;
20
22
 
21
- for(sample_now = start_sample; sample_now < sample_count; sample_now++) {
22
- target_point = rand() % root->children_size;
23
- for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE || count < root->children_size; i++) {
24
- if (root->index[i]) {
25
- if (count == target_point) {
26
- search_and_sample_array((branch_node)root->index[i], array);
27
- }
28
- count++;
29
- }
30
- }
31
- }
32
-
33
- if (RARRAY_LEN(array) < sample_count) {
34
- sample(root, array, sample_count);
35
- }
23
+ target_point = rand() % bit_count;
36
24
 
37
- rb_funcall(array, rb_intern("uniq!"), 0);
38
- if (RARRAY_LEN(array) < sample_count) {
39
- sample(root, array, sample_count);
25
+ while(x) {
26
+ if (x & 1UL) {
27
+ if (hit_count == target_point) {
28
+ rb_ary_push(array, ULONG2NUM(leaf->offset + i));
29
+ }
30
+ hit_count++;
40
31
  }
32
+ x = x >> 1UL;
33
+ i++;
34
+ }
41
35
  }
42
36
 
43
- void search_and_sample_array(branch_node branch, VALUE array)
37
+ static void
38
+ search_and_sample_array(branch_node branch, VALUE array)
44
39
  {
45
- unsigned int i, count, target_point;
40
+ unsigned int i, count, target_point;
46
41
 
47
- if (!branch->children_size) return;
42
+ if (!branch->children_size) return;
48
43
 
49
- target_point = rand() % branch->children_size;
44
+ target_point = rand() % branch->children_size;
50
45
 
51
- for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < branch->children_size; i++) {
52
- if (branch->index[i]) {
53
- if (count == target_point) {
54
- if (branch->children_type == CT_LEAF) {
55
- search_and_sample_array_at_leaf((leaf_node)branch->index[i], array);
56
- } else {
57
- search_and_sample_array((branch_node)branch->index[i], array);
58
- }
59
- }
60
- count++;
46
+ for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_BRANCH || count < branch->children_size; i++) {
47
+ if (branch->index[i]) {
48
+ if (count == target_point) {
49
+ if (branch->children_type == CT_LEAF) {
50
+ search_and_sample_array_at_leaf((leaf_node)branch->index[i], array);
51
+ } else {
52
+ search_and_sample_array((branch_node)branch->index[i], array);
61
53
  }
54
+ }
55
+ count++;
62
56
  }
57
+ }
63
58
  }
64
59
 
65
- void search_and_sample_array_at_leaf(leaf_node leaf, VALUE array)
60
+ //
61
+ // output Array object from sample set
62
+ //
63
+ void
64
+ sample(root_node root, VALUE array, unsigned long sample_count)
66
65
  {
67
- unsigned long i = 0, hit_count = 0;
68
- unsigned long bit_count, target_point;
69
- unsigned long x;
66
+ unsigned int start_sample, sample_now, i, count, target_point;
70
67
 
71
- x = leaf->data;
72
- bit_count = BIT_COUNT(leaf->data);
73
- if (!bit_count) return;
68
+ start_sample = (unsigned int)RARRAY_LEN(array);
74
69
 
75
- target_point = rand() % bit_count;
76
-
77
- while(x) {
78
- if (x & 1UL) {
79
- if (hit_count == target_point) {
80
- rb_ary_push(array, ULONG2NUM(leaf->offset + i));
81
- }
82
- hit_count++;
70
+ for(sample_now = start_sample; sample_now < sample_count; sample_now++) {
71
+ target_point = rand() % root->children_size;
72
+ for(i = 0, count = 0; i < MAX_CHILDREN_SIZE_OF_ROOT_NODE || count < root->children_size; i++) {
73
+ if (root->index[i]) {
74
+ if (count == target_point) {
75
+ search_and_sample_array((branch_node)root->index[i], array);
83
76
  }
84
- x = x >> 1UL;
85
- i++;
77
+ count++;
78
+ }
86
79
  }
80
+ }
81
+
82
+ if ((unsigned int)RARRAY_LEN(array) < sample_count) {
83
+ sample(root, array, sample_count);
84
+ }
85
+
86
+ rb_funcall(array, rb_intern("uniq!"), 0);
87
+ if ((unsigned int)RARRAY_LEN(array) < sample_count) {
88
+ sample(root, array, sample_count);
89
+ }
87
90
  }
data/lib/figure_set/version.rb CHANGED
@@ -1,5 +1,5 @@
1
1
  class FigureSet
2
- VERSION = "1.0.0"
2
+ VERSION = "1.0.1"
3
3
 
4
4
  class << self
5
5
  def version