cumo 0.1.0 → 0.1.1

data/ext/cumo/narray/ndloop.c

@@ -17,33 +17,33 @@
 #define va_init_list(a,b) va_start(a)
 #endif
 
-typedef struct NA_BUFFER_COPY {
+typedef struct CUMO_NA_BUFFER_COPY {
     int ndim;
     size_t elmsz;
     size_t *n;
     char *src_ptr;
     char *buf_ptr;
-    na_loop_iter_t *src_iter;
-    na_loop_iter_t *buf_iter;
-} na_buffer_copy_t;
-
-typedef struct NA_LOOP_XARGS {
-    na_loop_iter_t *iter;     // moved from na_loop_t
-    na_buffer_copy_t *bufcp;  // copy data to buffer
-    int flag;                 // NDL_READ NDL_WRITE
+    cumo_na_loop_iter_t *src_iter;
+    cumo_na_loop_iter_t *buf_iter;
+} cumo_na_buffer_copy_t;
+
+typedef struct CUMO_NA_LOOP_XARGS {
+    cumo_na_loop_iter_t *iter;     // moved from cumo_na_loop_t
+    cumo_na_buffer_copy_t *bufcp;  // copy data to buffer
+    int flag;                 // CUMO_NDL_READ CUMO_NDL_WRITE
     bool free_user_iter;   // alloc LARG(lp,j).iter=lp->xargs[j].iter
-} na_loop_xargs_t;
+} cumo_na_loop_xargs_t;
 
