carray 1.2.0 → 1.3.0

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 (75) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile +0 -1
  3. data/ca_iter_block.c +32 -30
  4. data/ca_iter_dimension.c +24 -22
  5. data/ca_iter_window.c +25 -23
  6. data/ca_obj_array.c +58 -56
  7. data/ca_obj_bitarray.c +27 -27
  8. data/ca_obj_bitfield.c +46 -45
  9. data/ca_obj_block.c +77 -72
  10. data/ca_obj_fake.c +20 -20
  11. data/ca_obj_farray.c +22 -22
  12. data/ca_obj_field.c +31 -30
  13. data/ca_obj_grid.c +63 -62
  14. data/ca_obj_mapping.c +35 -32
  15. data/ca_obj_object.c +54 -54
  16. data/ca_obj_reduce.c +13 -13
  17. data/ca_obj_refer.c +42 -39
  18. data/ca_obj_repeat.c +50 -47
  19. data/ca_obj_select.c +24 -24
  20. data/ca_obj_shift.c +61 -58
  21. data/ca_obj_transpose.c +52 -51
  22. data/ca_obj_unbound_repeat.c +28 -27
  23. data/ca_obj_window.c +77 -72
  24. data/carray.gemspec +0 -2
  25. data/carray.h +190 -163
  26. data/carray_access.c +137 -136
  27. data/carray_attribute.c +24 -13
  28. data/carray_call_cfunc.c +21 -21
  29. data/carray_cast.c +106 -110
  30. data/carray_cast_func.rb +17 -17
  31. data/carray_class.c +3 -3
  32. data/carray_conversion.c +15 -15
  33. data/carray_copy.c +27 -27
  34. data/carray_core.c +22 -21
  35. data/carray_element.c +55 -47
  36. data/carray_generate.c +32 -32
  37. data/carray_iterator.c +36 -35
  38. data/carray_loop.c +37 -37
  39. data/carray_mask.c +21 -21
  40. data/carray_math.rb +18 -18
  41. data/carray_numeric.c +1 -1
  42. data/carray_operator.c +19 -18
  43. data/carray_order.c +30 -30
  44. data/carray_random.c +34 -32
  45. data/carray_sort_addr.c +12 -12
  46. data/carray_stat.c +127 -127
  47. data/carray_stat_proc.rb +152 -141
  48. data/carray_test.c +16 -16
  49. data/carray_utils.c +58 -56
  50. data/ext/calculus/carray_calculus.c +19 -20
  51. data/ext/calculus/carray_interp.c +12 -11
  52. data/ext/fortio/lib/fortio/fortran_sequential.rb +2 -2
  53. data/ext/fortio/ruby_fortio.c +1 -1
  54. data/ext/imagemap/carray_imagemap.c +14 -14
  55. data/ext/narray/ca_wrap_narray.c +30 -21
  56. data/extconf.rb +5 -0
  57. data/lib/carray/base/basic.rb +4 -3
  58. data/lib/carray/base/serialize.rb +3 -3
  59. data/lib/carray/graphics/gnuplot.rb +10 -7
  60. data/lib/carray/io/csv.rb +14 -9
  61. data/lib/carray/io/imagemagick.rb +7 -0
  62. data/lib/carray/io/sqlite3.rb +6 -4
  63. data/mkmath.rb +20 -20
  64. data/ruby_carray.c +2 -0
  65. data/ruby_ccomplex.c +3 -3
  66. data/test/test_130.rb +23 -0
  67. data/test/test_ALL.rb +2 -1
  68. data/test/test_order.rb +3 -3
  69. data/test/test_stat.rb +2 -2
  70. data/version.h +4 -4
  71. metadata +4 -37
  72. data/examples/ex001.rb +0 -10
  73. data/examples/test-int.rb +0 -13
  74. data/lib/carray/autoload/autoload_io_excel.rb +0 -5
  75. data/lib/carray/io/excel.rb +0 -26
data/carray_stat_proc.rb CHANGED
@@ -11,6 +11,17 @@
11
11
  #
12
12
  # ----------------------------------------------------------------------------
13
13
 
14
+ have_type_long_double = false
15
+
16
+ open("carray_config.h") { |io|
17
+ while line = io.gets
18
+ case line
19
+ when /HAVE_TYPE_LONG_DOUBLE *1/
20
+ have_type_long_double = true
21
+ end
22
+ end
23
+ }
24
+
14
25
  def macro_expand (text, values)
15
26
  text = text.clone
16
27
  values.each do |key, val|
