cumo 0.1.0 → 0.1.1

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

@@ -10,20 +10,20 @@
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    BIT_DIGIT *ptr, val;
+    CUMO_BIT_DIGIT *ptr, val;
     size_t pos;
-    narray_t *na;
-    GetNArray(self,na);
+    cumo_narray_t *na;
+    CumoGetNArray(self,na);
 
     if (na->ndim==0) {
-        pos = na_get_offset(self);
-        ptr = (BIT_DIGIT*)na_get_pointer_for_read(self);
+        pos = cumo_na_get_offset(self);
+        ptr = (CUMO_BIT_DIGIT*)cumo_na_get_pointer_for_read(self);
 
-        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
         cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
-        val = ((*((ptr)+(pos)/NB)) >> ((pos)%NB)) & 1u;
-        na_release_lock(self);
+        val = ((*((ptr)+(pos)/CUMO_NB)) >> ((pos)%CUMO_NB)) & 1u;
+        cumo_na_release_lock(self);
         return INT2FIX(val);
     }
     return self;

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

@@ -9,20 +9,20 @@
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    BIT_DIGIT *ptr, val;
+    CUMO_BIT_DIGIT *ptr, val;
     size_t pos;
-    narray_t *na;
-    GetNArray(self,na);
+    cumo_narray_t *na;
+    CumoGetNArray(self,na);
 
     if (na->ndim==0) {
-        pos = na_get_offset(self);
-        ptr = (BIT_DIGIT*)na_get_pointer_for_read(self);
+        pos = cumo_na_get_offset(self);
+        ptr = (CUMO_BIT_DIGIT*)cumo_na_get_pointer_for_read(self);
 
-        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
         cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
-        val = ((*((ptr)+(pos)/NB)) >> ((pos)%NB)) & 1u;
-        na_release_lock(self);
+        val = ((*((ptr)+(pos)/CUMO_NB)) >> ((pos)%CUMO_NB)) & 1u;
+        cumo_na_release_lock(self);
         return INT2FIX(val);
     }
     return self;

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

@@ -1,53 +1,53 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  n;
     size_t  p3;
     ssize_t s3;
     size_t *idx3;
     int     len;
-    BIT_DIGIT *a3;
-    BIT_DIGIT  y;
+    CUMO_BIT_DIGIT *a3;
+    CUMO_BIT_DIGIT  y;
     VALUE x = lp->option;
 
     // 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());
 
     if (x==INT2FIX(0) || x==Qfalse) {
         y = 0;
     } else
     if (x==INT2FIX(1) || x==Qtrue) {
-        y = ~(BIT_DIGIT)0;
+        y = ~(CUMO_BIT_DIGIT)0;
     } else {
         rb_raise(rb_eArgError, "invalid value for Bit");
     }
 
-    INIT_COUNTER(lp, n);
-    INIT_PTR_BIT_IDX(lp, 0, a3, p3, s3, idx3);
+    CUMO_INIT_COUNTER(lp, n);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a3, p3, s3, idx3);
     if (idx3) {
         y = y&1;
         for (; n--;) {
-            STORE_BIT(a3, p3+*idx3, y); idx3++;
+            CUMO_STORE_BIT(a3, p3+*idx3, y); idx3++;
         }
     } else if (s3!=1) {
         y = y&1;
         for (; n--;) {
-            STORE_BIT(a3, p3, y); p3+=s3;
+            CUMO_STORE_BIT(a3, p3, y); p3+=s3;
         }
     } else {
-        if (p3>0 || n<NB) {
-            len = NB - p3;
+        if (p3>0 || n<CUMO_NB) {
+            len = CUMO_NB - p3;
             if ((int)n<len) len=n;
-            *a3 = (y & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            *a3 = (y & (CUMO_SLB(len)<<p3)) | (*a3 & ~(CUMO_SLB(len)<<p3));
             a3++;
             n -= len;
         }
-        for (; n>=NB; n-=NB) {
+        for (; n>=CUMO_NB; n-=CUMO_NB) {
             *(a3++) = y;
         }
         if (n>0) {
-            *a3 = (y & SLB(n)) | (*a3 & BALL<<n);
+            *a3 = (y & CUMO_SLB(n)) | (*a3 & CUMO_BALL<<n);
         }
     }
 }
@@ -61,9 +61,9 @@ static void
 static VALUE
 <%=c_func(1)%>(VALUE self, VALUE val)
 {
-    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_option}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[2] = {{CUMO_OVERWRITE,0},{cumo_sym_option}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 2,0, ain,0};
 
-    na_ndloop(&ndf, 2, self, val);
+    cumo_na_ndloop(&ndf, 2, self, val);
     return self;
 }

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

@@ -11,10 +11,10 @@ format_<%=type_name%>(VALUE fmt, dtype x)
 }
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
-    BIT_DIGIT *a1, x=0;
+    CUMO_BIT_DIGIT *a1, x=0;
     size_t     p1;
     char      *p2;
     ssize_t    s1, s2;
