cumo 0.1.0 → 0.1.1

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

@@ -65,12 +65,12 @@ extern "C" {
 #endif
 #endif
 
-void cumo_<%=type_name%>_sum_kernel_launch(na_reduction_arg_t* arg)
+void cumo_<%=type_name%>_sum_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce<dtype, <%=dtype%>, cumo_<%=type_name%>_sum_impl>(*arg, cumo_<%=type_name%>_sum_impl{});
 }
 
-void cumo_<%=type_name%>_prod_kernel_launch(na_reduction_arg_t* arg)
+void cumo_<%=type_name%>_prod_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce<dtype, <%=dtype%>, cumo_<%=type_name%>_prod_impl>(*arg, cumo_<%=type_name%>_prod_impl{});
 }

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

@@ -1,29 +1,29 @@
 <% unless type_name == 'robject' %>
-void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n);
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, CUMO_BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n);
 <% end %>
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
     char   *p1, *p2;
-    BIT_DIGIT *a3;
+    CUMO_BIT_DIGIT *a3;
     size_t  p3;
     ssize_t s1, s2, s3;
-    INIT_COUNTER(lp, i);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR_BIT(lp, 2, a3, p3, s3);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR(lp, 0, p1, s1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_PTR_BIT(lp, 2, a3, p3, s3);
     <% if type_name == 'robject' %>
     {
         dtype x, y;
-        BIT_DIGIT b;
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        CUMO_BIT_DIGIT b;
+        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);
             b = (m_<%=name%>(x,y)) ? 1:0;
-            STORE_BIT(a3,p3,b);
+            CUMO_STORE_BIT(a3,p3,b);
             p3+=s3;
         }
     }
@@ -37,11 +37,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[1] = {{cumo_cBit,0}};
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cumo_cBit,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_STRIDE_LOOP, 2, 1, ain, aout };
 
