carray 1.2.0 → 1.3.0

data/ca_obj_reduce.c

@@ -24,9 +24,9 @@ static VALUE rb_cCAReduce;
 /* ------------------------------------------------------------------- */
 
 int
-ca_reduce_setup (CAReduce *ca, CArray *parent, int32_t count, int32_t offset)
+ca_reduce_setup (CAReduce *ca, CArray *parent, ca_size_t count, ca_size_t offset)
 {
-  int32_t elements;
+  ca_size_t elements;
 
   /* check arguments */
 
@@ -66,7 +66,7 @@ ca_reduce_setup (CAReduce *ca, CArray *parent, int32_t count, int32_t offset)
 }
 
 CAReduce *
-ca_reduce_new (CArray *parent, int32_t count, int32_t offset)
+ca_reduce_new (CArray *parent, ca_size_t count, ca_size_t offset)
 {
   CAReduce *ca = ALLOC(CAReduce);
   ca_reduce_setup(ca, parent, count, offset);
@@ -94,21 +94,21 @@ ca_reduce_func_clone (void *ap)
 }
 
 static char *
-ca_reduce_func_ptr_at_addr (void *ap, int32_t addr)
+ca_reduce_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CAReduce *ca = (CAReduce *) ap;
   return ca->ptr + addr;
 }
 
 static char *
-ca_reduce_func_ptr_at_index (void *ap, int32_t *idx)
+ca_reduce_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CAReduce *ca = (CAReduce *) ap;
   return ca_func[CA_OBJ_ARRAY].ptr_at_index(ca, idx);
 }
 
 static void
-ca_reduce_func_fetch_addr (void *ap, int32_t addr, void *ptr)
+ca_reduce_func_fetch_addr (void *ap, ca_size_t addr, void *ptr)
 {
   CAReduce *ca = (CAReduce *) ap;
   char q;
@@ -124,10 +124,10 @@ ca_reduce_func_fetch_addr (void *ap, int32_t addr, void *ptr)
 }
 
 static void
