cumo 0.1.0 → 0.1.1

data/ext/cumo/narray/gen/tmpl/inspect.c

@@ -17,5 +17,5 @@ static VALUE
 <%=c_func(0)%>(VALUE ary)
 {
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-    return na_ndloop_inspect(ary, <%=c_iter%>, Qnil);
+    return cumo_na_ndloop_inspect(ary, <%=c_iter%>, Qnil);
 }

data/ext/cumo/narray/gen/tmpl/lib.c

@@ -21,7 +21,7 @@
 
 #define m_map(x) m_num_to_data(rb_yield(m_data_to_num(x)))
 
-<% id_decl.each do |x| %>
+<% cumo_id_decl.each do |x| %>
 <%= x %>
 <% end %>
 
@@ -41,7 +41,7 @@ Init_<%=lib_name%>(void)
 
     <%=ns_var%> = rb_define_module("Cumo");
 
-    <% id_assign.each do |x| %>
+    <% cumo_id_assign.each do |x| %>
     <%= x %><% end %>
 
 <% children.each do |c| %>

data/ext/cumo/narray/gen/tmpl/logseq.c

@@ -11,7 +11,7 @@ void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, ssize_t s1, seq_data_t
 <% end %>
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1;
@@ -21,8 +21,8 @@ static void
     seq_count_t c;
     logseq_opt_t *g;
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
     g = (logseq_opt_t*)(lp->opt_ptr);
     beg  = g->beg;
     step = g->step;
@@ -31,7 +31,7 @@ static void
     <% if is_object %>
     {
         dtype x;
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
         if (idx1) {
             for (; i--;) {
                 x = f_seq(beg,step,c++);
@@ -85,8 +85,8 @@ static VALUE
 {
     logseq_opt_t *g;
     VALUE vbeg, vstep, vbase;
-    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[1] = {{CUMO_OVERWRITE,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 1,0, ain,0};
 
     g = ALLOCA_N(logseq_opt_t,1);
     rb_scan_args(argc, args, "21", &vbeg, &vstep, &vbase);
@@ -97,6 +97,6 @@ static VALUE
     } else {
         g->base = m_num_to_data(vbase);
     }
-    na_ndloop3(&ndf, g, 1, self);
+    cumo_na_ndloop3(&ndf, g, 1, self);
     return self;
 }

data/ext/cumo/narray/gen/tmpl/logseq_kernel.cu

@@ -17,15 +17,15 @@ __global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, size_t s1, seq_dat
 
 void <%="cumo_#{c_iter}_index_kernel_launch"%>(char *p1, size_t* idx1, seq_data_t beg, seq_data_t step, seq_data_t base, seq_count_t c, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_index_kernel"%><<<gridDim, blockDim>>>(p1,idx1,beg,step,base,c,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_index_kernel"%><<<grid_dim, block_dim>>>(p1,idx1,beg,step,base,c,n);
 }
 
 void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, ssize_t s1, seq_data_t beg, seq_data_t step, seq_data_t base, seq_count_t c, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(p1,s1,beg,step,base,c,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<grid_dim, block_dim>>>(p1,s1,beg,step,base,c,n);
 }
 <% end %>

data/ext/cumo/narray/gen/tmpl/map_with_index.c

@@ -13,7 +13,7 @@ yield_map_with_index(dtype x, size_t *c, VALUE *a, int nd, int md)
 }
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2;
@@ -30,43 +30,43 @@ static void
     md = nd + 2;
     a = ALLOCA_N(VALUE,md);
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    CUMO_INIT_PTR_IDX(lp, 1, p2, s2, idx2);
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     c[nd] = 0;
     if (idx1) {
         if (idx2) {
             for (; i--;) {
-                GET_DATA_INDEX(p1,idx1,dtype,x);
+                CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
                 x = yield_map_with_index(x,c,a,nd,md);
-                SET_DATA_INDEX(p2,idx2,dtype,x);
+                CUMO_SET_DATA_INDEX(p2,idx2,dtype,x);
                 c[nd]++;
             }
         } else {
             for (; i--;) {
-                GET_DATA_INDEX(p1,idx1,dtype,x);
+                CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
                 x = yield_map_with_index(x,c,a,nd,md);
-                SET_DATA_STRIDE(p2,s2,dtype,x);
+                CUMO_SET_DATA_STRIDE(p2,s2,dtype,x);
                 c[nd]++;
             }
         }
     } else {
         if (idx2) {
             for (; i--;) {
-                GET_DATA_STRIDE(p1,s1,dtype,x);
+                CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
                 x = yield_map_with_index(x,c,a,nd,md);
-                SET_DATA_INDEX(p2,idx2,dtype,x);
+                CUMO_SET_DATA_INDEX(p2,idx2,dtype,x);
                 c[nd]++;
             }
         } else {
             for (; i--;) {
-                GET_DATA_STRIDE(p1,s1,dtype,x);
+                CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
                 x = yield_map_with_index(x,c,a,nd,md);
-                SET_DATA_STRIDE(p2,s2,dtype,x);
+                CUMO_SET_DATA_STRIDE(p2,s2,dtype,x);
                 c[nd]++;
             }
         }
@@ -90,9 +90,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
-    ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,1, ain,aout};
+    cumo_ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cT,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 1,1, ain,aout};
 
-    return na_ndloop_with_index(&ndf, 1, self);
+    return cumo_na_ndloop_with_index(&ndf, 1, self);
 }