@@ -22,24 +22,24 @@ static void
     VALUE  y;
     VALUE  fmt = lp->option;
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-    INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
 
     if (idx1) {
         for (; i--;) {
-            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            CUMO_LOAD_BIT(a1, p1+*idx1, x); idx1++;
             y = format_<%=type_name%>(fmt, x);
-            SET_DATA_STRIDE(p2, s2, VALUE, y);
+            CUMO_SET_DATA_STRIDE(p2, s2, VALUE, y);
         }
     } else {
         for (; i--;) {
-            LOAD_BIT(a1, p1, x); p1+=s1;
+            CUMO_LOAD_BIT(a1, p1, x); p1+=s1;
             y = format_<%=type_name%>(fmt, x);
-            SET_DATA_STRIDE(p2, s2, VALUE, y);
+            CUMO_SET_DATA_STRIDE(p2, s2, VALUE, y);
         }
     }
 }
@@ -55,10 +55,10 @@ static VALUE
 {
     VALUE fmt=Qnil;
 
-    ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_option}};
-    ndfunc_arg_out_t aout[1] = {{cumo_cRObject,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 2,1, ain,aout};
+    cumo_ndfunc_arg_in_t ain[2] = {{Qnil,0},{cumo_sym_option}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cumo_cRObject,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP_NIP, 2,1, ain,aout};
 
     rb_scan_args(argc, argv, "01", &fmt);
-    return na_ndloop(&ndf, 2, self, fmt);
+    return cumo_na_ndloop(&ndf, 2, self, fmt);
 }

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

@@ -1,8 +1,8 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
-    BIT_DIGIT *a1, x=0;
+    CUMO_BIT_DIGIT *a1, x=0;
     size_t     p1;
     ssize_t    s1;
     size_t   *idx1;
@@ -10,19 +10,19 @@ static void
     VALUE fmt = lp->option;
     volatile VALUE a;
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
     a = rb_ary_new2(i);
     rb_ary_push(lp->args[1].value, a);
     if (idx1) {
         for (; i--;) {
-            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            CUMO_LOAD_BIT(a1, p1+*idx1, x); idx1++;
             y = format_bit(fmt, x);
             rb_ary_push(a,y);
         }
     } else {
         for (; i--;) {
-            LOAD_BIT(a1, p1, x); p1+=s1;
+            CUMO_LOAD_BIT(a1, p1, x); p1+=s1;
             y = format_bit(fmt, x);
             rb_ary_push(a,y);
         }
@@ -39,13 +39,13 @@ static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE fmt=Qnil;
-    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
-    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 3,1, ain,aout};
+    cumo_ndfunc_arg_in_t ain[3] = {{Qnil,0},{cumo_sym_loop_opt},{cumo_sym_option}};
+    cumo_ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP_NIP, 3,1, ain,aout};
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     rb_scan_args(argc, argv, "01", &fmt);
-    return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
+    return cumo_na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
 }

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

@@ -2,7 +2,7 @@ static VALUE
 <%=c_iter%>(char *ptr, size_t pos, VALUE fmt)
 {
     dtype x;
-    LOAD_BIT(ptr,pos,x);
+    CUMO_LOAD_BIT(ptr,pos,x);
     return format_<%=type_name%>(fmt, x);
 }
 
