cumo 0.1.0 → 0.1.1

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

@@ -3,23 +3,23 @@ void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, char *p3, ch
 <% end %>
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t   i, n;
     char    *p1, *p2, *p3, *p4;
     ssize_t  s1, s2, s3, s4;
-    INIT_COUNTER(lp, n);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR(lp, 2, p3, s3);
-    INIT_PTR(lp, 3, p4, s4);
+    CUMO_INIT_COUNTER(lp, n);
+    CUMO_INIT_PTR(lp, 0, p1, s1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_PTR(lp, 2, p3, s3);
+    CUMO_INIT_PTR(lp, 3, p4, s4);
     for (i=n; i--;) {
         <% if type_name == 'robject' %>
         {
             dtype    x, y, a, b;
-            SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
-            GET_DATA_STRIDE(p1,s1,dtype,x);
-            GET_DATA_STRIDE(p2,s2,dtype,y);
+            CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p2,s2,dtype,y);
 <% if is_int and %w[divmod].include? name %>
                 if (y==0) {
                     lp->err_type = rb_eZeroDivError;
@@ -27,8 +27,8 @@ static void
                 }
 <% end %>
             m_<%=name%>(x,y,a,b);
-            SET_DATA_STRIDE(p3,s3,dtype,a);
-            SET_DATA_STRIDE(p4,s4,dtype,b);
+            CUMO_SET_DATA_STRIDE(p3,s3,dtype,a);
+            CUMO_SET_DATA_STRIDE(p4,s4,dtype,b);
         }
         <% else %>
         <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,p2,p3,p4,s1,s2,s3,s4,n);
@@ -39,11 +39,11 @@ static void
 static VALUE
 <%=c_func%>_self(VALUE self, VALUE other)
 {
-    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
-    ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 2, ain, aout };
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_STRIDE_LOOP, 2, 2, ain, aout };
 
