carray 1.2.0 → 1.3.0

data/ca_obj_select.c

@@ -24,9 +24,9 @@ typedef struct {
   int8_t    data_type;
   int8_t    rank;
   int32_t   flags;
-  int32_t   bytes;
-  int32_t   elements;
-  int32_t  *dim;  /* point to _dim */
+  ca_size_t   bytes;
+  ca_size_t   elements;
+  ca_size_t  *dim;  /* point to _dim */
   char     *ptr;
   CArray   *mask;
   CArray   *parent;
@@ -34,7 +34,7 @@ typedef struct {
   uint8_t   nosync;
   /* ---------- */
   CArray   *select;
-  int32_t  _dim;
+  ca_size_t  _dim;
 } CASelect;
 
 /* ------------------------------------------------------------------- */
@@ -43,7 +43,7 @@ static int
 ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
 {
   int8_t data_type;
-  int32_t bytes;
+  ca_size_t bytes;
   int i;
 
   if ( ! ca_is_boolean_type(select) ) {
@@ -157,7 +157,7 @@ ca_select_func_clone (void *ap)
 }
 
 static char *
-ca_select_func_ptr_at_addr (void *ap, int32_t addr)
+ca_select_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CASelect *ca = (CASelect *) ap;
 
@@ -165,8 +165,8 @@ ca_select_func_ptr_at_addr (void *ap, int32_t addr)
     return ca->ptr + ca->bytes * addr;
   }
   else {
-    int32_t n, i, a;
-    int32_t elements = ca->select->elements;
+    ca_size_t n, i, a;
+    ca_size_t elements = ca->select->elements;
     boolean8_t  s;
 
     n = 0;
@@ -192,10 +192,10 @@ ca_select_func_ptr_at_addr (void *ap, int32_t addr)
 }
 
 static char *
-ca_select_func_ptr_at_index (void *ap, int32_t *idx)
+ca_select_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CASelect *ca = (CASelect *) ap;
-  int32_t addr = idx[0];
+  ca_size_t addr = idx[0];
 
   if ( ca->ptr ) {
     return ca->ptr + ca->bytes * addr;
@@ -206,11 +206,11 @@ ca_select_func_ptr_at_index (void *ap, int32_t *idx)
 }
 
 static void
-ca_select_func_fetch_addr (void *ap, int32_t addr, void *ptr)
+ca_select_func_fetch_addr (void *ap, ca_size_t addr, void *ptr)
 {
   CASelect *ca = (CASelect *) ap;
-  int32_t n, i, a;
-  int32_t elements = ca->select->elements;
+  ca_size_t n, i, a;
+  ca_size_t elements = ca->select->elements;
   boolean8_t  s;
   n = 0;
   a = 0;
@@ -227,17 +227,17 @@ ca_select_func_fetch_addr (void *ap, int32_t addr, void *ptr)
 }
 
 static void
-ca_select_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_select_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   ca_select_func_fetch_addr(ap, idx[0], ptr);
 }
 
 static void
-ca_select_func_store_addr (void *ap, int32_t addr, void *ptr)
+ca_select_func_store_addr (void *ap, ca_size_t addr, void *ptr)
 {
   CASelect *ca = (CASelect *) ap;
-  int32_t n, i, a;
-  int32_t elements = ca->select->elements;
+  ca_size_t n, i, a;
+  ca_size_t elements = ca->select->elements;
   boolean8_t  s;
   n = 0;
   a = 0;
@@ -254,7 +254,7 @@ ca_select_func_store_addr (void *ap, int32_t addr, void *ptr)
 }
 
 static void
-ca_select_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_select_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   ca_select_func_store_addr(ap, idx[0], ptr);
 }