@@ -14,8 +14,8 @@ static VALUE
 static VALUE
 <%=c_func(0)%>(VALUE ary)
 {
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     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_bit/mask.c

@@ -1,24 +1,24 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
-    BIT_DIGIT *a;
+    CUMO_BIT_DIGIT *a;
     size_t  p1, p2;
     ssize_t s1, s2;
     size_t *idx1, *idx2, *pidx;
-    BIT_DIGIT x=0;
+    CUMO_BIT_DIGIT x=0;
     size_t  count;
     where_opt_t *g;
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     g = (where_opt_t*)(lp->opt_ptr);
     count = g->count;
     pidx  = (size_t*)(g->idx1);
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a, p1, s1, idx1);
-    //INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a, p1, s1, idx1);
+    //CUMO_INIT_PTR_IDX(lp, 1, p2, s2, idx2);
     p2 = lp->args[1].iter[0].pos;
     s2 = lp->args[1].iter[0].step;
     idx2 = lp->args[1].iter[0].idx;
@@ -26,7 +26,7 @@ static void
     if (idx1) {
         if (idx2) {
             for (; i--;) {
-                LOAD_BIT(a, p1+*idx1, x);
+                CUMO_LOAD_BIT(a, p1+*idx1, x);
                 idx1++;
                 if (x) {
                     *(pidx++) = p2+*idx2;
@@ -36,7 +36,7 @@ static void
             }
         } else {
             for (; i--;) {
-                LOAD_BIT(a, p1+*idx1, x);
+                CUMO_LOAD_BIT(a, p1+*idx1, x);
                 idx1++;
                 if (x) {
                     *(pidx++) = p2;
@@ -48,7 +48,7 @@ static void
     } else {
         if (idx2) {
             for (; i--;) {
-                LOAD_BIT(a, p1, x);
+                CUMO_LOAD_BIT(a, p1, x);
                 p1 += s1;
                 if (x) {
                     *(pidx++) = p2+*idx2;
@@ -58,7 +58,7 @@ static void
             }
         } else {
             for (; i--;) {
-                LOAD_BIT(a, p1, x);
+                CUMO_LOAD_BIT(a, p1, x);
                 p1 += s1;
                 if (x) {
                     *(pidx++) = p2;
@@ -88,48 +88,48 @@ static VALUE
 <%=c_func(1)%>(VALUE mask, VALUE val)
 {
     volatile VALUE idx_1, view;
-    narray_data_t *nidx;
-    narray_view_t *nv;
-    narray_t      *na;
-    narray_view_t *na1;
-    stridx_t stridx0;
+    cumo_narray_data_t *nidx;
+    cumo_narray_view_t *nv;
+    cumo_narray_t      *na;
+    cumo_narray_view_t *na1;
+    cumo_stridx_t stridx0;
     size_t n_1;
     where_opt_t g;
-    ndfunc_arg_in_t ain[2] = {{cT,0},{Qnil,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2, 0, ain, 0};
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{Qnil,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 2, 0, ain, 0};
 
     // TODO(sonots): bit_count_true synchronizes with CPU. Avoid.
     n_1 = NUM2SIZET(<%=find_tmpl("count_true_cpu").c_func%>(0, NULL, mask));
-    idx_1 = nary_new(cIndex, 1, &n_1);
+    idx_1 = cumo_na_new(cIndex, 1, &n_1);
     g.count = 0;
     g.elmsz = SIZEOF_VOIDP;
-    g.idx1 = na_get_pointer_for_write(idx_1);
+    g.idx1 = cumo_na_get_pointer_for_write(idx_1);
     g.idx0 = NULL;
-    na_ndloop3(&ndf, &g, 2, mask, val);
+    cumo_na_ndloop3(&ndf, &g, 2, mask, val);
 
-    view = na_s_allocate_view(CLASS_OF(val));
-    GetNArrayView(view, nv);
-    na_setup_shape((narray_t*)nv, 1, &n_1);
+    view = cumo_na_s_allocate_view(rb_obj_class(val));
+    CumoGetNArrayView(view, nv);
+    cumo_na_setup_shape((cumo_narray_t*)nv, 1, &n_1);
 
-    GetNArrayData(idx_1,nidx);
-    SDX_SET_INDEX(stridx0,(size_t*)nidx->ptr);
+    CumoGetNArrayData(idx_1,nidx);
+    CUMO_SDX_SET_INDEX(stridx0,(size_t*)nidx->ptr);
     nidx->ptr = NULL;
 
-    nv->stridx = ALLOC_N(stridx_t,1);
+    nv->stridx = ALLOC_N(cumo_stridx_t,1);
     nv->stridx[0] = stridx0;
     nv->offset = 0;
 
-    GetNArray(val, na);
-    switch(NA_TYPE(na)) {
-    case NARRAY_DATA_T:
+    CumoGetNArray(val, na);
+    switch(CUMO_NA_TYPE(na)) {
+    case CUMO_NARRAY_DATA_T:
         nv->data = val;
         break;
-    case NARRAY_VIEW_T:
-        GetNArrayView(val, na1);
+    case CUMO_NARRAY_VIEW_T:
+        CumoGetNArrayView(val, na1);
         nv->data = na1->data;
         break;
     default:
-        rb_raise(rb_eRuntimeError,"invalid NA_TYPE: %d",NA_TYPE(na));
+        rb_raise(rb_eRuntimeError,"invalid CUMO_NA_TYPE: %d",CUMO_NA_TYPE(na));
     }
 
     return view;

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

@@ -1,24 +1,24 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t i, n;
     size_t i1, n1;
     VALUE  v1, *ptr;
-    BIT_DIGIT *a1;
+    CUMO_BIT_DIGIT *a1;
     size_t p1;
     size_t s1, *idx1;
     VALUE  x;
     double y;
-    BIT_DIGIT z;
+    CUMO_BIT_DIGIT z;
     size_t len, c;
     double beg, step;
 
     // 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);
+    CUMO_INIT_COUNTER(lp, n);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
     v1 = lp->args[1].value;
     i = 0;
 
@@ -52,34 +52,34 @@ static void
     if (idx1) {
         for (i=i1=0; i1<n1 && i<n; i++,i1++) {
             x = ptr[i1];
-            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, na_cStep)) {
-                nary_step_sequence(x,&len,&beg,&step);
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, cumo_na_cStep)) {
+                cumo_na_step_sequence(x,&len,&beg,&step);
                 for (c=0; c<len && i<n; c++,i++) {
                     y = beg + step * c;
                     z = m_from_double(y);
-                    STORE_BIT(a1, p1+*idx1, z); idx1++;
+                    CUMO_STORE_BIT(a1, p1+*idx1, z); idx1++;
                 }
             }
             if (TYPE(x) != T_ARRAY) {
                 if (x == Qnil) x = INT2FIX(0);
                 z = m_num_to_data(x);
-                STORE_BIT(a1, p1+*idx1, z); idx1++;
+                CUMO_STORE_BIT(a1, p1+*idx1, z); idx1++;
             }
         }
     } else {
         for (i=i1=0; i1<n1 && i<n; i++,i1++) {
             x = ptr[i1];
-            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, na_cStep)) {
-                nary_step_sequence(x,&len,&beg,&step);
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, cumo_na_cStep)) {
+                cumo_na_step_sequence(x,&len,&beg,&step);
                 for (c=0; c<len && i<n; c++,i++) {
                     y = beg + step * c;
                     z = m_from_double(y);
-                    STORE_BIT(a1, p1, z); p1+=s1;
+                    CUMO_STORE_BIT(a1, p1, z); p1+=s1;
                 }
             }
             if (TYPE(x) != T_ARRAY) {
                 z = m_num_to_data(x);
-                STORE_BIT(a1, p1, z); p1+=s1;
+                CUMO_STORE_BIT(a1, p1, z); p1+=s1;
             }
         }
     }
@@ -88,11 +88,11 @@ static void
     z = m_zero;
     if (idx1) {
         for (; i<n; i++) {
-            STORE_BIT(a1, p1+*idx1, z); idx1++;
+            CUMO_STORE_BIT(a1, p1+*idx1, z); idx1++;
         }
     } else {
         for (; i<n; i++) {
-            STORE_BIT(a1, p1, z); p1+=s1;
+            CUMO_STORE_BIT(a1, p1, z); p1+=s1;
         }
     }
 }
@@ -100,9 +100,9 @@ static void
 static VALUE
 <%=c_func(:nodef)%>(VALUE self, VALUE rary)
 {
-    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0}, {rb_cArray,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2, 0, ain, 0};
+    cumo_ndfunc_arg_in_t ain[2] = {{CUMO_OVERWRITE,0}, {rb_cArray,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 2, 0, ain, 0};
 
-    na_ndloop_store_rarray(&ndf, self, rary);
+    cumo_na_ndloop_store_rarray(&ndf, self, rary);
     return self;
 }