cumo 0.1.0 → 0.1.1

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

@@ -1,5 +1,5 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2;
@@ -7,37 +7,37 @@ static void
     size_t *idx1, *idx2;
     dtype   x;
     <%=dtype%> y;
-    INIT_COUNTER(lp, i);
-    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    CUMO_INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
     if (idx1) {
         if (idx2) {
             for (; i--;) {
-                GET_DATA_INDEX(p1,idx1,dtype,x);
+                CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
                 y = m_<%=name%>(x);
-                SET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+                CUMO_SET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
             }
         } else {
             for (; i--;) {
-                GET_DATA_INDEX(p1,idx1,dtype,x);
+                CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
                 y = m_<%=name%>(x);
-                SET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+                CUMO_SET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
             }
         }
     } else {
         if (idx2) {
             for (; i--;) {
-                GET_DATA_STRIDE(p1,s1,dtype,x);
+                CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
                 y = m_<%=name%>(x);
-                SET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+                CUMO_SET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
             }
         } else {
             for (; i--;) {
-                GET_DATA_STRIDE(p1,s1,dtype,x);
+                CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
                 y = m_<%=name%>(x);
-                SET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+                CUMO_SET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
             }
         }
     }
@@ -52,9 +52,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{cT,0}};
-    ndfunc_arg_out_t aout[1] = {{<%=result_class%>,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 1, ain, aout };
+    cumo_ndfunc_arg_in_t ain[1] = {{cT,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{<%=result_class%>,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_FULL_LOOP, 1, 1, ain, aout };
 
-    return na_ndloop(&ndf, 1, self);
+    return cumo_na_ndloop(&ndf, 1, self);
 }

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

@@ -37,36 +37,36 @@ __global__ void <%="cumo_#{c_iter}_contiguous_kernel"%>(char *p1, char *p2, uint
 
 void <%="cumo_#{c_iter}_index_index_kernel_launch"%>(char *p1, char *p2, size_t *idx1, size_t *idx2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_index_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,idx1,idx2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_index_index_kernel"%><<<grid_dim, block_dim>>>(p1,p2,idx1,idx2,n);
 }
 
 void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(char *p1, char *p2, size_t *idx1, ssize_t s2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_index_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,idx1,s2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_index_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,idx1,s2,n);
 }
 
 void <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(char *p1, char *p2, ssize_t s1, size_t *idx2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_stride_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,s1,idx2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_stride_index_kernel"%><<<grid_dim, block_dim>>>(p1,p2,s1,idx2,n);
 }
 
 void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(char *p1, char *p2, ssize_t s1, ssize_t s2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,s1,s2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,s1,s2,n);
 }
 
 void <%="cumo_#{c_iter}_contiguous_kernel_launch"%>(char *p1, char *p2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_contiguous_kernel"%><<<gridDim, blockDim>>>(p1,p2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_contiguous_kernel"%><<<grid_dim, block_dim>>>(p1,p2,n);
 }
 <% end %>

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

@@ -1,20 +1,20 @@
 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;
     dtype   x, y, z;
-    INIT_COUNTER(lp, i);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR(lp, 2, p3, s3);
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    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);
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     for (; i--;) {
-        GET_DATA_STRIDE(p1,s1,dtype,x);
+        CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
         m_<%=name%>(x,y,z);
-        SET_DATA_STRIDE(p2,s2,dtype,y);
-        SET_DATA_STRIDE(p3,s3,dtype,z);
+        CUMO_SET_DATA_STRIDE(p2,s2,dtype,y);
+        CUMO_SET_DATA_STRIDE(p3,s3,dtype,z);
     }
 }
 
@@ -26,9 +26,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{cT,0}};
-    ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
-    ndfunc_t ndf = {<%=c_iter%>, STRIDE_LOOP, 1,2, ain,aout};
+    cumo_ndfunc_arg_in_t ain[1] = {{cT,0}};
+    cumo_ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_STRIDE_LOOP, 1,2, ain,aout};
 
-    return na_ndloop(&ndf, 1, self);
+    return cumo_na_ndloop(&ndf, 1, self);
 }

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