-    return na_ndloop(&ndf, 2, self, other);
+    return cumo_na_ndloop(&ndf, 2, self, other);
 }
 
 /*
@@ -57,12 +57,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/cond_binary_kernel.cu

@@ -1,18 +1,18 @@
 <% unless type_name == 'robject' %>
-__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, char *p2, BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, char *p2, CUMO_BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
 {
     for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
         dtype x = *(dtype*)(p1+(i*s1));
         dtype y = *(dtype*)(p2+(i*s2));
-        BIT_DIGIT b = (m_<%=name%>(x,y)) ? 1:0;
-        STORE_BIT(a3,p3+(i*s3),b);
+        CUMO_BIT_DIGIT b = (m_<%=name%>(x,y)) ? 1:0;
+        CUMO_STORE_BIT(a3,p3+(i*s3),b);
     }
 }
 
-void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, CUMO_BIT_DIGIT *a3, size_t 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,a3,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,a3,p3,s1,s2,s3,n);
 }
 <% end %>

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

@@ -1,30 +1,30 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t    i;
     char     *p1;
-    BIT_DIGIT *a2;
+    CUMO_BIT_DIGIT *a2;
     size_t    p2;
     ssize_t   s1, s2;
     size_t   *idx1;
     dtype     x;
-    BIT_DIGIT b;
-    INIT_COUNTER(lp, i);
-    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-    INIT_PTR_BIT(lp, 1, a2, p2, s2);
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_BIT_DIGIT b;
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    CUMO_INIT_PTR_BIT(lp, 1, a2, p2, s2);
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     if (idx1) {
         for (; i--;) {
-            GET_DATA_INDEX(p1,idx1,dtype,x);
+            CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
             b = (m_<%=name%>(x)) ? 1:0;
-            STORE_BIT(a2,p2,b);
+            CUMO_STORE_BIT(a2,p2,b);
             p2+=s2;
         }
     } else {
         for (; i--;) {
-            GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
             b = (m_<%=name%>(x)) ? 1:0;
-            STORE_BIT(a2,p2,b);
+            CUMO_STORE_BIT(a2,p2,b);
             p2+=s2;
         }
     }
@@ -38,9 +38,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{cT,0}};
-    ndfunc_arg_out_t aout[1] = {{cumo_cBit,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] = {{cumo_cBit,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/cum.c

@@ -1,25 +1,25 @@
 <% (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   i;
     char    *p1, *p2;
     ssize_t  s1, s2;
     dtype    x, y;
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR(lp, 0, p1, s1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
     //printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
 
-    GET_DATA_STRIDE(p1,s1,dtype,x);
-    SET_DATA_STRIDE(p2,s2,dtype,x);
+    CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+    CUMO_SET_DATA_STRIDE(p2,s2,dtype,x);
     //printf("i=%lu x=%f\n",i,x);
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
     for (i--; i--;) {
-        GET_DATA_STRIDE(p1,s1,dtype,y);
+        CUMO_GET_DATA_STRIDE(p1,s1,dtype,y);
         m_<%=name%><%=j%>(x,y);
-        SET_DATA_STRIDE(p2,s2,dtype,x);
+        CUMO_SET_DATA_STRIDE(p2,s2,dtype,x);
         //printf("i=%lu x=%f\n",i,x);
     }
 }
@@ -36,15 +36,15 @@ 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[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP|NDF_FLAT_REDUCE|NDF_CUM,
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{cumo_sym_reduce,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cT,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_STRIDE_LOOP|CUMO_NDF_FLAT_REDUCE|CUMO_NDF_CUM,
                      2, 1, 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/each.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, s1;
     char *p1;
@@ -7,21 +7,21 @@ static void
     dtype x;
     VALUE y;
 
-    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);
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     if (idx1) {
         for (; i--;) {
-            GET_DATA_INDEX(p1,idx1,dtype,x);
+            CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
             y = m_data_to_num(x);
             rb_yield(y);
         }
     } else {
         for (; i--;) {
-            GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
             y = m_data_to_num(x);
             rb_yield(y);
         }
@@ -39,9 +39,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP_NIP, 1,0, ain,0};
 
-    na_ndloop(&ndf, 1, self);
+    cumo_na_ndloop(&ndf, 1, self);
     return self;
 }

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

@@ -12,7 +12,7 @@ yield_each_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, s1;
     char *p1;
@@ -28,23 +28,23 @@ static void
     md = nd + 2;
     a = ALLOCA_N(VALUE,md);
 
-    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);
     c[nd] = 0;
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     if (idx1) {
         for (; i--;) {
-            GET_DATA_INDEX(p1,idx1,dtype,x);
+            CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);
             yield_each_with_index(x,c,a,nd,md);
             c[nd]++;
         }
     } else {
         for (; i--;) {
             cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-            GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
             yield_each_with_index(x,c,a,nd,md);
             c[nd]++;
         }
@@ -62,9 +62,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP_NIP, 1,0, ain,0};
 
-    na_ndloop_with_index(&ndf, 1, self);
+    cumo_na_ndloop_with_index(&ndf, 1, self);
     return self;
 }

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

@@ -20,28 +20,28 @@ void cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(char *p1, char* p2, cha
 <% end %>
 
 static void
-<%=c_iter%><%=nan%>(na_loop_t *const lp)
+<%=c_iter%><%=nan%>(cumo_na_loop_t *const lp)
 {
     size_t   n;
     char    *p1, *p2, *p3;
     ssize_t  s1, s2, s3;
 
-    INIT_COUNTER(lp, n);
-    INIT_PTR(lp, 0, p1, s1);
-    INIT_PTR(lp, 1, p2, s2);
-    INIT_PTR(lp, 2, p3, s3);
+    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);
 
     <% if type_name == 'robject' %>
     {
         size_t i;
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
         for (i=0; i<n; i++) {
             dtype x, y, z;
-            GET_DATA_STRIDE(p1,s1,dtype,x);
-            GET_DATA_STRIDE(p2,s2,dtype,y);
-            GET_DATA(p3,dtype,z);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p2,s2,dtype,y);
+            CUMO_GET_DATA(p3,dtype,z);
             z = f_<%=name%><%=nan%>(x,y);
-            SET_DATA_STRIDE(p3,s3,dtype,z);
+            CUMO_SET_DATA_STRIDE(p3,s3,dtype,z);
         }
     }
     <% else %>
@@ -57,13 +57,13 @@ static VALUE
 {
     VALUE a1 = Qnil;
     VALUE a2 = Qnil;
-    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_NIP, 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_STRIDE_LOOP_NIP, 2, 1, ain, aout };
 
     <% if is_float %>
     VALUE kw_hash = Qnil;
-    ID kw_table[1] = {id_nan};
+    ID kw_table[1] = {cumo_id_nan};
     VALUE opts[1] = {Qundef};
 
     rb_scan_args(argc, argv, "20:", &a1, &a2, &kw_hash);
@@ -75,5 +75,5 @@ static VALUE
     rb_scan_args(argc, argv, "20", &a1, &a2);
     <% end %>
 
-    return na_ndloop(&ndf, 2, a1, a2);
+    return cumo_na_ndloop(&ndf, 2, a1, a2);
 }

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

@@ -10,9 +10,9 @@ __global__ void <%="cumo_#{type_name}_#{name}#{nan}_kernel"%>(char* p1, char* p2
 
 void cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(char *p1, char *p2, char* p3, ssize_t s1, ssize_t s2, ssize_t s3, size_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{type_name}_#{name}#{nan}_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_#{type_name}_#{name}#{nan}_kernel"%><<<grid_dim, block_dim>>>(p1,p2,p3,s1,s2,s3,n);
 }
 
 <% end %>

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

@@ -11,15 +11,15 @@ static VALUE
 {
     volatile VALUE v;
     char *ptr;
-    narray_t *na;
-    GetNArray(self,na);
+    cumo_narray_t *na;
+    CumoGetNArray(self,na);
 
     if (na->ndim==0) {
-        ptr = na_get_pointer_for_read(self) + na_get_offset(self);
-        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        ptr = cumo_na_get_pointer_for_read(self) + cumo_na_get_offset(self);
+        CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
         cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
         v = m_extract(ptr);
-        na_release_lock(self);
+        cumo_na_release_lock(self);
         return v;
     }
     return self;

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

@@ -5,23 +5,23 @@
 static dtype
 <%=c_func(:nodef)%>(VALUE obj)
 {
-    narray_t *na;
+    cumo_narray_t *na;
     dtype  x;
     char  *ptr;
     size_t pos;
     VALUE  r, klass;
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
-    if (IsNArray(obj)) {
-        GetNArray(obj,na);
+    if (CumoIsNArray(obj)) {
+        CumoGetNArray(obj,na);
         if (na->size != 1) {
-            rb_raise(nary_eShapeError,"narray size should be 1");
+            rb_raise(cumo_na_eShapeError,"narray size should be 1");
        }
-        klass = CLASS_OF(obj);
-        ptr = na_get_pointer_for_read(obj);
-        pos = na_get_offset(obj);
+        klass = rb_obj_class(obj);
+        ptr = cumo_na_get_pointer_for_read(obj);
+        pos = cumo_na_get_offset(obj);
         <% find_tmpl("store").definitions.select{|x| x.class==Store}.each do |x| %>
         if (<%=x.condition("klass")%>) {
             <%=x.extract_data("ptr","pos","x")%>;
@@ -31,20 +31,20 @@ static dtype
 
         // coerce
         r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
-        if (CLASS_OF(r)==cT) {
+        if (rb_obj_class(r)==cT) {
             return <%=c_func%>(r);
         }
         <% if is_object %>
         return obj;
         <% else %>
-        rb_raise(nary_eCastError, "unknown conversion from %s to %s",
-                 rb_class2name(CLASS_OF(obj)),
+        rb_raise(cumo_na_eCastError, "unknown conversion from %s to %s",
+                 rb_class2name(rb_obj_class(obj)),
                  rb_class2name(cT));
         <% end %>
     }
     if (TYPE(obj)==T_ARRAY) {
         if (RARRAY_LEN(obj) != 1) {
-            rb_raise(nary_eShapeError,"array size should be 1");
+            rb_raise(cumo_na_eShapeError,"array size should be 1");
         }
         return m_num_to_data(RARRAY_AREF(obj,0));
     }