data/ext/cumo/narray/gen/tmpl/median.c

@@ -1,17 +1,17 @@
 <% (is_float ? ["_ignan","_prnan"] : [""]).each do |j| %>
 static void
-<%=c_iter%><%=j%>(na_loop_t *const lp)
+<%=c_iter%><%=j%>(cumo_na_loop_t *const lp)
 {
     size_t n;
     char *p1, *p2;
     dtype *buf;
 
-    INIT_COUNTER(lp, n);
+    CUMO_INIT_COUNTER(lp, n);
     p1 = (lp->args[0]).ptr + (lp->args[0].iter[0]).pos;
     p2 = (lp->args[1]).ptr + (lp->args[1].iter[0]).pos;
     buf = (dtype*)p1;
 
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
     <%=type_name%>_qsort<%=j%>(buf, n, sizeof(dtype));
 
     <% if is_float %>
@@ -49,18 +49,18 @@ static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE v, reduce;
-    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_reduce,0}};
-    ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
-    ndfunc_t ndf = {0, NDF_HAS_LOOP|NDF_FLAT_REDUCE, 2,1, ain,aout};
+    cumo_ndfunc_arg_in_t ain[2] = {{CUMO_OVERWRITE,0},{cumo_sym_reduce,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
+    cumo_ndfunc_t ndf = {0, CUMO_NDF_HAS_LOOP|CUMO_NDF_FLAT_REDUCE, 2,1, ain,aout};
 
-    self = na_copy(self); // as temporary buffer
+    self = cumo_na_copy(self); // as temporary buffer
   <% if is_float %>
     ndf.func = <%=c_iter%>_ignan;
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_prnan);
+    reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_prnan);
   <% else %>
     ndf.func = <%=c_iter%>;
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+    reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
   <% end %>
-    v = na_ndloop(&ndf, 2, self, reduce);
+    v = cumo_na_ndloop(&ndf, 2, self, reduce);
     return <%=type_name%>_extract(v);
 }

data/ext/cumo/narray/gen/tmpl/minmax.c

@@ -1,16 +1,16 @@
 <% (is_float ? ["","_nan"] : [""]).each do |j| %>
 static void
-<%=c_iter%><%=j%>(na_loop_t *const lp)
+<%=c_iter%><%=j%>(cumo_na_loop_t *const lp)
 {
     size_t   n;
     char    *p1;
     ssize_t  s1;
     dtype    xmin,xmax;
 
-    INIT_COUNTER(lp, n);
-    INIT_PTR(lp, 0, p1, s1);
+    CUMO_INIT_COUNTER(lp, n);
+    CUMO_INIT_PTR(lp, 0, p1, s1);
 
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     f_<%=name%><%=j%>(n,p1,s1,&xmin,&xmax);
 
     *(dtype*)(lp->args[1].ptr + lp->args[1].iter[0].pos) = xmin;
@@ -34,14 +34,14 @@ static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE reduce;
-    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
-    ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
-    ndfunc_t ndf = {<%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 2,2, ain,aout};
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{cumo_sym_reduce,0}};
+    cumo_ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_STRIDE_LOOP_NIP|CUMO_NDF_FLAT_REDUCE|CUMO_NDF_EXTRACT, 2,2, ain,aout};
 
   <% if is_float %>
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_nan);
+    reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_nan);
   <% else %>
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+    reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
   <% end %>
