carray 1.4.0 → 1.5.1

data/{ca_obj_bitarray.c → ext/ca_obj_bitarray.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;
@@ -55,7 +55,7 @@ static uint8_t bits[8] = {
 int
 ca_bitarray_setup (CABitarray *ca, CArray *parent)
 {
-  int8_t rank;
+  int8_t ndim;
   ca_size_t bitlen, elements;
 
   /* check arguments */
@@ -64,19 +64,19 @@ ca_bitarray_setup (CABitarray *ca, CArray *parent)
     rb_raise(rb_eCADataTypeError, "invalid data_type for bitarray");
   }
 
-  rank     = parent->rank + 1;
+  ndim     = parent->ndim + 1;
   bitlen   = 8 * parent->bytes;
   elements = bitlen * parent->elements;
 
   ca->obj_type  = CA_OBJ_BITARRAY;
   ca->data_type = CA_BOOLEAN;
   ca->flags     = 0;
-  ca->rank      = rank;
+  ca->ndim      = ndim;
   ca->bytes     = 1;
   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;
@@ -85,8 +85,8 @@ ca_bitarray_setup (CABitarray *ca, CArray *parent)
   ca->bytelen   = parent->bytes;
   ca->bitlen    = bitlen;
 
-  memcpy(ca->dim, parent->dim, (rank-1) * sizeof(ca_size_t));
-  ca->dim[rank-1] = bitlen;
+  memcpy(ca->dim, parent->dim, (ndim-1) * sizeof(ca_size_t));
+  ca->dim[ndim-1] = bitlen;
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -158,7 +158,7 @@ ca_bitarray_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CABitarray *ca = (CABitarray *) ap;
   ca_size_t bytes  = ca->parent->bytes;
-  ca_size_t offset = idx[ca->rank-1];
+  ca_size_t offset = idx[ca->ndim-1];
   ca_size_t major, minor;
   
   if ( ca_endian == CA_BIG_ENDIAN &&
@@ -190,7 +190,7 @@ ca_bitarray_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CABitarray *ca = (CABitarray *) ap;
   uint8_t test = *(uint8_t *) ptr;
-  ca_size_t offset = idx[ca->rank-1];
+  ca_size_t offset = idx[ca->ndim-1];
   ca_size_t bytes  = ca->parent->bytes;
   ca_size_t major, minor;
 
@@ -310,16 +310,16 @@ ca_bitarray_func_create_mask (void *ap)
   ca_size_t count[CA_RANK_MAX];
   int8_t i;
 
-  for (i=0; i<ca->rank-1; i++) {
+  for (i=0; i<ca->ndim-1; i++) {
     count[i] = 0;
   }
-  count[ca->rank-1] = ca->bitlen;
+  count[ca->ndim-1] = ca->bitlen;
 
   ca_update_mask(ca->parent);
   if ( ! ca->parent->mask ) {
     ca_create_mask(ca->parent);
   }
-  ca->mask = (CArray *) ca_repeat_new(ca->parent->mask, ca->rank, count);
+  ca->mask = (CArray *) ca_repeat_new(ca->parent->mask, ca->ndim, count);
 
   ca_unset_flag(ca->mask, CA_FLAG_READ_ONLY);
 }

data/{ca_obj_bitfield.c → ext/ca_obj_bitfield.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;
@@ -211,7 +211,7 @@ int
 ca_bitfield_setup (CABitfield *ca, CArray *parent,
                    ca_size_t offset, ca_size_t bitlen)
 {
-  int8_t rank;
+  int8_t ndim;
   int8_t data_type;
   ca_size_t bytes = 0, elements;
   ca_size_t bitsize;
@@ -228,7 +228,7 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
   }
   */
 
-  rank     = parent->rank;
+  ndim     = parent->ndim;
   bitsize  = parent->bytes * 8;
   elements = parent->elements;
 
@@ -293,12 +293,12 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
   ca->obj_type  = CA_OBJ_BITFIELD;
   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;
@@ -308,7 +308,7 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
   ca->bit_offset  = bit_offset;
   ca->bit_mask    = bit_mask;
 
-  memcpy(ca->dim, parent->dim, rank * sizeof(ca_size_t));
+  memcpy(ca->dim, parent->dim, ndim * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -484,7 +484,7 @@ ca_bitfield_func_create_mask (void *ap)
   }
 
   ca->mask = (CArray *) ca_refer_new(ca->parent->mask,
-                                     CA_BOOLEAN, ca->rank, ca->dim, 0, 0);
+                                     CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
 }
 
 ca_operation_function_t ca_bitfield_func = {

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

@@ -20,7 +20,7 @@ VALUE rb_cCABlock;
 */
 
 static int
-ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
+ca_block_setup (CABlock *ca, CArray *parent, int8_t ndim, ca_size_t *dim,
                ca_size_t *start, ca_size_t *step, ca_size_t *count, ca_size_t offset)
 {
   int8_t data_type;
@@ -33,7 +33,7 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
   bytes     = parent->bytes;
 
   elements = 1;
-  for (i=0; i<rank; i++) {
+  for (i=0; i<ndim; i++) {
     if ( count[i] < 0 ) {
       rb_raise(rb_eIndexError,
                "invalid size for %i-th dimension (negative)", i);
@@ -41,8 +41,8 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
     elements *= count[i];
   }
 
-  maxdim_index = rank-1;
-  for (i=rank-2; i>=0; i--) {
+  maxdim_index = ndim-1;
+  for (i=ndim-2; i>=0; i--) {
     if ( count[i] > count[maxdim_index] ) {
       maxdim_index = i;
     }
@@ -50,7 +50,7 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
 
   maxdim_step  = 1;
   maxdim_step0 = step[maxdim_index];
-  for (i=maxdim_index+1; i<rank; i++) {
+  for (i=maxdim_index+1; i<ndim; i++) {
     maxdim_step  *= count[i];
     maxdim_step0 *= dim[i];
   }
@@ -58,7 +58,7 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
   ca->obj_type  = CA_OBJ_BLOCK;
   ca->data_type = data_type;
   ca->flags     = 0;
-  ca->rank      = rank;
+  ca->ndim      = ndim;
   ca->bytes     = bytes;
   ca->elements  = elements;
   ca->ptr       = NULL;
@@ -67,10 +67,10 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
   ca->attach    = 0;
   ca->nosync    = 0;
   ca->offset    = offset;
-  ca->start     = ALLOC_N(ca_size_t, rank);
-  ca->step      = ALLOC_N(ca_size_t, rank);
-  ca->count     = ALLOC_N(ca_size_t, rank);
-  ca->size0     = ALLOC_N(ca_size_t, rank);
+  ca->start     = ALLOC_N(ca_size_t, ndim);
+  ca->step      = ALLOC_N(ca_size_t, ndim);
+  ca->count     = ALLOC_N(ca_size_t, ndim);
+  ca->size0     = ALLOC_N(ca_size_t, ndim);
 
   ca->maxdim_index = maxdim_index;
   ca->maxdim_step  = maxdim_step;
@@ -80,10 +80,10 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
 
   ca->dim = ca->count; /* ca->dim should not be free */
 
-  memcpy(ca->start, start, rank * sizeof(ca_size_t));
-  memcpy(ca->step,  step,  rank * sizeof(ca_size_t));
-  memcpy(ca->count, count, rank * sizeof(ca_size_t));
-  memcpy(ca->size0,  dim,  rank * sizeof(ca_size_t));
+  memcpy(ca->start, start, ndim * sizeof(ca_size_t));
+  memcpy(ca->step,  step,  ndim * sizeof(ca_size_t));
+  memcpy(ca->count, count, ndim * sizeof(ca_size_t));
+  memcpy(ca->size0,  dim,  ndim * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -93,11 +93,11 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t rank, ca_size_t *dim,
 }
 
 CABlock *
-ca_block_new (CArray *parent, int8_t rank, ca_size_t *dim,
+ca_block_new (CArray *parent, int8_t ndim, ca_size_t *dim,
              ca_size_t *start, ca_size_t *step, ca_size_t *count, ca_size_t offset)
 {
   CABlock *ca = ALLOC(CABlock);
-  ca_block_setup(ca, parent, rank, dim, start, step, count, offset);
+  ca_block_setup(ca, parent, ndim, dim, start, step, count, offset);
   return ca;
 }
 
@@ -126,7 +126,7 @@ ca_block_func_clone (void *ap)
 {
   CABlock *ca = (CABlock *) ap;
   return ca_block_new(ca->parent,
-                      ca->rank,  ca->size0,
+                      ca->ndim,  ca->size0,
                       ca->start, ca->step, ca->count, ca->offset);
 }
 
@@ -162,7 +162,7 @@ ca_block_func_ptr_at_index (void *ap, ca_size_t *idx)
     int8_t   i;
     ca_size_t  n;
     n = start[0] + idx[0]*step[0];
-    for (i=1; i<ca->rank; i++) {
+    for (i=1; i<ca->ndim; i++) {
       n *= size0[i];
       n += start[i] + idx[i]*step[i];
     }
@@ -186,7 +186,7 @@ ca_block_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
   int8_t   i;
   ca_size_t  n;
   n = start[0] + idx[0]*step[0];
-  for (i=1; i<ca->rank; i++) {
+  for (i=1; i<ca->ndim; i++) {
     n *= size0[i];
     n += start[i] + idx[i]*step[i];
   }
@@ -204,7 +204,7 @@ ca_block_func_store_index (void *ap, ca_size_t *idx, void *ptr)
   int8_t   i;
   ca_size_t  n;
   n = start[0] + idx[0]*step[0];
-  for (i=1; i<ca->rank; i++) {
+  for (i=1; i<ca->ndim; i++) {
     n *= size0[i];
     n += start[i] + idx[i]*step[i];
   }
@@ -292,7 +292,7 @@ ca_block_func_create_mask (void *ap)
   ca_create_mask(ca->parent);
   ca->mask =
     (CArray *) ca_block_new(ca->parent->mask,
-                            ca->rank, ca->size0,
+                            ca->ndim, ca->size0,
                             ca->start, ca->step, ca->count, ca->offset);
 }
 
@@ -320,7 +320,7 @@ ca_operation_function_t ca_block_func = {
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_block_new (VALUE cary, int8_t rank, ca_size_t *dim,
+rb_ca_block_new (VALUE cary, int8_t ndim, ca_size_t *dim,
                 ca_size_t *start, ca_size_t *step, ca_size_t *count, ca_size_t offset)
 {
   volatile VALUE obj;
@@ -330,7 +330,7 @@ rb_ca_block_new (VALUE cary, int8_t rank, ca_size_t *dim,
   rb_check_carray_object(cary);
   Data_Get_Struct(cary, CArray, parent);
 
-  ca = ca_block_new(parent, rank, dim, start, step, count, offset);
+  ca = ca_block_new(parent, ndim, dim, start, step, count, offset);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);
   rb_ca_data_type_inherit(obj, cary);
@@ -351,7 +351,7 @@ ca_block_attach_loop2 (CABlock *ca, int8_t level, ca_size_t saddr, ca_size_t sad
   ca_size_t count = ca->count[level];
   ca_size_t addr, addr0, i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( ca->parent->ptr ) {
       addr  = saddr  * ca->dim[level];
       addr0 = saddr0 * ca->size0[level] + ca->start[level];
@@ -386,7 +386,7 @@ ca_block_attach_loop (CABlock *ca, ca_size_t level, ca_size_t saddr, ca_size_t s
   ca_size_t count = ca->count[level];
   ca_size_t addr, addr0, i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( level == ca->maxdim_index ) {
       addr  = saddr  * ca->dim[level];
       addr0 = saddr0 * ca->size0[level] + ca->start[level];
@@ -431,7 +431,7 @@ static void
 ca_block_attach (CABlock *ca)
 {
   ca_size_t addr = 0, addr0 = 0;
-  if ( ca->rank <= 2 ) {
+  if ( ca->ndim <= 2 ) {
     ca_block_attach_loop2(ca, 0, addr, addr0);
   }
   else {
@@ -445,7 +445,7 @@ ca_block_sync_loop2 (CABlock *ca, int8_t level, ca_size_t saddr, ca_size_t saddr
   ca_size_t count = ca->count[level];
   ca_size_t addr, addr0, i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( ca->parent->ptr ) {
       addr  = saddr  * ca->dim[level];
       addr0 = saddr0 * ca->size0[level] + ca->start[level];
@@ -479,7 +479,7 @@ ca_block_sync_loop (CABlock *ca, int8_t level, ca_size_t saddr, ca_size_t saddr0
   ca_size_t count = ca->count[level];
   ca_size_t addr, addr0, i;
 
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( level == ca->maxdim_index ) {
       addr  = saddr  * ca->dim[level];
       addr0 = saddr0 * ca->size0[level] + ca->start[level];
@@ -520,7 +520,7 @@ static void
 ca_block_sync (CABlock *cb)
 {
   ca_size_t addr = 0, addr0 = 0;
-  if ( cb->rank <= 2 ) {
+  if ( cb->ndim <= 2 ) {
     ca_block_sync_loop2(cb, 0, addr, addr0);
   }
   else {
@@ -533,7 +533,7 @@ ca_block_fill_loop2 (CABlock *ca, int8_t level, ca_size_t saddr, char *val)
 {
   ca_size_t count = ca->count[level];
   ca_size_t addr, i;
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     addr = saddr * ca->dim[level];
     mfill_step(ca_ptr_at_addr(ca, addr),
                ca->bytes, count, ca->step[level], val);
@@ -551,7 +551,7 @@ ca_block_fill_loop (CABlock *ca, int8_t level, ca_size_t saddr, char *val)
 {
   ca_size_t count = ca->count[level];
   ca_size_t addr, i;
-  if ( level == ca->rank - 1 ) {
+  if ( level == ca->ndim - 1 ) {
     if ( level == ca->maxdim_index ) {
       addr = saddr * ca->dim[level];
       mfill_step(ca_ptr_at_addr(ca, addr),
@@ -586,7 +586,7 @@ static void
 ca_block_fill (CABlock *ca, char *val)
 {
   ca_size_t addr = 0;
-  if ( ca->rank <= 2 ) {
+  if ( ca->ndim <= 2 ) {
     ca_block_fill_loop2(ca, 0, addr, val);
   }
   else {
@@ -707,12 +707,12 @@ rb_cb_initialize_copy (VALUE self, VALUE other)
   Data_Get_Struct(self,  CABlock, ca);
   Data_Get_Struct(other, CABlock, cs);
 
-  for (i=0; i<cs->rank; i++) {
+  for (i=0; i<cs->ndim; i++) {
     shrink[i] = 0;
   }
 
   ca_block_setup(ca, cs->parent,
-                cs->rank, cs->size0, cs->start, cs->step, cs->count, cs->offset);
+                cs->ndim, cs->size0, cs->start, cs->step, cs->count, cs->offset);
 
   /* CHECK ME : other.parent instead of other ? */
   rb_ca_set_parent(self, rb_ca_parent(other));
@@ -728,8 +728,8 @@ rb_cb_initialize_copy (VALUE self, VALUE other)
     CABlock *cb;                    \
     int8_t i;                              \
     Data_Get_Struct(self, CABlock, cb);     \
-    ary = rb_ary_new2(cb->rank);            \
-    for (i=0; i<cb->rank; i++) {                    \
+    ary = rb_ary_new2(cb->ndim);            \
+    for (i=0; i<cb->ndim; i++) {                    \
       rb_ary_store(ary, i, LONG2NUM(cb->name[i]));  \
     }                                               \
     return ary;                                     \
@@ -780,13 +780,13 @@ rb_cb_idx2addr0 (int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, CABlock, cb);
 
-  if ( argc != cb->rank ) {
+  if ( argc != cb->ndim ) {
     rb_raise(rb_eArgError,
-             "invalid # of arguments (should be <%i>)", cb->rank);
+             "invalid # of arguments (should be <%i>)", cb->ndim);
   }
 
   addr = 0;
-  for (i=0; i<cb->rank; i++) {
+  for (i=0; i<cb->ndim; i++) {
     idxi = NUM2SIZE(argv[i]);
     CA_CHECK_INDEX(idxi, cb->dim[i]);
     addr = cb->size0[i] * addr + cb->start[i] + idxi * cb->step[i];
@@ -815,7 +815,7 @@ rb_cb_addr2addr0 (VALUE self, VALUE raddr)
   ca_addr2index((CArray*)cb, addr, idx);
 
   addr = 0;
-  for (i=0; i<cb->rank; i++) {
+  for (i=0; i<cb->ndim; i++) {
     addr *= cb->size0[i];
     addr += cb->start[i] + idx[i] * cb->step[i];
   }
@@ -840,13 +840,13 @@ rb_cb_move (int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, CABlock, cb);
 
-  if ( argc != cb->rank ) {
+  if ( argc != cb->ndim ) {
     rb_raise(rb_eArgError, "invalid # of arguments");
   }
 
   ca_update_mask(cb);
 
-  for (i=0; i<cb->rank; i++) {
+  for (i=0; i<cb->ndim; i++) {
     start = NUM2SIZE(argv[i]);
     if ( start < 0 ) {
       start += cb->size0[i];

data/{ca_obj_fake.c → ext/ca_obj_fake.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;
@@ -41,7 +41,7 @@ static VALUE rb_cCAFake;
 int
 ca_fake_setup (CAFake *ca, CArray *parent, int8_t data_type, ca_size_t bytes)
 {
-  int8_t rank;
+  int8_t ndim;
   ca_size_t *dim, elements;
 
   /* check arguments */
@@ -49,25 +49,25 @@ ca_fake_setup (CAFake *ca, CArray *parent, int8_t data_type, ca_size_t bytes)
   CA_CHECK_DATA_TYPE(data_type);
   CA_CHECK_BYTES(data_type, bytes);
 
-  rank     = parent->rank;
+  ndim     = parent->ndim;
   dim      = parent->dim;
   elements = parent->elements;
 
   ca->obj_type  = CA_OBJ_FAKE;
   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;
 
-  memcpy(ca->dim, dim, rank * sizeof(ca_size_t));
+  memcpy(ca->dim, dim, ndim * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -288,7 +288,7 @@ ca_fake_func_create_mask (void *ap)
   }
   ca->mask =
     (CArray *) ca_refer_new(ca->parent->mask,
-                            CA_BOOLEAN, ca->rank, ca->dim, 0, 0);
+                            CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
 }
 
 ca_operation_function_t ca_fake_func = {