carray 1.2.0 → 1.3.0

data/carray_mask.c

@@ -39,7 +39,7 @@ ca_has_mask (void *ap)
   else if ( ca_is_caobject(ca) ) { /* CAObject */
     CAObject *co = (CAObject *) ca;
     if ( rb_obj_respond_to(co->self, rb_intern("mask_created?"), Qtrue) ) {
-      return rb_funcall(co->self, rb_intern("mask_created?"), 0);
+      return RTEST(rb_funcall(co->self, rb_intern("mask_created?"), 0));
     }
     return ( ca->mask != NULL ) ? 1 : 0;
   }
@@ -60,7 +60,7 @@ ca_is_any_masked (void *ap)
 {
   CArray *ca = (CArray *) ap;
   boolean8_t *m;
-  int32_t i;
+  ca_size_t i;
   int flag = 0;
 
   ca_update_mask(ca);
@@ -84,7 +84,7 @@ ca_is_all_masked (void *ap)
 {
   CArray *ca = (CArray *) ap;
   boolean8_t *m;
-  int32_t i;
+  ca_size_t i;
   int flag;
 
   ca_update_mask(ca);
@@ -177,20 +177,20 @@ ca_setup_mask (void *ap, CArray *mask)
 }
 
 /*
-  ca_copy_mask_overlay_n (void *ap, int32_t elements, int n, CArray **slist)
+  ca_copy_mask_overlay_n (void *ap, ca_size_t elements, int n, CArray **slist)
 
   + slist[i] can be NULL (simply skipped)
 
  */
 
 void
-ca_copy_mask_overlay_n (void *ap, int32_t elements, int n, CArray **slist)
+ca_copy_mask_overlay_n (void *ap, ca_size_t elements, int n, CArray **slist)
 {
   CArray *ca = (CArray *) ap;
   CArray *cs;
   boolean8_t *ma, *ms;
   int i, some_has_mask = 0;
-  int32_t j;
+  ca_size_t j;
 
   for (i=0; i<n; i++) {
     if ( slist[i] && ca_has_mask(slist[i]) ) {
@@ -247,7 +247,7 @@ ca_copy_mask_overlay_n (void *ap, int32_t elements, int n, CArray **slist)
 }
 
 void
-ca_copy_mask_overlay (void *ap, int32_t elements, int n, ...)
+ca_copy_mask_overlay (void *ap, ca_size_t elements, int n, ...)
 {
   CArray *ca = (CArray *) ap;
   CArray **slist;
@@ -267,7 +267,7 @@ ca_copy_mask_overlay (void *ap, int32_t elements, int n, ...)
 }
 
 void
-ca_copy_mask_overwrite_n (void *ap, int32_t elements, int n, CArray **slist)
+ca_copy_mask_overwrite_n (void *ap, ca_size_t elements, int n, CArray **slist)
 {
   CArray *ca = (CArray *) ap;
 
@@ -281,7 +281,7 @@ ca_copy_mask_overwrite_n (void *ap, int32_t elements, int n, CArray **slist)
 }
 
 void
-ca_copy_mask_overwrite (void *ap, int32_t elements, int n, ...)
+ca_copy_mask_overwrite (void *ap, ca_size_t elements, int n, ...)
 {
   CArray *ca = (CArray *) ap;
   CArray **slist;
@@ -315,12 +315,12 @@ ca_copy_mask (void *ap, void *ao)
   ca_copy_mask_overlay(ca, ca->elements, 1, co);
 }
 
-int32_t
+ca_size_t
 ca_count_masked (void *ap)
 {
   CArray *ca = (CArray *) ap;
   boolean8_t *m;
-  int32_t i, count = 0;
+  ca_size_t i, count = 0;
 
   ca_update_mask(ca);
 
@@ -338,7 +338,7 @@ ca_count_masked (void *ap)
   return count;
 }
 
-int32_t
+ca_size_t
 ca_count_not_masked (void *ap)
 {
   CArray *ca = (CArray *) ap;
@@ -347,7 +347,7 @@ ca_count_not_masked (void *ap)
 
 #define proc_fill_bang(type)                    \
   {                                             \
-    int32_t i;                                  \
+    ca_size_t i;                                  \
     type *p = (type *)ca->ptr;                  \
     type  v = *(type *)fill_value;              \
     boolean8_t *m = (boolean8_t *) ca->mask->ptr; \
@@ -362,7 +362,7 @@ ca_count_not_masked (void *ap)
 
 #define proc_fill_bang_fixlen()                 \
   {                                             \
-    int32_t i;                                  \
+    ca_size_t i;                                  \
     char *p = ca->ptr;                          \
     boolean8_t *m = (boolean8_t *) ca->mask->ptr; \
     for (i=0; i<ca->elements; i++) {            \
@@ -424,7 +424,7 @@ ca_unmask_copy (void *ap, char *fill_value)
   CArray *co;
   char *p, *q;
   boolean8_t *m;
-  int32_t i;
+  ca_size_t i;
 
   co = ca_template(ca);
   ca_copy_data(ca, co->ptr);
@@ -451,7 +451,7 @@ ca_invert_mask (void *ap)
 {
   CArray *ca = (CArray *) ap;
   boolean8_t *m;
-  int32_t i;
+  ca_size_t i;
 
   ca_update_mask(ca);
 
@@ -475,7 +475,7 @@ ca_allocate_mask_iterator_n (int n, CArray **slist)
 {
   boolean8_t *m, *mp, *ms;
   CArray *cs;
-  int32_t j, elements = -1;
+  ca_size_t j, elements = -1;
   int i, some_has_mask = 0;
 
   for (i=0; i<n; i++) {
@@ -771,7 +771,7 @@ rb_ca_is_masked (VALUE self)
   CArray *ca, *cm, *co;
   boolean8_t zero = 0;
   boolean8_t *m, *p;
-  int32_t i;
+  ca_size_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -814,7 +814,7 @@ rb_ca_is_not_masked (VALUE self)
   CArray *ca, *cm, *co;
   boolean8_t one = 1;
   boolean8_t *m, *p;
-  int32_t i;
+  ca_size_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -853,7 +853,7 @@ rb_ca_count_masked (VALUE self)
 {
   CArray *ca;
   Data_Get_Struct(self, CArray, ca);
-  return INT2NUM(ca_count_masked(ca));
+  return SIZE2NUM(ca_count_masked(ca));
 }
 
 /* rdoc:
@@ -869,7 +869,7 @@ rb_ca_count_not_masked (VALUE self)
 {
   CArray *ca;
   Data_Get_Struct(self, CArray, ca);
-  return INT2NUM(ca_count_not_masked(ca));
+  return SIZE2NUM(ca_count_not_masked(ca));
 }
 
 static VALUE

data/carray_math.rb

@@ -148,7 +148,7 @@ monfunc("rcp", "rcp",
       INT_TYPES => "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);",
       FLOAT_TYPES => "(#2) = 1/(#1);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#2) = 1/(#1);" : nil,
-      OBJ_TYPES => '(#2) = rb_funcall(INT2FIX(1), id_slash, 1, (#1));')
+      OBJ_TYPES => '(#2) = rb_funcall(INT2NUM(1), id_slash, 1, (#1));')
 monfunc("sqrt", "sqrt",
       FLOAT_TYPES => "(#2) = sqrt(#1);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#2) = csqrt(#1);" : nil,
@@ -283,10 +283,10 @@ static VALUE
 rb_ca_bit_and (VALUE self, VALUE other)
 {
   if ( rb_ca_is_boolean_type(self) ) {
-    return rb_ca_bit_and_i(self, rb_ca_wrap_readonly(other, INT2FIX(CA_BOOLEAN)));
+    return rb_ca_bit_and_i(self, rb_ca_wrap_readonly(other, INT2NUM(CA_BOOLEAN)));
   }
   else if ( rb_obj_is_carray(other) && rb_ca_is_boolean_type(other) ) {
-    return rb_ca_bit_and_i(rb_ca_wrap_readonly(self, INT2FIX(CA_BOOLEAN)), other);
+    return rb_ca_bit_and_i(rb_ca_wrap_readonly(self, INT2NUM(CA_BOOLEAN)), other);
   }
   else {
     return rb_ca_bit_and_i(self, other);
@@ -297,10 +297,10 @@ static VALUE
 rb_ca_bit_or (VALUE self, VALUE other)
 {
   if ( rb_ca_is_boolean_type(self) ) {
-    return rb_ca_bit_or_i(self, rb_ca_wrap_readonly(other, INT2FIX(CA_BOOLEAN)));
+    return rb_ca_bit_or_i(self, rb_ca_wrap_readonly(other, INT2NUM(CA_BOOLEAN)));
   }
   else if ( rb_obj_is_carray(other) && rb_ca_is_boolean_type(other) ) {
-    return rb_ca_bit_or_i(rb_ca_wrap_readonly(self, INT2FIX(CA_BOOLEAN)), other);
+    return rb_ca_bit_or_i(rb_ca_wrap_readonly(self, INT2NUM(CA_BOOLEAN)), other);
   }
   else {
     return rb_ca_bit_or_i(self, other);
@@ -311,10 +311,10 @@ static VALUE
 rb_ca_bit_xor (VALUE self, VALUE other)
 {
   if ( rb_ca_is_boolean_type(self) ) {
-    return rb_ca_bit_xor_i(self, rb_ca_wrap_readonly(other, INT2FIX(CA_BOOLEAN)));
+    return rb_ca_bit_xor_i(self, rb_ca_wrap_readonly(other, INT2NUM(CA_BOOLEAN)));
   }
   else if ( rb_obj_is_carray(other) && rb_ca_is_boolean_type(other) ) {
-    return rb_ca_bit_xor_i(rb_ca_wrap_readonly(self, INT2FIX(CA_BOOLEAN)), other);
+    return rb_ca_bit_xor_i(rb_ca_wrap_readonly(self, INT2NUM(CA_BOOLEAN)), other);
   }
   else {
     return rb_ca_bit_xor_i(self, other);
@@ -415,10 +415,10 @@ static VALUE
 rb_ca_and (VALUE self, VALUE other)
 {
   if ( rb_ca_is_boolean_type(self) ) {
-    return rb_ca_and_i(self, rb_ca_wrap_readonly(other, INT2FIX(CA_BOOLEAN)));
+    return rb_ca_and_i(self, rb_ca_wrap_readonly(other, INT2NUM(CA_BOOLEAN)));
   }
   else if ( rb_obj_is_carray(other) && rb_ca_is_boolean_type(other) ) {
-    return rb_ca_and_i(rb_ca_wrap_readonly(self, INT2FIX(CA_BOOLEAN)), other);
+    return rb_ca_and_i(rb_ca_wrap_readonly(self, INT2NUM(CA_BOOLEAN)), other);
   }
   else {
     return rb_ca_and_i(self, other);
@@ -429,10 +429,10 @@ static VALUE
 rb_ca_or (VALUE self, VALUE other)
 {
   if ( rb_ca_is_boolean_type(self) ) {
-    return rb_ca_or_i(self, rb_ca_wrap_readonly(other, INT2FIX(CA_BOOLEAN)));
+    return rb_ca_or_i(self, rb_ca_wrap_readonly(other, INT2NUM(CA_BOOLEAN)));
   }
   else if ( rb_obj_is_carray(other) && rb_ca_is_boolean_type(other) ) {
-    return rb_ca_or_i(rb_ca_wrap_readonly(self, INT2FIX(CA_BOOLEAN)), other);
+    return rb_ca_or_i(rb_ca_wrap_readonly(self, INT2NUM(CA_BOOLEAN)), other);
   }
   else {
     return rb_ca_or_i(self, other);
@@ -443,10 +443,10 @@ static VALUE
 rb_ca_xor (VALUE self, VALUE other)
 {
   if ( rb_ca_is_boolean_type(self) ) {
-    return rb_ca_xor_i(self, rb_ca_wrap_readonly(other, INT2FIX(CA_BOOLEAN)));
+    return rb_ca_xor_i(self, rb_ca_wrap_readonly(other, INT2NUM(CA_BOOLEAN)));
   }
   else if ( rb_obj_is_carray(other) && rb_ca_is_boolean_type(other) ) {
-    return rb_ca_xor_i(rb_ca_wrap_readonly(self, INT2FIX(CA_BOOLEAN)), other);
+    return rb_ca_xor_i(rb_ca_wrap_readonly(self, INT2NUM(CA_BOOLEAN)), other);
   }
   else {
     return rb_ca_xor_i(self, other);
@@ -571,7 +571,7 @@ op_powi_fc(cmplx64_t);
 op_powi_fc(cmplx128_t);
 
 static void
-ca_ipower_float32_t (int32_t n, boolean8_t *m,
+ca_ipower_float32_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
   float32_t *p1 = (float32_t *) ptr1, *p2 = (float32_t *) ptr2;
@@ -586,7 +586,7 @@ ca_ipower_float32_t (int32_t n, boolean8_t *m,
 }
 
 static void
-ca_ipower_float64_t (int32_t n, boolean8_t *m,
+ca_ipower_float64_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
   float64_t *p1 = (float64_t *) ptr1, *p2 = (float64_t *) ptr2;
@@ -601,7 +601,7 @@ ca_ipower_float64_t (int32_t n, boolean8_t *m,
 }
 
 static void
-ca_ipower_float128_t (int32_t n, boolean8_t *m,
+ca_ipower_float128_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
   float128_t *p1 = (float128_t *) ptr1, *p2 = (float128_t *) ptr2;
@@ -616,7 +616,7 @@ ca_ipower_float128_t (int32_t n, boolean8_t *m,
 }
 
 static void
-ca_ipower_cmplx64_t (int32_t n, boolean8_t *m,
+ca_ipower_cmplx64_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
   cmplx64_t *p1 = (cmplx64_t *) ptr1, *p2 = (cmplx64_t *) ptr2;
@@ -631,7 +631,7 @@ ca_ipower_cmplx64_t (int32_t n, boolean8_t *m,
 }
 
 static void
-ca_ipower_cmplx128_t (int32_t n, boolean8_t *m,
+ca_ipower_cmplx128_t (ca_size_t n, boolean8_t *m,
                      char *ptr1, int32_t ipow, char *ptr2)
 {
   cmplx128_t *p1 = (cmplx128_t *) ptr1, *p2 = (cmplx128_t *) ptr2;

data/carray_numeric.c

@@ -146,7 +146,7 @@ rb_hack_star (VALUE x, VALUE y)
     type *p = (type *) ca->ptr;                 \
     double *q = (double *) co->ptr;             \
     boolean8_t *m = (ca->mask) ? (boolean8_t *) ca->mask->ptr : NULL; \
-    int32_t i;                                  \
+    ca_size_t i;                                  \
     if ( m ) {                                  \
       for (i=ca->elements; i; i--, p++, q++) {  \
         if ( ! *m++ )                           \

data/carray_operator.c

@@ -150,8 +150,8 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
     }
     else {                                         /* array vs array */
       if ( ca1->elements != ca2->elements ) {
-        rb_raise(rb_eRuntimeError, "elements mismatch (%i <-> %i)",
-                                 ca1->elements, ca2->elements);
+        rb_raise(rb_eRuntimeError, "elements mismatch (%lld <-> %lld)",
+                                   (ca_size_t) ca1->elements, (ca_size_t) ca2->elements);
       }
       if ( ca_has_mask(ca1) || ca_has_mask(ca2) ) {
         ca3 = ca_template_safe(ca1);              
@@ -212,8 +212,8 @@ rb_ca_call_binop_bang (VALUE self, VALUE other, ca_binop_func_t func[])
     }
     else {                                         /* scalar vs array */
       if ( ca1->elements != ca2->elements ) {
-        rb_raise(rb_eRuntimeError, "elements mismatch (%i <-> %i)",
-                                 ca1->elements, ca2->elements);
+        rb_raise(rb_eRuntimeError, "elements mismatch (%lld <-> %lld)",
+                                 (ca_size_t) ca1->elements, (ca_size_t) ca2->elements);
       }
 
       ca_copy_mask_overlay(ca1, ca1->elements, 2, ca1, ca2);
@@ -233,8 +233,8 @@ rb_ca_call_binop_bang (VALUE self, VALUE other, ca_binop_func_t func[])
     }
     else {                                          /* array vs array */
       if ( ca1->elements != ca2->elements ) {
-        rb_raise(rb_eRuntimeError, "elements mismatch in binop (%i <-> %i)",
-                                 ca1->elements, ca2->elements);
+        rb_raise(rb_eRuntimeError, "elements mismatch in binop (%lld <-> %lld)",
+                                 (ca_size_t) ca1->elements, (ca_size_t) ca2->elements);
       }
 
       ca_copy_mask_overlay(ca1, ca1->elements, 2, ca1, ca2);
@@ -285,6 +285,7 @@ rb_ca_call_moncmp (VALUE self, ca_moncmp_func_t func[])
   return out;
 }
 
+
 extern ca_monop_func_t ca_bincmp_eq[CA_NTYPE];
 extern ca_monop_func_t ca_bincmp_ne[CA_NTYPE];
 
@@ -352,8 +353,8 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
     }
     else {                                          /* array vs array */
       if ( ca1->elements != ca2->elements ) {
-        rb_raise(rb_eRuntimeError, "elements mismatch in bincmp (%i <-> %i)",
-                                 ca1->elements, ca2->elements);
+        rb_raise(rb_eRuntimeError, "elements mismatch in bincmp (%lld <-> %lld)",
+                                 (ca_size_t) ca1->elements, (ca_size_t) ca2->elements);
       }
       out = rb_carray_new(CA_BOOLEAN, ca1->rank, ca1->dim, 0, NULL);
       Data_Get_Struct(out, CArray, ca3);
@@ -378,28 +379,28 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
 }
 
 void
-ca_monop_not_implement(int32_t n, char *ptr1, char *ptr2)
+ca_monop_not_implement(ca_size_t n, char *ptr1, char *ptr2)
 {
   rb_raise(rb_eCADataTypeError,
            "invalid data type for monop (not implemented)");
 }
 
 void
-ca_binop_not_implement(int32_t n, char *ptr1, char *ptr2, char *ptr3)
+ca_binop_not_implement(ca_size_t n, char *ptr1, char *ptr2, char *ptr3)
 {
   rb_raise(rb_eCADataTypeError,
            "invalid data_type for binop (not implemented)");
 }
 
 void
-ca_moncmp_not_implement(int32_t n, char *ptr1, char *ptr2)
+ca_moncmp_not_implement(ca_size_t n, char *ptr1, char *ptr2)
 {
   rb_raise(rb_eCADataTypeError,
            "invalid data_type for moncmp (not implemented)");
 }
 
 void
-ca_bincmp_not_implement (int32_t n, char *ptr1, char *ptr2, char *ptr3)
+ca_bincmp_not_implement (ca_size_t n, char *ptr1, char *ptr2, char *ptr3)
 {
   rb_raise(rb_eTypeError, "invalid data_type for bincmp (not implemented)");
 }
@@ -470,11 +471,11 @@ rb_ca_coerce (VALUE self, VALUE other)
   { \
     type *p1 = (type*)ca->ptr; \
     type *p2; \
-    int   s2; \
+    ca_size_t   s2; \
     boolean8_t *m = mi; \
     type sum  = 0; \
-    int32_t count = 0; \
-    int32_t i; \
+    ca_size_t count = 0; \
+    ca_size_t i; \
     ca_set_iterator(1, cw, &p2, &s2); \
     if ( m ) { \
       count = 0; \
@@ -509,10 +510,10 @@ rb_ca_mul_add (int argc, VALUE *argv, volatile VALUE self)
   volatile VALUE rfval = Qnil;
   CArray *ca, *cw;
   boolean8_t *mi = NULL;
-  int min_count;
+  ca_size_t min_count;
 
   /* FIXME: to parse :mask_limit, :fill_value */
-  rb_scan_args(argc, argv, "12", &weight, &rmin_count, &rfval);
+  rb_scan_args(argc, argv, "12", (VALUE *) &weight, (VALUE *) &rmin_count, (VALUE *) &rfval);
 
   /* do implicit casting and resolving unbound repeat array */
   rb_ca_cast_self_or_other(&self, &weight);
@@ -533,7 +534,7 @@ rb_ca_mul_add (int argc, VALUE *argv, volatile VALUE self)
   }
 
   min_count = ( NIL_P(rmin_count) || ( ! mi ) ) ?
-                                   ca->elements - 1 : NUM2INT(rmin_count);
+                                   ca->elements - 1 : NUM2SIZE(rmin_count);
 
   if ( min_count < 0 ) {
     min_count += ca->elements;

data/carray_order.c

@@ -67,9 +67,9 @@ rb_ca_value_not_masked (VALUE self)
 static void
 ca_project_loop (CArray *co, CArray *ca, CArray *ci, char *lfill, char *ufill)
 {
-  int32_t map_elements = ca->elements;
-  int32_t *ip = (int32_t*) ci->ptr;
-  int32_t n, i;
+  ca_size_t map_elements = ca->elements;
+  ca_size_t *ip = (ca_size_t*) ci->ptr;
+  ca_size_t n, i;
   boolean8_t *mi, *ma;
   boolean8_t *mio, *mii, *mia;
 
@@ -154,12 +154,12 @@ rb_ca_project (int argc, VALUE *argv, VALUE self)
   CArray *ca, *ci, *co;
   char *lfval, *ufval;
 
-  rb_scan_args(argc, argv, "12", &rindex, &vlfval, &vufval);
+  rb_scan_args(argc, argv, "12", (VALUE *) &rindex, (VALUE *) &vlfval, (VALUE *) &vufval);
 
   Data_Get_Struct(self, CArray, ca);
 
   rb_check_carray_object(rindex);
-  ci = ca_wrap_readonly(rindex, CA_INT32);
+  ci = ca_wrap_readonly(rindex, CA_SIZE);
 
   lfval = malloc_with_check(ca->bytes);
   ufval = malloc_with_check(ca->bytes);
@@ -215,7 +215,7 @@ rb_ca_project (int argc, VALUE *argv, VALUE self)
 
 #define proc_reverse_bang_data()                        \
   {                                                     \
-    int32_t bytes = ca->bytes;                          \
+    ca_size_t bytes = ca->bytes;                          \
     char *p = ca->ptr;                                  \
     char *q = ca->ptr + bytes * (ca->elements - 1);     \
     char *v = malloc_with_check(bytes);                     \
@@ -299,7 +299,7 @@ rb_ca_reversed_copy (VALUE self)
 /* ------------------------------------------------------------------------- */
 
 typedef struct {
-  int32_t bytes;
+  ca_size_t bytes;
   char   *ptr;
 } cmp_data;
 
@@ -410,7 +410,7 @@ rb_ca_sort_bang (VALUE self)
   if ( ca_is_fixlen_type(ca) ) {
     cmp_data *cmp_ptr, *p;
     char *ca_ptr, *q;
-    int32_t i;
+    ca_size_t i;
     cmp_ptr = malloc_with_check(sizeof(cmp_data)*ca->elements);
     ca_ptr  = malloc_with_check(ca_length(ca));
     for (i=0, p=cmp_ptr, q=ca->ptr; i<ca->elements; i++, p++, q+=ca->bytes) {
@@ -468,7 +468,7 @@ rb_ca_sorted_copy (VALUE self)
 
 #define proc_shuffle(type)                      \
   {                                             \
-    int32_t idx, jdx;                           \
+    ca_size_t idx, jdx;                           \
     type *ptr, *p, *q;                          \
     type t1;                                    \
     ptr = (type *) ca->ptr;                     \
@@ -498,10 +498,10 @@ rb_ca_sorted_copy (VALUE self)
 
 #define proc_shuffle_fixlen()                   \
   {                                             \
-    int32_t idx, jdx;                           \
+    ca_size_t idx, jdx;                           \
     char *ptr, *p, *q;                          \
     char *t = (char*) malloc_with_check(ca->bytes); \
-    int32_t bytes = ca->bytes;                  \
+    ca_size_t bytes = ca->bytes;                  \
     ptr = ca->ptr;                              \
     if ( ca->mask ) {                           \
       boolean8_t *mptr, *mp, *mq;                \
@@ -636,18 +636,18 @@ rb_ca_binary_search (VALUE self, volatile VALUE rval)
     volatile VALUE vidx;
     CArray *cv, *co;
     char *ptr, *val;
-    int32_t i, idx;
+    ca_size_t i, idx;
     Data_Get_Struct(rval, CArray, cv);
     if ( ca->data_type != cv->data_type ) {
       cv = ca_wrap_readonly(rval, ca->data_type);
     }
-    co = carray_new(CA_INT32, cv->rank, cv->dim, 0, NULL);
+    co = carray_new(CA_SIZE, cv->rank, cv->dim, 0, NULL);
     out = ca_wrap_struct(co);
     ca_attach(cv);
     if ( ca_is_fixlen_type(ca) ) {
       cmp_data *cmp_ptr, *p, *ptr, cmp_val;
       char *q;
-      int32_t i;
+      ca_size_t i;
       cmp_val.bytes = ca->bytes;
       cmp_ptr = malloc_with_check(sizeof(cmp_data)*ca->elements);
       for (i=0, p=cmp_ptr, q=ca->ptr; i<ca->elements; i++, p++, q+=ca->bytes) {
@@ -658,7 +658,7 @@ rb_ca_binary_search (VALUE self, volatile VALUE rval)
         cmp_val.ptr = ca_ptr_at_addr(cv, i);
         ptr = bsearch(&cmp_val, cmp_ptr, ca->elements, sizeof(cmp_data),
                       ca_qsort_cmp[CA_FIXLEN]);
-        vidx = ( ! ptr ) ? CA_UNDEF : INT2NUM(ptr - cmp_ptr);      
+        vidx = ( ! ptr ) ? CA_UNDEF : SIZE2NUM(ptr - cmp_ptr);      
         rb_ca_store_addr(out, i, vidx);
       }
       free(cmp_ptr);
@@ -685,7 +685,7 @@ rb_ca_binary_search (VALUE self, volatile VALUE rval)
     if ( ca_is_fixlen_type(ca) ) {
       cmp_data *cmp_ptr, *p, *ptr, cmp_val;
       char *q;
-      int32_t i;
+      ca_size_t i;
       cmp_val.bytes = ca->bytes;
       cmp_val.ptr   = val;
       cmp_ptr = malloc_with_check(sizeof(cmp_data)*ca->elements);
@@ -695,14 +695,14 @@ rb_ca_binary_search (VALUE self, volatile VALUE rval)
       }
       ptr = bsearch(&cmp_val, cmp_ptr, ca->elements, sizeof(cmp_data),
                     ca_qsort_cmp[CA_FIXLEN]);
-      out = ( ! ptr ) ? Qnil : INT2NUM((ptr - cmp_ptr));
+      out = ( ! ptr ) ? Qnil : SIZE2NUM((ptr - cmp_ptr));
       free(cmp_ptr);
     }
     else {
       char *ptr;
       ptr = bsearch(val, ca->ptr, ca->elements, ca->bytes,
                     ca_qsort_cmp[ca->data_type]);
-      out = ( ! ptr ) ? Qnil : INT2NUM((ptr - ca->ptr)/ca->bytes);
+      out = ( ! ptr ) ? Qnil : SIZE2NUM((ptr - ca->ptr)/ca->bytes);
     }
   }
   ca_detach(ca);
@@ -729,8 +729,8 @@ rb_ca_binary_search_index (VALUE self, volatile VALUE rval)
   {                                                          \
     type *ptr = (type *) ca->ptr;                            \
     boolean8_t *m = (ca->mask) ? (boolean8_t*) ca->mask->ptr : NULL; \
-    type val  = (type) NUM2LONG(value);                      \
-    int32_t i;                                               \
+    type val  = (type) NUM2LL(value);                      \
+    ca_size_t i;                                               \
     if ( m ) {                                               \
       for (i=0; i<ca->elements; i++, ptr++) {                \
         if ( ! *m++ ) {                                      \
@@ -757,7 +757,7 @@ rb_ca_binary_search_index (VALUE self, volatile VALUE rval)
     boolean8_t *m = (ca->mask) ? (boolean8_t*) ca->mask->ptr : NULL; \
     type val  = (type) NUM2DBL(value);                       \
     double eps  = (NIL_P(veps)) ? defeps*fabs(val) : NUM2DBL(veps); \
-    int32_t i;                                               \
+    ca_size_t i;                                               \
     if ( m ) {                                               \
       for (i=0; i<ca->elements; i++, ptr++) {                \
         if ( ! *m++ ) {                                      \
@@ -784,7 +784,7 @@ rb_ca_binary_search_index (VALUE self, volatile VALUE rval)
     boolean8_t *m = (ca->mask) ? (boolean8_t*) ca->mask->ptr : NULL; \
     type val  = (type) NUM2CC(value);                        \
     double eps  = (NIL_P(veps)) ? defeps*cabs(val) : NUM2DBL(veps); \
-    int32_t i;                                               \
+    ca_size_t i;                                               \
     if ( m ) {                                               \
       for (i=0; i<ca->elements; i++, ptr++) {                \
         if ( ! *m++ ) {                                      \
@@ -809,7 +809,7 @@ rb_ca_binary_search_index (VALUE self, volatile VALUE rval)
   {                                                          \
     VALUE *ptr = (VALUE *) ca->ptr;                          \
     boolean8_t *m = (ca->mask) ? (boolean8_t*) ca->mask->ptr : NULL; \
-    int32_t i;                                               \
+    ca_size_t i;                                               \
     if ( m ) {                                               \
       for (i=0; i<ca->elements; i++, ptr++) {                \
         if ( ! *m++ ) {                                      \
@@ -843,9 +843,9 @@ rb_ca_linear_search (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE value, veps;
   CArray *ca;
-  int32_t addr;
+  ca_size_t addr;
 
-  rb_scan_args(argc, argv, "11", &value, &veps);
+  rb_scan_args(argc, argv, "11", (VALUE *) &value, (VALUE *) &veps);
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -878,7 +878,7 @@ rb_ca_linear_search (int argc, VALUE *argv, VALUE self)
 
   ca_detach(ca);
 
-  return ( addr == -1 ) ? Qnil : LONG2NUM(addr);
+  return ( addr == -1 ) ? Qnil : SIZE2NUM(addr);
 }
 
 /* rdoc:
@@ -904,7 +904,7 @@ rb_ca_linear_search_index (int argc, VALUE *argv, VALUE self)
     type val  = (type) from(value);                     \
     double trial;                                       \
     double diff = 1.0/0.0;                              \
-    int32_t i;                                          \
+    ca_size_t i;                                          \
     addr = -1;                                           \
     if ( m ) {                                          \
       for (i=0; i<ca->elements; i++, ptr++) {           \
@@ -935,7 +935,7 @@ rb_ca_linear_search_index (int argc, VALUE *argv, VALUE self)
     VALUE val  = value;                     \
     VALUE trial;                                       \
     VALUE diff = rb_float_new(1.0/0.0);                              \
-    int32_t i;                                          \
+    ca_size_t i;                                          \
     addr = -1;                                           \
     if ( m ) {                                          \
       for (i=0; i<ca->elements; i++, ptr++) {           \
@@ -970,7 +970,7 @@ static VALUE
 rb_ca_linear_search_nearest (VALUE self, VALUE value)
 {
   CArray *ca;
-  int32_t addr;
+  ca_size_t addr;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -1001,7 +1001,7 @@ rb_ca_linear_search_nearest (VALUE self, VALUE value)
 
   ca_detach(ca);
 
-  return ( addr == -1 ) ? Qnil : LONG2NUM(addr);
+  return ( addr == -1 ) ? Qnil : SIZE2NUM(addr);
 }
 
 static VALUE