carray 1.4.0 → 1.5.1

data/{ca_obj_object.c → ext/ca_obj_object.c}

@@ -59,10 +59,10 @@ static VALUE rb_cCAObjectMask;
 
 
 static CAObjectMask *
-ca_objmask_new (VALUE array, int8_t rank, ca_size_t *dim)
+ca_objmask_new (VALUE array, int8_t ndim, ca_size_t *dim)
 {
   CAObjectMask *ca = ALLOC(CAObjectMask);
-  ca_wrap_setup_null((CArray *)ca, CA_BOOLEAN, rank, dim, 0, NULL);
+  ca_wrap_setup_null((CArray *)ca, CA_BOOLEAN, ndim, dim, 0, NULL);
   ca->obj_type = CA_OBJ_OBJECT_MASK;
   ca->array = array;
 
@@ -81,7 +81,7 @@ static void *
 ca_objmask_func_clone (void *ap)
 {
   CAObjectMask *ca = (CAObjectMask *) ap;
-  return ca_objmask_new(ca->array, ca->rank, ca->dim);
+  return ca_objmask_new(ca->array, ca->ndim, ca->dim);
 }
 
 void
@@ -100,8 +100,8 @@ ca_objmask_func_fetch_addr (void *ap, ca_size_t addr, void *ptr)
   else if ( rb_obj_respond_to(ca->array, rb_intern("mask_fetch_index"), Qtrue) ) {
     ca_size_t idx[CA_RANK_MAX];
     ca_addr2index(ca, addr, idx);
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rval = rb_funcall(ca->array, rb_intern("mask_fetch_index"), 1, ridx);
@@ -121,8 +121,8 @@ ca_objmask_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
   int i;
 
   if ( rb_obj_respond_to(ca->array, rb_intern("mask_fetch_index"), Qtrue) ) {
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rval = rb_funcall(ca->array, rb_intern("mask_fetch_index"), 1, ridx);
@@ -158,8 +158,8 @@ ca_objmask_func_store_addr (void *ap, ca_size_t addr, void *ptr)
   else if ( rb_obj_respond_to(ca->array, rb_intern("mask_store_index"), Qtrue) ) {
     ca_size_t idx[CA_RANK_MAX];
     ca_addr2index(ca, addr, idx);
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rb_funcall(ca->array, rb_intern("mask_store_index"), 2, ridx, rval);
@@ -177,8 +177,8 @@ ca_objmask_func_store_index (void *ap, ca_size_t *idx, void *ptr)
   rval = INT2NUM( *(uint8_t*)ptr );
 
   if ( rb_obj_respond_to(ca->array, rb_intern("mask_store_index"), Qtrue) ) {
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rb_funcall(ca->array, rb_intern("mask_store_index"), 2, ridx, rval);
@@ -290,7 +290,7 @@ rb_ca_objmask_initialize_copy (VALUE self, VALUE other)
   Data_Get_Struct(self,  CAObjectMask, ca);
   Data_Get_Struct(other, CAObjectMask, cs);
 
-  carray_setup((CArray *)ca, CA_BOOLEAN, cs->rank, cs->dim, 0, NULL);
+  carray_setup((CArray *)ca, CA_BOOLEAN, cs->ndim, cs->dim, 0, NULL);
   ca->obj_type = CA_OBJ_OBJECT_MASK;
   ca->array = cs->array;
 
@@ -301,7 +301,7 @@ rb_ca_objmask_initialize_copy (VALUE self, VALUE other)
 
 static int
 ca_object_setup (CAObject *ca,
-               int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes)
+               int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes)
 {
   ca_size_t elements;
   double  length;
@@ -310,15 +310,15 @@ ca_object_setup (CAObject *ca,
   /* check arguments */
 
   CA_CHECK_DATA_TYPE(data_type);
-  CA_CHECK_RANK(rank);
-  CA_CHECK_DIM(rank, dim);
+  CA_CHECK_RANK(ndim);
+  CA_CHECK_DIM(ndim, dim);
   CA_CHECK_BYTES(data_type, bytes);
 
   /* calculate total number of elements */
 
   elements = 1;
   length = bytes;
-  for (i=0; i<rank; i++) {
+  for (i=0; i<ndim; i++) {
     elements *= dim[i];
     length   *= dim[i];
   }
@@ -330,7 +330,7 @@ ca_object_setup (CAObject *ca,
   ca->obj_type  = CA_OBJ_OBJECT;
   ca->data_type = data_type;
   ca->flags     = 0;
-  ca->rank      = rank;
+  ca->ndim      = ndim;
   ca->bytes     = bytes;
   ca->elements  = elements;
   ca->ptr       = NULL;
@@ -339,20 +339,20 @@ ca_object_setup (CAObject *ca,
   ca->attach    = 0;
   ca->nosync    = 0;
 
-  ca->dim       = ALLOC_N(ca_size_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, ndim);
 
-  ca->data      = ca_wrap_new_null(data_type, rank, dim, bytes, NULL);
+  ca->data      = ca_wrap_new_null(data_type, ndim, dim, bytes, NULL);
 
-  memcpy(ca->dim, dim, rank * sizeof(ca_size_t));
+  memcpy(ca->dim, dim, ndim * sizeof(ca_size_t));
 
   return 0;
 }
 
 static CAObject *
-ca_object_new (int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes)
+ca_object_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes)
 {
   CAObject *ca = ALLOC(CAObject);
-  ca_object_setup(ca, data_type, rank, dim, bytes);
+  ca_object_setup(ca, data_type, ndim, dim, bytes);
   return ca;
 }
 
@@ -373,7 +373,7 @@ static void *
 ca_object_func_clone (void *ap)
 {
   CAObject *ca = (CAObject *) ap;
-  return ca_object_new(ca->bytes, ca->rank, ca->dim, ca->bytes);
+  return ca_object_new(ca->bytes, ca->ndim, ca->dim, ca->bytes);
 }
 
 #define ca_object_func_ptr_at_addr ca_array_func_ptr_at_addr
@@ -408,8 +408,8 @@ ca_object_func_fetch_addr (void *ap, ca_size_t addr, void *ptr)
   else {
     ca_size_t idx[CA_RANK_MAX];
     ca_addr2index(ca, addr, idx);
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rval = rb_funcall(ca->self, rb_intern("fetch_index"), 1, ridx);
@@ -439,8 +439,8 @@ ca_object_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
   volatile VALUE ridx, raddr, rval;
   int i;
   if ( rb_obj_respond_to(ca->self, rb_intern("fetch_index"), Qtrue) ) {
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rval = rb_funcall(ca->self, rb_intern("fetch_index"), 1, ridx);
@@ -498,8 +498,8 @@ ca_object_func_store_addr (void *ap, ca_size_t addr, void *ptr)
   else {
     ca_size_t idx[CA_RANK_MAX];
     ca_addr2index(ca, addr, idx);
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rval = rb_ca_ptr2obj(ca->self, ptr);
@@ -514,8 +514,8 @@ ca_object_func_store_index (void *ap, ca_size_t *idx, void *ptr)
   volatile VALUE ridx, raddr, rval;
   int i;
   if ( rb_obj_respond_to(ca->self, rb_intern("store_index"), Qtrue) ) {
-    ridx = rb_ary_new2(ca->rank);
-    for (i=0; i<ca->rank; i++) {
+    ridx = rb_ary_new2(ca->ndim);
+    for (i=0; i<ca->ndim; i++) {
       rb_ary_store(ridx, i, SIZE2NUM(idx[i]));
     }
     rval = rb_ca_ptr2obj(ca->self, ptr);
@@ -634,7 +634,7 @@ ca_object_func_create_mask (void *ap)
   if ( ! ca->data->mask ) {
     ca_create_mask(ca->data);
   }
-  ca->mask = (CArray*) ca_objmask_new(ca->self, ca->rank, ca->dim);
+  ca->mask = (CArray*) ca_objmask_new(ca->self, ca->ndim, ca->dim);
   ca->mask->ptr = ca->data->mask->ptr;
   rmask = ca_wrap_struct(ca->mask);
   rb_ivar_set(ca->self, rb_intern("mask"), rmask);
@@ -679,7 +679,7 @@ rb_ca_object_initialize_copy (VALUE self, VALUE other)
   Data_Get_Struct(self,  CAObject, ca);
   Data_Get_Struct(other, CAObject, cs);
 
-  ca_object_setup(ca, cs->data_type, cs->rank, cs->dim, cs->bytes);
+  ca_object_setup(ca, cs->data_type, cs->ndim, cs->dim, cs->bytes);
   ca->self = self;
 
   rb_ca_data_type_inherit(self, other);
@@ -703,7 +703,7 @@ rb_ca_object_initialize (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE rtype, rdim, ropt, rbytes = Qnil, rrdonly = Qnil, rparent = Qnil, rdata;
   CAObject *ca;
-  int8_t data_type, rank;
+  int8_t data_type, ndim;
   ca_size_t dim[CA_RANK_MAX];
   ca_size_t bytes;
   int i;
@@ -721,13 +721,13 @@ rb_ca_object_initialize (int argc, VALUE *argv, VALUE self)
 
   Check_Type(rdim, T_ARRAY);
 
-  rank = RARRAY_LEN(rdim);
-  for (i=0; i<rank; i++) {
+  ndim = RARRAY_LEN(rdim);
+  for (i=0; i<ndim; i++) {
     dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
   }
 
   Data_Get_Struct(self, CAObject, ca);
-  ca_object_setup(ca, data_type, rank, dim, bytes);
+  ca_object_setup(ca, data_type, ndim, dim, bytes);
   ca->self = self;
 
   rdata = ca_wrap_struct(ca->data);

data/{ca_obj_reduce.c → ext/ca_obj_reduce.c}

@@ -40,7 +40,7 @@ ca_reduce_setup (CAReduce *ca, CArray *parent, ca_size_t count, ca_size_t offset
   ca->obj_type  = CA_OBJ_REDUCE;
   ca->data_type = CA_BOOLEAN;     /* data type is fixed to boolean */
   ca->flags     = 0;
-  ca->rank      = 1;
+  ca->ndim      = 1;
   ca->bytes     = ca_sizeof[CA_BOOLEAN];
   ca->elements  = elements;
   ca->ptr       = NULL;

data/{ca_obj_refer.c → ext/ca_obj_refer.c}

@@ -21,7 +21,7 @@ VALUE rb_cCARefer;
 
 static int
 ca_refer_setup (CARefer *ca, CArray *parent,
-                int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+                int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                 ca_size_t offset)
 {
   ca_size_t elements, ratio;
@@ -29,8 +29,8 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   int     is_deformed;
 
   CA_CHECK_DATA_TYPE(data_type);
-  CA_CHECK_RANK(rank);
-  CA_CHECK_DIM(rank, dim);
+  CA_CHECK_RANK(ndim);
+  CA_CHECK_DIM(ndim, dim);
   CA_CHECK_BYTES(data_type, bytes);
 
   if ( ca_is_object_type(parent) && data_type != CA_OBJECT ) {
@@ -42,10 +42,10 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   }
 
   /* calc datanum and check deformation */
-  is_deformed = ( rank == parent->rank ) ? 0 : 1;
+  is_deformed = ( ndim == parent->ndim ) ? 0 : 1;
   ratio = 1;
   elements = 1;
-  for (i=0; i<rank; i++) {
+  for (i=0; i<ndim; i++) {
     elements *= dim[i];
     if ( dim[i] != parent->dim[i] ) {
       is_deformed |= 1;
@@ -79,10 +79,10 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   ca->obj_type  = CA_OBJ_REFER;
   ca->data_type = data_type;
   ca->flags     = 0;
-  ca->rank      = rank;
+  ca->ndim      = ndim;
   ca->bytes     = bytes;
   ca->elements  = elements;
-  ca->dim       = ALLOC_N(ca_size_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, ndim);
   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(ca_size_t));
+  memcpy(ca->dim, dim, ndim * sizeof(ca_size_t));
 
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -110,11 +110,11 @@ ca_refer_setup (CARefer *ca, CArray *parent,
 
 CARefer *
 ca_refer_new (CArray *parent,
-              int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+              int8_t data_type, int8_t ndim, 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);
+  ca_refer_setup(ca, parent, data_type, ndim, dim, bytes, offset);
   return ca;
 }
 
@@ -137,7 +137,7 @@ ca_refer_func_clone (void *ap)
 {
   CARefer *ca = (CARefer *) ap;
   return ca_refer_new(ca->parent,
-                      ca->data_type, ca->rank, ca->dim, ca->bytes, ca->offset);
+                      ca->data_type, ca->ndim, ca->dim, ca->bytes, ca->offset);
 }
 
 static char *
@@ -167,9 +167,9 @@ ca_refer_func_ptr_at_index (void *ap, ca_size_t *idx)
   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] */
+  n = idx[0];                  /* n = idx[0]*dim[1]*dim[2]*...*dim[ndim-1] */
+  for (i=1; i<ca->ndim; i++) { /*    + idx[1]*dim[1]*dim[2]*...*dim[ndim-1] */
+    n = dim[i]*n+idx[i];       /*    ... + idx[ndim-2]*dim[1] + idx[ndim-1] */
   }
   return ca->ptr + ca->bytes * n;
 }
@@ -222,7 +222,7 @@ ca_refer_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
     int8_t   i;
     ca_size_t  n;
     n = idx[0];
-    for (i=1; i<ca->rank; i++) {
+    for (i=1; i<ca->ndim; i++) {
       n = dim[i]*n+idx[i];
     }
     ca_refer_func_fetch_addr(ca, n, ptr);
@@ -283,7 +283,7 @@ ca_refer_func_store_index (void *ap, ca_size_t *idx, void *ptr)
     int8_t   i;
     ca_size_t  n;
     n = idx[0];
-    for (i=1; i<ca->rank; i++) {
+    for (i=1; i<ca->ndim; i++) {
       n = dim[i]*n+idx[i];
     }
     ca_refer_func_store_addr(ca, n, ptr);
@@ -421,29 +421,29 @@ ca_refer_func_create_mask (void *ap)
   if ( ca->bytes == ca->parent->bytes ) {
     ca->mask =
       (CArray *) ca_refer_new(ca->parent->mask,
-                              CA_BOOLEAN, ca->rank, ca->dim, 0, ca->offset);
+                              CA_BOOLEAN, ca->ndim, ca->dim, 0, ca->offset);
   }
   else if ( ca->is_deformed == -2 ) {
     ca_size_t count[CA_RANK_MAX];
     int i;
-    for (i=0; i<ca->parent->rank; i++) {
+    for (i=0; i<ca->parent->ndim; i++) {
       count[i] = 0;
     }
-    count[ca->parent->rank] = ca->ratio;
+    count[ca->parent->ndim] = ca->ratio;
     ca->mask0 = 
-      (CArray *) ca_repeat_new(ca->parent->mask, ca->parent->rank+1, count);
+      (CArray *) ca_repeat_new(ca->parent->mask, ca->parent->ndim+1, count);
     ca_unset_flag(ca->mask0, CA_FLAG_READ_ONLY);
 
     ca->mask  = 
       (CArray *) ca_refer_new(ca->mask0, 
-                              CA_BOOLEAN, ca->rank, ca->dim, 0, ca->offset);
+                              CA_BOOLEAN, ca->ndim, ca->dim, 0, ca->offset);
   }
   else if ( ca->is_deformed == 2 ) {
     /* TODO */
     ca->mask0 = 
       (CArray *) ca_reduce_new(ca->parent->mask, ca->ratio, ca->offset);
     ca->mask  = 
-      (CArray *) ca_refer_new(ca->mask0, CA_BOOLEAN, ca->rank, ca->dim, 0, 0);
+      (CArray *) ca_refer_new(ca->mask0, CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
   }
 }
 
@@ -485,7 +485,7 @@ rb_ca_refer_initialize_copy (VALUE self, VALUE other)
   Data_Get_Struct(self,  CARefer, ca);
   Data_Get_Struct(other, CARefer, cs);
 
-  ca_refer_setup(ca, cs->parent, cs->data_type, cs->rank, cs->dim,
+  ca_refer_setup(ca, cs->parent, cs->data_type, cs->ndim, cs->dim,
                              cs->bytes, cs->offset);
 
   return self;
@@ -514,7 +514,7 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
   CArray *ca;
   CARefer *cr;
   int8_t  data_type;
-  int8_t  rank;
+  int8_t  ndim;
   ca_size_t dim[CA_RANK_MAX];
   ca_size_t bytes, offset = 0;
   int8_t i;
@@ -524,11 +524,11 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
   if ( argc == 0 ) {                 /* CArray#refer() */
     data_type = ca->data_type;
     bytes     = ca->bytes;
-    rank      = ca->rank;
-    for (i=0; i<rank; i++) {
+    ndim      = ca->ndim;
+    for (i=0; i<ndim; i++) {
       dim[i] = ca->dim[i];
     }
-    cr = ca_refer_new((CArray*)ca, data_type, rank, dim, bytes, offset);
+    cr = ca_refer_new((CArray*)ca, data_type, ndim, dim, bytes, offset);
     obj = ca_wrap_struct(cr);
     rb_ca_set_parent(obj, self);
     rb_ca_data_type_inherit(obj, self);
@@ -558,10 +558,10 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
     }
 
     Check_Type(rdim, T_ARRAY);
-    rank = RARRAY_LEN(rdim);
+    ndim = RARRAY_LEN(rdim);
 
     elements = 1;
-    for (i=0; i<rank; i++) {
+    for (i=0; i<ndim; i++) {
       dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
       elements *= dim[i];
     }
@@ -570,7 +570,7 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
       offset = NUM2SIZE(roffset);
     }
 
-    cr = ca_refer_new((CArray*)ca, data_type, rank, dim, bytes, offset);
+    cr = ca_refer_new((CArray*)ca, data_type, ndim, dim, bytes, offset);
     obj = ca_wrap_struct(cr);
     rb_ca_set_parent(obj, self);
     rb_ca_data_type_import(obj, rtype);
@@ -584,7 +584,7 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
 
 VALUE
 rb_ca_refer_new (VALUE self,
-                 int8_t data_type, int8_t rank, ca_size_t *dim, ca_size_t bytes,
+                 int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                  ca_size_t offset)
 {
   volatile VALUE list, rdim, ropt;
@@ -593,8 +593,8 @@ rb_ca_refer_new (VALUE self,
 
   Data_Get_Struct(self, CArray, ca);
 
-  rdim = rb_ary_new2(rank);
-  for (i=0; i<rank; i++) {
+  rdim = rb_ary_new2(ndim);
+  for (i=0; i<ndim; i++) {
     rb_ary_store(rdim, i, SIZE2NUM(dim[i]));
   }
 

data/{ca_obj_repeat.c → ext/ca_obj_repeat.c}

@@ -20,16 +20,16 @@ VALUE rb_cCARepeat;
 */
 
 int
-ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, ca_size_t *count)
+ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t ndim, ca_size_t *count)
 {
   int8_t data_type;
   ca_size_t elements, bytes, nrpt, repeat_level, repeat_num,
-                     contig_level, contig_num, data_rank;
+                     contig_level, contig_num, data_ndim;
   int i, j;
 
   nrpt = 1;
-  data_rank  = 0;
-  for (i=0; i<rank; i++) {
+  data_ndim  = 0;
+  for (i=0; i<ndim; i++) {
     if ( count[i] < 0 ) {
       rb_raise(rb_eRuntimeError,
                "negative size for %i-th dimension specified", i);
@@ -39,27 +39,27 @@ ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, ca_size_t *count)
       nrpt *= count[i];
     }
     else {
-      data_rank += 1;
+      data_ndim += 1;
     }
   }
 
   repeat_level = 0;
   repeat_num   = 1;
-  for (i=0; i<rank && count[i]; i++) {
+  for (i=0; i<ndim && count[i]; i++) {
     repeat_level = i+1;
     repeat_num  *= count[i];
   }
 
-  contig_level = rank-1;
+  contig_level = ndim-1;
   contig_num   = 1;
-  for (i=rank-1; i >= 0 && count[i]; i--) {
+  for (i=ndim-1; i >= 0 && count[i]; i--) {
     contig_level = i;
     contig_num  *= count[i];
   }
   
-  if ( data_rank != parent->rank ) {
+  if ( data_ndim != parent->ndim ) {
     rb_raise(rb_eRuntimeError,
-             "mismatch in rank between original array and determined by # of dummies");
+             "mismatch in ndim between original array and determined by # of dummies");
   }
 
   if ( ((double) parent->elements) * nrpt > CA_LENGTH_MAX ) {
@@ -73,24 +73,24 @@ ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, ca_size_t *count)
   ca->obj_type  = CA_OBJ_REPEAT;
   ca->data_type = data_type;
   ca->flags     = 0;
-  ca->rank      = rank;
+  ca->ndim      = ndim;
   ca->bytes     = bytes;
   ca->elements  = elements;
   ca->ptr       = NULL;
   ca->mask      = NULL;
-  ca->dim       = ALLOC_N(ca_size_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, ndim);
 
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
-  ca->count     = ALLOC_N(ca_size_t, rank);
+  ca->count     = ALLOC_N(ca_size_t, ndim);
   ca->repeat_level = repeat_level;
   ca->repeat_num   = repeat_num;
   ca->contig_level = contig_level;
   ca->contig_num   = contig_num;
 
   j = 0;
-  for (i=0; i<rank; i++) {
+  for (i=0; i<ndim; i++) {
     if ( count[i] ) {
       ca->dim[i] = count[i];
     }
@@ -99,7 +99,7 @@ ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, ca_size_t *count)
     }
   }
 
-  memcpy(ca->count, count, rank * sizeof(ca_size_t));
+  memcpy(ca->count, count, ndim * sizeof(ca_size_t));
 
   ca_set_flag(ca, CA_FLAG_READ_ONLY);
 
@@ -112,10 +112,10 @@ ca_repeat_setup (CARepeat *ca, CArray *parent, int8_t rank, ca_size_t *count)
 
 
 CARepeat *
-ca_repeat_new (CArray *parent, int8_t rank, ca_size_t *count)
+ca_repeat_new (CArray *parent, int8_t ndim, ca_size_t *count)
 {
   CARepeat *ca = ALLOC(CARepeat);
-  ca_repeat_setup(ca, parent, rank, count);
+  ca_repeat_setup(ca, parent, ndim, count);
   return ca;
 }
 
@@ -141,7 +141,7 @@ static void *
 ca_repeat_func_clone (void *ap)
 {
   CARepeat *ca = (CARepeat *) ap;
-  return ca_repeat_new(ca->parent, ca->rank, ca->count);
+  return ca_repeat_new(ca->parent, ca->ndim, ca->count);
 }
 
 static char *
@@ -173,7 +173,7 @@ ca_repeat_func_ptr_at_index (void *ap, ca_size_t *idx)
 
     j = 0;
     n = 0;
-    for (i=0; i<ca->rank; i++) {
+    for (i=0; i<ca->ndim; i++) {
       if ( ! count[i] ) {
         n = dim0[j]*n + idx[i];
         j++;
@@ -199,7 +199,7 @@ ca_repeat_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
   ca_size_t  n, j;
   j = 0;
   n = 0;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     if ( ! count[i] ) {
       idx0[j++] = idx[i];
     }
@@ -217,7 +217,7 @@ ca_repeat_func_store_index (void *ap, ca_size_t *idx, void *ptr)
   ca_size_t  n, j;
   j = 0;
   n = 0;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     if ( ! count[i] ) {
       idx0[j++] = idx[i];
     }
@@ -305,7 +305,7 @@ ca_repeat_func_create_mask (void *ap)
     ca_create_mask(ca->parent);
   }
   ca->mask =
-    (CArray *) ca_repeat_new(ca->parent->mask, ca->rank, ca->count);
+    (CArray *) ca_repeat_new(ca->parent->mask, ca->ndim, ca->count);
 }
 
 ca_operation_function_t ca_repeat_func = {
@@ -410,7 +410,7 @@ ca_repeat_attach (CARepeat *ca)
   ca_size_t i;
   char *dp, *sp;
 
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     idx[i] = 0;
     idx0[i] = 0;
   }
@@ -459,7 +459,7 @@ ca_repeat_sync (CARepeat *ca)
   ca_size_t idx[CA_RANK_MAX];
   ca_size_t idx0[CA_RANK_MAX];
   int8_t i;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     idx[i] = 0;
     idx0[i] = 0;
   }
@@ -475,14 +475,14 @@ ca_repeat_fill (CARepeat *ca, char *ptr)
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_repeat_new (VALUE cary, int8_t rank, ca_size_t *count)
+rb_ca_repeat_new (VALUE cary, int8_t ndim, ca_size_t *count)
 {
   volatile VALUE obj;
   CArray *parent;
   CARepeat *ca;
   rb_check_carray_object(cary);
   Data_Get_Struct(cary, CArray, parent);
-  ca = ca_repeat_new(parent, rank, count);
+  ca = ca_repeat_new(parent, ndim, count);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);
   rb_ca_data_type_inherit(obj, cary);
@@ -507,7 +507,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
        ) ) {
     volatile VALUE args;
     CArray *ct;
-    ca_size_t rank, dim[CA_RANK_MAX];
+    ca_size_t ndim, dim[CA_RANK_MAX];
     int k;
     if ( argv[0] == ID2SYM(rb_intern("%") ) ) {
       Data_Get_Struct(argv[1], CArray, ct);
@@ -515,34 +515,34 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
     else {
       Data_Get_Struct(argv[0], CArray, ct);
     }
-    if ( ct->rank < ca->rank ) {
-      rb_raise(rb_eRuntimeError, "invalid rank to template");
+    if ( ct->ndim < ca->ndim ) {
+      rb_raise(rb_eRuntimeError, "invalid ndim to template");
     }
     args = rb_ary_new();
-    rank = 0;
+    ndim = 0;
     if ( argv[0] == ID2SYM(rb_intern("%") ) ) {
       k = 0;
-      for (i=0; i<ct->rank; i++) {
+      for (i=0; i<ct->ndim; i++) {
         if ( ca->dim[k] == 1 ) {
           rb_ary_push(args, SIZE2NUM(ct->dim[i]));
           k++;
         }
         else if ( ct->dim[i] == ca->dim[k] ) {
           rb_ary_push(args, ID2SYM(rb_intern("%")));
-          dim[rank] = ca->dim[k];
-          k++; rank++;
+          dim[ndim] = ca->dim[k];
+          k++; ndim++;
         }
         else {
           rb_ary_push(args, SIZE2NUM(ct->dim[i]));
         }
       }
-      if ( rank != ca->rank ) {
-        self = rb_ca_refer_new(self, ca->data_type, rank, dim, ca->bytes, 0);
+      if ( ndim != ca->ndim ) {
+        self = rb_ca_refer_new(self, ca->data_type, ndim, dim, ca->bytes, 0);
       }
     }
     else {
-      k = ca->rank - 1;
-      for (i=ct->rank-1; i>=0; i--) {
+      k = ca->ndim - 1;
+      for (i=ct->ndim-1; i>=0; i--) {
         if ( ca->dim[k] == 1 ) {
           rb_ary_unshift(args, SIZE2NUM(ct->dim[i]));
           k--;
@@ -556,14 +556,14 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
         }
       }
       if ( k != 0 ) {
-        rank = 0;
-        for (i=0; i<ca->rank; i++) {
+        ndim = 0;
+        for (i=0; i<ca->ndim; i++) {
           if ( ca->dim[i] != 1 ) {
-            dim[rank] = ca->dim[i];
-            rank++;
+            dim[ndim] = ca->dim[i];
+            ndim++;
           }
         }
-        self = rb_ca_refer_new(self, ca->data_type, rank, dim, ca->bytes, 0);
+        self = rb_ca_refer_new(self, ca->data_type, ndim, dim, ca->bytes, 0);
       }
     }
     return rb_ca_repeat((int)RARRAY_LEN(args), RARRAY_PTR(args), self);
@@ -625,7 +625,7 @@ rb_ca_repeat_initialize_copy (VALUE self, VALUE other)
   Data_Get_Struct(self,  CARepeat, ca);
   Data_Get_Struct(other, CARepeat, cs);
 
-  ca_repeat_setup(ca, cs->parent, cs->rank, cs->count);
+  ca_repeat_setup(ca, cs->parent, cs->ndim, cs->count);
 
   return self;
 }