carray 1.4.0 → 1.5.1

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

@@ -22,7 +22,7 @@ VALUE rb_cCASelect;
 typedef struct {
   int16_t   obj_type;
   int8_t    data_type;
-  int8_t    rank;
+  int8_t    ndim;
   int32_t   flags;
   ca_size_t   bytes;
   ca_size_t   elements;
@@ -58,7 +58,7 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->obj_type  = CA_OBJ_SELECT;
   ca->data_type = data_type;
   ca->flags     = 0;
-  ca->rank      = 1;
+  ca->ndim      = 1;
   ca->bytes     = bytes;
 
   if ( share && ca_is_entity(select) ) {

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

@@ -22,7 +22,7 @@ static VALUE rb_cCAShift;
 typedef struct {
   int16_t   obj_type;
   int8_t    data_type;
-  int8_t    rank;
+  int8_t    ndim;
   int32_t   flags;
   ca_size_t   bytes;
   ca_size_t   elements;
@@ -47,35 +47,35 @@ int
 ca_shift_setup (CAShift *ca, CArray *parent,
                ca_size_t *shift, char *fill, int8_t *roll)
 {
-  int8_t data_type, rank;
+  int8_t data_type, ndim;
   ca_size_t elements, bytes;
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
-  rank      = parent->rank;
+  ndim      = parent->ndim;
   elements  = parent->elements;
 
 
   ca->obj_type  = CA_OBJ_SHIFT;
   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->shift     = ALLOC_N(ca_size_t, rank);
+  ca->shift     = ALLOC_N(ca_size_t, ndim);
   ca->fill      = ALLOC_N(char, ca->bytes);
-  ca->roll      = ALLOC_N(int8_t, rank);
+  ca->roll      = ALLOC_N(int8_t, ndim);
 
-  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));
+  memcpy(ca->dim, parent->dim, ndim * sizeof(ca_size_t));
+  memcpy(ca->shift, shift, ndim * sizeof(ca_size_t));
+  memcpy(ca->roll, roll, ndim * sizeof(int8_t));
 
   if ( fill ) {
     ca->fill_mask = 0;
@@ -194,7 +194,7 @@ ca_shift_func_ptr_at_index (void *ap, ca_size_t *idx)
     int8_t i;
     ca_size_t k, n;
     n = 0;
-    for (i=0; i<ca->rank; i++) {
+    for (i=0; i<ca->ndim; i++) {
       k = idx[i];
       if ( roll[i] ) {
         k = ca_shift_rolled_index(ca, i, k);
@@ -230,7 +230,7 @@ ca_shift_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
   int8_t  i;
   ca_size_t k, n;
   n = 0;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     k = idx[i];
     if ( roll[i] ) {
       k = ca_shift_rolled_index(ca, i, k);
@@ -257,7 +257,7 @@ ca_shift_func_store_index (void *ap, ca_size_t *idx, void *ptr)
   int8_t i;
   ca_size_t k, n;
   n = 0;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     k = idx[i];
     if ( roll[i] ) {
       k = ca_shift_rolled_index(ca, i, k);
@@ -402,7 +402,7 @@ ca_shift_attach_loop (CAShift *ca, int16_t level, ca_size_t *idx, ca_size_t *idx
   int8_t roll = ca->roll[level];
   ca_size_t i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( fill ) {
       for (i=0; i<ca->dim[level]; i++) {
         idx[level] = i;
@@ -561,7 +561,7 @@ ca_shift_sync_loop (CAShift *ca, int16_t level, ca_size_t *idx, ca_size_t *idx0)
   int8_t roll = ca->roll[level];
   ca_size_t i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( ! shift ) {
       idx[level] = 0;
       idx0[level] = 0;
@@ -705,7 +705,7 @@ ca_shift_fill_loop (CAShift *ca, char *ptr,
   int8_t roll = ca->roll[level];
   ca_size_t i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( ( ! shift ) || roll ) {
       for (i=0; i<dim; i++) {
         idx0[level] = i;
@@ -851,11 +851,11 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
   ropt = rb_pop_options(&argc, &argv);
   rb_scan_options(ropt, "roll,fill_value", &rroll, &rfval);
 
-  if ( argc != ca->rank ) {
-    rb_raise(rb_eArgError, "# of arguments mismatch with rank");
+  if ( argc != ca->ndim ) {
+    rb_raise(rb_eArgError, "# of arguments mismatch with ndim");
   }
 
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     shift[i] = NUM2SIZE(argv[i]);
   }
 
@@ -889,18 +889,18 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
   }
 
   if ( NIL_P(rroll) ) {
-    for (i=0; i<ca->rank; i++) {
+    for (i=0; i<ca->ndim; i++) {
       roll[i] = 0;
     }
   }
   else {
     Check_Type(rroll, T_ARRAY);
 
-    if ( RARRAY_LEN(rroll) != ca->rank ) {
-      rb_raise(rb_eArgError, "# of arguments mismatch with rank");
+    if ( RARRAY_LEN(rroll) != ca->ndim ) {
+      rb_raise(rb_eArgError, "# of arguments mismatch with ndim");
     }
 
-    for (i=0; i<ca->rank; i++) {
+    for (i=0; i<ca->ndim; i++) {
       roll[i] = NUM2INT(rb_ary_entry(rroll, i));
     }
   }

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

@@ -15,7 +15,7 @@
 typedef struct {
   int16_t   obj_type;
   int8_t    data_type;
-  int8_t    rank;
+  int8_t    ndim;
   int32_t   flags;
   ca_size_t   bytes;
   ca_size_t   elements;
@@ -44,7 +44,7 @@ static VALUE rb_cCATrans;
 int
 ca_trans_setup (CATrans *ca, CArray *parent, ca_size_t *imap)
 {
-  int8_t data_type, rank;
+  int8_t data_type, ndim;
   ca_size_t bytes, elements;
   ca_size_t *dim0;
   ca_size_t newdim[CA_RANK_MAX];
@@ -54,17 +54,17 @@ ca_trans_setup (CATrans *ca, CArray *parent, ca_size_t *imap)
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
-  rank      = parent->rank;
+  ndim      = parent->ndim;
   elements  = parent->elements;
   dim0      = parent->dim;
 
-  for (i=0; i<rank; i++) {
+  for (i=0; i<ndim; i++) {
     map[i] = -1;
   }
 
-  for (i=0; i<rank; i++) {
+  for (i=0; i<ndim; i++) {
     idim = imap[i];
-    if ( idim < 0 || idim >= rank ) {
+    if ( idim < 0 || idim >= ndim ) {
       rb_raise(rb_eRuntimeError,
                "specified %i-th dimension number out of range", i);
     }
@@ -78,28 +78,28 @@ ca_trans_setup (CATrans *ca, CArray *parent, ca_size_t *imap)
   }
 
   step = 1;
-  for (i=imap[rank-1]+1; i<rank; i++) {
+  for (i=imap[ndim-1]+1; i<ndim; i++) {
     step *= dim0[i];
   }
 
   ca->obj_type  = CA_OBJ_TRANSPOSE;
   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->imap      = ALLOC_N(ca_size_t, rank);
+  ca->imap      = ALLOC_N(ca_size_t, ndim);
   ca->step      = step;
 
-  memcpy(ca->dim,  newdim, rank * sizeof(ca_size_t));
-  memcpy(ca->imap, imap,   rank * sizeof(ca_size_t));
+  memcpy(ca->dim,  newdim, ndim * sizeof(ca_size_t));
+  memcpy(ca->imap, imap,   ndim * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -167,7 +167,7 @@ ca_trans_func_ptr_at_index (void *ap, ca_size_t *idx)
     ca_size_t *imap = ca->imap;
     ca_size_t idx0[CA_RANK_MAX];
     int8_t i;
-    for (i=0; i<ca->rank; i++) {
+    for (i=0; i<ca->ndim; i++) {
       idx0[imap[i]] = idx[i];
     }
     return ca_ptr_at_index(ca->parent, idx0);
@@ -181,7 +181,7 @@ ca_trans_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
   ca_size_t *imap = ca->imap;
   ca_size_t idx0[CA_RANK_MAX];
   int8_t i;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     idx0[imap[i]] = idx[i];
   }
   ca_fetch_index(ca->parent, idx0, ptr);
@@ -194,7 +194,7 @@ ca_trans_func_store_index (void *ap, ca_size_t *idx, void *ptr)
   ca_size_t *imap = ca->imap;
   ca_size_t idx0[CA_RANK_MAX];
   int8_t i;
-  for (i=0; i<ca->rank; i++) {
+  for (i=0; i<ca->ndim; i++) {
     idx0[imap[i]] = idx[i];
   }
   ca_store_index(ca->parent, idx0, ptr);
@@ -311,7 +311,7 @@ ca_trans_attach_loop (CATrans *ca, int8_t level, ca_size_t *idx, ca_size_t *idx0
   ca_size_t *imap = ca->imap;
   ca_size_t i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     idx[level] = 0;
     idx0[imap[level]] = 0;
     switch ( ca->bytes ) {
@@ -392,7 +392,7 @@ ca_trans_sync_loop (CATrans *ca, int8_t level, ca_size_t *idx, ca_size_t *idx0)
   ca_size_t *imap = ca->imap;
   ca_size_t i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     idx[level] = 0;
     idx0[imap[level]] = 0;
     switch ( ca->bytes ) {
@@ -473,7 +473,7 @@ ca_trans_fill_loop (CATrans *ca, char *ptr,
   ca_size_t *imap = ca->imap;
   ca_size_t i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     for (i=0; i<ca->dim[level]; i++) {
       idx0[imap[level]] = i;
       memcpy(ca_ptr_at_index(ca->parent, idx0), ptr, ca->bytes);
@@ -529,17 +529,17 @@ rb_ca_trans (int argc, VALUE *argv, VALUE self)
   Data_Get_Struct(self, CArray, ca);
 
   if ( argc == 0 ) {
-    for (i=0; i<ca->rank; i++) {
-      imap[i] = ca->rank - i - 1;
+    for (i=0; i<ca->ndim; i++) {
+      imap[i] = ca->ndim - i - 1;
     }
   }
-  else if ( argc == ca->rank ) {
-    for (i=0; i<ca->rank; i++) {
+  else if ( argc == ca->ndim ) {
+    for (i=0; i<ca->ndim; i++) {
       imap[i] = NUM2SIZE(argv[i]);
     }
   }
   else {
-    rb_raise(rb_eArgError, "# of arguments should be equal to rank");
+    rb_raise(rb_eArgError, "# of arguments should be equal to ndim");
   }
 
   obj = rb_ca_trans_new(self, imap);

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

@@ -21,39 +21,39 @@ VALUE rb_cCAUnboundRepeat;
 
 int
 ca_ubrep_setup (CAUnboundRepeat *ca, CArray *parent,
-                int32_t rep_rank, ca_size_t *rep_dim)
+                int32_t rep_ndim, ca_size_t *rep_dim)
 {
-  int8_t data_type, rank;
+  int8_t data_type, ndim;
   ca_size_t bytes, elements;
 
   /* check arguments */
 
-  CA_CHECK_RANK(rep_rank);
+  CA_CHECK_RANK(rep_ndim);
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
-  rank      = parent->rank;
+  ndim      = parent->ndim;
   elements  = parent->elements;
 
   ca->obj_type  = CA_OBJ_UNBOUND_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->rep_rank  = rep_rank;
-  ca->rep_dim   = ALLOC_N(ca_size_t, rep_rank);
+  ca->rep_ndim  = rep_ndim;
+  ca->rep_dim   = ALLOC_N(ca_size_t, rep_ndim);
 
-  memcpy(ca->dim, parent->dim, rank * sizeof(ca_size_t));
-  memcpy(ca->rep_dim, rep_dim, rep_rank * sizeof(ca_size_t));
+  memcpy(ca->dim, parent->dim, ndim * sizeof(ca_size_t));
+  memcpy(ca->rep_dim, rep_dim, rep_ndim * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -63,10 +63,10 @@ ca_ubrep_setup (CAUnboundRepeat *ca, CArray *parent,
 }
 
 CAUnboundRepeat *
-ca_ubrep_new (CArray *parent, int32_t rep_rank, ca_size_t *rep_dim)
+ca_ubrep_new (CArray *parent, int32_t rep_ndim, ca_size_t *rep_dim)
 {
   CAUnboundRepeat *ca = ALLOC(CAUnboundRepeat);
-  ca_ubrep_setup(ca, parent, rep_rank, rep_dim);
+  ca_ubrep_setup(ca, parent, rep_ndim, rep_dim);
   return ca;
 }
 
@@ -88,7 +88,7 @@ static void *
 ca_ubrep_func_clone (void *ap)
 {
   CAUnboundRepeat *ca = (CAUnboundRepeat *) ap;
-  return ca_ubrep_new(ca->parent, ca->rep_rank, ca->rep_dim);
+  return ca_ubrep_new(ca->parent, ca->rep_ndim, ca->rep_dim);
 }
 
 static char *
@@ -212,7 +212,7 @@ ca_ubrep_func_create_mask (void *ap)
     ca_create_mask(ca->parent);
   }
   ca->mask =
-    (CArray *) ca_ubrep_new(ca->parent->mask, ca->rep_rank, ca->rep_dim);
+    (CArray *) ca_ubrep_new(ca->parent->mask, ca->rep_ndim, ca->rep_dim);
 }
 
 ca_operation_function_t ca_ubrep_func = {
@@ -239,14 +239,14 @@ ca_operation_function_t ca_ubrep_func = {
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_ubrep_new (VALUE cary, int32_t rep_rank, ca_size_t *rep_dim)
+rb_ca_ubrep_new (VALUE cary, int32_t rep_ndim, ca_size_t *rep_dim)
 {
   volatile VALUE obj;
   CArray *parent;
   CAUnboundRepeat *ca;
   rb_check_carray_object(cary);
   Data_Get_Struct(cary, CArray, parent);
-  ca = ca_ubrep_new(parent, rep_rank, rep_dim);
+  ca = ca_ubrep_new(parent, rep_ndim, rep_dim);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);
   rb_ca_data_type_inherit(obj, cary);
@@ -257,8 +257,8 @@ VALUE
 rb_ca_unbound_repeat (int argc, VALUE *argv, VALUE self)
 {
   CArray *ca;
-  ca_size_t rank, dim[CA_RANK_MAX];
-  int32_t rep_rank;
+  ca_size_t ndim, dim[CA_RANK_MAX];
+  int32_t rep_ndim;
   ca_size_t rep_dim[CA_RANK_MAX];
   ca_size_t count, i;
 
@@ -271,7 +271,7 @@ rb_ca_unbound_repeat (int argc, VALUE *argv, VALUE self)
     args = rb_ary_new();
     if ( rb_obj_is_kind_of(self, rb_cCAUnboundRepeat) ) {
       repeatable = 1;
-      for (i=0; i<cr->rep_rank; i++) {
+      for (i=0; i<cr->rep_ndim; i++) {
         if ( cr->rep_dim[i] == 1 ) {
           rb_ary_push(args, ID2SYM(rb_intern("*")));
           repeatable = 1;
@@ -285,7 +285,7 @@ rb_ca_unbound_repeat (int argc, VALUE *argv, VALUE self)
       }
     }
     else {
-      for (i=0; i<ca->rank; i++) {
+      for (i=0; i<ca->ndim; i++) {
         if ( ca->dim[i] == 1 ) {
           rb_ary_push(args, ID2SYM(rb_intern("*")));
           repeatable = 1;
@@ -319,12 +319,12 @@ rb_ca_unbound_repeat (int argc, VALUE *argv, VALUE self)
     return ca_ubrep_bind_with(obj, argv[0]);
   }
 
-  rep_rank = argc;
+  rep_ndim = argc;
 
   count = 0;
-  rank = 0;
+  ndim = 0;
 
-  for (i=0; i<rep_rank; i++) {
+  for (i=0; i<rep_ndim; i++) {
     if ( rb_obj_is_kind_of(argv[i], rb_cSymbol) ) {
       if ( argv[i] == ID2SYM(rb_intern("*")) ) {
         rep_dim[i] = 0;
@@ -341,25 +341,25 @@ rb_ca_unbound_repeat (int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "invalid argument");
       }
       rep_dim[i] = ca->dim[count];
-      dim[rank] = ca->dim[count];
-      count++; rank++;
+      dim[ndim] = ca->dim[count];
+      count++; ndim++;
     }
   }
 
-  if ( count != ca->rank ) {
+  if ( count != ca->ndim ) {
     rb_raise(rb_eRuntimeError, "too small # of nil");
   }
 
-  if ( rank != ca->rank ) {
+  if ( ndim != ca->ndim ) {
     volatile VALUE par, obj;
-    par = rb_ca_refer_new(self, ca->data_type, rank, dim, ca->bytes, 0);
-    obj = rb_ca_ubrep_new(par, rep_rank, rep_dim);
+    par = rb_ca_refer_new(self, ca->data_type, ndim, dim, ca->bytes, 0);
+    obj = rb_ca_ubrep_new(par, rep_ndim, rep_dim);
     rb_ivar_set(obj, rb_intern("__real_parent__"), par);
     rb_ca_set_parent(obj, self);
     return obj;
   }
   else {
-    return rb_ca_ubrep_new(self, rep_rank, rep_dim);
+    return rb_ca_ubrep_new(self, rep_ndim, rep_dim);
   }
 }
 
@@ -378,21 +378,21 @@ rb_ca_ubrep_initialize_copy (VALUE self, VALUE other)
   Data_Get_Struct(self,  CAUnboundRepeat, ca);
   Data_Get_Struct(other, CAUnboundRepeat, cs);
 
-  ca_ubrep_setup(ca, cs->parent, cs->rep_rank, cs->rep_dim);
+  ca_ubrep_setup(ca, cs->parent, cs->rep_ndim, cs->rep_dim);
 
   return self;
 }
 
 /*
 static CARepeat *
-ca_ubrep_bind (CAUnboundRepeat *ca, int32_t new_rank, ca_size_t *new_dim)
+ca_ubrep_bind (CAUnboundRepeat *ca, int32_t new_ndim, ca_size_t *new_dim)
 {
   ca_size_t rep_spec[CA_RANK_MAX];
   int i;
-  if ( ca->rep_rank != new_rank ) {
-    rb_raise(rb_eArgError, "invalid new_rank");
+  if ( ca->rep_ndim != new_ndim ) {
+    rb_raise(rb_eArgError, "invalid new_ndim");
   }
-  for (i=0; i<new_rank; i++) {
+  for (i=0; i<new_ndim; i++) {
     if ( ca->rep_dim[i] == 0 ) {
       rep_spec[i] = new_dim[i];
     }
@@ -400,57 +400,57 @@ ca_ubrep_bind (CAUnboundRepeat *ca, int32_t new_rank, ca_size_t *new_dim)
       rep_spec[i] = 0;
     }
   }
-  return ca_repeat_new((CArray*)ca, new_rank, rep_spec);
+  return ca_repeat_new((CArray*)ca, new_ndim, rep_spec);
 }
 */
 
 VALUE
-ca_ubrep_bind2 (VALUE self, int32_t new_rank, ca_size_t *new_dim)
+ca_ubrep_bind2 (VALUE self, int32_t new_ndim, ca_size_t *new_dim)
 {
   CAUnboundRepeat *ca;
   ca_size_t rep_spec[CA_RANK_MAX];
   ca_size_t upr_spec[CA_RANK_MAX];
   ca_size_t srp_spec[CA_RANK_MAX];
-  int uprep = 0, srp_rank;
+  int uprep = 0, srp_ndim;
   int i;
 
   Data_Get_Struct(self, CAUnboundRepeat, ca);
 
-  if ( ca->rep_rank != new_rank ) {
-    rb_raise(rb_eArgError, "invalid new_rank (%i <-> %i)",
-                           ca->rep_rank, new_rank);
+  if ( ca->rep_ndim != new_ndim ) {
+    rb_raise(rb_eArgError, "invalid new_ndim (%i <-> %i)",
+                           ca->rep_ndim, new_ndim);
   }
 
-  srp_rank = 0;
-  for (i=0; i<new_rank; i++) {
+  srp_ndim = 0;
+  for (i=0; i<new_ndim; i++) {
     if ( ca->rep_dim[i] == 0 ) {
       if ( new_dim[i] == 0 ) {
         uprep = 1;
       }
       else {
-        srp_spec[srp_rank++] = new_dim[i];
+        srp_spec[srp_ndim++] = new_dim[i];
       }
       rep_spec[i] = new_dim[i];
       upr_spec[i] = new_dim[i];
     }
     else {
       rep_spec[i] = 0;
-      srp_spec[srp_rank++] = 0;
+      srp_spec[srp_ndim++] = 0;
       upr_spec[i] = ca->rep_dim[i];
     }
   }
   if ( uprep ) {
     volatile VALUE rep;
-    if ( srp_rank >= ca->rank ) {
-      rep = rb_ca_repeat_new(rb_ca_parent(self), srp_rank, srp_spec);
+    if ( srp_ndim >= ca->ndim ) {
+      rep = rb_ca_repeat_new(rb_ca_parent(self), srp_ndim, srp_spec);
     }
     else {
       rep = rb_ca_parent(self);
     }
-    return rb_ca_ubrep_new(rep, new_rank, upr_spec);
+    return rb_ca_ubrep_new(rep, new_ndim, upr_spec);
   }
   else {
-    return rb_ca_repeat_new(self, new_rank, rep_spec);
+    return rb_ca_repeat_new(self, new_ndim, rep_spec);
   }
 }
 
@@ -474,13 +474,13 @@ ca_ubrep_bind_with (VALUE self, VALUE other)
 
   if ( co->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
     Data_Get_Struct(other, CAUnboundRepeat, cup);
-    return ca_ubrep_bind2(self, cup->rep_rank, cup->rep_dim);
+    return ca_ubrep_bind2(self, cup->rep_ndim, cup->rep_dim);
   }
   else if ( ca_is_scalar(co) ) {
     return self;
   }
   else {
-    return ca_ubrep_bind2(self, co->rank, co->dim);
+    return ca_ubrep_bind2(self, co->ndim, co->dim);
   }
 }
 
@@ -500,8 +500,8 @@ rb_ca_ubrep_bind (int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, CAUnboundRepeat, ca);
 
-  if ( ca->rep_rank != argc ) {
-    rb_raise(rb_eArgError, "invalid new_rank");
+  if ( ca->rep_ndim != argc ) {
+    rb_raise(rb_eArgError, "invalid new_ndim");
   }
   for (i=0; i<argc; i++) {
     if ( ca->rep_dim[i] == 0 ) {
@@ -524,8 +524,8 @@ rb_ca_ubrep_spec (VALUE self)
 
   Data_Get_Struct(self, CAUnboundRepeat, ca);
 
-  spec = rb_ary_new2(ca->rep_rank);
-  for (i=0; i<ca->rep_rank; i++) {
+  spec = rb_ary_new2(ca->rep_ndim);
+  for (i=0; i<ca->rep_ndim; i++) {
     if ( ca->rep_dim[i] ) {
       rb_ary_store(spec, i, SIZE2NUM(ca->rep_dim[i]));
     }