-    return na_ndloop(&ndf, 2, self, reduce);
+    return cumo_na_ndloop(&ndf, 2, self, reduce);
 }

data/ext/cumo/narray/gen/tmpl/new_dim0.c

@@ -6,10 +6,10 @@ static VALUE
     VALUE v;
     dtype *ptr;
 
-    v = nary_new(cT, 0, NULL);
-    ptr = (dtype*)na_get_pointer_for_write(v);
+    v = cumo_na_new(cT, 0, NULL);
+    ptr = (dtype*)cumo_na_get_pointer_for_write(v);
     <%="cumo_#{c_func(:nodef)}_kernel_launch"%>(ptr, x);
 
-    na_release_lock(v);
+    cumo_na_release_lock(v);
     return v;
 }

data/ext/cumo/narray/gen/tmpl/poly.c

@@ -1,10 +1,10 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     dtype  x, y, a;
 
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     x = *(dtype*)(lp->args[0].ptr + lp->args[0].iter[0].pos);
     i = lp->narg - 2;
     y = *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos);
@@ -30,12 +30,12 @@ static VALUE
     int argc, i;
     VALUE *argv;
     volatile VALUE v, a;
-    ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, NO_LOOP, 0, 1, 0, aout };
+    cumo_ndfunc_arg_out_t aout[1] = {{cT,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_NO_LOOP, 0, 1, 0, aout };
 
     argc = RARRAY_LEN(args);
     ndf.nin = argc+1;
-    ndf.ain = ALLOCA_N(ndfunc_arg_in_t,argc+1);
+    ndf.ain = ALLOCA_N(cumo_ndfunc_arg_in_t,argc+1);
     for (i=0; i<argc+1; i++) {
         ndf.ain[i].type = cT;
     }
@@ -45,6 +45,6 @@ static VALUE
         argv[i+1] = RARRAY_PTR(args)[i];
     }
     a = rb_ary_new4(argc+1, argv);
-    v = na_ndloop2(&ndf, a);
+    v = cumo_na_ndloop2(&ndf, a);
     return <%=type_name%>_extract(v);
 }

data/ext/cumo/narray/gen/tmpl/pow.c

@@ -4,24 +4,24 @@ void <%="cumo_#{c_iter}_int32_kernel_launch"%>(char *p1, char *p2, char *p3, ssi
 <% end %>
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char    *p1, *p2, *p3;
     ssize_t s1, s2, s3;
-    INIT_COUNTER(lp, i);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR(lp, 2, p3, s3);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR(lp, 0, p1, s1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_PTR(lp, 2, p3, s3);
     <% if type_name == 'robject' %>
     {
         dtype x, y;
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
         for (; i--;) {
-            GET_DATA_STRIDE(p1,s1,dtype,x);
-            GET_DATA_STRIDE(p2,s2,dtype,y);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p2,s2,dtype,y);
             x = m_pow(x,y);
-            SET_DATA_STRIDE(p3,s3,dtype,x);
+            CUMO_SET_DATA_STRIDE(p3,s3,dtype,x);
         }
     }
     <% else %>
@@ -30,25 +30,25 @@ static void
 }
 
 static void
-<%=c_iter%>_int32(na_loop_t *const lp)
+<%=c_iter%>_int32(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2, *p3;
     ssize_t s1, s2, s3;
-    INIT_COUNTER(lp, i);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR(lp, 2, p3, s3);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR(lp, 0, p1, s1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_PTR(lp, 2, p3, s3);
     <% if type_name == 'robject' %>
     {
         dtype   x;
         int32_t y;
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>_int32", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>_int32", "<%=type_name%>");
         for (; i--;) {
-            GET_DATA_STRIDE(p1,s1,dtype,x);
-            GET_DATA_STRIDE(p2,s2,int32_t,y);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p2,s2,int32_t,y);
             x = m_pow_int(x,y);
-            SET_DATA_STRIDE(p3,s3,dtype,x);
+            CUMO_SET_DATA_STRIDE(p3,s3,dtype,x);
         }
     }
     <% else %>
