cumo 0.1.0 → 0.1.1

data/ext/cumo/narray/index.c

@@ -31,7 +31,7 @@ struct enumerator {
 // note: the memory refed by this pointer is not freed and causes memroy leak.
 //
 // @example
-//     a[1..3,1] generates two na_index_arg_t(s). First is for 1..3, and second is for 1.
+//     a[1..3,1] generates two cumo_na_index_arg_t(s). First is for 1..3, and second is for 1.
 typedef struct {
     size_t  n; // the number of elements of the dimesnion
     size_t  beg; // the starting point in the dimension
@@ -39,14 +39,14 @@ typedef struct {
     size_t *idx; // list of indices
     int     reduce; // true if the dimension is reduced by addition
     int     orig_dim; // the dimension of original array
-} na_index_arg_t;
+} cumo_na_index_arg_t;
 
 
 static void
-print_index_arg(na_index_arg_t *q, int n)
+print_index_arg(cumo_na_index_arg_t *q, int n)
 {
     int i;
-    printf("na_index_arg_t = 0x%"SZF"x {\n",(size_t)q);
+    printf("cumo_na_index_arg_t = 0x%"SZF"x {\n",(size_t)q);
     for (i=0; i<n; i++) {
         printf("  q[%d].n=%"SZF"d\n",i,q[i].n);
         printf("  q[%d].beg=%"SZF"d\n",i,q[i].beg);
@@ -58,29 +58,29 @@ print_index_arg(na_index_arg_t *q, int n)
     printf("}\n");
 }
 
-static VALUE sym_ast;
-static VALUE sym_all;
-//static VALUE sym_reduce;
-static VALUE sym_minus;
-static VALUE sym_new;
-static VALUE sym_reverse;
-static VALUE sym_plus;
-static VALUE sym_sum;
-static VALUE sym_tilde;
-static VALUE sym_rest;
-static ID id_beg;
-static ID id_end;
-static ID id_exclude_end;
-static ID id_each;
-static ID id_step;
-static ID id_dup;
-static ID id_bracket;
-static ID id_shift_left;
-static ID id_mask;
+static VALUE cumo_sym_ast;
+static VALUE cumo_sym_all;
+//static VALUE cumo_sym_reduce;
+static VALUE cumo_sym_minus;
+static VALUE cumo_sym_new;
+static VALUE cumo_sym_reverse;
+static VALUE cumo_sym_plus;
+static VALUE cumo_sym_sum;
+static VALUE cumo_sym_tilde;
+static VALUE cumo_sym_rest;
+static ID cumo_id_beg;
+static ID cumo_id_end;
+static ID cumo_id_exclude_end;
+static ID cumo_id_each;
+static ID cumo_id_step;
+static ID cumo_id_dup;
+static ID cumo_id_bracket;
+static ID cumo_id_shift_left;
+static ID cumo_id_mask;
 
 
 static void
-na_index_set_step(na_index_arg_t *q, int i, size_t n, size_t beg, ssize_t step)
+cumo_na_index_set_step(cumo_na_index_arg_t *q, int i, size_t n, size_t beg, ssize_t step)
 {
     q->n    = n;
     q->beg  = beg;
@@ -91,7 +91,7 @@ na_index_set_step(na_index_arg_t *q, int i, size_t n, size_t beg, ssize_t step)
 }
 
 static void
-na_index_set_scalar(na_index_arg_t *q, int i, ssize_t size, ssize_t x)
+cumo_na_index_set_scalar(cumo_na_index_arg_t *q, int i, ssize_t size, ssize_t x)
 {
     if (x < -size || x >= size)
         rb_raise(rb_eRangeError,
@@ -108,7 +108,7 @@ na_index_set_scalar(na_index_arg_t *q, int i, ssize_t size, ssize_t x)
 }
 
 static inline ssize_t
-na_range_check(ssize_t pos, ssize_t size, int dim)
+cumo_na_range_check(ssize_t pos, ssize_t size, int dim)
 {
     ssize_t idx=pos;
 
@@ -121,13 +121,13 @@ na_range_check(ssize_t pos, ssize_t size, int dim)
 }
 
 static void
-na_parse_array(VALUE ary, int orig_dim, ssize_t size, na_index_arg_t *q)
+cumo_na_parse_array(VALUE ary, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
 {
     int k;
     int n = RARRAY_LEN(ary);
     q->idx = ALLOC_N(size_t, n);
     for (k=0; k<n; k++) {
-        q->idx[k] = na_range_check(NUM2SSIZET(RARRAY_AREF(ary,k)), size, orig_dim);
+        q->idx[k] = cumo_na_range_check(NUM2SSIZET(RARRAY_AREF(ary,k)), size, orig_dim);
     }
     q->n    = n;
     q->beg  = 0;
@@ -137,32 +137,32 @@ na_parse_array(VALUE ary, int orig_dim, ssize_t size, na_index_arg_t *q)
 }
 
 static void
-na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, na_index_arg_t *q)
+cumo_na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
 {
     VALUE idx;
-    narray_t *na;
-    narray_data_t *nidx;
+    cumo_narray_t *na;
+    cumo_narray_data_t *nidx;
     size_t k, n;
     ssize_t *nidxp;
 
-    GetNArray(a,na);
-    if (NA_NDIM(na) != 1) {
+    CumoGetNArray(a,na);
+    if (CUMO_NA_NDIM(na) != 1) {
         rb_raise(rb_eIndexError, "should be 1-d NArray");
     }
-    n = NA_SIZE(na);
-    idx = nary_new(cIndex,1,&n);
-    na_store(idx,a);
+    n = CUMO_NA_SIZE(na);
+    idx = cumo_na_new(cIndex,1,&n);
+    cumo_na_store(idx,a);
 
-    GetNArrayData(idx,nidx);
+    CumoGetNArrayData(idx,nidx);
     nidxp   = (ssize_t*)nidx->ptr;
     q->idx  = ALLOC_N(size_t, n);
 
     // ndixp is cuda memory (cuda narray)
-    SHOW_SYNCHRONIZE_WARNING_ONCE("na_parse_narray_index", "any");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("cumo_na_parse_narray_index", "any");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     for (k=0; k<n; k++) {
-        q->idx[k] = na_range_check(nidxp[k], size, orig_dim);
+        q->idx[k] = cumo_na_range_check(nidxp[k], size, orig_dim);
     }
     q->n    = n;
     q->beg  = 0;
@@ -172,22 +172,22 @@ na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, na_index_arg_t *q)
 }
 
 static void
-na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, na_index_arg_t *q)
+cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
 {
     int n;
     VALUE excl_end;
     ssize_t beg, end, beg_orig, end_orig;
     const char *dot = "..", *edot = "...";
 
-    beg = beg_orig = NUM2SSIZET(rb_funcall(range,id_beg,0));
+    beg = beg_orig = NUM2SSIZET(rb_funcall(range,cumo_id_beg,0));
     if (beg < 0) {
         beg += size;
     }
-    end = end_orig = NUM2SSIZET(rb_funcall(range,id_end,0));
+    end = end_orig = NUM2SSIZET(rb_funcall(range,cumo_id_end,0));
     if (end < 0) {
         end += size;
     }
-    excl_end = rb_funcall(range,id_exclude_end,0);
+    excl_end = rb_funcall(range,cumo_id_exclude_end,0);
     if (RTEST(excl_end)) {
         end--;
         dot = edot;
@@ -199,12 +199,12 @@ na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, na_index_a
     }
     n = (end-beg)/step+1;
     if (n<0) n=0;
-    na_index_set_step(q,orig_dim,n,beg,step);
+    cumo_na_index_set_step(q,orig_dim,n,beg,step);
 
 }
 
 static void
-na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, na_index_arg_t *q)
+cumo_na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
 {
     int len;
     ssize_t step;
@@ -216,10 +216,10 @@ na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, na_index_arg_t *
     e = (struct enumerator *)DATA_PTR(enum_obj);
 
     if (rb_obj_is_kind_of(e->obj, rb_cRange)) {
-        if (e->meth == id_each) {
-            na_parse_range(e->obj, 1, orig_dim, size, q);
+        if (e->meth == cumo_id_each) {
+            cumo_na_parse_range(e->obj, 1, orig_dim, size, q);
         }
-        else if (e->meth == id_step) {
+        else if (e->meth == cumo_id_step) {
             if (TYPE(e->args) != T_ARRAY) {
                 rb_raise(rb_eArgError,"no argument for step");
             }
@@ -228,7 +228,7 @@ na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, na_index_arg_t *
                 rb_raise(rb_eArgError,"invalid number of step argument (1 for %d)",len);
             }
             step = NUM2SSIZET(RARRAY_AREF(e->args,0));
-            na_parse_range(e->obj, step, orig_dim, size, q);
+            cumo_na_parse_range(e->obj, step, orig_dim, size, q);
         } else {
             rb_raise(rb_eTypeError,"unknown Range method: %s",rb_id2name(e->meth));
         }
@@ -244,39 +244,39 @@ na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, na_index_arg_t *
 // i: parse i-th index
 // q: parsed information is stored to *q
 static void
-na_index_parse_each(volatile VALUE a, ssize_t size, int i, na_index_arg_t *q)
+cumo_na_index_parse_each(volatile VALUE a, ssize_t size, int i, cumo_na_index_arg_t *q)
 {
     switch(TYPE(a)) {
 
     case T_FIXNUM:
-        na_index_set_scalar(q,i,size,FIX2LONG(a));
+        cumo_na_index_set_scalar(q,i,size,FIX2LONG(a));
         break;
 
     case T_BIGNUM:
-        na_index_set_scalar(q,i,size,NUM2SSIZET(a));
+        cumo_na_index_set_scalar(q,i,size,NUM2SSIZET(a));
         break;
 
     case T_FLOAT:
-        na_index_set_scalar(q,i,size,NUM2SSIZET(a));
+        cumo_na_index_set_scalar(q,i,size,NUM2SSIZET(a));
         break;
 
     case T_NIL:
     case T_TRUE:
-        na_index_set_step(q,i,size,0,1);
+        cumo_na_index_set_step(q,i,size,0,1);
         break;
 
     case T_SYMBOL:
-        if (a==sym_all || a==sym_ast) {
-            na_index_set_step(q,i,size,0,1);
+        if (a==cumo_sym_all || a==cumo_sym_ast) {
+            cumo_na_index_set_step(q,i,size,0,1);
         }
-        else if (a==sym_reverse) {
-            na_index_set_step(q,i,size,size-1,-1);
+        else if (a==cumo_sym_reverse) {
+            cumo_na_index_set_step(q,i,size,size-1,-1);
         }
-        else if (a==sym_new) {
-            na_index_set_step(q,i,1,0,1);
+        else if (a==cumo_sym_new) {
+            cumo_na_index_set_step(q,i,1,0,1);
         }
-        else if (a==sym_reduce || a==sym_sum || a==sym_plus) {
-            na_index_set_step(q,i,size,0,1);
+        else if (a==cumo_sym_reduce || a==cumo_sym_sum || a==cumo_sym_plus) {
+            cumo_na_index_set_step(q,i,size,0,1);
             q->reduce = 1;
         } else {
             rb_raise(rb_eIndexError, "invalid symbol for index");
@@ -284,24 +284,24 @@ na_index_parse_each(volatile VALUE a, ssize_t size, int i, na_index_arg_t *q)
         break;
 
     case T_ARRAY:
-        na_parse_array(a, i, size, q);
+        cumo_na_parse_array(a, i, size, q);
         break;
 
     default:
         if (rb_obj_is_kind_of(a, rb_cRange)) {
-            na_parse_range(a, 1, i, size, q);
+            cumo_na_parse_range(a, 1, i, size, q);
         }
         else if (rb_obj_is_kind_of(a, rb_cEnumerator)) {
-            na_parse_enumerator(a, i, size, q);
+            cumo_na_parse_enumerator(a, i, size, q);
         }
-        else if (rb_obj_is_kind_of(a, na_cStep)) {
+        else if (rb_obj_is_kind_of(a, cumo_na_cStep)) {
             ssize_t beg, step, n;
-            nary_step_array_index(a, size, (size_t*)(&n), &beg, &step);
-            na_index_set_step(q,i,n,beg,step);
+            cumo_na_step_array_index(a, size, (size_t*)(&n), &beg, &step);
+            cumo_na_index_set_step(q,i,n,beg,step);
         }
         // NArray index
-        else if (NA_IsNArray(a)) {
-            na_parse_narray_index(a, i, size, q);
+        else if (CUMO_NA_CumoIsNArray(a)) {
+            cumo_na_parse_narray_index(a, i, size, q);
         }
         else {
             rb_raise(rb_eIndexError, "not allowed type");
@@ -311,7 +311,7 @@ na_index_parse_each(volatile VALUE a, ssize_t size, int i, na_index_arg_t *q)
 
 
 static size_t
-na_index_parse_args(VALUE args, narray_t *na, na_index_arg_t *q, int ndim)
+cumo_na_index_parse_args(VALUE args, cumo_narray_t *na, cumo_na_index_arg_t *q, int ndim)
 {
     int i, j, k, l, nidx;
     size_t total=1;
@@ -329,7 +329,7 @@ na_index_parse_args(VALUE args, narray_t *na, na_index_arg_t *q, int ndim)
         if (v==Qfalse) {
             for (l = ndim - (nidx-1); l>0; l--) {
                 //printf("i=%d j=%d k=%d l=%d ndim=%d nidx=%d\n",i,j,k,l,ndim,nidx);
-                na_index_parse_each(Qtrue, na->shape[k], k, &q[j]);
+                cumo_na_index_parse_each(Qtrue, na->shape[k], k, &q[j]);
                 if (q[j].n > 1) {
                     total *= q[j].n;
                 }
@@ -338,13 +338,13 @@ na_index_parse_args(VALUE args, narray_t *na, na_index_arg_t *q, int ndim)
             }
         }
         // new dimension
-        else if (v==sym_new) {
-            na_index_parse_each(v, 1, k, &q[j]);
+        else if (v==cumo_sym_new) {
+            cumo_na_index_parse_each(v, 1, k, &q[j]);
             j++;
         }
         // other dimention
         else {
-            na_index_parse_each(v, na->shape[k], k, &q[j]);
+            cumo_na_index_parse_each(v, na->shape[k], k, &q[j]);
             if (q[j].n > 1) {
                 total *= q[j].n;
             }
@@ -357,7 +357,7 @@ na_index_parse_args(VALUE args, narray_t *na, na_index_arg_t *q, int ndim)
 
 
 static void
-na_get_strides_nadata(const narray_data_t *na, ssize_t *strides, ssize_t elmsz)
+cumo_na_get_strides_nadata(const cumo_narray_data_t *na, ssize_t *strides, ssize_t elmsz)
 {
     int i = na->base.ndim - 1;
     strides[i] = elmsz;
@@ -367,8 +367,8 @@ na_get_strides_nadata(const narray_data_t *na, ssize_t *strides, ssize_t elmsz)
 }
 
 static void
-na_index_aref_nadata(narray_data_t *na1, narray_view_t *na2,
-                     na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
+cumo_na_index_aref_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
+                     cumo_na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
 {
     int i, j;
     ssize_t size, k, total=1;
@@ -379,7 +379,7 @@ na_index_aref_nadata(narray_data_t *na1, narray_view_t *na2,
     VALUE m;
 
     strides_na1 = ALLOCA_N(ssize_t, na1->base.ndim);
-    na_get_strides_nadata(na1, strides_na1, elmsz);
+    cumo_na_get_strides_nadata(na1, strides_na1, elmsz);
 
     for (i=j=0; i<ndim; i++) {
         stride1 = strides_na1[q[i].orig_dim];
@@ -394,14 +394,14 @@ na_index_aref_nadata(narray_data_t *na1, narray_view_t *na2,
         na2->base.shape[j] = size = q[i].n;
 
         if (q[i].reduce != 0) {
-            m = rb_funcall(INT2FIX(1),id_shift_left,1,INT2FIX(j));
+            m = rb_funcall(INT2FIX(1),cumo_id_shift_left,1,INT2FIX(j));
             na2->base.reduce = rb_funcall(m,'|',1,na2->base.reduce);
         }
 
         // array index
         if (q[i].idx != NULL) {
             index = q[i].idx;
-            SDX_SET_INDEX(na2->stridx[j],index);
+            CUMO_SDX_SET_INDEX(na2->stridx[j],index);
             q[i].idx = NULL;
             for (k=0; k<size; k++) {
                 index[k] = index[k] * stride1;
@@ -410,7 +410,7 @@ na_index_aref_nadata(narray_data_t *na1, narray_view_t *na2,
             beg  = q[i].beg;
             step = q[i].step;
             na2->offset += stride1*beg;
-            SDX_SET_STRIDE(na2->stridx[j], stride1*step);
+            CUMO_SDX_SET_STRIDE(na2->stridx[j], stride1*step);
         }
         j++;
         total *= size;
@@ -420,22 +420,22 @@ na_index_aref_nadata(narray_data_t *na1, narray_view_t *na2,
 
 
 static void
-na_index_aref_naview(narray_view_t *na1, narray_view_t *na2,
-                     na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
+cumo_na_index_aref_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
+                     cumo_na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
 {
     int i, j;
     ssize_t total=1;
 
     for (i=j=0; i<ndim; i++) {
-        stridx_t sdx1 = na1->stridx[q[i].orig_dim];
+        cumo_stridx_t sdx1 = na1->stridx[q[i].orig_dim];
         ssize_t size;
 
         // numeric index -- trim dimension
         if (!keep_dim && q[i].n==1 && q[i].step==0) {
-            if (SDX_IS_INDEX(sdx1)) {
-                na2->offset += SDX_GET_INDEX(sdx1)[q[i].beg];
+            if (CUMO_SDX_IS_INDEX(sdx1)) {
+                na2->offset += CUMO_SDX_GET_INDEX(sdx1)[q[i].beg];
             } else {
-                na2->offset += SDX_GET_STRIDE(sdx1)*q[i].beg;
+                na2->offset += CUMO_SDX_GET_STRIDE(sdx1)*q[i].beg;
             }
             continue;
         }
@@ -443,30 +443,30 @@ na_index_aref_naview(narray_view_t *na1, narray_view_t *na2,
         na2->base.shape[j] = size = q[i].n;
 
         if (q[i].reduce != 0) {
-            VALUE m = rb_funcall(INT2FIX(1),id_shift_left,1,INT2FIX(j));
+            VALUE m = rb_funcall(INT2FIX(1),cumo_id_shift_left,1,INT2FIX(j));
             na2->base.reduce = rb_funcall(m,'|',1,na2->base.reduce);
         }
 
         if (q[i].orig_dim >= na1->base.ndim) {
             // new dimension
-            SDX_SET_STRIDE(na2->stridx[j], elmsz);
+            CUMO_SDX_SET_STRIDE(na2->stridx[j], elmsz);
         }
-        else if (q[i].idx != NULL && SDX_IS_INDEX(sdx1)) {
+        else if (q[i].idx != NULL && CUMO_SDX_IS_INDEX(sdx1)) {
             // index <- index
             int k;
             size_t *index = q[i].idx;
-            SDX_SET_INDEX(na2->stridx[j], index);
+            CUMO_SDX_SET_INDEX(na2->stridx[j], index);
             q[i].idx = NULL;
 
             for (k=0; k<size; k++) {
-                index[k] = SDX_GET_INDEX(sdx1)[index[k]];
+                index[k] = CUMO_SDX_GET_INDEX(sdx1)[index[k]];
             }
         }
-        else if (q[i].idx != NULL && SDX_IS_STRIDE(sdx1)) {
+        else if (q[i].idx != NULL && CUMO_SDX_IS_STRIDE(sdx1)) {
             // index <- step
-            ssize_t stride1 = SDX_GET_STRIDE(sdx1);
+            ssize_t stride1 = CUMO_SDX_GET_STRIDE(sdx1);
             size_t *index = q[i].idx;
-            SDX_SET_INDEX(na2->stridx[j],index);
+            CUMO_SDX_SET_INDEX(na2->stridx[j],index);
             q[i].idx = NULL;
 
             if (stride1<0) {
@@ -488,24 +488,24 @@ na_index_aref_naview(narray_view_t *na1, narray_view_t *na2,
                 }
             }
         }
-        else if (q[i].idx == NULL && SDX_IS_INDEX(sdx1)) {
+        else if (q[i].idx == NULL && CUMO_SDX_IS_INDEX(sdx1)) {
             // step <- index
             int k;
             size_t beg  = q[i].beg;
             ssize_t step = q[i].step;
             size_t *index = ALLOC_N(size_t, size);
-            SDX_SET_INDEX(na2->stridx[j],index);
+            CUMO_SDX_SET_INDEX(na2->stridx[j],index);
             for (k=0; k<size; k++) {
-                index[k] = SDX_GET_INDEX(sdx1)[beg+step*k];
+                index[k] = CUMO_SDX_GET_INDEX(sdx1)[beg+step*k];
             }
         }
-        else if (q[i].idx == NULL && SDX_IS_STRIDE(sdx1)) {
+        else if (q[i].idx == NULL && CUMO_SDX_IS_STRIDE(sdx1)) {
             // step <- step
             size_t beg  = q[i].beg;
             ssize_t step = q[i].step;
-            ssize_t stride1 = SDX_GET_STRIDE(sdx1);
+            ssize_t stride1 = CUMO_SDX_GET_STRIDE(sdx1);
             na2->offset += stride1*beg;
-            SDX_SET_STRIDE(na2->stridx[j], stride1*step);
+            CUMO_SDX_SET_STRIDE(na2->stridx[j], stride1*step);
         }
 
         j++;
@@ -516,7 +516,7 @@ na_index_aref_naview(narray_view_t *na1, narray_view_t *na2,
 
 
 static int
-na_ndim_new_narray(int ndim, const na_index_arg_t *q)
+cumo_na_ndim_new_narray(int ndim, const cumo_na_index_arg_t *q)
 {
     int i, ndim_new=0;
     for (i=0; i<ndim; i++) {
@@ -530,20 +530,20 @@ na_ndim_new_narray(int ndim, const na_index_arg_t *q)
 typedef struct {
     VALUE args, self, store;
     int ndim;
-    na_index_arg_t *q; // multi-dimensional index args
-    narray_t *na1;
+    cumo_na_index_arg_t *q; // multi-dimensional index args
+    cumo_narray_t *na1;
     int keep_dim;
     size_t pos; // offset position for 0-dimensional narray. 0-dimensional array does not use q.
-} na_aref_md_data_t;
+} cumo_na_aref_md_data_t;
 
-static na_index_arg_t*
-na_allocate_index_args(int ndim)
+static cumo_na_index_arg_t*
+cumo_na_allocate_index_args(int ndim)
 {
-    na_index_arg_t *q;
+    cumo_na_index_arg_t *q;
     int i;
     if (ndim == 0) return NULL;
 
-    q = ALLOC_N(na_index_arg_t, ndim);
+    q = ALLOC_N(cumo_na_index_arg_t, ndim);
     for (i=0; i<ndim; i++) {
         q[i].idx = NULL;
     }
@@ -551,77 +551,77 @@ na_allocate_index_args(int ndim)
 }
 
 static
-VALUE na_aref_md_protected(VALUE data_value)
+VALUE cumo_na_aref_md_protected(VALUE data_value)
 {
-    na_aref_md_data_t *data = (na_aref_md_data_t*)(data_value);
+    cumo_na_aref_md_data_t *data = (cumo_na_aref_md_data_t*)(data_value);
     VALUE self = data->self;
     VALUE args = data->args;
     VALUE store = data->store;
     int ndim = data->ndim;
-    na_index_arg_t *q = data->q;
-    narray_t *na1 = data->na1;
+    cumo_na_index_arg_t *q = data->q;
+    cumo_narray_t *na1 = data->na1;
     int keep_dim = data->keep_dim;
 
     int ndim_new;
     VALUE view;
-    narray_view_t *na2;
+    cumo_narray_view_t *na2;
     ssize_t elmsz;
 
-    na_index_parse_args(args, na1, q, ndim);
+    cumo_na_index_parse_args(args, na1, q, ndim);
 
-    if (na_debug_flag) print_index_arg(q,ndim);
+    if (cumo_na_debug_flag) print_index_arg(q,ndim);
 
     if (keep_dim) {
         ndim_new = ndim;
     } else {
-        ndim_new = na_ndim_new_narray(ndim, q);
+        ndim_new = cumo_na_ndim_new_narray(ndim, q);
     }
-    view = na_s_allocate_view(CLASS_OF(self));
+    view = cumo_na_s_allocate_view(rb_obj_class(self));
 
-    na_copy_flags(self, view);
-    GetNArrayView(view,na2);
+    cumo_na_copy_flags(self, view);
+    CumoGetNArrayView(view,na2);
 
-    na_alloc_shape((narray_t*)na2, ndim_new);
+    cumo_na_alloc_shape((cumo_narray_t*)na2, ndim_new);
 
-    na2->stridx = ALLOC_N(stridx_t,ndim_new);
+    na2->stridx = ALLOC_N(cumo_stridx_t,ndim_new);
 
-    elmsz = nary_element_stride(self);
+    elmsz = cumo_na_element_stride(self);
 
     switch(na1->type) {
-    case NARRAY_DATA_T:
-    case NARRAY_FILEMAP_T:
+    case CUMO_NARRAY_DATA_T:
+    case CUMO_NARRAY_FILEMAP_T:
         if (ndim == 0) {
             na2->offset = data->pos;
             na2->base.size = 1;
         } else {
-            na_index_aref_nadata((narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            cumo_na_index_aref_nadata((cumo_narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
         }
         na2->data = self;
         break;
-    case NARRAY_VIEW_T:
+    case CUMO_NARRAY_VIEW_T:
         if (ndim == 0) {
-            na2->offset = ((narray_view_t *)na1)->offset + data->pos;
-            na2->data = ((narray_view_t *)na1)->data;
+            na2->offset = ((cumo_narray_view_t *)na1)->offset + data->pos;
+            na2->data = ((cumo_narray_view_t *)na1)->data;
             na2->base.size = 1;
         } else {
-            na2->offset = ((narray_view_t *)na1)->offset;
-            na2->data = ((narray_view_t *)na1)->data;
-            na_index_aref_naview((narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            na2->offset = ((cumo_narray_view_t *)na1)->offset;
+            na2->data = ((cumo_narray_view_t *)na1)->data;
+            cumo_na_index_aref_naview((cumo_narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
         }
         break;
     }
     if (store) {
-        na_get_pointer_for_write(store); // allocate memory
-        na_store(na_flatten_dim(store,0),view);
+        cumo_na_get_pointer_for_write(store); // allocate memory
+        cumo_na_store(cumo_na_flatten_dim(store,0),view);
         return store;
     }
     return view;
 }
 
 static VALUE
-na_aref_md_ensure(VALUE data_value)
+cumo_na_aref_md_ensure(VALUE data_value)
 {
-    na_aref_md_data_t *data = (na_aref_md_data_t*)(data_value);
+    cumo_na_aref_md_data_t *data = (cumo_na_aref_md_data_t*)(data_value);
     int i;
     for (i=0; i<data->ndim; i++) {
         xfree(data->q[i].idx);
@@ -631,36 +631,36 @@ na_aref_md_ensure(VALUE data_value)
 }
 
 static VALUE
-na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd, size_t pos)
+cumo_na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd, size_t pos)
 {
     VALUE args; // should be GC protected
-    narray_t *na1;
-    na_aref_md_data_t data;
+    cumo_narray_t *na1;
+    cumo_na_aref_md_data_t data;
     VALUE store = 0;
     VALUE idx;
-    narray_t *nidx;
+    cumo_narray_t *nidx;
 
-    GetNArray(self,na1);
+    CumoGetNArray(self,na1);
 
     args = rb_ary_new4(argc,argv);
 
     if (argc == 1 && result_nd == 1) {
         idx = argv[0];
         if (rb_obj_is_kind_of(idx, rb_cArray)) {
-            idx = rb_apply(cumo_cNArray,id_bracket,idx);
+            idx = rb_apply(cumo_cNArray,cumo_id_bracket,idx);
         }
         if (rb_obj_is_kind_of(idx, cumo_cNArray)) {
-            GetNArray(idx,nidx);
-            if (NA_NDIM(nidx)>1) {
-                store = nary_new(CLASS_OF(self),NA_NDIM(nidx),NA_SHAPE(nidx));
-                idx = na_flatten(idx);
+            CumoGetNArray(idx,nidx);
+            if (CUMO_NA_NDIM(nidx)>1) {
+                store = cumo_na_new(rb_obj_class(self),CUMO_NA_NDIM(nidx),CUMO_NA_SHAPE(nidx));
+                idx = cumo_na_flatten(idx);
                 RARRAY_ASET(args,0,idx);
             }
         }
         // flatten should be done only for narray-view with non-uniform stride.
         if (na1->ndim > 1) {
-            self = na_flatten(self);
-            GetNArray(self,na1);
+            self = cumo_na_flatten(self);
+            CumoGetNArray(self,na1);
         }
     }
 
@@ -668,95 +668,95 @@ na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd, size_
     data.self = self;
     data.store = store;
     data.ndim = result_nd;
-    data.q = na_allocate_index_args(result_nd);
+    data.q = cumo_na_allocate_index_args(result_nd);
     data.na1 = na1;
     data.keep_dim = keep_dim;
 
     switch(na1->type) {
-    case NARRAY_DATA_T:
+    case CUMO_NARRAY_DATA_T:
         data.pos = pos;
         break;
-    case NARRAY_FILEMAP_T:
+    case CUMO_NARRAY_FILEMAP_T:
         data.pos = pos; // correct? I have never used..
         break;
-    case NARRAY_VIEW_T:
+    case CUMO_NARRAY_VIEW_T:
         {
-            narray_view_t *nv;
-            GetNArrayView(self,nv);
-            // pos obtained by na_get_result_dimension adds view->offset.
+            cumo_narray_view_t *nv;
+            CumoGetNArrayView(self,nv);
+            // pos obtained by cumo_na_get_result_dimension adds view->offset.
             data.pos = pos - nv->offset;
         }
         break;
     }
 
-    return rb_ensure(na_aref_md_protected, (VALUE)&data, na_aref_md_ensure, (VALUE)&data);
+    return rb_ensure(cumo_na_aref_md_protected, (VALUE)&data, cumo_na_aref_md_ensure, (VALUE)&data);
 }
 
 
 /* method: [](idx1,idx2,...,idxN) */
 VALUE
-na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result_nd, size_t pos)
+cumo_na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result_nd, size_t pos)
 {
-    na_index_arg_to_internal_order(nidx, idx, self);
+    cumo_na_index_arg_to_internal_order(nidx, idx, self);
 
     if (nidx==0) {
-        return rb_funcall(self,id_dup,0);
+        return rb_funcall(self,cumo_id_dup,0);
     }
     if (nidx==1) {
-        if (CLASS_OF(*idx)==cumo_cBit) {
-            return rb_funcall(*idx,id_mask,1,self);
+        if (rb_obj_class(*idx)==cumo_cBit) {
+            return rb_funcall(*idx,cumo_id_mask,1,self);
         }
     }
-    return na_aref_md(nidx, idx, self, keep_dim, result_nd, pos);
+    return cumo_na_aref_md(nidx, idx, self, keep_dim, result_nd, pos);
 }
 
 
 /* method: slice(idx1,idx2,...,idxN) */
-static VALUE na_slice(int argc, VALUE *argv, VALUE self)
+static VALUE cumo_na_slice(int argc, VALUE *argv, VALUE self)
 {
     int result_nd;
     size_t pos;
 
-    result_nd = na_get_result_dimension(self, argc, argv, 0, &pos);
-    return na_aref_main(argc, argv, self, 1, result_nd, pos);
+    result_nd = cumo_na_get_result_dimension(self, argc, argv, 0, &pos);
+    return cumo_na_aref_main(argc, argv, self, 1, result_nd, pos);
 }
 
 
 static int
-check_index_count(int argc, int na_ndim, int count_new, int count_rest)
+check_index_count(int argc, int cumo_na_ndim, int count_new, int count_rest)
 {
-    int result_nd = na_ndim + count_new;
+    int result_nd = cumo_na_ndim + count_new;
 
     switch(count_rest) {
     case 0:
         if (count_new == 0 && argc == 1) return 1;
         if (argc == result_nd) return result_nd;
         rb_raise(rb_eIndexError,"# of index(=%i) should be "
-                 "equal to ndim(=%i)",argc,na_ndim);
+                 "equal to ndim(=%i)",argc,cumo_na_ndim);
         break;
     case 1:
         if (argc-1 <= result_nd) return result_nd;
         rb_raise(rb_eIndexError,"# of index(=%i) > ndim(=%i) with :rest",
-                 argc,na_ndim);
+                 argc,cumo_na_ndim);
         break;
     }
     return -1;
 }
 
 int
-na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx)
+cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx)
 {
     int i, j;
     int count_new=0;
     int count_rest=0;
     int count_else=0;
     ssize_t x, s, m, pos, *idx;
-    narray_t *na;
-    narray_view_t *nv;
-    stridx_t sdx;
+    cumo_narray_t *na;
+    cumo_narray_view_t *nv;
+    cumo_stridx_t sdx;
     VALUE a;
 
-    GetNArray(self,na);
+    CumoGetNArray(self,na);
     if (na->size == 0) {
         rb_raise(rb_eRuntimeError, "cannot get index of empty array");
         return -1;
@@ -774,12 +774,12 @@ na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_
             break;
         case T_FALSE:
         case T_SYMBOL:
-            if (a==sym_rest || a==sym_tilde || a==Qfalse) {
+            if (a==cumo_sym_rest || a==cumo_sym_tilde || a==Qfalse) {
                 argv[i] = Qfalse;
                 count_rest++;
                 break;
-            } else if (a==sym_new || a==sym_minus) {
-                argv[i] = sym_new;
+            } else if (a==cumo_sym_new || a==cumo_sym_minus) {
+                argv[i] = cumo_sym_new;
                 count_new++;
             }
             // not break
@@ -796,32 +796,32 @@ na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_
     }
 
     switch(na->type) {
-    case NARRAY_VIEW_T:
-        GetNArrayView(self,nv);
+    case CUMO_NARRAY_VIEW_T:
+        CumoGetNArrayView(self,nv);
         pos = nv->offset;
         if (j == na->ndim) {
             for (i=j-1; i>=0; i--) {
-                x = na_range_check(idx[i], na->shape[i], i);
+                x = cumo_na_range_check(idx[i], na->shape[i], i);
                 sdx = nv->stridx[i];
-                if (SDX_IS_INDEX(sdx)) {
-                    pos += SDX_GET_INDEX(sdx)[x];
+                if (CUMO_SDX_IS_INDEX(sdx)) {
+                    pos += CUMO_SDX_GET_INDEX(sdx)[x];
                 } else {
-                    pos += SDX_GET_STRIDE(sdx)*x;
+                    pos += CUMO_SDX_GET_STRIDE(sdx)*x;
                 }
             }
             *pos_idx = pos;
         }
         else if (argc==1 && j==1) {
-            x = na_range_check(idx[0], na->size, 0);
+            x = cumo_na_range_check(idx[0], na->size, 0);
             for (i=na->ndim-1; i>=0; i--) {
                 s = na->shape[i];
                 m = x % s;
                 x = x / s;
                 sdx = nv->stridx[i];
-                if (SDX_IS_INDEX(sdx)) {
-                    pos += SDX_GET_INDEX(sdx)[m];
+                if (CUMO_SDX_IS_INDEX(sdx)) {
+                    pos += CUMO_SDX_GET_INDEX(sdx)[m];
                 } else {
-                    pos += SDX_GET_STRIDE(sdx)*m;
+                    pos += CUMO_SDX_GET_STRIDE(sdx)*m;
                 }
             }
             *pos_idx = pos;
@@ -831,16 +831,16 @@ na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_
         break;
     default:
         if (!stride) {
-            stride = nary_element_stride(self);
+            stride = cumo_na_element_stride(self);
         }
         if (argc==1 && j==1) {
-            x = na_range_check(idx[0], na->size, 0);
+            x = cumo_na_range_check(idx[0], na->size, 0);
             *pos_idx = stride * x;
         }
         else if (j == na->ndim) {
             pos = 0;
             for (i=j-1; i>=0; i--) {
-                x = na_range_check(idx[i], na->shape[i], i);
+                x = cumo_na_range_check(idx[i], na->shape[i], i);
                 pos += stride * x;
                 stride *= na->shape[i];
             }
@@ -854,27 +854,27 @@ na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_
 
 
 void
-Init_cumo_nary_index()
+Init_cumo_na_index()
 {
-    rb_define_method(cNArray, "slice", na_slice, -1);
-
-    sym_ast        = ID2SYM(rb_intern("*"));
-    sym_all        = ID2SYM(rb_intern("all"));
-    sym_minus      = ID2SYM(rb_intern("-"));
-    sym_new        = ID2SYM(rb_intern("new"));
-    sym_reverse    = ID2SYM(rb_intern("reverse"));
-    sym_plus       = ID2SYM(rb_intern("+"));
-    //sym_reduce   = ID2SYM(rb_intern("reduce"));
-    sym_sum        = ID2SYM(rb_intern("sum"));
-    sym_tilde      = ID2SYM(rb_intern("~"));
-    sym_rest       = ID2SYM(rb_intern("rest"));
-    id_beg         = rb_intern("begin");
-    id_end         = rb_intern("end");
-    id_exclude_end = rb_intern("exclude_end?");
-    id_each        = rb_intern("each");
-    id_step        = rb_intern("step");
-    id_dup         = rb_intern("dup");
-    id_bracket     = rb_intern("[]");
-    id_shift_left  = rb_intern("<<");
-    id_mask        = rb_intern("mask");
+    rb_define_method(cNArray, "slice", cumo_na_slice, -1);
+
+    cumo_sym_ast        = ID2SYM(rb_intern("*"));
+    cumo_sym_all        = ID2SYM(rb_intern("all"));
+    cumo_sym_minus      = ID2SYM(rb_intern("-"));
+    cumo_sym_new        = ID2SYM(rb_intern("new"));
+    cumo_sym_reverse    = ID2SYM(rb_intern("reverse"));
+    cumo_sym_plus       = ID2SYM(rb_intern("+"));
+    //cumo_sym_reduce   = ID2SYM(rb_intern("reduce"));
+    cumo_sym_sum        = ID2SYM(rb_intern("sum"));
+    cumo_sym_tilde      = ID2SYM(rb_intern("~"));
+    cumo_sym_rest       = ID2SYM(rb_intern("rest"));
+    cumo_id_beg         = rb_intern("begin");
+    cumo_id_end         = rb_intern("end");
+    cumo_id_exclude_end = rb_intern("exclude_end?");
+    cumo_id_each        = rb_intern("each");
+    cumo_id_step        = rb_intern("step");
+    cumo_id_dup         = rb_intern("dup");
+    cumo_id_bracket     = rb_intern("[]");
+    cumo_id_shift_left  = rb_intern("<<");
+    cumo_id_mask        = rb_intern("mask");
 }