-    return na_ndloop(&ndf, 2, self, other);
+    return cumo_na_ndloop(&ndf, 2, self, other);
 }
 
 /*
@@ -59,12 +59,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_op%>, 1, other);
+        v = rb_funcall(klass, cumo_id_cast, 1, self);
+        return rb_funcall(v, <%=cumo_id_op%>, 1, other);
     }
     <% end %>
 }

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

@@ -8,8 +8,8 @@ __global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, char *p2, char *p3
 
 void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, char *p3, char *p4, ssize_t s1, ssize_t s2, ssize_t s3, ssize_t s4, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,p3,p4,s1,s2,s3,s4,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,p2,p3,p4,s1,s2,s3,s4,n);
 }
 <% end %>

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

@@ -1,7 +1,7 @@
 <% unless type_name == 'robject' %>
 
 <% ((0..opt_indexer_ndim).to_a << '').each do |idim| %>
-__global__ void <%="cumo_#{c_iter}_kernel_dim#{idim}"%>(na_iarray_t a1, na_iarray_t a2, na_iarray_t a3, na_indexer_t indexer)
+__global__ void <%="cumo_#{c_iter}_kernel_dim#{idim}"%>(cumo_na_iarray_t a1, cumo_na_iarray_t a2, cumo_na_iarray_t a3, cumo_na_indexer_t indexer)
 {
     for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < indexer.total_size; i += blockDim.x * gridDim.x) {
         cumo_na_indexer_set_dim<%=idim%>(&indexer, i);
@@ -13,18 +13,18 @@ __global__ void <%="cumo_#{c_iter}_kernel_dim#{idim}"%>(na_iarray_t a1, na_iarra
 }
 <% end %>
 
-void <%="cumo_#{c_iter}_kernel_launch"%>(na_iarray_t* a1, na_iarray_t* a2, na_iarray_t* a3, na_indexer_t* indexer)
+void <%="cumo_#{c_iter}_kernel_launch"%>(cumo_na_iarray_t* a1, cumo_na_iarray_t* a2, cumo_na_iarray_t* a3, cumo_na_indexer_t* indexer)
 {
-    size_t gridDim = get_gridDim(indexer->total_size);
-    size_t blockDim = get_blockDim(indexer->total_size);
+    size_t grid_dim = cumo_get_grid_dim(indexer->total_size);
+    size_t block_dim = cumo_get_block_dim(indexer->total_size);
     switch (indexer->ndim) {
     <% (0..opt_indexer_ndim).each do |idim| %>
     case <%=idim%>:
-        <%="cumo_#{c_iter}_kernel_dim#{idim}"%><<<gridDim, blockDim>>>(*a1,*a2,*a3,*indexer);
+        <%="cumo_#{c_iter}_kernel_dim#{idim}"%><<<grid_dim, block_dim>>>(*a1,*a2,*a3,*indexer);
         break;
     <% end %>
     default:
-        <%="cumo_#{c_iter}_kernel_dim"%><<<gridDim, blockDim>>>(*a1,*a2,*a3,*indexer);
+        <%="cumo_#{c_iter}_kernel_dim"%><<<grid_dim, block_dim>>>(*a1,*a2,*a3,*indexer);
         break;
     }
 }

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

@@ -3,24 +3,24 @@ void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, char *p3, ss
 <% 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_<%=name%>(x,y);
-            SET_DATA_STRIDE(p3,s3,dtype,x);
+            CUMO_SET_DATA_STRIDE(p3,s3,dtype,x);
         }
     }
     <% else %>
@@ -38,8 +38,8 @@ static void
 static VALUE
 <%=c_func(2)%>(VALUE mod, VALUE a1, VALUE a2)
 {
-    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
-    ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
-    return na_ndloop(&ndf, 2, a1, a2);
+    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_STRIDE_LOOP, 2, 1, ain, aout };
+    return cumo_na_ndloop(&ndf, 2, a1, a2);
 }

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

@@ -8,8 +8,8 @@ __global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, char *p2, char *p3
 
 void <%="cumo_#{c_iter}_stride_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}_stride_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}_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,p3,s1,s2,s3,n);
 }
 <% end %>

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

@@ -5,15 +5,15 @@
    cnt_type = "u_int#{bits}_t"
 %>
 static void
-<%=c_iter%>_<%=bits%>(na_loop_t *const lp)
+<%=c_iter%>_<%=bits%>(cumo_na_loop_t *const lp)
 {
     size_t   i, x, n;
     char    *p1, *p2;
     ssize_t  s1, s2;
     size_t  *idx1;
 
-    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-    INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
     i = lp->args[0].shape[0];
     n = lp->args[1].shape[0];
 
@@ -22,15 +22,15 @@ static void
         *(<%=cnt_type%>*)(p2 + s2*x) = 0;
     }
 
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>_<%=bits%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>_<%=bits%>", "<%=type_name%>");
     if (idx1) {
         for (; i--;) {
-            GET_DATA_INDEX(p1,idx1,dtype,x);
+            CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
             (*(<%=cnt_type%>*)(p2 + s2*x))++;
         }
     } else {
         for (; i--;) {
-            GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
             (*(<%=cnt_type%>*)(p2 + s2*x))++;
         }
     }
@@ -40,12 +40,12 @@ static VALUE
 <%=c_func%>_<%=bits%>(VALUE self, size_t length)
 {
     size_t shape_out[1] = {length};
-    ndfunc_arg_in_t ain[1] = {{cT,1}};
-    ndfunc_arg_out_t aout[1] = {{<%=cnt_cT%>,1,shape_out}};
-    ndfunc_t ndf = {<%=c_iter%>_<%=bits%>, NO_LOOP|NDF_STRIDE_LOOP|NDF_INDEX_LOOP,
+    cumo_ndfunc_arg_in_t ain[1] = {{cT,1}};
+    cumo_ndfunc_arg_out_t aout[1] = {{<%=cnt_cT%>,1,shape_out}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>_<%=bits%>, CUMO_NO_LOOP|CUMO_NDF_STRIDE_LOOP|CUMO_NDF_INDEX_LOOP,
                     1, 1, ain, aout};
 
-    return na_ndloop(&ndf, 1, self);
+    return cumo_na_ndloop(&ndf, 1, self);
 }
 <% end %>
 // ------- end of Integer count without weights -------
@@ -58,22 +58,22 @@ static VALUE
   fn = fn.downcase
 %>
 static void
-<%=c_iter%>_<%=fn%>(na_loop_t *const lp)
+<%=c_iter%>_<%=fn%>(cumo_na_loop_t *const lp)
 {
     <%=cnt_type%> w;
     size_t   i, x, n, m;
     char    *p1, *p2, *p3;
     ssize_t  s1, s2, s3;
 
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR(lp, 2, p3, s3);
+    CUMO_INIT_PTR(lp, 0, p1, s1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_PTR(lp, 2, p3, s3);
     i = lp->args[0].shape[0];
     m = lp->args[1].shape[0];
     n = lp->args[2].shape[0];
 
     if (i != m) {
-        rb_raise(nary_eShapeError,
+        rb_raise(cumo_na_eShapeError,
                  "size mismatch along last axis between self and weight");
     }
 
@@ -82,8 +82,8 @@ static void
         *(<%=cnt_type%>*)(p3 + s3*x) = 0;
     }
     for (; i--;) {
-        GET_DATA_STRIDE(p1,s1,dtype,x);
-        GET_DATA_STRIDE(p2,s2,<%=cnt_type%>,w);
+        CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+        CUMO_GET_DATA_STRIDE(p2,s2,<%=cnt_type%>,w);
         (*(<%=cnt_type%>*)(p3 + s3*x)) += w;
     }
 }
@@ -92,12 +92,12 @@ static VALUE
 <%=c_func%>_<%=fn%>(VALUE self, VALUE weight, size_t length)
 {
     size_t shape_out[1] = {length};
-    ndfunc_arg_in_t ain[2] = {{cT,1},{<%=cnt_cT%>,1}};
-    ndfunc_arg_out_t aout[1] = {{<%=cnt_cT%>,1,shape_out}};
-    ndfunc_t ndf = {<%=c_iter%>_<%=fn%>, NO_LOOP|NDF_STRIDE_LOOP,
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,1},{<%=cnt_cT%>,1}};
+    cumo_ndfunc_arg_out_t aout[1] = {{<%=cnt_cT%>,1,shape_out}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>_<%=fn%>, CUMO_NO_LOOP|CUMO_NDF_STRIDE_LOOP,
                     2, 1, ain, aout};
 
-    return na_ndloop(&ndf, 2, self, weight);
+    return cumo_na_ndloop(&ndf, 2, self, weight);
 }
 <% end %>
 // ------- end of Float count with weights -------
@@ -140,7 +140,7 @@ static VALUE
     VALUE weight=Qnil, kw=Qnil;
     VALUE opts[1] = {Qundef};
     VALUE v, wclass;
-    ID table[1] = {id_minlength};
+    ID table[1] = {cumo_id_minlength};
     size_t length, minlength;
 
     rb_scan_args(argc, argv, "01:", &weight, &kw);
@@ -171,7 +171,7 @@ static VALUE
             return <%=c_func%>_32(self, length);
         }
     } else {
-        wclass = CLASS_OF(weight);
+        wclass = rb_obj_class(weight);
         if (wclass == cumo_cSFloat) {
             return <%=c_func%>_sf(self, weight, length);
         } else {

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

@@ -14,10 +14,10 @@ static VALUE
 <%=c_func(1)%>(VALUE type, VALUE obj)
 {
     VALUE v;
-    narray_t *na;
+    cumo_narray_t *na;
     dtype x;
 
-    if (CLASS_OF(obj)==cT) {
+    if (rb_obj_class(obj)==cT) {
         return obj;
     }
     if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
@@ -27,10 +27,10 @@ static VALUE
     if (RTEST(rb_obj_is_kind_of(obj,rb_cArray))) {
         return <%=find_tmpl("cast_array").c_func%>(obj);
     }
-    if (IsNArray(obj)) {
-        GetNArray(obj,na);
-        v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
-        if (NA_SIZE(na) > 0) {
+    if (CumoIsNArray(obj)) {
+        CumoGetNArray(obj,na);
+        v = cumo_na_new(cT, CUMO_NA_NDIM(na), CUMO_NA_SHAPE(na));
+        if (CUMO_NA_SIZE(na) > 0) {
             <%=find_tmpl("store").c_func%>(v,obj);
         }
         return v;
@@ -38,7 +38,7 @@ static VALUE
     <% if is_object %>
     return robject_new_dim0(obj);
     <% else %>
-    rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
+    rb_raise(cumo_na_eCastError,"cannot cast to %s",rb_class2name(type));
     return Qnil;
     <% end %>
 }

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

@@ -2,10 +2,10 @@ static VALUE
 <%=c_func(:nodef)%>(VALUE rary)
 {
     VALUE nary;
-    narray_t *na;
+    cumo_narray_t *na;
 
-    nary = na_s_new_like(cT, rary);
-    GetNArray(nary,na);
+    nary = cumo_na_s_new_like(cT, rary);
+    CumoGetNArray(nary,na);
     if (na->size > 0) {
         <%=find_tmpl("store").find("array").c_func%>(nary,rary);
     }

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

@@ -1,64 +1,64 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2, *p3, *p4;
     ssize_t s1, s2, s3, s4;
     dtype   x, min, max;
-    INIT_COUNTER(lp, i);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR(lp, 2, p3, s3);
-    INIT_PTR(lp, 3, p4, s4);
-    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_INIT_PTR(lp, 3, p4, s4);
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     for (; i--;) {
-        GET_DATA_STRIDE(p1,s1,dtype,x);
-        GET_DATA_STRIDE(p2,s2,dtype,min);
-        GET_DATA_STRIDE(p3,s3,dtype,max);
-        if (m_gt(min,max)) {rb_raise(nary_eOperationError,"min is greater than max");}
+        CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+        CUMO_GET_DATA_STRIDE(p2,s2,dtype,min);
+        CUMO_GET_DATA_STRIDE(p3,s3,dtype,max);
+        if (m_gt(min,max)) {rb_raise(cumo_na_eOperationError,"min is greater than max");}
         if (m_lt(x,min)) {x=min;}
         if (m_gt(x,max)) {x=max;}
-        SET_DATA_STRIDE(p4,s4,dtype,x);
+        CUMO_SET_DATA_STRIDE(p4,s4,dtype,x);
     }
 }
 
 static void
-<%=c_iter%>_min(na_loop_t *const lp)
+<%=c_iter%>_min(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2, *p3;
     ssize_t s1, s2, s3;
     dtype   x, min;
-    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%>_min", "<%=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%>_min", "<%=type_name%>");
     for (; i--;) {
-        GET_DATA_STRIDE(p1,s1,dtype,x);
-        GET_DATA_STRIDE(p2,s2,dtype,min);
+        CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+        CUMO_GET_DATA_STRIDE(p2,s2,dtype,min);
         if (m_lt(x,min)) {x=min;}
-        SET_DATA_STRIDE(p3,s3,dtype,x);
+        CUMO_SET_DATA_STRIDE(p3,s3,dtype,x);
     }
 }
 
 static void
-<%=c_iter%>_max(na_loop_t *const lp)
+<%=c_iter%>_max(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2, *p3;
     ssize_t s1, s2, s3;
     dtype   x, max;
-    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%>_max", "<%=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%>_max", "<%=type_name%>");
     for (; i--;) {
-        GET_DATA_STRIDE(p1,s1,dtype,x);
-        GET_DATA_STRIDE(p2,s2,dtype,max);
+        CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+        CUMO_GET_DATA_STRIDE(p2,s2,dtype,max);
         if (m_gt(x,max)) {x=max;}
-        SET_DATA_STRIDE(p3,s3,dtype,x);
+        CUMO_SET_DATA_STRIDE(p3,s3,dtype,x);
     }
 }
 
@@ -99,21 +99,21 @@ static void
 static VALUE
 <%=c_func(2)%>(VALUE self, VALUE min, VALUE max)
 {
-    ndfunc_arg_in_t ain[3] = {{Qnil,0},{cT,0},{cT,0}};
-    ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf_min = { <%=c_iter%>_min, STRIDE_LOOP, 2, 1, ain, aout };
-    ndfunc_t ndf_max = { <%=c_iter%>_max, STRIDE_LOOP, 2, 1, ain, aout };
-    ndfunc_t ndf_both = { <%=c_iter%>, STRIDE_LOOP, 3, 1, ain, aout };
+    cumo_ndfunc_arg_in_t ain[3] = {{Qnil,0},{cT,0},{cT,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cT,0}};
+    cumo_ndfunc_t ndf_min = { <%=c_iter%>_min, CUMO_STRIDE_LOOP, 2, 1, ain, aout };
+    cumo_ndfunc_t ndf_max = { <%=c_iter%>_max, CUMO_STRIDE_LOOP, 2, 1, ain, aout };
+    cumo_ndfunc_t ndf_both = { <%=c_iter%>, CUMO_STRIDE_LOOP, 3, 1, ain, aout };
 
     if (RTEST(min)) {
         if (RTEST(max)) {
-            return na_ndloop(&ndf_both, 3, self, min, max);
+            return cumo_na_ndloop(&ndf_both, 3, self, min, max);
         } else {
-            return na_ndloop(&ndf_min, 2, self, min);
+            return cumo_na_ndloop(&ndf_min, 2, self, min);
         }
     } else {
         if (RTEST(max)) {
-            return na_ndloop(&ndf_max, 2, self, max);
+            return cumo_na_ndloop(&ndf_max, 2, self, max);
         }
     }
     rb_raise(rb_eArgError,"min and max are not given");