@@ -28,7 +39,7 @@ TYPEINFO = {
28
39
  'type2obj' => 'LONG2NUM',
29
40
  'type2dbl' => '(float64_t)',
30
41
  'int2type' => '',
31
- 'atype' => 'double',
42
+ 'atype' => have_type_long_double ? 'long double' : 'double',
32
43
  'azero' => '0.0',
33
44
  'aone' => '1.0',
34
45
  'atype2obj' => 'rb_float_new',
@@ -43,7 +54,7 @@ TYPEINFO = {
43
54
  'type2obj' => 'LONG2NUM',
44
55
  'type2dbl' => '(float64_t)',
45
56
  'int2type' => '',
46
- 'atype' => 'double',
57
+ 'atype' => have_type_long_double ? 'long double' : 'double',
47
58
  'azero' => '0.0',
48
59
  'aone' => '1.0',
49
60
  'atype2obj' => 'rb_float_new',
@@ -58,7 +69,7 @@ TYPEINFO = {
58
69
  'type2obj' => 'ULONG2NUM',
59
70
  'type2dbl' => '(float64_t)',
60
71
  'int2type' => '',
61
- 'atype' => 'double',
72
+ 'atype' => have_type_long_double ? 'long double' : 'double',
62
73
  'azero' => '0.0',
63
74
  'aone' => '1.0',
64
75
  'atype2obj' => 'rb_float_new',
@@ -73,7 +84,7 @@ TYPEINFO = {
73
84
  'type2obj' => 'LONG2NUM',
74
85
  'type2dbl' => '(float64_t)',
75
86
  'int2type' => '',
76
- 'atype' => 'double',
87
+ 'atype' => have_type_long_double ? 'long double' : 'double',
77
88
  'azero' => '0.0',
78
89
  'aone' => '1.0',
79
90
  'atype2obj' => 'rb_float_new',
@@ -88,7 +99,7 @@ TYPEINFO = {
88
99
  'type2obj' => 'ULONG2NUM',
89
100
  'type2dbl' => '(float64_t)',
90
101
  'int2type' => '',
91
- 'atype' => 'double',
102
+ 'atype' => have_type_long_double ? 'long double' : 'double',
92
103
  'azero' => '0.0',
93
104
  'aone' => '1.0',
94
105
  'atype2obj' => 'rb_float_new',
@@ -103,7 +114,7 @@ TYPEINFO = {
103
114
  'type2obj' => 'LONG2NUM',
104
115
  'type2dbl' => '(float64_t)',
105
116
  'int2type' => '',
106
- 'atype' => 'double',
117
+ 'atype' => have_type_long_double ? 'long double' : 'double',
107
118
  'azero' => '0.0',
108
119
  'aone' => '1.0',
109
120
  'atype2obj' => 'rb_float_new',
@@ -118,7 +129,7 @@ TYPEINFO = {
118
129
  'type2obj' => 'ULONG2NUM',
119
130
  'type2dbl' => '(float64_t)',
120
131
  'int2type' => '',
121
- 'atype' => 'double',
132
+ 'atype' => have_type_long_double ? 'long double' : 'double',
122
133
  'azero' => '0.0',
123
134
  'aone' => '1.0',
124
135
  'atype2obj' => 'rb_float_new',
@@ -133,7 +144,7 @@ TYPEINFO = {
133
144
  'type2obj' => 'LL2NUM',
134
145
  'type2dbl' => '(float64_t)',
135
146
  'int2type' => '',
136
- 'atype' => 'double',
147
+ 'atype' => have_type_long_double ? 'long double' : 'double',
137
148
  'azero' => '0.0',
138
149
  'aone' => '1.0',
139
150
  'atype2obj' => 'rb_float_new',
@@ -148,7 +159,7 @@ TYPEINFO = {
148
159
  'type2obj' => 'ULL2NUM',
149
160
  'type2dbl' => '(float64_t)',
150
161
  'int2type' => '',
151
- 'atype' => 'double',
162
+ 'atype' => have_type_long_double ? 'long double' : 'double',
152
163
  'azero' => '0.0',
153
164
  'aone' => '1.0',
154
165
  'atype2obj' => 'rb_float_new',
@@ -163,7 +174,7 @@ TYPEINFO = {
163
174
  'type2obj' => 'rb_float_new',
164
175
  'type2dbl' => '(float64_t)',
165
176
  'int2type' => '',
166
- 'atype' => 'double',
177
+ 'atype' => have_type_long_double ? 'long double' : 'double',
167
178
  'azero' => '0.0',
168
179
  'aone' => '1.0',
169
180
  'atype2obj' => 'rb_float_new',
@@ -178,7 +189,7 @@ TYPEINFO = {
178
189
  'type2obj' => 'rb_float_new',
179
190
  'type2dbl' => '',
180
191
  'int2type' => '',
181
- 'atype' => 'double',
192
+ 'atype' => have_type_long_double ? 'long double' : 'double',
182
193
  'azero' => '0.0',
183
194
  'aone' => '1.0',
184
195
  'atype2obj' => 'rb_float_new',
@@ -193,7 +204,7 @@ TYPEINFO = {
193
204
  'type2obj' => 'rb_float_new',
194
205
  'type2dbl' => '',
195
206
  'int2type' => '',
196
- 'atype' => 'double',
207
+ 'atype' => have_type_long_double ? 'long double' : 'double',
197
208
  'azero' => '0.0',
198
209
  'aone' => '1.0',
199
210
  'atype2obj' => 'rb_float_new',
@@ -247,7 +258,7 @@ TYPEINFO = {
247
258
  },
248
259
  'VALUE' => {
249
260
  'type' => "VALUE",
250
- 'zero' => 'INT2FIX(0)',
261
+ 'zero' => 'INT2NUM(0)',
251
262
  'dat2type' => '',
252
263
  'obj2type' => '',
253
264
  'type2obj' => '',
@@ -289,10 +300,10 @@ header = <<HERE_END
289
300
  #include "carray.h"
290
301
 
291
302
  typedef struct {
292
- int32_t offset;
293
- int32_t count;
294
- int32_t step;
295
- int32_t *addr;
303
+ ca_size_t offset;
304
+ ca_size_t count;
305
+ ca_size_t step;
306
+ ca_size_t *addr;
296
307
  } CAStatIterator;
297
308
 
298
309
  typedef void (*ca_stat_proc_t)();
@@ -363,16 +374,16 @@ text = <<'HERE_END'
363
374
  /* ============================= */
364
375
 
365
376
  static void
366
- ca_proc_prod_<type> (int32_t elements, int32_t min_count,
377
+ ca_proc_prod_<type> (ca_size_t elements, ca_size_t min_count,
367
378
  boolean8_t *m, void *ptr, CAStatIterator *it,
368
379
  int return_object, VALUE *retobj,
369
- boolean8_t *retmask, <atype> *retval)
380
+ boolean8_t *retmask, float64_t *retval)
370
381
  {
371
382
  volatile <atype> prod = <aone>;
372
383
  <type> *p = (<type> *) ptr;
373
- int32_t *a = (int32_t *) it;
374
- int32_t count = 0;
375
- int32_t i;
384
+ ca_size_t *a = (ca_size_t *) it;
385
+ ca_size_t count = 0;
386
+ ca_size_t i;
376
387
  iterator_rewind(it);
377
388
  if ( m ) {
378
389
  for (i=0; i<elements; i++) {
@@ -398,7 +409,7 @@ ca_proc_prod_<type> (int32_t elements, int32_t min_count,
398
409
  if ( retmask ) {
399
410
  *retmask = ( count > min_count ) ? 1 : 0;
400
411
  }
401
- *retval = prod;
412
+ *retval = <type2dbl>(prod);
402
413
  }
403
414
  }
404
415
 
@@ -407,14 +418,14 @@ ca_proc_prod_<type> (int32_t elements, int32_t min_count,
407
418
  /* ============================= */
408
419
 
409
420
  static void
410
- ca_proc_count_<type> (int32_t elements, int32_t min_count,
421
+ ca_proc_count_<type> (ca_size_t elements, ca_size_t min_count,
411
422
  boolean8_t *m, void *ptr, CAStatIterator *it,
412
423
  int return_object, VALUE *retobj,
413
- boolean8_t *retmask, int32_t *retval)
424
+ boolean8_t *retmask, ca_size_t *retval)
414
425
  {
415
- int32_t *a = (int32_t *) it;
416
- int32_t count = 0;
417
- int32_t i;
426
+ ca_size_t *a = (ca_size_t *) it;
427
+ ca_size_t count = 0;
428
+ ca_size_t i;
418
429
  iterator_rewind(it);
419
430
  if ( m ) {
420
431
  for (i=0; i<elements; i++) {
@@ -425,7 +436,7 @@ ca_proc_count_<type> (int32_t elements, int32_t min_count,
425
436
  }
426
437
  }
427
438
  if ( return_object ) {
428
- *retobj = ( count > min_count ) ? CA_UNDEF : LONG2NUM(elements - count);
439
+ *retobj = ( count > min_count ) ? CA_UNDEF : SIZE2NUM(elements - count);
429
440
  }
430
441
  else {
431
442
  if ( retmask ) {
@@ -436,16 +447,16 @@ ca_proc_count_<type> (int32_t elements, int32_t min_count,
436
447
  }
437
448
 
438
449
  static void
439
- ca_proc_sum_<type> (int32_t elements, int32_t min_count,
450
+ ca_proc_sum_<type> (ca_size_t elements, ca_size_t min_count,
440
451
  boolean8_t *m, void *ptr, CAStatIterator *it,
441
452
  int return_object, VALUE *retobj,
442
453
  boolean8_t *retmask, float64_t *retval)
443
454
  {
444
455
  volatile <atype> sum = <azero>;
445
456
  <type> *p = (<type> *) ptr;
446
- int32_t *a = (int32_t *)it;
447
- int32_t count = 0;
448
- int32_t i;
457
+ ca_size_t *a = (ca_size_t *)it;
458
+ ca_size_t count = 0;
459
+ ca_size_t i;
449
460
  iterator_rewind(it);
450
461
  if ( m ) {
451
462
  for (i=0; i<elements; i++) {
@@ -481,16 +492,16 @@ ca_proc_sum_<type> (int32_t elements, int32_t min_count,
481
492
  /* ============================= */
482
493
 
483
494
  static void
484
- ca_proc_mean_<type> (int32_t elements, int32_t min_count,
495
+ ca_proc_mean_<type> (ca_size_t elements, ca_size_t min_count,
485
496
  boolean8_t *m, void *ptr, CAStatIterator *it,
486
497
  int return_object, VALUE *retobj,
487
498
  boolean8_t *retmask, float64_t *retval)
488
499
  {
489
500
  volatile <atype> sum = <azero>, ave;
490
501
  <type> *p = (<type> *) ptr;
491
- int32_t *a = (int32_t *) it;
492
- int32_t count = 0;
493
- int32_t i;
502
+ ca_size_t *a = (ca_size_t *) it;
503
+ ca_size_t count = 0;
504
+ ca_size_t i;
494
505
  iterator_rewind(it);
495
506
  if ( m ) {
496
507
  for (i=0; i<elements; i++) {
@@ -526,16 +537,16 @@ ca_proc_mean_<type> (int32_t elements, int32_t min_count,
526
537
  /* ============================= */
527
538
 
528
539
  static void
529
- ca_proc_variancep_<type> (int32_t elements, int32_t min_count,
540
+ ca_proc_variancep_<type> (ca_size_t elements, ca_size_t min_count,
530
541
  boolean8_t *m, void *ptr, CAStatIterator *it,
531
542
  int return_object, VALUE *retobj,
532
543
  boolean8_t *retmask, float64_t *retval)
533
544
  {
534
545
  volatile <atype> sum = <azero>, sum2 = <azero>, ave, var, diff;
535
546
  <type> *p = (<type> *) ptr;
536
- int32_t *a = (int32_t *) it;
537
- int32_t count = 0;
538
- int32_t i;
547
+ ca_size_t *a = (ca_size_t *) it;
548
+ ca_size_t count = 0;
549
+ ca_size_t i;
539
550
  iterator_rewind(it);
540
551
  if ( m ) {
541
552
  for (i=0; i<elements; i++) {
@@ -595,16 +606,16 @@ ca_proc_variancep_<type> (int32_t elements, int32_t min_count,
595
606
  /* ============================= */
596
607
 
597
608
  static void
598
- ca_proc_stddevp_<type> (int32_t elements, int32_t min_count,
609
+ ca_proc_stddevp_<type> (ca_size_t elements, ca_size_t min_count,
599
610
  boolean8_t *m, void *ptr, CAStatIterator *it,
600
611
  int return_object, VALUE *retobj,
601
612
  boolean8_t *retmask, float64_t *retval)
602
613
  {
603
614
  volatile <atype> sum = <azero>, sum2 = <azero>, ave, var, diff;
604
615
  <type> *p = (<type> *) ptr;
605
- int32_t *a = (int32_t *) it;
606
- int32_t count = 0;
607
- int32_t i;
616
+ ca_size_t *a = (ca_size_t *) it;
617
+ ca_size_t count = 0;
618
+ ca_size_t i;
608
619
  iterator_rewind(it);
609
620
  if ( m ) {
610
621
  for (i=0; i<elements; i++) {
@@ -664,16 +675,16 @@ ca_proc_stddevp_<type> (int32_t elements, int32_t min_count,
664
675
  /* ============================= */
665
676
 
666
677
  static void
667
- ca_proc_variance_<type> (int32_t elements, int32_t min_count,
678
+ ca_proc_variance_<type> (ca_size_t elements, ca_size_t min_count,
668
679
  boolean8_t *m, void *ptr, CAStatIterator *it,
669
680
  int return_object, VALUE *retobj,
670
681
  boolean8_t *retmask, float64_t *retval)
671
682
  {
672
683
  volatile <atype> sum = <azero>, sum2 = <azero>, ave, var, diff;
673
684
  <type> *p = (<type> *) ptr;
674
- int32_t *a = (int32_t *) it;
675
- int32_t count = 0;
676
- int32_t i;
685
+ ca_size_t *a = (ca_size_t *) it;
686
+ ca_size_t count = 0;
687
+ ca_size_t i;
677
688
  iterator_rewind(it);
678
689
  if ( m ) {
679
690
  for (i=0; i<elements; i++) {
@@ -733,16 +744,16 @@ ca_proc_variance_<type> (int32_t elements, int32_t min_count,
733
744
  /* ============================= */
734
745
 
735
746
  static void
736
- ca_proc_stddev_<type> (int32_t elements, int32_t min_count,
747
+ ca_proc_stddev_<type> (ca_size_t elements, ca_size_t min_count,
737
748
  boolean8_t *m, void *ptr, CAStatIterator *it,
738
749
  int return_object, VALUE *retobj,
739
750
  boolean8_t *retmask, <atype> *retval)
740
751
  {
741
752
  volatile <atype> sum = <azero>, sum2 = <azero>, ave, var, diff;
742
753
  <type> *p = (<type> *) ptr;
743
- int32_t *a = (int32_t *) it;
744
- int32_t count = 0;
745
- int32_t i;
754
+ ca_size_t *a = (ca_size_t *) it;
755
+ ca_size_t count = 0;
756
+ ca_size_t i;
746
757
  iterator_rewind(it);
747
758
  if ( m ) {
748
759
  for (i=0; i<elements; i++) {
@@ -802,17 +813,17 @@ ca_proc_stddev_<type> (int32_t elements, int32_t min_count,
802
813
  /* ============================= */
803
814
 
804
815
  static void
805
- ca_proc_min_<type> (int32_t elements, int32_t min_count,
816
+ ca_proc_min_<type> (ca_size_t elements, ca_size_t min_count,
806
817
  boolean8_t *m, void *ptr, CAStatIterator *it,
807
818
  int return_object, VALUE *retobj,
808
819
  boolean8_t *retmask, <type> *retval)
809
820
  {
810
821
  <type> min = <zero>;
811
822
  <type> *p = (<type> *) ptr;
812
- int32_t *a = (int32_t *) it;
813
- int32_t count = 0;
814
- int32_t addr;
815
- int32_t i;
823
+ ca_size_t *a = (ca_size_t *) it;
824
+ ca_size_t count = 0;
825
+ ca_size_t addr;
826
+ ca_size_t i;
816
827
  iterator_rewind(it);
817
828
  if ( m ) {
818
829
  addr = -1;
@@ -870,17 +881,17 @@ ca_proc_min_<type> (int32_t elements, int32_t min_count,
870
881
  /* ============================= */
871
882
 
872
883
  static void
873
- ca_proc_min_addr_<type> (int32_t elements, int32_t min_count,
884
+ ca_proc_min_addr_<type> (ca_size_t elements, ca_size_t min_count,
874
885
  boolean8_t *m, void *ptr, CAStatIterator *it,
875
886
  int return_object, VALUE *retobj,
876
- boolean8_t *retmask, int32_t *retval)
887
+ boolean8_t *retmask, ca_size_t *retval)
877
888
  {
878
889
  <type> min = <zero>;
879
890
  <type> *p = (<type> *) ptr;
880
- int32_t *a = (int32_t *) it;
881
- int32_t count = 0;
882
- int32_t addr;
883
- int32_t i;
891
+ ca_size_t *a = (ca_size_t *) it;
892
+ ca_size_t count = 0;
893
+ ca_size_t addr;
894
+ ca_size_t i;
884
895
  iterator_rewind(it);
885
896
  if ( m ) {
886
897
  addr = -1;
@@ -924,7 +935,7 @@ ca_proc_min_addr_<type> (int32_t elements, int32_t min_count,
924
935
  }
925
936
  if ( return_object ) {
926
937
  *retobj = ( count > min_count ) ? CA_UNDEF
927
- : ( addr < 0 ) ? Qnil : LONG2NUM(addr);
938
+ : ( addr < 0 ) ? Qnil : SIZE2NUM(addr);
928
939
  }
929
940
  else {
930
941
  if ( retmask ) {
@@ -939,17 +950,17 @@ ca_proc_min_addr_<type> (int32_t elements, int32_t min_count,
939
950
  /* ============================= */
940
951
 
941
952
  static void
942
- ca_proc_max_<type> (int32_t elements, int32_t min_count,
953
+ ca_proc_max_<type> (ca_size_t elements, ca_size_t min_count,
943
954
  boolean8_t *m, void *ptr, CAStatIterator *it,
944
955
  int return_object, VALUE *retobj,
945
956
  boolean8_t *retmask, <type> *retval)
946
957
  {
947
958
  <type> max = 0;
948
959
  <type> *p = (<type> *) ptr;
949
- int32_t *a = (int32_t *) it;
950
- int32_t count = 0;
951
- int32_t addr;
952
- int32_t i;
960
+ ca_size_t *a = (ca_size_t *) it;
961
+ ca_size_t count = 0;
962
+ ca_size_t addr;
963
+ ca_size_t i;
953
964
  iterator_rewind(it);
954
965
  if ( m ) {
955
966
  addr = -1;
@@ -1007,17 +1018,17 @@ ca_proc_max_<type> (int32_t elements, int32_t min_count,
1007
1018
  /* ============================= */
1008
1019
 
1009
1020
  static void
1010
- ca_proc_max_addr_<type> (int32_t elements, int32_t min_count,
1021
+ ca_proc_max_addr_<type> (ca_size_t elements, ca_size_t min_count,
1011
1022
  boolean8_t *m, void *ptr, CAStatIterator *it,
1012
1023
  int return_object, VALUE *retobj,
1013
- boolean8_t *retmask, int32_t *retval)
1024
+ boolean8_t *retmask, ca_size_t *retval)
1014
1025
  {
1015
1026
  <type> max = 0;
1016
1027
  <type> *p = (<type> *) ptr;
1017
- int32_t *a = (int32_t *) it;
1018
- int32_t count = 0;
1019
- int32_t addr;
1020
- int32_t i;
1028
+ ca_size_t *a = (ca_size_t *) it;
1029
+ ca_size_t count = 0;
1030
+ ca_size_t addr;
1031
+ ca_size_t i;
1021
1032
  iterator_rewind(it);
1022
1033
  if ( m ) {
1023
1034
  addr = -1;
@@ -1061,7 +1072,7 @@ ca_proc_max_addr_<type> (int32_t elements, int32_t min_count,
1061
1072
  }
1062
1073
  if ( return_object ) {
1063
1074
  *retobj = ( count > min_count ) ? CA_UNDEF
1064
- : ( addr < 0 ) ? Qnil : LONG2NUM(addr);
1075
+ : ( addr < 0 ) ? Qnil : SIZE2NUM(addr);
1065
1076
  }
1066
1077
  else {
1067
1078
  if ( retmask ) {
@@ -1077,13 +1088,13 @@ ca_proc_max_addr_<type> (int32_t elements, int32_t min_count,
1077
1088
  /* ============================= */
1078
1089
 
1079
1090
  static void
1080
- ca_proc_cumcount_<type> (int32_t elements, int32_t min_count,
1091
+ ca_proc_cumcount_<type> (ca_size_t elements, ca_size_t min_count,
1081
1092
  boolean8_t *m, void *ptr, CAStatIterator *it,
1082
- boolean8_t *retmask, int32_t *retval)
1093
+ boolean8_t *retmask, ca_size_t *retval)
1083
1094
  {
1084
- int32_t *a = (int32_t *) it;
1085
- int32_t count = 0;
1086
- int32_t i;
1095
+ ca_size_t *a = (ca_size_t *) it;
1096
+ ca_size_t count = 0;
1097
+ ca_size_t i;
1087
1098
  iterator_rewind(it);
1088
1099
  if ( m ) {
1089
1100
  for (i=0; i<elements; i++) {
@@ -1117,15 +1128,15 @@ ca_proc_cumcount_<type> (int32_t elements, int32_t min_count,
1117
1128
  /* ============================= */
1118
1129
 
1119
1130
  static void
1120
- ca_proc_cumsum_<type> (int32_t elements, int32_t min_count,
1131
+ ca_proc_cumsum_<type> (ca_size_t elements, ca_size_t min_count,
1121
1132
  boolean8_t *m, void *ptr, CAStatIterator *it,
1122
1133
  boolean8_t *retmask, float64_t *retval)
1123
1134
  {
1124
1135
  volatile <atype> sum = <azero>;
1125
1136
  <type> *p = (<type> *) ptr;
1126
- int32_t *a = (int32_t *) it;
1127
- int32_t count = 0;
1128
- int32_t i;
1137
+ ca_size_t *a = (ca_size_t *) it;
1138
+ ca_size_t count = 0;
1139
+ ca_size_t i;
1129
1140
  iterator_rewind(it);
1130
1141
  if ( m ) {
1131
1142
  for (i=0; i<elements; i++) {
@@ -1230,16 +1241,16 @@ text = <<'HERE_END'
1230
1241
  /* ============================= */
1231
1242
 
1232
1243
  static void
1233
- ca_proc_accum_<type> (int32_t elements, int32_t min_count,
1244
+ ca_proc_accum_<type> (ca_size_t elements, ca_size_t min_count,
1234
1245
  boolean8_t *m, void *ptr, CAStatIterator *it,
1235
1246
  int return_object, VALUE *retobj,
1236
1247
  boolean8_t *retmask, <type> *retval)
1237
1248
  {
1238
1249
  <type> sum = <zero>;
1239
1250
  <type> *p = (<type> *) ptr;
1240
- int32_t *a = (int32_t *) it;
1241
- int32_t count = 0;
1242
- int32_t i;
1251
+ ca_size_t *a = (ca_size_t *) it;
1252
+ ca_size_t count = 0;
1253
+ ca_size_t i;
1243
1254
  iterator_rewind(it);
1244
1255
  if ( m ) {
1245
1256
  for (i=0; i<elements; i++) {
@@ -1332,7 +1343,7 @@ rb_ca_stat_1d (VALUE self, VALUE rmc, VALUE vfval,
1332
1343
  CArray *ca;
1333
1344
  CAStatIterator it;
1334
1345
  boolean8_t *m;
1335
- int32_t mc;
1346
+ ca_size_t mc;
1336
1347
 
1337
1348
  Data_Get_Struct(self, CArray, ca);
1338
1349
 
@@ -1348,7 +1359,7 @@ rb_ca_stat_1d (VALUE self, VALUE rmc, VALUE vfval,
1348
1359
  else {
1349
1360
  ca_attach(ca);
1350
1361
  m = ( ca->mask ) ? (boolean8_t *)ca->mask->ptr : NULL;
1351
- mc = ( ( ! ca_has_mask(ca) ) || NIL_P(rmc)) ? ca->elements - 1 : NUM2LONG(rmc);
1362
+ mc = ( ( ! ca_has_mask(ca) ) || NIL_P(rmc)) ? ca->elements - 1 : NUM2SIZE(rmc);
1352
1363
  if ( mc < 0 ) {
1353
1364
  mc += ca->elements;
1354
1365
  }
@@ -1365,13 +1376,13 @@ rb_ca_stat_1d (VALUE self, VALUE rmc, VALUE vfval,
1365
1376
  }
1366
1377
 
1367
1378
  static void
1368
- ca_stat_nd_contig_loop (CArray *ca, CArray *co, int32_t mc,
1379
+ ca_stat_nd_contig_loop (CArray *ca, CArray *co, ca_size_t mc,
1369
1380
  ca_stat_proc_t *ca_proc,
1370
- int level, int32_t *idx, char **op, boolean8_t **om)
1381
+ int level, ca_size_t *idx, char **op, boolean8_t **om)
1371
1382
  {
1372
1383
  void *p;
1373
1384
  boolean8_t *m;
1374
- int32_t i, n;
1385
+ ca_size_t i, n;
1375
1386
  if ( level == co->rank ) {
1376
1387
  CAStatIterator it;
1377
1388
  n = ca->elements/co->elements;
@@ -1400,7 +1411,7 @@ rb_ca_stat_nd_contig (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1400
1411
  {
1401
1412
  volatile VALUE out;
1402
1413
  CArray *ca, *co;
1403
- int32_t mc, ndim;
1414
+ ca_size_t mc, ndim;
1404
1415
 
1405
1416
  Data_Get_Struct(self, CArray, ca);
1406
1417
 
@@ -1426,7 +1437,7 @@ rb_ca_stat_nd_contig (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1426
1437
  mc = ca->elements/co->elements - 1;
1427
1438
  }
1428
1439
  else {
1429
- mc = NUM2LONG(rmc);
1440
+ mc = NUM2SIZE(rmc);
1430
1441
  }
1431
1442
 
1432
1443
  if ( mc < 0 ) {
@@ -1434,10 +1445,10 @@ rb_ca_stat_nd_contig (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1434
1445
  }
1435
1446
 
1436
1447
  {
1437
- int32_t idx[CA_RANK_MAX];
1448
+ ca_size_t idx[CA_RANK_MAX];
1438
1449
  char *op;
1439
1450
  boolean8_t *om;
1440
- int32_t i;
1451
+ int8_t i;
1441
1452
  for (i=0; i<ca->rank; i++) {
1442
1453
  idx[i] = 0;
1443
1454
  }
@@ -1457,22 +1468,22 @@ rb_ca_stat_nd_contig (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1457
1468
  }
1458
1469
 
1459
1470
  static void
1460
- ca_stat_get_offset_loop (CArray *ca, int32_t *dm,
1461
- int level, int32_t *idx,
1462
- int level1, int32_t *idx1,
1471
+ ca_stat_get_offset_loop (CArray *ca, ca_size_t *dm,
1472
+ int level, ca_size_t *idx,
1473
+ int level1, ca_size_t *idx1,
1463
1474
  CArray *offset)
1464
1475
  {
1465
- int32_t i;
1476
+ ca_size_t i;
1466
1477
  if ( level == ca->rank - 1 ) {
1467
1478
  if ( dm[level] == 0 ) {
1468
1479
  idx[level] = 0;
1469
- *(int32_t *)ca_ptr_at_index(offset, idx1) = ca_index2addr(ca, idx);
1480
+ *(ca_size_t *)ca_ptr_at_index(offset, idx1) = ca_index2addr(ca, idx);
1470
1481
  }
1471
1482
  else {
1472
1483
  for (i=0; i<ca->dim[level]; i++) {
1473
1484
  idx[level] = i;
1474
1485
  idx1[level1] = i;
1475
- *(int32_t *)ca_ptr_at_index(offset, idx1) = ca_index2addr(ca, idx);
1486
+ *(ca_size_t *)ca_ptr_at_index(offset, idx1) = ca_index2addr(ca, idx);
1476
1487
  }
1477
1488
  }
1478
1489
  }
@@ -1496,15 +1507,15 @@ rb_ca_stat_nd_discrete (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1496
1507
  int8_t data_type, ca_stat_proc_t *ca_proc)
1497
1508
  {
1498
1509
  volatile VALUE out;
1499
- int32_t idx[CA_RANK_MAX];
1500
- int32_t idx1[CA_RANK_MAX];
1501
- int32_t out_dim[CA_RANK_MAX];
1502
- int32_t loop_dim[CA_RANK_MAX];
1503
- int32_t dm[CA_RANK_MAX], dn[CA_RANK_MAX];
1510
+ ca_size_t idx[CA_RANK_MAX];
1511
+ ca_size_t idx1[CA_RANK_MAX];
1512
+ ca_size_t out_dim[CA_RANK_MAX];
1513
+ ca_size_t loop_dim[CA_RANK_MAX];
1514
+ ca_size_t dm[CA_RANK_MAX], dn[CA_RANK_MAX];
1504
1515
  CArray *ca, *co, *first, *offset;
1505
- int32_t out_rank, loop_rank;
1506
- int32_t mc;
1507
- int32_t i, k;
1516
+ ca_size_t out_rank, loop_rank;
1517
+ ca_size_t mc;
1518
+ ca_size_t i, k;
1508
1519
 
1509
1520
  Data_Get_Struct(self, CArray, ca);
1510
1521
 
@@ -1514,7 +1525,7 @@ rb_ca_stat_nd_discrete (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1514
1525
  }
1515
1526
 
1516
1527
  for (i=0; i<RARRAY_LEN(vaxis); i++) {
1517
- k = NUM2INT(rb_ary_entry(vaxis, i));
1528
+ k = NUM2SIZE(rb_ary_entry(vaxis, i));
1518
1529
  dm[k] = 1;
1519
1530
  dn[k] = 0;
1520
1531
  }
@@ -1535,10 +1546,10 @@ rb_ca_stat_nd_discrete (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1535
1546
  out = rb_carray_new(data_type, out_rank, out_dim, 0, NULL);
1536
1547
  Data_Get_Struct(out, CArray, co);
1537
1548
 
1538
- first = carray_new(CA_INT32, out_rank, out_dim, 0, NULL);
1549
+ first = carray_new(CA_SIZE, out_rank, out_dim, 0, NULL);
1539
1550
  first->ptr = realloc(first->ptr, first->bytes*(first->elements+1));
1540
1551
 
1541
- offset = carray_new(CA_INT32, loop_rank, loop_dim, 0, NULL);
1552
+ offset = carray_new(CA_SIZE, loop_rank, loop_dim, 0, NULL);
1542
1553
  offset->ptr = realloc(offset->ptr, offset->bytes*(offset->elements+1));
1543
1554
 
1544
1555
  ca_stat_get_offset_loop(ca, dn, 0, idx, 0, idx1, first);
@@ -1552,7 +1563,7 @@ rb_ca_stat_nd_discrete (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1552
1563
  mc = offset->elements - 1;
1553
1564
  }
1554
1565
  else {
1555
- mc = NUM2LONG(rmc);
1566
+ mc = NUM2SIZE(rmc);
1556
1567
  }
1557
1568
 
1558
1569
  if ( mc < 0 ) {
@@ -1563,14 +1574,14 @@ rb_ca_stat_nd_discrete (VALUE self, VALUE vaxis, VALUE rmc, VALUE vfval,
1563
1574
 
1564
1575
  {
1565
1576
  CAStatIterator it, jt;
1566
- int32_t *a = (int32_t *) (&it);
1577
+ ca_size_t *a = (ca_size_t *) (&it);
1567
1578
  boolean8_t *m0, *m, *om;
1568
1579
  char *p, *op;
1569
1580
 
1570
1581
  it.step = 1;
1571
- it.addr = (int32_t *)first->ptr;
1582
+ it.addr = (ca_size_t *)first->ptr;
1572
1583
  jt.step = 1;
1573
- jt.addr = (int32_t *)offset->ptr;
1584
+ jt.addr = (ca_size_t *)offset->ptr;
1574
1585
 
1575
1586
  m0 = ( ca->mask && ca->mask->ptr ) ? (boolean8_t *)ca->mask->ptr : NULL;
1576
1587
  om = ( co->mask && co->mask->ptr ) ? (boolean8_t *)co->mask->ptr : NULL;
@@ -1622,21 +1633,21 @@ rb_ca_stat_general (int argc, VALUE *argv, VALUE self,
1622
1633
  "don't specify mask_limit and min_count simaltaniously");
1623
1634
  }
1624
1635
  else if ( ! NIL_P(rmin_count) ) {
1625
- int min_count = NUM2LONG(rmin_count);
1636
+ ca_size_t min_count = NUM2SIZE(rmin_count);
1626
1637
  if ( min_count == 0 ) {
1627
1638
  rmc = Qnil;
1628
1639
  }
1629
1640
  else {
1630
- rmc = LONG2NUM(-min_count);
1641
+ rmc = SIZE2NUM(-min_count);
1631
1642
  }
1632
1643
  }
1633
1644
  else if ( ! NIL_P(rmask_limit) ) {
1634
- int mask_limit = NUM2LONG(rmask_limit);
1645
+ ca_size_t mask_limit = NUM2SIZE(rmask_limit);
1635
1646
  if ( mask_limit == 0 ) {
1636
1647
  rmc = Qnil;
1637
1648
  }
1638
1649
  else {
1639
- rmc = LONG2NUM(mask_limit-1);
1650
+ rmc = SIZE2NUM(mask_limit-1);
1640
1651
  }
1641
1652
  }
1642
1653
  else {
@@ -1655,13 +1666,13 @@ rb_ca_stat_general (int argc, VALUE *argv, VALUE self,
1655
1666
  }
1656
1667
  else {
1657
1668
  int is_contig = 1;
1658
- int i, k;
1669
+ ca_size_t i, k;
1659
1670
 
1660
1671
  vaxis = rb_funcall(vaxis, rb_intern("sort"), 0);
1661
1672
  vaxis = rb_funcall(vaxis, rb_intern("uniq"), 0);
1662
1673
 
1663
1674
  for (i=0; i<RARRAY_LEN(vaxis); i++) {
1664
- k = NUM2INT(rb_ary_entry(vaxis, RARRAY_LEN(vaxis)-1-i));
1675
+ k = NUM2SIZE(rb_ary_entry(vaxis, RARRAY_LEN(vaxis)-1-i));
1665
1676
  CA_CHECK_INDEX(k, ca->rank);
1666
1677
  if ( k != ca->rank-1-i ) {
1667
1678
  is_contig = 0;
@@ -1773,11 +1784,11 @@ static VALUE
1773
1784
  rb_ca_stat_type2 (int argc, VALUE *argv, VALUE self,
1774
1785
  int8_t data_type, ca_stat_proc_t *ca_proc)
1775
1786
  {
1776
- VALUE out, rmc, rfval;
1787
+ volatile VALUE out, rmc, rfval;
1777
1788
  CArray *ca, *co;
1778
- int32_t mc;
1789
+ ca_size_t mc;
1779
1790
 
1780
- rb_scan_args(argc, argv, "02", &rmc, &rfval);
1791
+ rb_scan_args(argc, argv, "02", (VALUE *) &rmc, (VALUE *) &rfval);
1781
1792
 
1782
1793
  Data_Get_Struct(self, CArray, ca);
1783
1794
 
@@ -1801,7 +1812,7 @@ rb_ca_stat_type2 (int argc, VALUE *argv, VALUE self,
1801
1812
  if ( ca->mask ) {
1802
1813
  m = (boolean8_t *)ca->mask->ptr;
1803
1814
  }
1804
- mc = ( (! ca->mask) || NIL_P(rmc) ) ? ca->elements - 1 : NUM2LONG(rmc);
1815
+ mc = ( (! ca->mask) || NIL_P(rmc) ) ? ca->elements - 1 : NUM2SIZE(rmc);
1805
1816
  if ( mc < 0 ) {
1806
1817
  mc += ca->elements;
1807
1818
  }
@@ -1823,13 +1834,13 @@ rb_ca_stat_type2 (int argc, VALUE *argv, VALUE self,
1823
1834
  }
1824
1835
 
1825
1836
  static void
1826
- ca_dimstat_type2_loop (CArray *ca, CArray *co, int32_t mc,
1837
+ ca_dimstat_type2_loop (CArray *ca, CArray *co, ca_size_t mc,
1827
1838
  ca_stat_proc_t *ca_proc,
1828
- int level, int32_t *idx, char **op, boolean8_t **om)
1839
+ int level, ca_size_t *idx, char **op, boolean8_t **om)
1829
1840
  {
1830
1841
  void *p;
1831
1842
  boolean8_t *m;
1832
- int32_t i, n;
1843
+ ca_size_t i, n;
1833
1844
  if ( level == co->rank ) {
1834
1845
  CAStatIterator it;
1835
1846
  n = ca->elements/co->elements;
@@ -1854,12 +1865,12 @@ ca_dimstat_type2_loop (CArray *ca, CArray *co, int32_t mc,
1854
1865
  }
1855
1866
 
1856
1867
  static void
1857
- ca_dimstat_type2 (CArray *ca, CArray *co, int32_t mc, ca_stat_proc_t *ca_proc)
1868
+ ca_dimstat_type2 (CArray *ca, CArray *co, ca_size_t mc, ca_stat_proc_t *ca_proc)
1858
1869
  {
1859
- int32_t idx[CA_RANK_MAX];
1870
+ ca_size_t idx[CA_RANK_MAX];
1860
1871
  char *op;
1861
1872
  boolean8_t *om;
1862
- int32_t i;
1873
+ int8_t i;
1863
1874
  for (i=0; i<ca->rank; i++) {
1864
1875
  idx[i] = 0;
1865
1876
  }
@@ -1878,11 +1889,11 @@ rb_ca_dimstat_type2 (int argc, VALUE *argv, VALUE self,
1878
1889
  volatile VALUE rndim, rmc, rfval;
1879
1890
  volatile VALUE out;
1880
1891
  CArray *ca, *co;
1881
- int32_t odim[CA_RANK_MAX], n;
1882
- int32_t mc, ndim;
1892
+ ca_size_t odim[CA_RANK_MAX], n;
1893
+ ca_size_t mc, ndim;
1883
1894
  int32_t i;
1884
1895
 
1885
- rb_scan_args(argc, argv, "12", &rndim, &rmc, &rfval);
1896
+ rb_scan_args(argc, argv, "12", (VALUE *) &rndim, (VALUE *) &rmc, (VALUE *) &rfval);
1886
1897
 
1887
1898
  Data_Get_Struct(self, CArray, ca);
1888
1899
 
@@ -1892,7 +1903,7 @@ rb_ca_dimstat_type2 (int argc, VALUE *argv, VALUE self,
1892
1903
  ca_type_name[ca->data_type]);
1893
1904
  }
1894
1905
 
1895
- ndim = NUM2INT(rndim);
1906
+ ndim = NUM2SIZE(rndim);
1896
1907
  if ( ndim <= 0 || ndim > ca->rank ) {
1897
1908
  rb_raise(rb_eRuntimeError, "invalid dimension specified");
1898
1909
  }
@@ -1915,7 +1926,7 @@ rb_ca_dimstat_type2 (int argc, VALUE *argv, VALUE self,
1915
1926
  mc = ca->elements/co->elements - 1;
1916
1927
  }
1917
1928
  else {
1918
- mc = NUM2LONG(rmc);
1929
+ mc = NUM2SIZE(rmc);
1919
1930
  }
1920
1931
 
1921
1932
  if ( mc < 0 ) {