-typedef struct NA_MD_LOOP {
+typedef struct CUMO_NA_MD_LOOP {
     int  narg;
     int  nin;
     int  ndim;                // n of total dimention looped at loop_narray. NOTE: lp->ndim + lp-.user.ndim is the total dimension.
     unsigned int copy_flag;   // set i-th bit if i-th arg is cast
     void    *ptr;             // memory for n
-    na_loop_iter_t *iter_ptr; // memory for iter
+    cumo_na_loop_iter_t *iter_ptr; // memory for iter
     size_t  *n;               // n of elements for each dim (shape)
-    na_loop_t  user;          // loop in user function
-    na_loop_xargs_t *xargs;   // extra data for each arg
+    cumo_na_loop_t  user;          // loop in user function
+    cumo_na_loop_xargs_t *xargs;   // extra data for each arg
     int    writeback;         // write back result to i-th arg
     int    init_aidx;         // index of initializer argument
     int    reduce_dim;        // number of dimensions to reduce in reduction kernel, e.g., for an array of shape: [2,3,4],
@@ -53,35 +53,35 @@ typedef struct NA_MD_LOOP {
     VALUE  reduce;            // dimension indicies to reduce in reduction kernel (in bits), e.g., for an array of shape:
                               // [2,3,4], 111b for sum(), 010b for sum(axis: 1), 110b for sum(axis: [1,2])
     VALUE  loop_opt;
-    ndfunc_t  *ndfunc;
+    cumo_ndfunc_t  *ndfunc;
     void (*loop_func)();
-} na_md_loop_t;
+} cumo_na_md_loop_t;
 
 #define LARG(lp,iarg) ((lp)->user.args[iarg])
 #define LITER(lp,idim,iarg) ((lp)->xargs[iarg].iter[idim])
 #define LITER_SRC(lp,idim) ((lp)->src_iter[idim])
 #define LBUFCP(lp,j) ((lp)->xargs[j].bufcp)
 
-#define CASTABLE(t) (RTEST(t) && (t)!=OVERWRITE)
+#define CASTABLE(t) (RTEST(t) && (t)!=CUMO_OVERWRITE)
 
-#define NDL_READ 1
-#define NDL_WRITE 2
-#define NDL_READ_WRITE (NDL_READ|NDL_WRITE)
+#define CUMO_NDL_READ 1
+#define CUMO_NDL_WRITE 2
+#define CUMO_NDL_READ_WRITE (CUMO_NDL_READ|CUMO_NDL_WRITE)
 
-static ID id_cast;
-static ID id_extract;
+static ID cumo_id_cast;
+static ID cumo_id_extract;
 
 static inline VALUE
-nary_type_s_cast(VALUE type, VALUE obj)
+cumo_na_type_s_cast(VALUE type, VALUE obj)
 {
-    return rb_funcall(type,id_cast,1,obj);
+    return rb_funcall(type,cumo_id_cast,1,obj);
 }
 
 static void
-print_ndfunc(ndfunc_t *nf) {
+print_ndfunc(cumo_ndfunc_t *nf) {
     volatile VALUE t;
     int i, k;
-    printf("ndfunc_t = 0x%"SZF"x {\n",(size_t)nf);
+    printf("cumo_ndfunc_t = 0x%"SZF"x {\n",(size_t)nf);
     printf("  func  = 0x%"SZF"x\n", (size_t)nf->func);
     printf("  flag  = 0x%"SZF"x\n", (size_t)nf->flag);
     printf("  nin   = %d\n", nf->nin);
@@ -106,9 +106,9 @@ print_ndfunc(ndfunc_t *nf) {
 
 
 static void
-print_ndloop(na_md_loop_t *lp) {
+print_ndloop(cumo_na_md_loop_t *lp) {
     int i,j,nd;
-    printf("na_md_loop_t = 0x%"SZF"x {\n",(size_t)lp);
+    printf("cumo_na_md_loop_t = 0x%"SZF"x {\n",(size_t)lp);
     printf("  narg = %d\n", lp->narg);
     printf("  nin  = %d\n", lp->nin);
     printf("  ndim = %d\n", lp->ndim);
@@ -190,18 +190,18 @@ print_ndloop(na_md_loop_t *lp) {
 }
 
 
-// returns 0x01 if NDF_HAS_LOOP, but not supporting NDF_STRIDE_LOOP
-// returns 0x02 if NDF_HAS_LOOP, but not supporting NDF_INDEX_LOOP
+// returns 0x01 if CUMO_NDF_HAS_LOOP, but not supporting CUMO_NDF_STRIDE_LOOP
+// returns 0x02 if CUMO_NDF_HAS_LOOP, but not supporting CUMO_NDF_INDEX_LOOP
 static unsigned int
-ndloop_func_loop_spec(ndfunc_t *nf, int user_ndim)
+ndloop_func_loop_spec(cumo_ndfunc_t *nf, int user_ndim)
 {
     unsigned int f=0;
     // If user function supports LOOP
-    if (user_ndim > 0 || NDF_TEST(nf,NDF_HAS_LOOP)) {
-        if (!NDF_TEST(nf,NDF_STRIDE_LOOP)) {
+    if (user_ndim > 0 || CUMO_NDF_TEST(nf,CUMO_NDF_HAS_LOOP)) {
+        if (!CUMO_NDF_TEST(nf,CUMO_NDF_STRIDE_LOOP)) {
             f |= 1;
         }
-        if (!NDF_TEST(nf,NDF_INDEX_LOOP)) {
+        if (!CUMO_NDF_TEST(nf,CUMO_NDF_INDEX_LOOP)) {
             f |= 2;
         }
     }
@@ -214,7 +214,7 @@ ndloop_func_loop_spec(ndfunc_t *nf, int user_ndim)
 static int
 ndloop_cast_required(VALUE type, VALUE value)
 {
-    return CASTABLE(type) && type != CLASS_OF(value);
+    return CASTABLE(type) && type != rb_obj_class(value);
 }
 
 static int
@@ -237,7 +237,7 @@ ndloop_cast_error(VALUE type, VALUE value)
 //              to type specified by nf->args[j].type
 // returns copy_flag where nth-bit is set if nth argument is converted.
 static unsigned int
-ndloop_cast_args(ndfunc_t *nf, VALUE args)
+ndloop_cast_args(cumo_ndfunc_t *nf, VALUE args)
 {
     int j;
     unsigned int copy_flag=0;
@@ -253,7 +253,7 @@ ndloop_cast_args(ndfunc_t *nf, VALUE args)
             continue;
 
         if (ndloop_castable_type(type)) {
-            RARRAY_ASET(args,j,nary_type_s_cast(type, value));
+            RARRAY_ASET(args,j,cumo_na_type_s_cast(type, value));
             copy_flag |= 1<<j;
         } else {
             ndloop_cast_error(type, value);
@@ -266,18 +266,18 @@ ndloop_cast_args(ndfunc_t *nf, VALUE args)
 
 
 static void
-ndloop_handle_symbol_in_ain(VALUE type, VALUE value, int at, na_md_loop_t *lp)
+ndloop_handle_symbol_in_ain(VALUE type, VALUE value, int at, cumo_na_md_loop_t *lp)
 {
-    if (type==sym_reduce) {
+    if (type==cumo_sym_reduce) {
         lp->reduce = value;
     }
-    else if (type==sym_option) {
+    else if (type==cumo_sym_option) {
         lp->user.option = value;
     }
-    else if (type==sym_loop_opt) {
+    else if (type==cumo_sym_loop_opt) {
         lp->loop_opt = value;
     }
-    else if (type==sym_init) {
+    else if (type==cumo_sym_init) {
         lp->init_aidx = at;
     }
     else {
@@ -292,7 +292,7 @@ max2(int x, int y)
 }
 
 static void
-ndloop_find_max_dimension(na_md_loop_t *lp, ndfunc_t *nf, VALUE args)
+ndloop_find_max_dimension(cumo_na_md_loop_t *lp, cumo_ndfunc_t *nf, VALUE args)
 {
     int j;
     int nin=0; // number of input objects (except for symbols)
@@ -307,8 +307,8 @@ ndloop_find_max_dimension(na_md_loop_t *lp, ndfunc_t *nf, VALUE args)
         } else {
             nin++;
             user_nd = max2(user_nd, nf->ain[j].dim);
-            if (IsNArray(v))
-                loop_nd = max2(loop_nd, RNARRAY_NDIM(v) - nf->ain[j].dim);
+            if (CumoIsNArray(v))
+                loop_nd = max2(loop_nd, CUMO_RNARRAY_NDIM(v) - nf->ain[j].dim);
         }
     }
 
@@ -329,9 +329,9 @@ ndloop_find_max_dimension(na_md_loop_t *lp, ndfunc_t *nf, VALUE args)
 */
 
 static void
-ndloop_alloc(na_md_loop_t *lp, ndfunc_t *nf, VALUE args,
+ndloop_alloc(cumo_na_md_loop_t *lp, cumo_ndfunc_t *nf, VALUE args,
              void *opt_ptr, unsigned int copy_flag,
-             void (*loop_func)(ndfunc_t*, na_md_loop_t*))
+             void (*loop_func)(cumo_ndfunc_t*, cumo_na_md_loop_t*))
 {
     int i,j;
     int narg;
@@ -342,7 +342,7 @@ ndloop_alloc(na_md_loop_t *lp, ndfunc_t *nf, VALUE args,
 
     long args_len;
 
-    na_loop_iter_t *iter;
+    cumo_na_loop_iter_t *iter;
 
     int trans_dim;
     unsigned int f;
@@ -375,19 +375,19 @@ ndloop_alloc(na_md_loop_t *lp, ndfunc_t *nf, VALUE args,
     max_nd = lp->ndim + lp->user.ndim;
 
     n1 = sizeof(size_t)*(max_nd+1);
-    n2 = sizeof(na_loop_xargs_t)*narg;
+    n2 = sizeof(cumo_na_loop_xargs_t)*narg;
     n2 = ((n2-1)/8+1)*8;
-    n3 = sizeof(na_loop_args_t)*narg;
+    n3 = sizeof(cumo_na_loop_args_t)*narg;
     n3 = ((n3-1)/8+1)*8;
-    n4 = sizeof(na_loop_iter_t)*narg*(max_nd+1);
+    n4 = sizeof(cumo_na_loop_iter_t)*narg*(max_nd+1);
     n4 = ((n4-1)/8+1)*8;
     n5 = sizeof(int)*(max_nd+1);
 
     lp->ptr = buf = (char*)xmalloc(n1+n2+n3+n4+n5);
     lp->n = (size_t*)buf; buf+=n1;
-    lp->xargs = (na_loop_xargs_t*)buf; buf+=n2;
-    lp->user.args = (na_loop_args_t*)buf; buf+=n3;
-    lp->iter_ptr = iter = (na_loop_iter_t*)buf; buf+=n4;
+    lp->xargs = (cumo_na_loop_xargs_t*)buf; buf+=n2;
+    lp->user.args = (cumo_na_loop_args_t*)buf; buf+=n3;
+    lp->iter_ptr = iter = (cumo_na_loop_iter_t*)buf; buf+=n4;
     lp->trans_map = (int*)buf;
 
     for (j=0; j<narg; j++) {
@@ -397,7 +397,7 @@ ndloop_alloc(na_md_loop_t *lp, ndfunc_t *nf, VALUE args,
         LARG(lp,j).ndim = 0;
         lp->xargs[j].iter = &(iter[(max_nd+1)*j]);
         lp->xargs[j].bufcp = NULL;
-        lp->xargs[j].flag = (j<lp->nin) ? NDL_READ : NDL_WRITE;
+        lp->xargs[j].flag = (j<lp->nin) ? CUMO_NDL_READ : CUMO_NDL_WRITE;
         lp->xargs[j].free_user_iter = 0;
     }
 
@@ -414,10 +414,10 @@ ndloop_alloc(na_md_loop_t *lp, ndfunc_t *nf, VALUE args,
     //              array          loop
     //           [*,+,*,+,*] => [*,*,*,+,+]
     // trans_map=[0,3,1,4,2] <= [0,1,2,3,4]
-    if (NDF_TEST(nf,NDF_FLAT_REDUCE) && RTEST(lp->reduce)) {
+    if (CUMO_NDF_TEST(nf,CUMO_NDF_FLAT_REDUCE) && RTEST(lp->reduce)) {
         trans_dim = 0;
         for (i=0; i<max_nd; i++) {
-            if (na_test_reduce(lp->reduce, i)) {
+            if (cumo_na_test_reduce(lp->reduce, i)) {
                 lp->trans_map[i] = -1;
             } else {
                 lp->trans_map[i] = trans_dim++;
@@ -449,12 +449,12 @@ ndloop_release(VALUE vlp)
 {
     int j;
     VALUE v;
-    na_md_loop_t *lp = (na_md_loop_t*)(vlp);
+    cumo_na_md_loop_t *lp = (cumo_na_md_loop_t*)(vlp);
 
     for (j=0; j < lp->narg; j++) {
         v = LARG(lp,j).value;
-        if (IsNArray(v)) {
-            na_release_lock(v);
+        if (CumoIsNArray(v)) {
+            cumo_na_release_lock(v);
         }
     }
     for (j=0; j<lp->narg; j++) {
@@ -483,7 +483,7 @@ ndloop_release(VALUE vlp)
   set lp->n[i] (shape of n-d iteration) here
 */
 static void
-ndloop_check_shape(na_md_loop_t *lp, int nf_dim, narray_t *na)
+ndloop_check_shape(cumo_na_md_loop_t *lp, int nf_dim, cumo_narray_t *na)
 {
     int i, k;
     size_t n;
@@ -500,7 +500,7 @@ ndloop_check_shape(na_md_loop_t *lp, int nf_dim, narray_t *na)
                 lp->n[i] = n;
             } else if (lp->n[i] != n) {
                 // inconsistent array shape
-                rb_raise(nary_eShapeError,"shape1[%d](=%"SZF"u) != shape2[%d](=%"SZF"u)",
+                rb_raise(cumo_na_eShapeError,"shape1[%d](=%"SZF"u) != shape2[%d](=%"SZF"u)",
                          i, lp->n[i], k, n);
             }
         }
@@ -512,37 +512,37 @@ ndloop_check_shape(na_md_loop_t *lp, int nf_dim, narray_t *na)
 na->shape[i] == lp->n[ dim_map[i] ]
  */
 static void
-ndloop_set_stepidx(na_md_loop_t *lp, int j, VALUE vna, int *dim_map, int rwflag)
+ndloop_set_stepidx(cumo_na_md_loop_t *lp, int j, VALUE vna, int *dim_map, int rwflag)
 {
     size_t n, s;
     int i, k, nd;
-    stridx_t sdx;
-    narray_t *na;
+    cumo_stridx_t sdx;
+    cumo_narray_t *na;
 
     LARG(lp,j).value = vna;
-    LARG(lp,j).elmsz = nary_element_stride(vna);
-    if (rwflag == NDL_READ) {
-        LARG(lp,j).ptr = na_get_pointer_for_read(vna);
+    LARG(lp,j).elmsz = cumo_na_element_stride(vna);
+    if (rwflag == CUMO_NDL_READ) {
+        LARG(lp,j).ptr = cumo_na_get_pointer_for_read(vna);
     } else
-    if (rwflag == NDL_WRITE) {
-        LARG(lp,j).ptr = na_get_pointer_for_write(vna);
+    if (rwflag == CUMO_NDL_WRITE) {
+        LARG(lp,j).ptr = cumo_na_get_pointer_for_write(vna);
     } else
-    if (rwflag == NDL_READ_WRITE) {
-        LARG(lp,j).ptr = na_get_pointer_for_read_write(vna);
+    if (rwflag == CUMO_NDL_READ_WRITE) {
+        LARG(lp,j).ptr = cumo_na_get_pointer_for_read_write(vna);
     } else {
         rb_bug("invalid value for read-write flag");
     }
-    GetNArray(vna,na);
+    CumoGetNArray(vna,na);
     nd = LARG(lp,j).ndim;
 
-    switch(NA_TYPE(na)) {
-    case NARRAY_DATA_T:
-        if (NA_DATA_PTR(na)==NULL && NA_SIZE(na)>0) {
+    switch(CUMO_NA_TYPE(na)) {
+    case CUMO_NARRAY_DATA_T:
+        if (CUMO_NA_DATA_PTR(na)==NULL && CUMO_NA_SIZE(na)>0) {
             rb_bug("cannot read no-data NArray");
             rb_raise(rb_eRuntimeError,"cannot read no-data NArray");
         }
         // through
-    case NARRAY_FILEMAP_T:
+    case CUMO_NARRAY_FILEMAP_T:
         s = LARG(lp,j).elmsz;
         for (k=na->ndim; k--;) {
             n = na->shape[k];
@@ -557,25 +557,25 @@ ndloop_set_stepidx(na_md_loop_t *lp, int j, VALUE vna, int *dim_map, int rwflag)
         }
         LITER(lp,0,j).pos = 0;
         break;
-    case NARRAY_VIEW_T:
-        LITER(lp,0,j).pos = NA_VIEW_OFFSET(na);
+    case CUMO_NARRAY_VIEW_T:
+        LITER(lp,0,j).pos = CUMO_NA_VIEW_OFFSET(na);
         for (k=0; k<na->ndim; k++) {
             n = na->shape[k];
-            sdx = NA_VIEW_STRIDX(na)[k];
+            sdx = CUMO_NA_VIEW_STRIDX(na)[k];
             if (n > 1 || nd > 0) {
                 i = dim_map[k];
-                if (SDX_IS_INDEX(sdx)) {
+                if (CUMO_SDX_IS_INDEX(sdx)) {
                     LITER(lp,i,j).step = 0;
-                    LITER(lp,i,j).idx = SDX_GET_INDEX(sdx);
+                    LITER(lp,i,j).idx = CUMO_SDX_GET_INDEX(sdx);
                 } else {
-                    LITER(lp,i,j).step = SDX_GET_STRIDE(sdx);
+                    LITER(lp,i,j).step = CUMO_SDX_GET_STRIDE(sdx);
                     //LITER(lp,i,j).idx = NULL;
                 }
             } else if (n==1) {
-                if (SDX_IS_INDEX(sdx)) {
-                    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("ndloop_set_stepidx", "any");
+                if (CUMO_SDX_IS_INDEX(sdx)) {
+                    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("ndloop_set_stepidx", "any");
                     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-                    LITER(lp,0,j).pos += SDX_GET_INDEX(sdx)[0];
+                    LITER(lp,0,j).pos += CUMO_SDX_GET_INDEX(sdx)[0];
                 }
             }
             nd--;
@@ -589,11 +589,11 @@ ndloop_set_stepidx(na_md_loop_t *lp, int j, VALUE vna, int *dim_map, int rwflag)
 
 
 static void
-ndloop_init_args(ndfunc_t *nf, na_md_loop_t *lp, VALUE args)
+ndloop_init_args(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, VALUE args)
 {
     int i, j;
     VALUE v;
-    narray_t *na;
+    cumo_narray_t *na;
     int nf_dim;
     int dim_beg;
     int *dim_map;
@@ -612,12 +612,12 @@ na->shape[i] == lp->n[ dim_map[i] ]
             continue;
         }
         v = RARRAY_AREF(args,j);
-        if (IsNArray(v)) {
+        if (CumoIsNArray(v)) {
             // set LARG(lp,j) with v
-            GetNArray(v,na);
+            CumoGetNArray(v,na);
             nf_dim = nf->ain[j].dim;
             if (nf_dim > na->ndim) {
-                rb_raise(nary_eDimensionError,"requires >= %d-dimensioal array "
+                rb_raise(cumo_na_eDimensionError,"requires >= %d-dimensioal array "
                          "while %d-dimensional array is given",nf_dim,na->ndim);
             }
             ndloop_check_shape(lp, nf_dim, na);
@@ -626,10 +626,10 @@ na->shape[i] == lp->n[ dim_map[i] ]
                 dim_map[i] = lp->trans_map[i+dim_beg];
                 //printf("dim_map[%d]=%d na->shape[%d]=%d\n",i,dim_map[i],i,na->shape[i]);
             }
-            if (nf->ain[j].type==OVERWRITE) {
-                lp->xargs[j].flag = flag = NDL_WRITE;
+            if (nf->ain[j].type==CUMO_OVERWRITE) {
+                lp->xargs[j].flag = flag = CUMO_NDL_WRITE;
             } else {
-                lp->xargs[j].flag = flag = NDL_READ;
+                lp->xargs[j].flag = flag = CUMO_NDL_READ;
             }
             LARG(lp,j).ndim = nf_dim;
             ndloop_set_stepidx(lp, j, v, dim_map, flag);
@@ -658,22 +658,22 @@ na->shape[i] == lp->n[ dim_map[i] ]
 
 
 static int
-ndloop_check_inplace(VALUE type, int na_ndim, size_t *na_shape, VALUE v)
+ndloop_check_inplace(VALUE type, int cumo_na_ndim, size_t *cumo_na_shape, VALUE v)
 {
     int i;
-    narray_t *na;
+    cumo_narray_t *na;
 
     // type check
-    if (type != CLASS_OF(v)) {
+    if (type != rb_obj_class(v)) {
         return 0;
     }
-    GetNArray(v,na);
+    CumoGetNArray(v,na);
     // shape check
-    if (na->ndim != na_ndim) {
+    if (na->ndim != cumo_na_ndim) {
         return 0;
     }
-    for (i=0; i<na_ndim; i++) {
-        if (na_shape[i] != na->shape[i]) {
+    for (i=0; i<cumo_na_ndim; i++) {
+        if (cumo_na_shape[i] != na->shape[i]) {
             return 0;
         }
     }
@@ -682,8 +682,8 @@ ndloop_check_inplace(VALUE type, int na_ndim, size_t *na_shape, VALUE v)
 }
 
 static VALUE
-ndloop_find_inplace(ndfunc_t *nf, na_md_loop_t *lp, VALUE type,
-                    int na_ndim, size_t *na_shape, VALUE args)
+ndloop_find_inplace(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, VALUE type,
+                    int cumo_na_ndim, size_t *cumo_na_shape, VALUE args)
 {
     int j;
     VALUE v;
@@ -691,9 +691,9 @@ ndloop_find_inplace(ndfunc_t *nf, na_md_loop_t *lp, VALUE type,
     // find inplace
     for (j=0; j<nf->nin; j++) {
         v = RARRAY_AREF(args,j);
-        if (IsNArray(v)) {
-            if (TEST_INPLACE(v)) {
-                if (ndloop_check_inplace(type,na_ndim,na_shape,v)) {
+        if (CumoIsNArray(v)) {
+            if (CUMO_TEST_INPLACE(v)) {
+                if (ndloop_check_inplace(type,cumo_na_ndim,cumo_na_shape,v)) {
                     // if already copied, create outary and write-back
                     if (lp->copy_flag & (1<<j)) {
                         lp->writeback = j;
@@ -707,7 +707,7 @@ ndloop_find_inplace(ndfunc_t *nf, na_md_loop_t *lp, VALUE type,
     for (j=0; j<nf->nin; j++) {
         if (lp->copy_flag & (1<<j)) {
             v = RARRAY_AREF(args,j);
-            if (ndloop_check_inplace(type,na_ndim,na_shape,v)) {
+            if (ndloop_check_inplace(type,cumo_na_ndim,cumo_na_shape,v)) {
                 return v;
             }
         }
@@ -718,7 +718,7 @@ ndloop_find_inplace(ndfunc_t *nf, na_md_loop_t *lp, VALUE type,
 
 
 static VALUE
-ndloop_get_arg_type(ndfunc_t *nf, VALUE args, VALUE t)
+ndloop_get_arg_type(cumo_ndfunc_t *nf, VALUE args, VALUE t)
 {
     int i;
 
@@ -731,7 +731,7 @@ ndloop_get_arg_type(ndfunc_t *nf, VALUE args, VALUE t)
         t = nf->ain[i].type;
         // if i-th type is Qnil, get the type of i-th input value
         if (!CASTABLE(t)) {
-            t = CLASS_OF(RARRAY_AREF(args,i));
+            t = rb_obj_class(RARRAY_AREF(args,i));
         }
     }
     return t;
@@ -739,61 +739,61 @@ ndloop_get_arg_type(ndfunc_t *nf, VALUE args, VALUE t)
 
 
 static VALUE
-ndloop_set_output_narray(ndfunc_t *nf, na_md_loop_t *lp, int k,
+ndloop_set_output_narray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, int k,
                          VALUE type, VALUE args)
 {
     int i, j;
-    int na_ndim;
+    int cumo_na_ndim;
     int lp_dim;
     volatile VALUE v=Qnil;
-    size_t *na_shape;
+    size_t *cumo_na_shape;
     int *dim_map;
-    int flag = NDL_READ_WRITE;
+    int flag = CUMO_NDL_READ_WRITE;
     int nd;
     int max_nd = lp->ndim + nf->aout[k].dim;
 
-    na_shape = ALLOCA_N(size_t, max_nd);
+    cumo_na_shape = ALLOCA_N(size_t, max_nd);
     dim_map = ALLOCA_N(int, max_nd);
 
     //printf("max_nd=%d lp->ndim=%d\n",max_nd,lp->ndim);
 
     // md-loop shape
-    na_ndim = 0;
+    cumo_na_ndim = 0;
     for (i=0; i<lp->ndim; i++) {
-        // na_shape[i] == lp->n[lp->trans_map[i]]
+        // cumo_na_shape[i] == lp->n[lp->trans_map[i]]
         lp_dim = lp->trans_map[i];
         //printf("i=%d lp_dim=%d\n",i,lp_dim);
-        if (NDF_TEST(nf,NDF_CUM)) {   // cumulate with shape kept
-            na_shape[na_ndim] = lp->n[lp_dim];
+        if (CUMO_NDF_TEST(nf,CUMO_NDF_CUM)) {   // cumulate with shape kept
+            cumo_na_shape[cumo_na_ndim] = lp->n[lp_dim];
         } else
-        if (na_test_reduce(lp->reduce,lp_dim)) {   // accumulate dimension
-            if (NDF_TEST(nf,NDF_KEEP_DIM)) {
-                na_shape[na_ndim] = 1;         // leave it
+        if (cumo_na_test_reduce(lp->reduce,lp_dim)) {   // accumulate dimension
+            if (CUMO_NDF_TEST(nf,CUMO_NDF_KEEP_DIM)) {
+                cumo_na_shape[cumo_na_ndim] = 1;         // leave it
             } else {
                 continue;  // delete dimension
             }
         } else {
-            na_shape[na_ndim] = lp->n[lp_dim];
+            cumo_na_shape[cumo_na_ndim] = lp->n[lp_dim];
         }
-        //printf("i=%d lp_dim=%d na_shape[%d]=%ld\n",i,lp_dim,i,na_shape[i]);
-        dim_map[na_ndim++] = lp_dim;
-        //dim_map[lp_dim] = na_ndim++;
+        //printf("i=%d lp_dim=%d cumo_na_shape[%d]=%ld\n",i,lp_dim,i,cumo_na_shape[i]);
+        dim_map[cumo_na_ndim++] = lp_dim;
+        //dim_map[lp_dim] = cumo_na_ndim++;
     }
 
     // user-specified shape
     for (i=0; i<nf->aout[k].dim; i++) {
-        na_shape[na_ndim] = nf->aout[k].shape[i];
-        dim_map[na_ndim++] = i + lp->ndim;
+        cumo_na_shape[cumo_na_ndim] = nf->aout[k].shape[i];
+        dim_map[cumo_na_ndim++] = i + lp->ndim;
     }
 
     // find inplace from input arrays
-    if (k==0 && NDF_TEST(nf,NDF_INPLACE)) {
-        v = ndloop_find_inplace(nf,lp,type,na_ndim,na_shape,args);
+    if (k==0 && CUMO_NDF_TEST(nf,CUMO_NDF_INPLACE)) {
+        v = ndloop_find_inplace(nf,lp,type,cumo_na_ndim,cumo_na_shape,args);
     }
     if (!RTEST(v)) {
         // new object
-        v = nary_new(type, na_ndim, na_shape);
-        flag = NDL_WRITE;
+        v = cumo_na_new(type, cumo_na_ndim, cumo_na_shape);
+        flag = CUMO_NDL_WRITE;
     }
 
     j = lp->nin + k;
@@ -807,7 +807,7 @@ ndloop_set_output_narray(ndfunc_t *nf, na_md_loop_t *lp, int k,
 }
 
 static VALUE
-ndloop_set_output(ndfunc_t *nf, na_md_loop_t *lp, VALUE args)
+ndloop_set_output(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, VALUE args)
 {
     int i, j, k, idx;
     volatile VALUE v, t, results;
@@ -848,7 +848,7 @@ ndloop_set_output(ndfunc_t *nf, na_md_loop_t *lp, VALUE args)
         idx = nf->ain[k].dim;
         v = RARRAY_AREF(results,idx);
         init = RARRAY_AREF(args,k);
-        na_store(v,init);
+        cumo_na_store(v,init);
     }
 
     return results;
@@ -860,12 +860,12 @@ ndloop_set_output(ndfunc_t *nf, na_md_loop_t *lp, VALUE args)
 // For example, compressing [2,3] shape into [6] so that we can process
 // all elements with one user loop.
 static void
-ndfunc_contract_loop(na_md_loop_t *lp)
+cumo_ndfunc_contract_loop(cumo_na_md_loop_t *lp)
 {
     int i,j,k,success,cnt=0;
     int red0, redi;
 
-    redi = na_test_reduce(lp->reduce,0);
+    redi = cumo_na_test_reduce(lp->reduce,0);
 
     //for (i=0; i<lp->ndim; i++) {
     //    printf("lp->n[%d]=%lu\n",i,lp->n[i]);
@@ -873,7 +873,7 @@ ndfunc_contract_loop(na_md_loop_t *lp)
 
     for (i=1; i<lp->ndim; i++) {
         red0 = redi;
-        redi = na_test_reduce(lp->reduce,i);
+        redi = cumo_na_test_reduce(lp->reduce,i);
         //printf("contract i=%d reduce_cond=%d %d\n",i,red0,redi);
         if (red0 != redi) {
             continue;
@@ -932,7 +932,7 @@ ndfunc_contract_loop(na_md_loop_t *lp)
 //
 // For example, for element-wise function, lp->user.ndim is 1, and lp->ndim -= 1.
 static void
-ndfunc_set_user_loop(ndfunc_t *nf, na_md_loop_t *lp)
+cumo_ndfunc_set_user_loop(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     int j, ud=0;
 
@@ -940,7 +940,7 @@ ndfunc_set_user_loop(ndfunc_t *nf, na_md_loop_t *lp)
         // Increase user.ndim by number of dimensions to reduce for reduction function.
         ud = lp->reduce_dim;
     }
-    else if (lp->ndim > 0 && NDF_TEST(nf,NDF_HAS_LOOP)) {
+    else if (lp->ndim > 0 && CUMO_NDF_TEST(nf,CUMO_NDF_HAS_LOOP)) {
         // Set user.ndim to 1 (default is 0) for element-wise function.
         ud = 1;
     }
@@ -964,29 +964,29 @@ ndfunc_set_user_loop(ndfunc_t *nf, na_md_loop_t *lp)
     //printf("lp->reduce_dim=%d lp->user.ndim=%d lp->ndim=%d\n",lp->reduce_dim,lp->user.ndim,lp->ndim);
 
  skip_ud:
-    // user function shape is the latter part of na_md_loop shape.
+    // user function shape is the latter part of cumo_na_md_loop shape.
     lp->user.n = &(lp->n[lp->ndim]);
     for (j=0; j<lp->narg; j++) {
         LARG(lp,j).iter = &LITER(lp,lp->ndim,j);
-        //printf("in ndfunc_set_user_loop: lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
+        //printf("in cumo_ndfunc_set_user_loop: lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
     }
 }
 
 
 // Initialize lp->user for indexer loop.
 static void
-ndfunc_set_user_indexer_loop(ndfunc_t *nf, na_md_loop_t *lp)
+cumo_ndfunc_set_user_indexer_loop(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     int j;
 
     lp->user.ndim = lp->ndim;
     lp->ndim = 0;
 
-    if (NDF_TEST(nf,NDF_FLAT_REDUCE)) {
+    if (CUMO_NDF_TEST(nf,CUMO_NDF_FLAT_REDUCE)) {
         // in
         LARG(lp,0).ndim = lp->user.ndim;
         LARG(lp,0).shape = &(lp->n[lp->ndim]);
-        // out is constructed at na_make_reduction_arg from in and lp->reduce
+        // out is constructed at cumo_na_make_reduction_arg from in and lp->reduce
 
         lp->user.n = &(lp->n[lp->ndim]);
         for (j=0; j<lp->narg; j++) {
@@ -1015,10 +1015,10 @@ ndfunc_set_user_indexer_loop(ndfunc_t *nf, na_md_loop_t *lp)
 // Judge whether a (contiguous) buffer copy is required or not, and malloc if it is required.
 //
 // CASES TO REQUIRE A BUFFER COPY:
-// 1) ndloop has `idx` but does not support NDF_INDEX_LOOP.
-// 2) ndloop has non-contiguous arrays but does not support NDF_STRIDE_LOOP.
+// 1) ndloop has `idx` but does not support CUMO_NDF_INDEX_LOOP.
+// 2) ndloop has non-contiguous arrays but does not support CUMO_NDF_STRIDE_LOOP.
 static void
-ndfunc_set_bufcp(ndfunc_t *nf, na_md_loop_t *lp)
+cumo_ndfunc_set_bufcp(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     unsigned int f;
     int i, j;
@@ -1026,7 +1026,7 @@ ndfunc_set_bufcp(ndfunc_t *nf, na_md_loop_t *lp)
     bool zero_step;
     ssize_t n, sz, elmsz, stride, n_total; //, last_step;
     size_t *buf_shape;
-    na_loop_iter_t *buf_iter=NULL, *src_iter;
+    cumo_na_loop_iter_t *buf_iter=NULL, *src_iter;
 
     unsigned int loop_spec = ndloop_func_loop_spec(nf, lp->user.ndim);
     //if (loop_spec==0) return;
@@ -1087,7 +1087,7 @@ ndfunc_set_bufcp(ndfunc_t *nf, na_md_loop_t *lp)
         // over loop_spec or reduce_loop is not contiguous
         if (f & loop_spec || (lp->reduce_dim > 1 && ndim > 0)) {
             //printf("(buf,nd=%d)",nd);
-            buf_iter = ALLOC_N(na_loop_iter_t,nd+3);
+            buf_iter = ALLOC_N(cumo_na_loop_iter_t,nd+3);
             buf_shape = ALLOC_N(size_t,nd);
             buf_iter[nd].pos = 0;
             buf_iter[nd].step = 0;
@@ -1104,14 +1104,14 @@ ndfunc_set_bufcp(ndfunc_t *nf, na_md_loop_t *lp)
                 buf_shape[i] = n;
                 sz *= n;
             }
-            LBUFCP(lp,j) = ALLOC(na_buffer_copy_t);
+            LBUFCP(lp,j) = ALLOC(cumo_na_buffer_copy_t);
             LBUFCP(lp,j)->ndim = ndim;
             LBUFCP(lp,j)->elmsz = elmsz;
             LBUFCP(lp,j)->n = buf_shape;
             LBUFCP(lp,j)->src_iter = src_iter;
             LBUFCP(lp,j)->buf_iter = buf_iter;
             LARG(lp,j).iter = buf_iter;
-            //printf("in ndfunc_set_bufcp(1): lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
+            //printf("in cumo_ndfunc_set_bufcp(1): lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
             LBUFCP(lp,j)->src_ptr = LARG(lp,j).ptr;
             if (cumo_cuda_runtime_is_device_memory(LARG(lp,j).ptr)) {
                 LARG(lp,j).ptr = LBUFCP(lp,j)->buf_ptr = cumo_cuda_runtime_malloc(sz);
@@ -1130,7 +1130,7 @@ ndfunc_set_bufcp(ndfunc_t *nf, na_md_loop_t *lp)
         last_step = src_iter[ndim-1].step;
         if (lp->reduce_dim>1) {
             //printf("(reduce_dim=%d,ndim=%d,nd=%d,n=%ld,lst=%ld)\n",lp->reduce_dim,ndim,nd,n_total,last_step);
-            buf_iter = ALLOC_N(na_loop_iter_t,2);
+            buf_iter = ALLOC_N(cumo_na_loop_iter_t,2);
             buf_iter[0].pos = LARG(lp,j).iter[0].pos;
             buf_iter[0].step = last_step;
             buf_iter[0].idx = NULL;
@@ -1138,7 +1138,7 @@ ndfunc_set_bufcp(ndfunc_t *nf, na_md_loop_t *lp)
             buf_iter[1].step = 0;
             buf_iter[1].idx = NULL;
             LARG(lp,j).iter = buf_iter;
-            //printf("in ndfunc_set_bufcp(2): lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
+            //printf("in cumo_ndfunc_set_bufcp(2): lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
             lp->xargs[j].free_user_iter = 1;
         }
     }
@@ -1161,7 +1161,7 @@ ndfunc_set_bufcp(ndfunc_t *nf, na_md_loop_t *lp)
 
 // Make contiguous memory for ops not supporting index or stride (step) loop
 static void
-ndloop_copy_to_buffer(na_buffer_copy_t *lp)
+ndloop_copy_to_buffer(cumo_na_buffer_copy_t *lp)
 {
     size_t *c;
     char *src, *buf;
@@ -1195,7 +1195,7 @@ ndloop_copy_to_buffer(na_buffer_copy_t *lp)
         // i-th dimension
         for (; i<nd; i++) {
             if (LITER_SRC(lp,i).idx) {
-                SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("ndloop_copy_to_buffer", "any");
+                CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("ndloop_copy_to_buffer", "any");
                 cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
                 LITER_SRC(lp,i+1).pos = LITER_SRC(lp,i).pos + LITER_SRC(lp,i).idx[c[i]];
             } else {
@@ -1227,7 +1227,7 @@ ndloop_copy_to_buffer(na_buffer_copy_t *lp)
 }
 
 static void
-ndloop_copy_from_buffer(na_buffer_copy_t *lp)
+ndloop_copy_from_buffer(cumo_na_buffer_copy_t *lp)
 {
     size_t *c;
     char *src, *buf;
@@ -1291,25 +1291,25 @@ ndloop_copy_from_buffer(na_buffer_copy_t *lp)
 
 
 static void
-ndfunc_write_back(ndfunc_t *nf, na_md_loop_t *lp, VALUE orig_args, VALUE results)
+cumo_ndfunc_write_back(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, VALUE orig_args, VALUE results)
 {
     VALUE src, dst;
 
     if (lp->writeback >= 0) {
         dst = RARRAY_AREF(orig_args,lp->writeback);
         src = RARRAY_AREF(results,0);
-        na_store(dst,src);
+        cumo_na_store(dst,src);
         RARRAY_ASET(results,0,dst);
     }
 }
 
 
 static VALUE
-ndloop_extract(VALUE results, ndfunc_t *nf)
+ndloop_extract(VALUE results, cumo_ndfunc_t *nf)
 {
     // long n, i;
     // VALUE x, y;
-    // narray_t *na;
+    // cumo_narray_t *na;
 
     // extract result objects
     switch(nf->nout) {
@@ -1318,24 +1318,24 @@ ndloop_extract(VALUE results, ndfunc_t *nf)
     case 1:
         return RARRAY_AREF(results,0);
         // x = RARRAY_AREF(results,0);
-        // if (NDF_TEST(nf,NDF_EXTRACT)) {
-        //     if (IsNArray(x)){
-        //         GetNArray(x,na);
-        //         if (NA_NDIM(na)==0) {
-        //             x = rb_funcall(x, id_extract, 0);
+        // if (CUMO_NDF_TEST(nf,CUMO_NDF_EXTRACT)) {
+        //     if (CumoIsNArray(x)){
+        //         CumoGetNArray(x,na);
+        //         if (CUMO_NA_NDIM(na)==0) {
+        //             x = rb_funcall(x, cumo_id_extract, 0);
         //         }
         //     }
         // }
         // return x;
     }
-    // if (NDF_TEST(nf,NDF_EXTRACT)) {
+    // if (CUMO_NDF_TEST(nf,CUMO_NDF_EXTRACT)) {
     //     n = RARRAY_LEN(results);
     //     for (i=0; i<n; i++) {
     //         x = RARRAY_AREF(results,i);
-    //         if (IsNArray(x)){
-    //             GetNArray(x,na);
-    //             if (NA_NDIM(na)==0) {
-    //                 y = rb_funcall(x, id_extract, 0);
+    //         if (CumoIsNArray(x)){
+    //             CumoGetNArray(x,na);
+    //             if (CUMO_NA_NDIM(na)==0) {
+    //                 y = rb_funcall(x, cumo_id_extract, 0);
     //                 RARRAY_ASET(results,i,y);
     //             }
     //         }
@@ -1345,7 +1345,7 @@ ndloop_extract(VALUE results, ndfunc_t *nf)
 }
 
 static bool
-loop_is_using_idx(na_md_loop_t *lp)
+loop_is_using_idx(cumo_na_md_loop_t *lp)
 {
     int  i, j;
     int  nd = lp->ndim;
@@ -1367,14 +1367,14 @@ loop_is_using_idx(na_md_loop_t *lp)
 }
 
 static void
-loop_narray(ndfunc_t *nf, na_md_loop_t *lp);
+loop_narray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp);
 
 static VALUE
 ndloop_run(VALUE vlp)
 {
     volatile VALUE args, orig_args, results;
-    na_md_loop_t *lp = (na_md_loop_t*)(vlp);
-    ndfunc_t *nf;
+    cumo_na_md_loop_t *lp = (cumo_na_md_loop_t*)(vlp);
+    cumo_ndfunc_t *nf;
 
     orig_args = lp->vargs;
     nf = lp->ndfunc;
@@ -1384,49 +1384,49 @@ ndloop_run(VALUE vlp)
     // setup ndloop iterator with arguments
     ndloop_init_args(nf, lp, args);
     results = ndloop_set_output(nf, lp, args);
-    //if (na_debug_flag) {
+    //if (cumo_na_debug_flag) {
     //    printf("-- ndloop_set_output --\n");
     //    print_ndloop(lp);
     //}
 
     // contract loop (compact dimessions)
-    if (NDF_TEST(nf,NDF_INDEXER_LOOP) && NDF_TEST(nf,NDF_FLAT_REDUCE)) {
+    if (CUMO_NDF_TEST(nf,CUMO_NDF_INDEXER_LOOP) && CUMO_NDF_TEST(nf,CUMO_NDF_FLAT_REDUCE)) {
         // do nothing
         // TODO(sonots): support compacting dimensions in reduction indexer loop if it allows speed up.
     } else {
         if (lp->loop_func == loop_narray) {
-            ndfunc_contract_loop(lp);
-            if (na_debug_flag) {
-                printf("-- ndfunc_contract_loop --\n");
+            cumo_ndfunc_contract_loop(lp);
+            if (cumo_na_debug_flag) {
+                printf("-- cumo_ndfunc_contract_loop --\n");
                 print_ndloop(lp);
             }
         }
     }
 
     // setup lp->user
-    if (NDF_TEST(nf,NDF_INDEXER_LOOP)) {
-        ndfunc_set_user_indexer_loop(nf, lp);
-        if (na_debug_flag) {
-            printf("-- ndfunc_set_user_indexer_loop --\n");
+    if (CUMO_NDF_TEST(nf,CUMO_NDF_INDEXER_LOOP)) {
+        cumo_ndfunc_set_user_indexer_loop(nf, lp);
+        if (cumo_na_debug_flag) {
+            printf("-- cumo_ndfunc_set_user_indexer_loop --\n");
             print_ndloop(lp);
         }
     } else {
-        ndfunc_set_user_loop(nf, lp);
-        if (na_debug_flag) {
-            printf("-- ndfunc_set_user_loop --\n");
+        cumo_ndfunc_set_user_loop(nf, lp);
+        if (cumo_na_debug_flag) {
+            printf("-- cumo_ndfunc_set_user_loop --\n");
             print_ndloop(lp);
         }
     }
 
     // setup buffering during loop
-    if (NDF_TEST(nf,NDF_INDEXER_LOOP) && NDF_TEST(nf,NDF_FLAT_REDUCE) && !loop_is_using_idx(lp)) {
+    if (CUMO_NDF_TEST(nf,CUMO_NDF_INDEXER_LOOP) && CUMO_NDF_TEST(nf,CUMO_NDF_FLAT_REDUCE) && !loop_is_using_idx(lp)) {
         // do nothing
     } else {
         if (lp->loop_func == loop_narray) {
-            ndfunc_set_bufcp(nf, lp);
+            cumo_ndfunc_set_bufcp(nf, lp);
         }
-        if (na_debug_flag) {
-            printf("-- ndfunc_set_bufcp --\n");
+        if (cumo_na_debug_flag) {
+            printf("-- cumo_ndfunc_set_bufcp --\n");
             print_ndloop(lp);
         }
     }
@@ -1439,7 +1439,7 @@ ndloop_run(VALUE vlp)
     }
 
     // write-back will be placed here
-    ndfunc_write_back(nf, lp, orig_args, results);
+    cumo_ndfunc_write_back(nf, lp, orig_args, results);
 
     // extract result objects
     return ndloop_extract(results, nf);
@@ -1449,7 +1449,7 @@ ndloop_run(VALUE vlp)
 // ---------------------------------------------------------------------------
 
 static void
-loop_narray(ndfunc_t *nf, na_md_loop_t *lp)
+loop_narray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     size_t *c;
     int  i, j;
@@ -1459,7 +1459,7 @@ loop_narray(ndfunc_t *nf, na_md_loop_t *lp)
         rb_bug("bug? lp->ndim = %d\n", lp->ndim);
     }
 
-    if (nd==0 || NDF_TEST(nf,NDF_INDEXER_LOOP)) {
+    if (nd==0 || CUMO_NDF_TEST(nf,CUMO_NDF_INDEXER_LOOP)) {
         for (j=0; j<lp->nin; j++) {
             if (lp->xargs[j].bufcp) {
                 //printf("copy_to_buffer j=%d\n",j);
@@ -1468,7 +1468,7 @@ loop_narray(ndfunc_t *nf, na_md_loop_t *lp)
         }
         (*(nf->func))(&(lp->user));
         for (j=0; j<lp->narg; j++) {
-            if (lp->xargs[j].bufcp && (lp->xargs[j].flag & NDL_WRITE)) {
+            if (lp->xargs[j].bufcp && (lp->xargs[j].flag & CUMO_NDL_WRITE)) {
                 //printf("copy_from_buffer j=%d\n",j);
                 // copy data to work buffer
                 ndloop_copy_from_buffer(lp->xargs[j].bufcp);
@@ -1505,7 +1505,7 @@ loop_narray(ndfunc_t *nf, na_md_loop_t *lp)
         }
         (*(nf->func))(&(lp->user));
         for (j=0; j<lp->narg; j++) {
-            if (lp->xargs[j].bufcp && (lp->xargs[j].flag & NDL_WRITE)) {
+            if (lp->xargs[j].bufcp && (lp->xargs[j].flag & CUMO_NDL_WRITE)) {
                 // copy data to work buffer
                 //printf("copy_from_buffer j=%d\n",j);
                 ndloop_copy_from_buffer(lp->xargs[j].bufcp);
@@ -1526,12 +1526,12 @@ loop_narray(ndfunc_t *nf, na_md_loop_t *lp)
 
 
 static VALUE
-na_ndloop_main(ndfunc_t *nf, VALUE args, void *opt_ptr)
+cumo_na_ndloop_main(cumo_ndfunc_t *nf, VALUE args, void *opt_ptr)
 {
     unsigned int copy_flag;
-    na_md_loop_t lp;
+    cumo_na_md_loop_t lp;
 
-    if (na_debug_flag) print_ndfunc(nf);
+    if (cumo_na_debug_flag) print_ndfunc(nf);
 
     // cast arguments to NArray
     copy_flag = ndloop_cast_args(nf, args);
@@ -1545,10 +1545,10 @@ na_ndloop_main(ndfunc_t *nf, VALUE args, void *opt_ptr)
 
 VALUE
 #ifdef HAVE_STDARG_PROTOTYPES
-na_ndloop(ndfunc_t *nf, int argc, ...)
+cumo_na_ndloop(cumo_ndfunc_t *nf, int argc, ...)
 #else
-na_ndloop(nf, argc, va_alist)
-  ndfunc_t *nf;
+cumo_na_ndloop(nf, argc, va_alist)
+  cumo_ndfunc_t *nf;
   int argc;
   va_dcl
 #endif
@@ -1569,22 +1569,22 @@ na_ndloop(nf, argc, va_alist)
 
     args = rb_ary_new4(argc, argv);
 
-    return na_ndloop_main(nf, args, NULL);
+    return cumo_na_ndloop_main(nf, args, NULL);
 }
 
 
 VALUE
-na_ndloop2(ndfunc_t *nf, VALUE args)
+cumo_na_ndloop2(cumo_ndfunc_t *nf, VALUE args)
 {
-    return na_ndloop_main(nf, args, NULL);
+    return cumo_na_ndloop_main(nf, args, NULL);
 }
 
 VALUE
 #ifdef HAVE_STDARG_PROTOTYPES
-na_ndloop3(ndfunc_t *nf, void *ptr, int argc, ...)
+cumo_na_ndloop3(cumo_ndfunc_t *nf, void *ptr, int argc, ...)
 #else
-na_ndloop3(nf, ptr, argc, va_alist)
-  ndfunc_t *nf;
+cumo_na_ndloop3(nf, ptr, argc, va_alist)
+  cumo_ndfunc_t *nf;
   void *ptr;
   int argc;
   va_dcl
@@ -1606,30 +1606,30 @@ na_ndloop3(nf, ptr, argc, va_alist)
 
     args = rb_ary_new4(argc, argv);
 
-    return na_ndloop_main(nf, args, ptr);
+    return cumo_na_ndloop_main(nf, args, ptr);
 }
 
 VALUE
-na_ndloop4(ndfunc_t *nf, void *ptr, VALUE args)
+cumo_na_ndloop4(cumo_ndfunc_t *nf, void *ptr, VALUE args)
 {
-    return na_ndloop_main(nf, args, ptr);
+    return cumo_na_ndloop_main(nf, args, ptr);
 }
 
 //----------------------------------------------------------------------
 
 VALUE
-na_info_str(VALUE ary)
+cumo_na_info_str(VALUE ary)
 {
     int nd, i;
     char tmp[32];
     VALUE buf;
-    narray_t *na;
+    cumo_narray_t *na;
 
-    GetNArray(ary,na);
+    CumoGetNArray(ary,na);
     nd = na->ndim;
 
-    buf = rb_str_new2(rb_class2name(CLASS_OF(ary)));
-    if (NA_TYPE(na) == NARRAY_VIEW_T) {
+    buf = rb_str_new2(rb_class2name(rb_obj_class(ary)));
+    if (CUMO_NA_TYPE(na) == CUMO_NARRAY_VIEW_T) {
         rb_str_cat(buf,"(view)",6);
     }
     rb_str_cat(buf,"#shape=[",8);
@@ -1648,19 +1648,20 @@ na_info_str(VALUE ary)
 
 //----------------------------------------------------------------------
 
-#define ncol cumo_na_inspect_cols
-#define nrow cumo_na_inspect_rows
-extern int ncol, nrow;
+extern int cumo_na_inspect_cols_;
+extern int cumo_na_inspect_rows_;
+#define ncol cumo_na_inspect_cols_
+#define nrow cumo_na_inspect_rows_
 
 static void
-loop_inspect(ndfunc_t *nf, na_md_loop_t *lp)
+loop_inspect(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     int nd, i, ii;
     size_t *c;
     int col=0, row=0;
     long len;
     VALUE str;
-    na_text_func_t func = (na_text_func_t)(nf->func);
+    cumo_na_text_func_t func = (cumo_na_text_func_t)(nf->func);
     VALUE buf, opt;
 
     nd = lp->ndim;
@@ -1734,23 +1735,23 @@ loop_inspect(ndfunc_t *nf, na_md_loop_t *lp)
 
 
 VALUE
-na_ndloop_inspect(VALUE nary, na_text_func_t func, VALUE opt)
+cumo_na_ndloop_inspect(VALUE nary, cumo_na_text_func_t func, VALUE opt)
 {
     volatile VALUE args;
-    na_md_loop_t lp;
+    cumo_na_md_loop_t lp;
     VALUE buf;
-    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
-    ndfunc_t nf = { (na_iter_func_t)func, NO_LOOP, 3, 0, ain, 0 };
-    //nf = ndfunc_alloc(NULL, NO_LOOP, 1, 0, Qnil);
+    cumo_ndfunc_arg_in_t ain[3] = {{Qnil,0},{cumo_sym_loop_opt},{cumo_sym_option}};
+    cumo_ndfunc_t nf = { (cumo_na_iter_func_t)func, CUMO_NO_LOOP, 3, 0, ain, 0 };
+    //nf = cumo_ndfunc_alloc(NULL, CUMO_NO_LOOP, 1, 0, Qnil);
 
-    buf = na_info_str(nary);
+    buf = cumo_na_info_str(nary);
 
-    if (na_get_pointer(nary)==NULL) {
+    if (cumo_na_get_pointer(nary)==NULL) {
         return rb_str_cat(buf,"(empty)",7);
     }
 
     //rb_p(args);
-    //if (na_debug_flag) print_ndfunc(&nf);
+    //if (cumo_na_debug_flag) print_ndfunc(&nf);
 
     args = rb_ary_new3(3,nary,buf,opt);
 
@@ -1769,21 +1770,21 @@ na_ndloop_inspect(VALUE nary, na_text_func_t func, VALUE opt)
 //----------------------------------------------------------------------
 
 static void
-loop_store_subnarray(ndfunc_t *nf, na_md_loop_t *lp, int i0, size_t *c, VALUE a)
+loop_store_subnarray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, int i0, size_t *c, VALUE a)
 {
     int nd = lp->ndim;
     int i, j;
-    narray_t *na;
+    cumo_narray_t *na;
     int *dim_map;
     VALUE a_type;
 
-    a_type = CLASS_OF(LARG(lp,0).value);
-    if (CLASS_OF(a) != a_type) {
-        a = rb_funcall(a_type, id_cast, 1, a);
+    a_type = rb_obj_class(LARG(lp,0).value);
+    if (rb_obj_class(a) != a_type) {
+        a = rb_funcall(a_type, cumo_id_cast, 1, a);
     }
-    GetNArray(a,na);
+    CumoGetNArray(a,na);
     if (na->ndim != nd-i0+1) {
-        rb_raise(nary_eShapeError, "mismatched dimension of sub-narray: "
+        rb_raise(cumo_na_eShapeError, "mismatched dimension of sub-narray: "
                  "nd_src=%d, nd_dst=%d", na->ndim, nd-i0+1);
     }
     dim_map = ALLOCA_N(int, na->ndim);
@@ -1791,7 +1792,7 @@ loop_store_subnarray(ndfunc_t *nf, na_md_loop_t *lp, int i0, size_t *c, VALUE a)
         dim_map[i] = lp->trans_map[i+i0];
         //printf("dim_map[i=%d] = %d, i0=%d\n", i, dim_map[i], i0);
     }
-    ndloop_set_stepidx(lp, 1, a, dim_map, NDL_READ);
+    ndloop_set_stepidx(lp, 1, a, dim_map, CUMO_NDL_READ);
     LARG(lp,1).shape = &(na->shape[na->ndim-1]);
 
     // loop body
@@ -1825,7 +1826,7 @@ loop_store_subnarray(ndfunc_t *nf, na_md_loop_t *lp, int i0, size_t *c, VALUE a)
 
 
 static void
-loop_store_rarray(ndfunc_t *nf, na_md_loop_t *lp)
+loop_store_rarray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     size_t *c;
     int     i;
@@ -1856,7 +1857,7 @@ loop_store_rarray(ndfunc_t *nf, na_md_loop_t *lp)
                 } else {
                     a[i+1] = Qnil;
                 }
-            } else if (IsNArray(a[i])) {
+            } else if (CumoIsNArray(a[i])) {
                 //printf("a[i=%d]=0x%lx\n",i,a[i]);
                 loop_store_subnarray(nf,lp,i,c,a[i]);
                 goto loop_next;
@@ -1871,7 +1872,7 @@ loop_store_rarray(ndfunc_t *nf, na_md_loop_t *lp)
         }
 
         //printf("a[i=%d]=0x%lx\n",i,a[i]);
-        if (IsNArray(a[i])) {
+        if (CumoIsNArray(a[i])) {
             loop_store_subnarray(nf,lp,i,c,a[i]);
         } else {
             LARG(lp,1).value = a[i];
@@ -1891,13 +1892,13 @@ loop_store_rarray(ndfunc_t *nf, na_md_loop_t *lp)
 }
 
 VALUE
-na_ndloop_store_rarray(ndfunc_t *nf, VALUE nary, VALUE rary)
+cumo_na_ndloop_store_rarray(cumo_ndfunc_t *nf, VALUE nary, VALUE rary)
 {
-    na_md_loop_t lp;
+    cumo_na_md_loop_t lp;
     VALUE args;
 
     //rb_p(args);
-    if (na_debug_flag) print_ndfunc(nf);
+    if (cumo_na_debug_flag) print_ndfunc(nf);
 
     args = rb_assoc_new(nary,rary);
 
@@ -1912,13 +1913,13 @@ na_ndloop_store_rarray(ndfunc_t *nf, VALUE nary, VALUE rary)
 
 
 VALUE
-na_ndloop_store_rarray2(ndfunc_t *nf, VALUE nary, VALUE rary, VALUE opt)
+cumo_na_ndloop_store_rarray2(cumo_ndfunc_t *nf, VALUE nary, VALUE rary, VALUE opt)
 {
-    na_md_loop_t lp;
+    cumo_na_md_loop_t lp;
     VALUE args;
 
     //rb_p(args);
-    if (na_debug_flag) print_ndfunc(nf);
+    if (cumo_na_debug_flag) print_ndfunc(nf);
 
     //args = rb_assoc_new(rary,nary);
     args = rb_ary_new3(3,nary,rary,opt);
@@ -1936,7 +1937,7 @@ na_ndloop_store_rarray2(ndfunc_t *nf, VALUE nary, VALUE rary, VALUE opt)
 //----------------------------------------------------------------------
 
 static void
-loop_narray_to_rarray(ndfunc_t *nf, na_md_loop_t *lp)
+loop_narray_to_rarray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     size_t *c;
     int i;
@@ -1984,13 +1985,13 @@ loop_narray_to_rarray(ndfunc_t *nf, na_md_loop_t *lp)
 }
 
 VALUE
-na_ndloop_cast_narray_to_rarray(ndfunc_t *nf, VALUE nary, VALUE fmt)
+cumo_na_ndloop_cast_narray_to_rarray(cumo_ndfunc_t *nf, VALUE nary, VALUE fmt)
 {
-    na_md_loop_t lp;
+    cumo_na_md_loop_t lp;
     VALUE args, a0;
 
     //rb_p(args);
-    if (na_debug_flag) print_ndfunc(nf);
+    if (cumo_na_debug_flag) print_ndfunc(nf);
 
     a0 = rb_ary_new();
     args = rb_ary_new3(3,nary,a0,fmt);
@@ -2009,7 +2010,7 @@ na_ndloop_cast_narray_to_rarray(ndfunc_t *nf, VALUE nary, VALUE fmt)
 //----------------------------------------------------------------------
 
 static void
-loop_narray_with_index(ndfunc_t *nf, na_md_loop_t *lp)
+loop_narray_with_index(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
 {
     size_t *c;
     int i,j;
@@ -2059,10 +2060,10 @@ loop_narray_with_index(ndfunc_t *nf, na_md_loop_t *lp)
 
 VALUE
 #ifdef HAVE_STDARG_PROTOTYPES
-na_ndloop_with_index(ndfunc_t *nf, int argc, ...)
+cumo_na_ndloop_with_index(cumo_ndfunc_t *nf, int argc, ...)
 #else
-na_ndloop_with_index(nf, argc, va_alist)
-  ndfunc_t *nf;
+cumo_na_ndloop_with_index(nf, argc, va_alist)
+  cumo_ndfunc_t *nf;
   int argc;
   va_dcl
 #endif
@@ -2072,7 +2073,7 @@ na_ndloop_with_index(nf, argc, va_alist)
     int i;
     VALUE *argv;
     volatile VALUE args;
-    na_md_loop_t lp;
+    cumo_na_md_loop_t lp;
 
     argv = ALLOCA_N(VALUE,argc);
 
@@ -2084,8 +2085,8 @@ na_ndloop_with_index(nf, argc, va_alist)
 
     args = rb_ary_new4(argc, argv);
 
-    //return na_ndloop_main(nf, args, NULL);
-    if (na_debug_flag) print_ndfunc(nf);
+    //return cumo_na_ndloop_main(nf, args, NULL);
+    if (cumo_na_debug_flag) print_ndfunc(nf);
 
     // cast arguments to NArray
     //copy_flag = ndloop_cast_args(nf, args);
@@ -2098,8 +2099,8 @@ na_ndloop_with_index(nf, argc, va_alist)
 
 
 void
-Init_cumo_nary_ndloop()
+Init_cumo_na_ndloop()
 {
-    id_cast    = rb_intern("cast");
-    id_extract = rb_intern("extract");
+    cumo_id_cast    = rb_intern("cast");
+    cumo_id_extract = rb_intern("extract");
 }