@@ -59,17 +59,17 @@ static void
 static VALUE
 <%=c_func%>_self(VALUE self, VALUE other)
 {
-    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
-    ndfunc_arg_in_t ain_i[2] = {{cT,0},{cumo_cInt32,0}};
-    ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
-    ndfunc_t ndf_i = { <%=c_iter%>_int32, STRIDE_LOOP, 2, 1, ain_i, aout };
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_arg_in_t ain_i[2] = {{cT,0},{cumo_cInt32,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cT,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_STRIDE_LOOP, 2, 1, ain, aout };
+    cumo_ndfunc_t ndf_i = { <%=c_iter%>_int32, CUMO_STRIDE_LOOP, 2, 1, ain_i, aout };
 
     // fixme : use na.integer?
     if (FIXNUM_P(other) || rb_obj_is_kind_of(other,cumo_cInt32)) {
-        return na_ndloop(&ndf_i, 2, self, other);
+        return cumo_na_ndloop(&ndf_i, 2, self, other);
     } else {
-        return na_ndloop(&ndf, 2, self, other);
+        return cumo_na_ndloop(&ndf, 2, self, other);
     }
 }
 
@@ -86,12 +86,12 @@ static VALUE
     return <%=c_func%>_self(self,other);
     <% else %>
     VALUE klass, v;
-    klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
+    klass = cumo_na_upcast(rb_obj_class(self),rb_obj_class(other));
     if (klass==cT) {
         return <%=c_func%>_self(self,other);
     } else {
-        v = rb_funcall(klass, id_cast, 1, self);
-        return rb_funcall(v, id_pow, 1, other);
+        v = rb_funcall(klass, cumo_id_cast, 1, self);
+        return rb_funcall(v, cumo_id_pow, 1, other);
     }
     <% end %>
 }

data/ext/cumo/narray/gen/tmpl/pow_kernel.cu

@@ -15,15 +15,15 @@ __global__ void <%="cumo_#{c_iter}_int32_kernel"%>(char *p1, char *p2, char *p3,
 
 void <%="cumo_#{c_iter}_kernel_launch"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_kernel"%><<<gridDim, blockDim>>>(p1,p2,p3,s1,s2,s3,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_kernel"%><<<grid_dim, block_dim>>>(p1,p2,p3,s1,s2,s3,n);
 }
 
 void <%="cumo_#{c_iter}_int32_kernel_launch"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_int32_kernel"%><<<gridDim, blockDim>>>(p1,p2,p3,s1,s2,s3,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_int32_kernel"%><<<grid_dim, block_dim>>>(p1,p2,p3,s1,s2,s3,n);
 }
 <% end %>

data/ext/cumo/narray/gen/tmpl/rand.c

@@ -72,7 +72,7 @@ typedef struct {
 } rand_opt_t;
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t   i;
     char    *p1;
@@ -84,25 +84,25 @@ static void
     <%=rand_type%> max;
     <%=shift_def%>
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
     g = (rand_opt_t*)(lp->opt_ptr);
     low = g->low;
     max = g->max;
     <%=shift_set%>
 
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
     if (idx1) {
         for (; i--;) {
             x = m_add(<%=m_rand%>,low);
-            SET_DATA_INDEX(p1,idx1,dtype,x);
+            CUMO_SET_DATA_INDEX(p1,idx1,dtype,x);
         }
     } else {
         for (; i--;) {
             x = m_add(<%=m_rand%>,low);
-            SET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_SET_DATA_STRIDE(p1,s1,dtype,x);
         }
     }
 }
@@ -131,8 +131,8 @@ static VALUE
     rand_opt_t g;
     VALUE v1=Qnil, v2=Qnil;
     dtype high;
-    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[1] = {{CUMO_OVERWRITE,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 1,0, ain,0};
 
     <% if is_int && !is_object %>
     rb_scan_args(argc, args, "11", &v1, &v2);
@@ -163,6 +163,6 @@ static VALUE
         rb_raise(rb_eArgError,"high must be larger than low");
     }
     <% end %>
-    na_ndloop3(&ndf, &g, 1, self);
+    cumo_na_ndloop3(&ndf, &g, 1, self);
     return self;
 }