-ca_reduce_func_store_addr (void *ap, int32_t addr, void *ptr)
+ca_reduce_func_store_addr (void *ap, ca_size_t addr, void *ptr)
 {
   CAReduce *ca = (CAReduce *) ap;
-  int32_t i;
+  ca_size_t i;
   for (i=0; i<ca->count; i++) {
     ca_store_addr(ca->parent, addr*ca->count+i+ca->offset, ptr);
   }
@@ -147,7 +147,7 @@ ca_reduce_func_attach (void *ap)
 {
   CAReduce *ca = (CAReduce *) ap;
   char *p;
-  int32_t i;
+  ca_size_t i;
   ca_attach(ca->parent);
   /* ca->ptr = ALLOC_N(char, ca->elements); */
   ca->ptr = malloc_with_check(ca_length(ca));  
@@ -163,7 +163,7 @@ ca_reduce_func_sync (void *ap)
 {
   CAReduce *ca = (CAReduce *) ap;
   char *p;
-  int32_t i;
+  ca_size_t i;
   p = ca->ptr;
   ca_attach(ca->parent);
   for (i=0; i<ca->elements; i++) {
@@ -187,7 +187,7 @@ static void
 ca_reduce_func_copy_data (void *ap, void *ptr)
 {
   CAReduce *ca = (CAReduce *) ap;
-  int32_t i;
+  ca_size_t i;
   char *p;
   ca_attach(ca->parent);
   p = ptr;
@@ -203,7 +203,7 @@ ca_reduce_func_sync_data (void *ap, void *ptr)
 {
   CAReduce *ca = (CAReduce *) ap;
   char *p;
-  int32_t i;
+  ca_size_t i;
   ca_attach(ca->parent);
   p = ptr;
   for (i=0; i<ca->elements; i++) {
@@ -218,7 +218,7 @@ static void
 ca_reduce_func_fill_data (void *ap, void *ptr)
 {
   CAReduce *ca = (CAReduce *) ap;
-  int32_t i;
+  ca_size_t i;
   ca_attach(ca->parent);
   for (i=0; i<ca->elements; i++) {
     ca_reduce_func_store_addr(ca, i, ptr);

data/ca_obj_refer.c

@@ -21,11 +21,11 @@ VALUE rb_cCARefer;
 
 static int
 ca_refer_setup (CARefer *ca, CArray *parent,
-                int8_t data_type, int8_t rank, int32_t *dim, int32_t bytes,
-                int32_t offset)
+                int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+                ca_size_t offset)
 {
-  int32_t elements, ratio;
-  int32_t i;
+  ca_size_t elements, ratio;
+  int8_t i;
   int     is_deformed;
 
   CA_CHECK_DATA_TYPE(data_type);
@@ -82,7 +82,7 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   ca->rank      = rank;
   ca->bytes     = bytes;
   ca->elements  = elements;
-  ca->dim       = ALLOC_N(int32_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, rank);
   ca->ptr       = NULL;
   ca->mask      = NULL;
   ca->mask0     = NULL;
@@ -99,7 +99,7 @@ ca_refer_setup (CARefer *ca, CArray *parent,
     ca->is_deformed = 1;
   }
 
-  memcpy(ca->dim, dim, rank * sizeof(int32_t));
+  memcpy(ca->dim, dim, rank * sizeof(ca_size_t));
 
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -110,8 +110,8 @@ ca_refer_setup (CARefer *ca, CArray *parent,
 
 CARefer *
 ca_refer_new (CArray *parent,
-              int8_t data_type, int8_t rank, int32_t *dim, int32_t bytes,
-              int32_t offset)
+              int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+              ca_size_t offset)
 {
   CARefer *ca = ALLOC(CARefer);
   ca_refer_setup(ca, parent, data_type, rank, dim, bytes, offset);
@@ -141,10 +141,10 @@ ca_refer_func_clone (void *ap)
 }
 
 static char *
-ca_refer_func_ptr_at_addr (void *ap, int32_t addr)
+ca_refer_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CARefer *ca = (CARefer *) ap;
-  int major, minor;
+  ca_size_t major, minor;
   switch ( ca->is_deformed ) {
   case 0:
   case 1:
@@ -161,11 +161,12 @@ ca_refer_func_ptr_at_addr (void *ap, int32_t addr)
 }
 
 static char *
-ca_refer_func_ptr_at_index (void *ap, int32_t *idx)
+ca_refer_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CARefer *ca  = (CARefer*) ap;
-  int32_t *dim = ca->dim;
-  int32_t  n, i;
+  ca_size_t *dim = ca->dim;
+  int8_t   i;
+  ca_size_t  n;
   n = idx[0];                  /* n = idx[0]*dim[1]*dim[2]*...*dim[rank-1] */
   for (i=1; i<ca->rank; i++) { /*    + idx[1]*dim[1]*dim[2]*...*dim[rank-1] */
     n = dim[i]*n+idx[i];       /*    ... + idx[rank-2]*dim[1] + idx[rank-1] */
@@ -174,10 +175,10 @@ ca_refer_func_ptr_at_index (void *ap, int32_t *idx)
 }
 
 static void
-ca_refer_func_fetch_addr (void *ap, int32_t addr, void *ptr)
+ca_refer_func_fetch_addr (void *ap, ca_size_t addr, void *ptr)
 {
   CARefer *ca = (CARefer *) ap;
-  int major, minor;
+  ca_size_t major, minor;
   switch ( ca->is_deformed ) {
   case 0:
     ca_fetch_addr(ca->parent, addr, ptr);
@@ -213,12 +214,13 @@ ca_refer_func_fetch_addr (void *ap, int32_t addr, void *ptr)
 }
 
 static void
-ca_refer_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_refer_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CARefer *ca = (CARefer *) ap;
   if ( ca->is_deformed ) {
-    int32_t *dim = ca->dim;
-    int32_t  n, i;
+    ca_size_t *dim = ca->dim;
+    int8_t   i;
+    ca_size_t  n;
     n = idx[0];
     for (i=1; i<ca->rank; i++) {
       n = dim[i]*n+idx[i];
@@ -231,10 +233,10 @@ ca_refer_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_refer_func_store_addr (void *ap, int32_t addr, void *ptr)
+ca_refer_func_store_addr (void *ap, ca_size_t addr, void *ptr)
 {
   CARefer *ca = (CARefer *) ap;
-  int major, minor;
+  ca_size_t major, minor;
   switch ( ca->is_deformed ) {
   case 0:
     ca_store_addr(ca->parent, addr, ptr);
@@ -273,12 +275,13 @@ ca_refer_func_store_addr (void *ap, int32_t addr, void *ptr)
 }
 
 static void
-ca_refer_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_refer_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CARefer *ca = (CARefer *) ap;
   if ( ca->is_deformed ) {
-    int32_t *dim = ca->dim;
-    int32_t  n, i;
+    ca_size_t *dim = ca->dim;
+    int8_t   i;
+    ca_size_t  n;
     n = idx[0];
     for (i=1; i<ca->rank; i++) {
       n = dim[i]*n+idx[i];
@@ -354,8 +357,8 @@ ca_refer_func_sync_data (void *ap, void *ptr)
 
 #define proc_fill_bang_fixlen()                 \
   {                                             \
-    int32_t i;                                  \
-    int32_t bytes = ca->bytes;                  \
+    ca_size_t i;                                  \
+    ca_size_t bytes = ca->bytes;                  \
     char *p = ca->parent->ptr + ca->parent->bytes * ca->offset; \
     for (i=ca->elements; i; i--, p+=bytes) {    \
       memcpy(p, val, bytes);                    \
@@ -364,7 +367,7 @@ ca_refer_func_sync_data (void *ap, void *ptr)
 
 #define proc_fill_bang(type)                    \
   {                                             \
-    int32_t i;                                  \
+    ca_size_t i;                                  \
     type *p = (type *)(ca->parent->ptr + ca->parent->bytes * ca->offset); \
     type  v = *(type *)val;                     \
     for (i=ca->elements; i; i--, p++) {         \
@@ -421,7 +424,7 @@ ca_refer_func_create_mask (void *ap)
                               CA_BOOLEAN, ca->rank, ca->dim, 0, ca->offset);
   }
   else if ( ca->is_deformed == -2 ) {
-    int32_t count[CA_RANK_MAX];
+    ca_size_t count[CA_RANK_MAX];
     int i;
     for (i=0; i<ca->parent->rank; i++) {
       count[i] = 0;
@@ -512,9 +515,9 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
   CARefer *cr;
   int8_t  data_type;
   int8_t  rank;
-  int32_t dim[CA_RANK_MAX];
-  int32_t bytes, offset = 0;
-  int32_t i;
+  ca_size_t dim[CA_RANK_MAX];
+  ca_size_t bytes, offset = 0;
+  int8_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -532,10 +535,10 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
   }
   else {
     volatile VALUE rtype, rdim, ropt, rbytes = Qnil, roffset = Qnil;
-    int32_t elements;
+    ca_size_t elements;
 
     ropt = rb_pop_options(&argc, &argv);
-    rb_scan_args(argc, argv, "11", &rtype, &rdim);
+    rb_scan_args(argc, argv, "11", (VALUE *) &rtype, (VALUE *) &rdim);
     rb_scan_options(ropt, "bytes,offset", &rbytes, &roffset);
 
     if ( NIL_P(rbytes) ) {
@@ -559,12 +562,12 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
 
     elements = 1;
     for (i=0; i<rank; i++) {
-      dim[i] = NUM2INT(rb_ary_entry(rdim, i));
+      dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
       elements *= dim[i];
     }
 
     if ( ! NIL_P(roffset) ) {
-      offset = NUM2LONG(roffset);
+      offset = NUM2SIZE(roffset);
     }
 
     cr = ca_refer_new((CArray*)ca, data_type, rank, dim, bytes, offset);
@@ -581,18 +584,18 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
 
 VALUE
 rb_ca_refer_new (VALUE self,
-                 int8_t data_type, int8_t rank, int32_t *dim, int32_t bytes,
-                 int32_t offset)
+                 int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+                 ca_size_t offset)
 {
   volatile VALUE list, rdim, ropt;
   CArray *ca;
-  int32_t i;
+  int8_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
   rdim = rb_ary_new2(rank);
   for (i=0; i<rank; i++) {
-    rb_ary_store(rdim, i, INT2NUM(dim[i]));
+    rb_ary_store(rdim, i, SIZE2NUM(dim[i]));
   }
 
   list = rb_ary_new2(3);
@@ -604,7 +607,7 @@ rb_ca_refer_new (VALUE self,
   }
   rb_ary_store(list, 1, rdim);
   ropt = rb_hash_new();
-  rb_set_options(ropt, "bytes,offset", INT2NUM(bytes), INT2NUM(offset));
+  rb_set_options(ropt, "bytes,offset", SIZE2NUM(bytes), SIZE2NUM(offset));
   rb_ary_store(list, 2, ropt);
 
   return rb_ca_refer(3, RARRAY_PTR(list), self);

data/ca_obj_repeat.c

@@ -20,10 +20,10 @@ VALUE rb_cCARepeat;
 */
 
 int
-ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, int32_t *count)
+ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, ca_size_t *count)
 {
   int8_t data_type;
-  int32_t elements, bytes, nrpt, repeat_level, repeat_num,
+  ca_size_t elements, bytes, nrpt, repeat_level, repeat_num,
                      contig_level, contig_num, data_rank;
   int i, j;
 
@@ -78,12 +78,12 @@ ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, int32_t *count)
   ca->elements  = elements;
   ca->ptr       = NULL;
   ca->mask      = NULL;
-  ca->dim       = ALLOC_N(int32_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, rank);
 
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
-  ca->count     = ALLOC_N(int32_t, rank);
+  ca->count     = ALLOC_N(ca_size_t, rank);
   ca->repeat_level = repeat_level;
   ca->repeat_num   = repeat_num;
   ca->contig_level = contig_level;
@@ -99,7 +99,7 @@ ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, int32_t *count)
     }
   }
 
-  memcpy(ca->count, count, rank * sizeof(int32_t));
+  memcpy(ca->count, count, rank * sizeof(ca_size_t));
 
   ca_set_flag(ca, CA_FLAG_READ_ONLY);
 
@@ -112,7 +112,7 @@ ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, int32_t *count)
 
 
 CARepeat *
-ca_repeat_new (CArray *parent, int8_t rank, int32_t *count)
+ca_repeat_new (CArray *parent, int8_t rank, ca_size_t *count)
 {
   CARepeat *ca = ALLOC(CARepeat);
   ca_repeat_setup(ca, parent, rank, count);
@@ -145,30 +145,31 @@ ca_repeat_func_clone (void *ap)
 }
 
 static char *
-ca_repeat_func_ptr_at_addr (void *ap, int32_t addr)
+ca_repeat_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CARepeat *ca = (CARepeat *) ap;
   if ( ca->ptr ) {
     return ca->ptr + ca->bytes * addr;
   }
   else {
-    int32_t idx[CA_RANK_MAX];
+    ca_size_t idx[CA_RANK_MAX];
     ca_addr2index((CArray *)ca, addr, idx);
     return ca_ptr_at_index(ca, idx);
   }
 }
 
 static char *
-ca_repeat_func_ptr_at_index (void *ap, int32_t *idx)
+ca_repeat_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CARepeat *ca = (CARepeat *) ap;
   if ( ca->ptr ) {
     return ca_array_func_ptr_at_index(ca, idx);
   }
   else {
-    int32_t *count = ca->count;
-    int32_t *dim0  = ca->parent->dim;
-    int32_t  n, i, j;
+    ca_size_t *count = ca->count;
+    ca_size_t *dim0  = ca->parent->dim;
+    int8_t   i;
+    ca_size_t  n, j;
 
     j = 0;
     n = 0;
@@ -189,12 +190,13 @@ ca_repeat_func_ptr_at_index (void *ap, int32_t *idx)
 }
 
 static void
-ca_repeat_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_repeat_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CARepeat *ca = (CARepeat *) ap;
-  int32_t *count = ca->count;
-  int32_t idx0[CA_RANK_MAX];
-  int32_t  n, i, j;
+  ca_size_t *count = ca->count;
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t   i;
+  ca_size_t  n, j;
   j = 0;
   n = 0;
   for (i=0; i<ca->rank; i++) {
@@ -206,12 +208,13 @@ ca_repeat_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_repeat_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_repeat_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CARepeat *ca = (CARepeat *) ap;
-  int32_t *count = ca->count;
-  int32_t idx0[CA_RANK_MAX];
-  int32_t  n, i, j;
+  ca_size_t *count = ca->count;
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t   i;
+  ca_size_t  n, j;
   j = 0;
   n = 0;
   for (i=0; i<ca->rank; i++) {
@@ -329,7 +332,7 @@ ca_operation_function_t ca_repeat_func = {
 /* ------------------------------------------------------------------- */
 
 static void
-memfill (void *dp, void *sp, size_t bytes, size_t n)
+memfill (void *dp, void *sp, ca_size_t bytes, ca_size_t n)
 {
   switch ( bytes ) {
   case 1:
@@ -351,7 +354,7 @@ memfill (void *dp, void *sp, size_t bytes, size_t n)
     break;
   }
   default: {
-    int32_t i;
+    ca_size_t i;
     char *p = (char *) dp, *q = (char *) sp;
     for (i=0; i<n; i++) {
       memcpy(p, q, bytes);
@@ -363,10 +366,10 @@ memfill (void *dp, void *sp, size_t bytes, size_t n)
 
 static void
 ca_repeat_attach_loop1 (CARepeat *ca, int8_t level, int8_t level0,
-                                    int32_t *idx, int32_t *idx0)
+                                    ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t *count = ca->count;
-  int32_t i;
+  ca_size_t *count = ca->count;
+  ca_size_t i;
 
   if ( level == ca->contig_level ) {
     if ( ca->contig_num == 1 ) {
@@ -402,9 +405,9 @@ ca_repeat_attach_loop1 (CARepeat *ca, int8_t level, int8_t level0,
 static void
 ca_repeat_attach (CARepeat *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
+  ca_size_t i;
   char *dp, *sp;
 
   for (i=0; i<ca->rank; i++) {
@@ -422,10 +425,10 @@ ca_repeat_attach (CARepeat *ca)
 
 static void
 ca_repeat_sync_loop (CARepeat *ca, int8_t level, int8_t level0,
-                                    int32_t *idx, int32_t *idx0)
+                                    ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t *count = ca->count;
-  int32_t i;
+  ca_size_t *count = ca->count;
+  ca_size_t i;
 
   if ( level == ca->contig_level ) {
     if ( ca->contig_num == 1 ) {
@@ -453,9 +456,9 @@ ca_repeat_sync_loop (CARepeat *ca, int8_t level, int8_t level0,
 static void
 ca_repeat_sync (CARepeat *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t i;
   for (i=0; i<ca->rank; i++) {
     idx[i] = 0;
     idx0[i] = 0;
@@ -472,7 +475,7 @@ ca_repeat_fill (CARepeat *ca, char *ptr)
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_repeat_new (VALUE cary, int8_t rank, int32_t *count)
+rb_ca_repeat_new (VALUE cary, int8_t rank, ca_size_t *count)
 {
   volatile VALUE obj;
   CArray *parent;
@@ -491,9 +494,9 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE obj;
   CArray *ca;
-  int32_t count[CA_RANK_MAX];
-  int32_t repeat;
-  int32_t i;
+  ca_size_t count[CA_RANK_MAX];
+  ca_size_t repeat;
+  ca_size_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -504,7 +507,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
        ) ) {
     volatile VALUE args;
     CArray *ct;
-    int32_t rank, dim[CA_RANK_MAX];
+    ca_size_t rank, dim[CA_RANK_MAX];
     int k;
     if ( argv[0] == ID2SYM(rb_intern("%") ) ) {
       Data_Get_Struct(argv[1], CArray, ct);
@@ -521,7 +524,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
       k = 0;
       for (i=0; i<ct->rank; i++) {
         if ( ca->dim[k] == 1 ) {
-          rb_ary_push(args, INT2NUM(ct->dim[i]));
+          rb_ary_push(args, SIZE2NUM(ct->dim[i]));
           k++;
         }
         else if ( ct->dim[i] == ca->dim[k] ) {
@@ -530,7 +533,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
           k++; rank++;
         }
         else {
-          rb_ary_push(args, INT2NUM(ct->dim[i]));
+          rb_ary_push(args, SIZE2NUM(ct->dim[i]));
         }
       }
       if ( rank != ca->rank ) {
@@ -541,7 +544,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
       k = ca->rank - 1;
       for (i=ct->rank-1; i>=0; i--) {
         if ( ca->dim[k] == 1 ) {
-          rb_ary_unshift(args, INT2NUM(ct->dim[i]));
+          rb_ary_unshift(args, SIZE2NUM(ct->dim[i]));
           k--;
         }
         else if ( ct->dim[i] == ca->dim[k] ) {
@@ -549,7 +552,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
           k--;
         }
         else {
-          rb_ary_unshift(args, INT2NUM(ct->dim[i]));
+          rb_ary_unshift(args, SIZE2NUM(ct->dim[i]));
         }
       }
       if ( k != 0 ) {
@@ -563,7 +566,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
         self = rb_ca_refer_new(self, ca->data_type, rank, dim, ca->bytes, 0);
       }
     }
-    return rb_ca_repeat(RARRAY_LEN(args), RARRAY_PTR(args), self);
+    return rb_ca_repeat((int)RARRAY_LEN(args), RARRAY_PTR(args), self);
   }
 
   repeat = 1;
@@ -577,7 +580,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
       }
     }
     else {
-      count[i] = NUM2INT(argv[i]);
+      count[i] = NUM2SIZE(argv[i]);
       if ( count[i] == 0 ) {
         rb_raise(rb_eArgError,
                  "zero repeat count specified in creating CARepeat object");
@@ -587,8 +590,8 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
   }
 
   if ( repeat == 1 ) {
-    int32_t dim[CA_RANK_MAX];
-    int j = 0;
+    ca_size_t dim[CA_RANK_MAX];
+    int8_t j = 0;
     for (i=0; i<argc; i++) {
       if ( count[i] == 0 ) {
         dim[i] = ca->dim[j];