@@ -418,7 +418,7 @@ void
 ca_select_to_ptr (CArray *ca, CArray *select, char *ptr)
 {
   boolean8_t *s = (boolean8_t*) select->ptr;
-  int32_t i;
+  ca_size_t i;
 
   switch ( ca->bytes ) {
   case 1: proc_select_to_ptr(int8_t); break;
@@ -427,7 +427,7 @@ ca_select_to_ptr (CArray *ca, CArray *select, char *ptr)
   case 8: proc_select_to_ptr(float64_t); break;
   default: {
     char *p = ptr, *q = ca->ptr;
-    int32_t bytes = ca->bytes;
+    ca_size_t bytes = ca->bytes;
     for (i=ca->elements; i; i--) {
       if ( *s ) {
         memcpy(q, p, bytes);
@@ -459,7 +459,7 @@ void
 ca_select_from_ptr (CArray *ca, CArray *select, char *ptr)
 {
   boolean8_t *s = (boolean8_t *) select->ptr;
-  int32_t i;
+  ca_size_t i;
 
   switch ( ca->bytes ) {
   case 1: proc_select_from_ptr(int8_t); break;
@@ -469,7 +469,7 @@ ca_select_from_ptr (CArray *ca, CArray *select, char *ptr)
   default: {
     char *p = ptr;
     char *q = ca->ptr;
-    int32_t bytes = ca->bytes;
+    ca_size_t bytes = ca->bytes;
     for (i=ca->elements; i; i--) {
       if ( *s ) {
         memcpy(q, p, bytes);
@@ -501,7 +501,7 @@ void
 ca_select_fill (CArray *ca, CArray *select, char *valp)
 {
   boolean8_t *s = (boolean8_t *) select->ptr;
-  int32_t i;
+  ca_size_t i;
 
   switch ( ca->bytes ) {
   case 1: proc_select_fill(int8_t); break;
@@ -510,7 +510,7 @@ ca_select_fill (CArray *ca, CArray *select, char *valp)
   case 8: proc_select_fill(float64_t); break;
   default: {
     char *q = ca->ptr;
-    int32_t bytes = ca->bytes;
+    ca_size_t bytes = ca->bytes;
     for (i=ca->elements; i; i--) {
       if ( *s ) {
         memcpy(q, valp, bytes);

data/ca_obj_shift.c

@@ -24,16 +24,16 @@ typedef struct {
   int8_t    data_type;
   int8_t    rank;
   int32_t   flags;
-  int32_t   bytes;
-  int32_t   elements;
-  int32_t  *dim;
+  ca_size_t   bytes;
+  ca_size_t   elements;
+  ca_size_t  *dim;
   char     *ptr;
   CArray   *mask;
   CArray   *parent;
   uint32_t  attach;
   uint8_t   nosync;
   /* -------------*/
-  int32_t  *shift;
+  ca_size_t  *shift;
   char     *fill;
   int8_t   *roll;
   int       fill_mask;
@@ -45,10 +45,10 @@ static int8_t CA_OBJ_SHIFT;
 
 int
 ca_shift_setup (CAShift *ca, CArray *parent,
-               int32_t *shift, char *fill, int8_t *roll)
+               ca_size_t *shift, char *fill, int8_t *roll)
 {
   int8_t data_type, rank;
-  int32_t elements, bytes;
+  ca_size_t elements, bytes;
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
@@ -64,17 +64,17 @@ ca_shift_setup (CAShift *ca, CArray *parent,
   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->shift     = ALLOC_N(int32_t, rank);
+  ca->shift     = ALLOC_N(ca_size_t, rank);
   ca->fill      = ALLOC_N(char, ca->bytes);
   ca->roll      = ALLOC_N(int8_t, rank);
 
-  memcpy(ca->dim, parent->dim, rank * sizeof(int32_t));
-  memcpy(ca->shift, shift, rank * sizeof(int32_t));
+  memcpy(ca->dim, parent->dim, rank * sizeof(ca_size_t));
+  memcpy(ca->shift, shift, rank * sizeof(ca_size_t));
   memcpy(ca->roll, roll, rank * sizeof(int8_t));
 
   if ( fill ) {
@@ -94,7 +94,7 @@ ca_shift_setup (CAShift *ca, CArray *parent,
 }
 
 CAShift *
-ca_shift_new (CArray *parent, int32_t *shift, char *fill, int8_t *roll)
+ca_shift_new (CArray *parent, ca_size_t *shift, char *fill, int8_t *roll)
 {
   CAShift *ca = ALLOC(CAShift);
   ca_shift_setup(ca, parent, shift, fill, roll);
@@ -119,11 +119,11 @@ static void ca_shift_attach (CAShift *ca);
 static void ca_shift_sync (CAShift *ca);
 static void ca_shift_fill (CAShift *ca, char *ptr);
 
-static int32_t
-ca_shift_normalized_roll_shift (CAShift *ca, int32_t i)
+static ca_size_t
+ca_shift_normalized_roll_shift (CAShift *ca, ca_size_t i)
 {
-  int32_t dim   = ca->dim[i];
-  int32_t shift = ca->shift[i];
+  ca_size_t dim   = ca->dim[i];
+  ca_size_t shift = ca->shift[i];
   if ( shift >= 0 ) {
     return shift % dim;
   }
@@ -132,12 +132,12 @@ ca_shift_normalized_roll_shift (CAShift *ca, int32_t i)
   }
 }
 
-static int32_t
-ca_shift_rolled_index (CAShift *ca, int32_t i, int32_t k)
+static ca_size_t
+ca_shift_rolled_index (CAShift *ca, ca_size_t i, ca_size_t k)
 {
-  int32_t dim = ca->dim[i];
-  int32_t shift = ca->shift[i];
-  int32_t idx = k - shift;
+  ca_size_t dim = ca->dim[i];
+  ca_size_t shift = ca->shift[i];
+  ca_size_t idx = k - shift;
   if ( idx >= 0 ) {
     return idx % dim;
   }
@@ -147,12 +147,12 @@ ca_shift_rolled_index (CAShift *ca, int32_t i, int32_t k)
   }
 }
 
-static int32_t
-ca_shift_shifted_index (CAShift *ca, int32_t i, int32_t k)
+static ca_size_t
+ca_shift_shifted_index (CAShift *ca, ca_size_t i, ca_size_t k)
 {
-  int32_t dim   = ca->dim[i];
-  int32_t shift = ca->shift[i];
-  int32_t idx   = k - shift;
+  ca_size_t dim   = ca->dim[i];
+  ca_size_t shift = ca->shift[i];
+  ca_size_t idx   = k - shift;
   if ( idx < 0 || idx >= dim ) {
     return -1;
   }
@@ -171,11 +171,11 @@ ca_shift_func_clone (void *ap)
 }
 
 static char *
-ca_shift_func_ptr_at_addr (void *ap, int32_t addr)
+ca_shift_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CAShift *ca = (CAShift *) ap;
   if ( ! ca->ptr ) {
-    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);
   }
@@ -185,13 +185,14 @@ ca_shift_func_ptr_at_addr (void *ap, int32_t addr)
 }
 
 static char *
-ca_shift_func_ptr_at_index (void *ap, int32_t *idx)
+ca_shift_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CAShift *ca = (CAShift *) ap;
   if ( ! ca->ptr ) {
-    int32_t *dim    = ca->dim;
+    ca_size_t *dim    = ca->dim;
     int8_t *roll = ca->roll;
-    int32_t i, k, n;
+    int8_t i;
+    ca_size_t k, n;
     n = 0;
     for (i=0; i<ca->rank; i++) {
       k = idx[i];
@@ -221,12 +222,13 @@ ca_shift_func_ptr_at_index (void *ap, int32_t *idx)
 }
 
 static void
-ca_shift_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_shift_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAShift *ca = (CAShift *) ap;
-  int32_t *dim    = ca->dim;
+  ca_size_t *dim    = ca->dim;
   int8_t *roll = ca->roll;
-  int32_t i, k, n;
+  int8_t  i;
+  ca_size_t k, n;
   n = 0;
   for (i=0; i<ca->rank; i++) {
     k = idx[i];
@@ -247,12 +249,13 @@ ca_shift_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_shift_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_shift_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAShift *ca = (CAShift *) ap;
-  int32_t *dim    = ca->dim;
+  ca_size_t *dim    = ca->dim;
   int8_t *roll = ca->roll;
-  int32_t i, k, n;
+  int8_t i;
+  ca_size_t k, n;
   n = 0;
   for (i=0; i<ca->rank; i++) {
     k = idx[i];
@@ -391,13 +394,13 @@ ca_operation_function_t ca_shift_func = {
 /* ------------------------------------------------------------------- */
 
 static void
-ca_shift_attach_loop (CAShift *ca, int16_t level, int32_t *idx, int32_t *idx0,
+ca_shift_attach_loop (CAShift *ca, int16_t level, ca_size_t *idx, ca_size_t *idx0,
                                                                   int32_t fill)
 {
-  int32_t dim   = ca->dim[level];
-  int32_t shift = ca->shift[level];
+  ca_size_t dim   = ca->dim[level];
+  ca_size_t shift = ca->shift[level];
   int8_t roll = ca->roll[level];
-  int32_t i;
+  ca_size_t i;
 
   if ( level == ca->rank - 1 ) {
     if ( fill ) {
@@ -545,18 +548,18 @@ ca_shift_attach_loop (CAShift *ca, int16_t level, int32_t *idx, int32_t *idx0,
 static void
 ca_shift_attach (CAShift *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_shift_attach_loop(ca, (int16_t) 0, idx, idx0, 0);
 }
 
 static void
-ca_shift_sync_loop (CAShift *ca, int16_t level, int32_t *idx, int32_t *idx0)
+ca_shift_sync_loop (CAShift *ca, int16_t level, ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t dim   = ca->dim[level];
-  int32_t shift = ca->shift[level];
+  ca_size_t dim   = ca->dim[level];
+  ca_size_t shift = ca->shift[level];
   int8_t roll = ca->roll[level];
-  int32_t i;
+  ca_size_t i;
 
   if ( level == ca->rank - 1 ) {
     if ( ! shift ) {
@@ -688,19 +691,19 @@ ca_shift_sync_loop (CAShift *ca, int16_t level, int32_t *idx, int32_t *idx0)
 static void
 ca_shift_sync (CAShift *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_shift_sync_loop(ca, (int16_t) 0, idx, idx0);
 }
 
 static void
 ca_shift_fill_loop (CAShift *ca, char *ptr,
-                  int16_t level, int32_t *idx0)
+                  int16_t level, ca_size_t *idx0)
 {
-  int32_t dim   = ca->dim[level];
-  int32_t shift = ca->shift[level];
+  ca_size_t dim   = ca->dim[level];
+  ca_size_t shift = ca->shift[level];
   int8_t roll = ca->roll[level];
-  int32_t i;
+  ca_size_t i;
 
   if ( level == ca->rank - 1 ) {
     if ( ( ! shift ) || roll ) {
@@ -783,7 +786,7 @@ ca_shift_fill_loop (CAShift *ca, char *ptr,
 static void
 ca_shift_fill (CAShift *ca, char *ptr)
 {
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_shift_fill_loop(ca, ptr, (int16_t) 0, idx0);
 }
 
@@ -811,7 +814,7 @@ rb_ca_shift_set_fill_value (VALUE self, VALUE rfval)
 */
 
 VALUE
-rb_ca_shift_new (VALUE cary, int32_t *shift, char *fill, int8_t *roll)
+rb_ca_shift_new (VALUE cary, ca_size_t *shift, char *fill, int8_t *roll)
 {
   volatile VALUE obj;
   CArray *parent;
@@ -838,10 +841,10 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
   volatile VALUE obj, ropt, rfval = CA_NIL, rroll = Qnil, rcs;
   CArray *ca;
   CScalar *cs;
-  int32_t shift[CA_RANK_MAX];
+  ca_size_t shift[CA_RANK_MAX];
   int8_t roll[CA_RANK_MAX];
   char *fill = NULL;
-  int32_t i;
+  int8_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -853,7 +856,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
   }
 
   for (i=0; i<ca->rank; i++) {
-    shift[i] = NUM2INT(argv[i]);
+    shift[i] = NUM2SIZE(argv[i]);
   }
 
   if ( rfval == CA_NIL ) {
@@ -870,7 +873,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
     Data_Get_Struct(rcs, CScalar, cs);
     fill = cs->ptr;
     if ( ca_is_object_type(ca) ) {
-      *(VALUE *)fill = INT2FIX(0);
+      *(VALUE *)fill = INT2NUM(0);
     }
     else {
       memset(fill, 0, cs->bytes);

data/ca_obj_transpose.c

@@ -17,17 +17,17 @@ typedef struct {
   int8_t    data_type;
   int8_t    rank;
   int32_t   flags;
-  int32_t   bytes;
-  int32_t   elements;
-  int32_t  *dim;
+  ca_size_t   bytes;
+  ca_size_t   elements;
+  ca_size_t  *dim;
   char     *ptr;
   CArray   *mask;
   CArray   *parent;
   uint32_t  attach;
   uint8_t   nosync;
   /* -------------*/
-  int32_t  *imap;
-  int32_t   step;
+  ca_size_t  *imap;
+  ca_size_t   step;
 } CATrans;
 
 static int8_t CA_OBJ_TRANSPOSE;
@@ -42,14 +42,15 @@ static VALUE rb_cCATrans;
 /* ------------------------------------------------------------------- */
 
 int
-ca_trans_setup (CATrans *ca, CArray *parent, int32_t *imap)
+ca_trans_setup (CATrans *ca, CArray *parent, ca_size_t *imap)
 {
   int8_t data_type, rank;
-  int32_t bytes, elements;
-  int32_t *dim0;
-  int32_t newdim[CA_RANK_MAX];
-  int32_t map[CA_RANK_MAX];
-  int i, idim, step;
+  ca_size_t bytes, elements;
+  ca_size_t *dim0;
+  ca_size_t newdim[CA_RANK_MAX];
+  ca_size_t map[CA_RANK_MAX];
+  int8_t i;
+  ca_size_t idim, step;
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
@@ -89,16 +90,16 @@ ca_trans_setup (CATrans *ca, CArray *parent, int32_t *imap)
   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->imap      = ALLOC_N(int32_t, rank);
+  ca->imap      = ALLOC_N(ca_size_t, rank);
   ca->step      = step;
 
-  memcpy(ca->dim,  newdim, rank * sizeof(int32_t));
-  memcpy(ca->imap, imap,   rank * sizeof(int32_t));
+  memcpy(ca->dim,  newdim, rank * sizeof(ca_size_t));
+  memcpy(ca->imap, imap,   rank * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -108,7 +109,7 @@ ca_trans_setup (CATrans *ca, CArray *parent, int32_t *imap)
 }
 
 CATrans *
-ca_trans_new (CArray *parent, int32_t *imap)
+ca_trans_new (CArray *parent, ca_size_t *imap)
 {
   CATrans *ca = ALLOC(CATrans);
   ca_trans_setup(ca, parent, imap);
@@ -142,30 +143,30 @@ ca_trans_func_clone (void *ap)
 }
 
 static char *
-ca_trans_func_ptr_at_addr (void *ap, int32_t addr)
+ca_trans_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CATrans *ca = (CATrans *) 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_trans_func_ptr_at_index (void *ap, int32_t *idx)
+ca_trans_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CATrans *ca = (CATrans *) ap;
   if ( ca->ptr ) {
     return ca_array_func_ptr_at_index(ca, idx);
   }
   else {
-    int32_t *imap = ca->imap;
-    int32_t idx0[CA_RANK_MAX];
-    int32_t i;
+    ca_size_t *imap = ca->imap;
+    ca_size_t idx0[CA_RANK_MAX];
+    int8_t i;
     for (i=0; i<ca->rank; i++) {
       idx0[imap[i]] = idx[i];
     }
@@ -174,12 +175,12 @@ ca_trans_func_ptr_at_index (void *ap, int32_t *idx)
 }
 
 static void
-ca_trans_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_trans_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CATrans *ca = (CATrans *) ap;
-  int32_t *imap = ca->imap;
-  int32_t idx0[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t *imap = ca->imap;
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t i;
   for (i=0; i<ca->rank; i++) {
     idx0[imap[i]] = idx[i];
   }
@@ -187,12 +188,12 @@ ca_trans_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_trans_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_trans_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CATrans *ca = (CATrans *) ap;
-  int32_t *imap = ca->imap;
-  int32_t idx0[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t *imap = ca->imap;
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t i;
   for (i=0; i<ca->rank; i++) {
     idx0[imap[i]] = idx[i];
   }
@@ -303,12 +304,12 @@ ca_operation_function_t ca_trans_func = {
 /* ------------------------------------------------------------------- */
 
 static void
-ca_trans_attach_loop (CATrans *ca, int8_t level, int32_t *idx, int32_t *idx0)
+ca_trans_attach_loop (CATrans *ca, int8_t level, ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t step = ca->step;
-  int32_t dim = ca->dim[level];
-  int32_t *imap = ca->imap;
-  int32_t i;
+  ca_size_t step = ca->step;
+  ca_size_t dim = ca->dim[level];
+  ca_size_t *imap = ca->imap;
+  ca_size_t i;
 
   if ( level == ca->rank - 1 ) {
     idx[level] = 0;
@@ -378,18 +379,18 @@ ca_trans_attach_loop (CATrans *ca, int8_t level, int32_t *idx, int32_t *idx0)
 static void
 ca_trans_attach (CATrans *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_trans_attach_loop(ca, 0, idx, idx0);
 }
 
 static void
-ca_trans_sync_loop (CATrans *ca, int8_t level, int32_t *idx, int32_t *idx0)
+ca_trans_sync_loop (CATrans *ca, int8_t level, ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t step = ca->step;
-  int32_t dim = ca->dim[level];
-  int32_t *imap = ca->imap;
-  int32_t i;
+  ca_size_t step = ca->step;
+  ca_size_t dim = ca->dim[level];
+  ca_size_t *imap = ca->imap;
+  ca_size_t i;
 
   if ( level == ca->rank - 1 ) {
     idx[level] = 0;
@@ -459,18 +460,18 @@ ca_trans_sync_loop (CATrans *ca, int8_t level, int32_t *idx, int32_t *idx0)
 static void
 ca_trans_sync (CATrans *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_trans_sync_loop(ca, 0, idx, idx0);
 }
 
 /*
 static void
 ca_trans_fill_loop (CATrans *ca, char *ptr,
-                   int8_t level, int32_t *idx0)
+                   int8_t level, ca_size_t *idx0)
 {
-  int32_t *imap = ca->imap;
-  int32_t i;
+  ca_size_t *imap = ca->imap;
+  ca_size_t i;
 
   if ( level == ca->rank - 1 ) {
     for (i=0; i<ca->dim[level]; i++) {
@@ -496,7 +497,7 @@ ca_trans_fill (CATrans *ca, char *ptr)
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_trans_new (VALUE cary, int32_t *imap)
+rb_ca_trans_new (VALUE cary, ca_size_t *imap)
 {
   volatile VALUE obj;
   CArray *parent;
@@ -522,8 +523,8 @@ rb_ca_trans (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE obj;
   CArray *ca;
-  int32_t imap[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t imap[CA_RANK_MAX];
+  int8_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -534,7 +535,7 @@ rb_ca_trans (int argc, VALUE *argv, VALUE self)
   }
   else if ( argc == ca->rank ) {
     for (i=0; i<ca->rank; i++) {
-      imap[i] = NUM2INT(argv[i]);
+      imap[i] = NUM2SIZE(argv[i]);
     }
   }
   else {