carray 1.4.0 → 1.5.5

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

@@ -3,10 +3,8 @@
   ca_obj_reduce.c
 
   This file is part of Ruby/CArray extension library.
-  You can redistribute it and/or modify it under the terms of
-  the Ruby Licence.
 
-  Copyright (C) 2005 Hiroki Motoyoshi
+  Copyright (C) 2005-2020 Hiroki Motoyoshi
 
 ---------------------------------------------------------------------------- */
 
@@ -16,7 +14,7 @@ static int8_t CA_OBJ_REDUCE;
 
 static VALUE rb_cCAReduce;
 
-/* rdoc:
+/* yard:
   class CAReduce < CAVirtual # :nodoc:
   end
 */
@@ -40,7 +38,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}

@@ -3,10 +3,8 @@
   ca_obj_refer.c
 
   This file is part of Ruby/CArray extension library.
-  You can redistribute it and/or modify it under the terms of
-  the Ruby Licence.
 
-  Copyright (C) 2005 Hiroki Motoyoshi
+  Copyright (C) 2005-2020 Hiroki Motoyoshi
 
 ---------------------------------------------------------------------------- */
 
@@ -14,14 +12,14 @@
 
 VALUE rb_cCARefer;
 
-/* rdoc:
+/* yard:
   class CARefer < CAVirtual # :nodoc:
   end
 */
 
 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,23 +27,23 @@ 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 ) {
-    rb_raise(rb_eRuntimeError, "object carray can't be referred by other type");
+    rb_raise(rb_eRuntimeError, "object array can't be referred by other data type");
   }
 
   if ( parent->elements && bytes > parent->bytes * parent->elements ) {
-    rb_raise(rb_eRuntimeError, "byte size mismatch");
+    rb_raise(rb_eRuntimeError, "bytes exceeds the data size of referent");
   }
 
   /* 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;
@@ -53,36 +51,34 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   }
   if ( bytes < parent->bytes ) {
     if ( parent->bytes % bytes != 0 ) {
-      rb_raise(rb_eArgError, "invalid bytes");
+      rb_raise(rb_eRuntimeError, "bytes of reference array must be a multiple of that of referent");
     }
     is_deformed = -2;
     ratio = parent->bytes / bytes;
   }
   else if ( bytes > parent->bytes ) {
     if ( bytes % parent->bytes != 0 ) {
-      rb_raise(rb_eArgError, "invalid bytes");
+      rb_raise(rb_eRuntimeError, "bytes of reference array must be a multiple of that of referent");
     }
     is_deformed = 2;
     ratio = bytes / parent->bytes;
   }
-
   if ( offset < 0 ) {
-    rb_raise(rb_eRuntimeError, 
-             "negative offset for CARefer");
+    rb_raise(rb_eRuntimeError, "negative offset is not permitted for CARefer");
   }
 
   if ( ( bytes * elements + parent->bytes * offset ) >
                                      ( parent->bytes * parent->elements ) ) {
-    rb_raise(rb_eRuntimeError, "data size too large for CARefer");
+    rb_raise(rb_eRuntimeError, "data size of reference array must not exceed that of referent");
   }
 
   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 +95,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 +106,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 +133,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 +163,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;
 }
@@ -206,7 +202,7 @@ ca_refer_func_fetch_addr (void *ap, ca_size_t addr, void *ptr)
     for (i=0; i<ca->ratio; i++) {
       ca_fetch_addr(ca->parent,
                        addr * ca->ratio + i + ca->offset,
-                       ptr + i * ca->parent->bytes);
+                       (char *) ptr + i * ca->parent->bytes);
     }
     break;
   }
@@ -222,7 +218,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);
@@ -267,7 +263,7 @@ ca_refer_func_store_addr (void *ap, ca_size_t addr, void *ptr)
     for (i=0; i<ca->ratio; i++) {
       ca_store_addr(ca->parent,
                        addr * ca->ratio + i + ca->offset,
-                       ptr + i * ca->parent->bytes);
+                       (char *) ptr + i * ca->parent->bytes);
     }
     break;
   }
@@ -283,7 +279,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 +417,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,13 +481,13 @@ 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;
 }
 
-/* rdoc:
+/* yard:
   class CArray
     # call-seq: 
     #    CArray.refer()
@@ -514,7 +510,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 +520,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 +554,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 +566,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 +580,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 +589,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}

@@ -3,10 +3,8 @@
   ca_obj_repeat.c
 
   This file is part of Ruby/CArray extension library.
-  You can redistribute it and/or modify it under the terms of
-  the Ruby Licence.
 
-  Copyright (C) 2005 Hiroki Motoyoshi
+  Copyright (C) 2005-2020 Hiroki Motoyoshi
 
 ---------------------------------------------------------------------------- */
 
@@ -14,22 +12,22 @@
 
 VALUE rb_cCARepeat;
 
-/* rdoc:
+/* yard:
   class CARepeat < CAVirtual # :nodoc:
   end
 */
 
 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 +37,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 +71,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 +97,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 +110,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 +139,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 +171,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 +197,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 +215,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 +303,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 +408,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 +457,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 +473,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 +505,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 +513,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 +554,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 +623,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;
 }