@@ -6,46 +6,46 @@ void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(char *p1, char *p2, ssize
 <% end %>
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2;
     ssize_t s1, s2;
     size_t *idx1, *idx2;
-    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);
 
     <% if type_name == 'robject' %>
     {
         dtype x;
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
         if (idx1) {
             if (idx2) {
                 for (; i--;) {
-                    GET_DATA_INDEX(p1,idx1,dtype,x);
+                    CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
                     x = m_<%=name%>(x);
-                    SET_DATA_INDEX(p2,idx2,dtype,x);
+                    CUMO_SET_DATA_INDEX(p2,idx2,dtype,x);
                 }
             } else {
                 for (; i--;) {
-                    GET_DATA_INDEX(p1,idx1,dtype,x);
+                    CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
                     x = m_<%=name%>(x);
-                    SET_DATA_STRIDE(p2,s2,dtype,x);
+                    CUMO_SET_DATA_STRIDE(p2,s2,dtype,x);
                 }
             }
         } else {
             if (idx2) {
                 for (; i--;) {
-                    GET_DATA_STRIDE(p1,s1,dtype,x);
+                    CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
                     x = m_<%=name%>(x);
-                    SET_DATA_INDEX(p2,idx2,dtype,x);
+                    CUMO_SET_DATA_INDEX(p2,idx2,dtype,x);
                 }
             } else {
                 for (; i--;) {
-                    GET_DATA_STRIDE(p1,s1,dtype,x);
+                    CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
                     x = m_<%=name%>(x);
-                    SET_DATA_STRIDE(p2,s2,dtype,x);
+                    CUMO_SET_DATA_STRIDE(p2,s2,dtype,x);
                 }
             }
         }
@@ -78,9 +78,9 @@ static void
 static VALUE
 <%=c_func(1)%>(VALUE mod, VALUE a1)
 {
-    ndfunc_arg_in_t ain[1] = {{cT,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] = {{cT,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(&ndf, 1, a1);
+    return cumo_na_ndloop(&ndf, 1, a1);
 }

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

@@ -29,30 +29,30 @@ __global__ void <%="cumo_#{c_iter}_stride_stride_kernel"%>(char *p1, char *p2, s
 
 void <%="cumo_#{c_iter}_index_index_kernel_launch"%>(char *p1, char *p2, size_t *idx1, size_t *idx2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_index_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,idx1,idx2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_index_index_kernel"%><<<grid_dim, block_dim>>>(p1,p2,idx1,idx2,n);
 }
 
 void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(char *p1, char *p2, size_t *idx1, ssize_t s2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_index_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,idx1,s2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_index_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,idx1,s2,n);
 }
 
 void <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(char *p1, char *p2, ssize_t s1, size_t *idx2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_stride_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,s1,idx2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_stride_index_kernel"%><<<grid_dim, block_dim>>>(p1,p2,s1,idx2,n);
 }
 
 void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(char *p1, char *p2, ssize_t s1, ssize_t s2, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,s1,s2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,s1,s2,n);
 }
 
 <% end %>

data/ext/cumo/narray/gen/tmpl_bit/allocate.c

@@ -1,21 +1,21 @@
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    narray_t *na;
+    cumo_narray_t *na;
     char *ptr;
 
-    GetNArray(self,na);
+    CumoGetNArray(self,na);
 
-    switch(NA_TYPE(na)) {
-    case NARRAY_DATA_T:
-        ptr = NA_DATA_PTR(na);
+    switch(CUMO_NA_TYPE(na)) {
+    case CUMO_NARRAY_DATA_T:
+        ptr = CUMO_NA_DATA_PTR(na);
         if (na->size > 0 && ptr == NULL) {
-            ptr = cumo_cuda_runtime_malloc(((na->size-1)/8/sizeof(BIT_DIGIT)+1)*sizeof(BIT_DIGIT));
-            NA_DATA_PTR(na) = ptr;
+            ptr = cumo_cuda_runtime_malloc(((na->size-1)/8/sizeof(CUMO_BIT_DIGIT)+1)*sizeof(CUMO_BIT_DIGIT));
+            CUMO_NA_DATA_PTR(na) = ptr;
         }
         break;
-    case NARRAY_VIEW_T:
-        rb_funcall(NA_VIEW_DATA(na), rb_intern("allocate"), 0);
+    case CUMO_NARRAY_VIEW_T:
+        rb_funcall(CUMO_NA_VIEW_DATA(na), rb_intern("allocate"), 0);
         break;
     default:
         rb_raise(rb_eRuntimeError,"invalid narray type");

data/ext/cumo/narray/gen/tmpl_bit/aref.c

@@ -48,7 +48,7 @@ static VALUE
         int result_nd;
         size_t pos;
 
-        result_nd = na_get_result_dimension(self, argc, argv, 1, &pos);
-        return na_aref_main(argc, argv, self, 0, result_nd, pos);
+        result_nd = cumo_na_get_result_dimension(self, argc, argv, 1, &pos);
+        return cumo_na_aref_main(argc, argv, self, 0, result_nd, pos);
     }
 }

data/ext/cumo/narray/gen/tmpl_bit/aref_cpu.c

@@ -44,14 +44,14 @@ static VALUE
     char *ptr;
     dtype x;
 
-    nd = na_get_result_dimension(self, argc, argv, 1, &pos);
+    nd = cumo_na_get_result_dimension(self, argc, argv, 1, &pos);
     if (nd) {
-        return na_aref_main(argc, argv, self, 0, nd, pos);
+        return cumo_na_aref_main(argc, argv, self, 0, nd, pos);
     } else {
-        ptr = na_get_pointer_for_read(self);
-        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        ptr = cumo_na_get_pointer_for_read(self);
+        CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
         cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-        LOAD_BIT(ptr,pos,x);
+        CUMO_LOAD_BIT(ptr,pos,x);
         return m_data_to_num(x);
     }
 }

data/ext/cumo/narray/gen/tmpl_bit/aset.c

@@ -48,8 +48,8 @@ static VALUE
     if (argc==0) {
         <%=c_func.sub(/_aset/,"_store")%>(self, argv[argc]);
     } else {
-        nd = na_get_result_dimension(self, argc, argv, 1, &pos);
-        a = na_aref_main(argc, argv, self, 0, nd, pos);
+        nd = cumo_na_get_result_dimension(self, argc, argv, 1, &pos);
+        a = cumo_na_aref_main(argc, argv, self, 0, nd, pos);
         <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
     }
     return argv[argc];

data/ext/cumo/narray/gen/tmpl_bit/binary.c

@@ -1,63 +1,63 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  n;
     size_t  p1, p2, p3;
     ssize_t s1, s2, s3;
     size_t *idx1, *idx2, *idx3;
     int     o1, o2, l1, l2, r1, r2, len;
-    BIT_DIGIT *a1, *a2, *a3;
-    BIT_DIGIT  x, y;
+    CUMO_BIT_DIGIT *a1, *a2, *a3;
+    CUMO_BIT_DIGIT  x, y;
 
     // TODO(sonots): CUDA kernelize
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
-    INIT_COUNTER(lp, n);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
-    INIT_PTR_BIT_IDX(lp, 2, a3, p3, s3, idx3);
+    CUMO_INIT_COUNTER(lp, n);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+    CUMO_INIT_PTR_BIT_IDX(lp, 2, a3, p3, s3, idx3);
     if (s1!=1 || s2!=1 || s3!=1 || idx1 || idx2 || idx3) {
         for (; n--;) {
-            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
-            LOAD_BIT_STEP(a2, p2, s2, idx2, y);
+            CUMO_LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            CUMO_LOAD_BIT_STEP(a2, p2, s2, idx2, y);
             x = m_<%=name%>(x,y);
-            STORE_BIT_STEP(a3, p3, s3, idx3, x);
+            CUMO_STORE_BIT_STEP(a3, p3, s3, idx3, x);
         }
     } else {
-        o1 =  p1 % NB;
+        o1 =  p1 % CUMO_NB;
         o1 -= p3;
-        o2 =  p2 % NB;
+        o2 =  p2 % CUMO_NB;
         o2 -= p3;
-        l1 =  NB+o1;
-        r1 =  NB-o1;
-        l2 =  NB+o2;
-        r2 =  NB-o2;
-        if (p3>0 || n<NB) {
-            len = NB - p3;
+        l1 =  CUMO_NB+o1;
+        r1 =  CUMO_NB-o1;
+        l2 =  CUMO_NB+o2;
+        r2 =  CUMO_NB-o2;
+        if (p3>0 || n<CUMO_NB) {
+            len = CUMO_NB - p3;
             if ((int)n<len) len=n;
             if (o1>=0) x = *a1>>o1;
             else       x = *a1<<-o1;
-            if (p1+len>NB)  x |= *(a1+1)<<r1;
+            if (p1+len>CUMO_NB)  x |= *(a1+1)<<r1;
             a1++;
             if (o2>=0) y = *a2>>o2;
             else       y = *a2<<-o2;
-            if (p2+len>NB)  y |= *(a2+1)<<r2;
+            if (p2+len>CUMO_NB)  y |= *(a2+1)<<r2;
             a2++;
             x = m_<%=name%>(x,y);
-            *a3 = (x & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            *a3 = (x & (CUMO_SLB(len)<<p3)) | (*a3 & ~(CUMO_SLB(len)<<p3));
             a3++;
             n -= len;
         }
         if (o1==0 && o2==0) {
-            for (; n>=NB; n-=NB) {
+            for (; n>=CUMO_NB; n-=CUMO_NB) {
                 x = *(a1++);
                 y = *(a2++);
                 x = m_<%=name%>(x,y);
                 *(a3++) = x;
             }
         } else {
-            for (; n>=NB; n-=NB) {
+            for (; n>=CUMO_NB; n-=CUMO_NB) {
                 x = *a1>>o1;
                 if (o1<0)  x |= *(a1-1)>>l1;
                 if (o1>0)  x |= *(a1+1)<<r1;
@@ -76,7 +76,7 @@ static void
             y = *a2>>o2;
             if (o2<0)  y |= *(a2-1)>>l2;
             x = m_<%=name%>(x,y);
-            *a3 = (x & SLB(n)) | (*a3 & BALL<<n);
+            *a3 = (x & CUMO_SLB(n)) | (*a3 & CUMO_BALL<<n);
         }
     }
 }
@@ -90,9 +90,9 @@ static void
 static VALUE
 <%=c_func(1)%>(VALUE self, VALUE other)
 {
-    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
-    ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 1, ain, aout };
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cT,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_FULL_LOOP, 2, 1, ain, aout };
 
-    return na_ndloop(&ndf, 2, self, other);
+    return cumo_na_ndloop(&ndf, 2, self, other);
 }