cumo 0.1.0 → 0.1.1

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

@@ -1,49 +1,49 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  n;
     size_t  p1, p3;
     ssize_t s1, s3;
     size_t *idx1, *idx3;
     int     o1, l1, r1, len;
-    BIT_DIGIT *a1, *a3;
-    BIT_DIGIT  x;
+    CUMO_BIT_DIGIT *a1, *a3;
+    CUMO_BIT_DIGIT  x;
 
     // 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, a3, p3, s3, idx3);
-    INIT_PTR_BIT_IDX(lp, 1, a1, p1, s1, idx1);
+    CUMO_INIT_COUNTER(lp, n);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a3, p3, s3, idx3);
+    CUMO_INIT_PTR_BIT_IDX(lp, 1, a1, p1, s1, idx1);
     if (s1!=1 || s3!=1 || idx1 || idx3) {
         for (; n--;) {
-            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
-            STORE_BIT_STEP(a3, p3, s3, idx3, x);
+            CUMO_LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            CUMO_STORE_BIT_STEP(a3, p3, s3, idx3, x);
         }
     } else {
-        o1 =  p1 % NB;
+        o1 =  p1 % CUMO_NB;
         o1 -= p3;
-        l1 =  NB+o1;
-        r1 =  NB-o1;
-        if (p3>0 || n<NB) {
-            len = NB - p3;
+        l1 =  CUMO_NB+o1;
+        r1 =  CUMO_NB-o1;
+        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++;
-            *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) {
-            for (; n>=NB; n-=NB) {
+            for (; n>=CUMO_NB; n-=CUMO_NB) {
                 x = *(a1++);
                 *(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;
@@ -54,7 +54,7 @@ static void
         if (n>0) {
             x = *a1>>o1;
             if (o1<0)  x |= *(a1-1)>>l1;
-            *a3 = (x & SLB(n)) | (*a3 & BALL<<n);
+            *a3 = (x & CUMO_SLB(n)) | (*a3 & CUMO_BALL<<n);
         }
     }
 }
@@ -62,9 +62,9 @@ static void
 static VALUE
 <%=c_func(:nodef)%>(VALUE self, VALUE obj)
 {
-    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[2] = {{CUMO_OVERWRITE,0},{Qnil,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 2,0, ain,0};
 
-    na_ndloop(&ndf, 2, self, obj);
+    cumo_na_ndloop(&ndf, 2, self, obj);
     return self;
 }

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

@@ -1,48 +1,48 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     ssize_t  i, s1, s2;
     size_t   p1;
     char    *p2;
     size_t  *idx1, *idx2;
     <%=dtype%> x;
-    BIT_DIGIT *a1;
-    BIT_DIGIT  y;
+    CUMO_BIT_DIGIT *a1;
+    CUMO_BIT_DIGIT  y;
 
     // TODO(sonots): CUDA kernelize
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("store_<%=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_IDX(lp, 1, p2, s2, idx2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_PTR_IDX(lp, 1, p2, s2, idx2);
 
     if (idx2) {
         if (idx1) {
             for (; i--;) {
-                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                CUMO_GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
                 y = <%=macro%>(x);
-                STORE_BIT(a1, p1+*idx1, y); idx1++;
+                CUMO_STORE_BIT(a1, p1+*idx1, y); idx1++;
             }
         } else {
             for (; i--;) {
-                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                CUMO_GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
                 y = <%=macro%>(x);
-                STORE_BIT(a1, p1, y); p1+=s1;
+                CUMO_STORE_BIT(a1, p1, y); p1+=s1;
             }
         }
     } else {
         if (idx1) {
             for (; i--;) {
-                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                CUMO_GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
                 y = <%=macro%>(x);
-                STORE_BIT(a1, p1+*idx1, y); idx1++;
+                CUMO_STORE_BIT(a1, p1+*idx1, y); idx1++;
             }
         } else {
             for (; i--;) {
-                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                CUMO_GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
                 y = <%=macro%>(x);
-                STORE_BIT(a1, p1, y); p1+=s1;
+                CUMO_STORE_BIT(a1, p1, y); p1+=s1;
             }
         }
     }
@@ -52,9 +52,9 @@ static void
 static VALUE
 <%=c_func(:nodef)%>(VALUE self, VALUE obj)
 {
-    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[2] = {{CUMO_OVERWRITE,0},{Qnil,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP, 2,0, ain,0};
 
-    na_ndloop(&ndf, 2, self, obj);
+    cumo_na_ndloop(&ndf, 2, self, obj);
     return self;
 }

data/ext/cumo/narray/gen/tmpl_bit/to_a.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;
-    BIT_DIGIT *a1;
+    CUMO_BIT_DIGIT *a1;
     size_t     p1;
     ssize_t    s1;
     size_t    *idx1;
-    BIT_DIGIT  x=0;
+    CUMO_BIT_DIGIT  x=0;
     VALUE      a, y;
 
-    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);
+    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 = m_data_to_num(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 = m_data_to_num(x);
             rb_ary_push(a,y);
         }
@@ -39,9 +39,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    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};
 
-    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
+    return cumo_na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
 }

data/ext/cumo/narray/gen/tmpl_bit/unary.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  p1, p3;
     ssize_t s1, s3;
     size_t *idx1, *idx3;
     int     o1, l1, r1, len;
-    BIT_DIGIT *a1, *a3;
-    BIT_DIGIT  x;
-    BIT_DIGIT  y;
+    CUMO_BIT_DIGIT *a1, *a3;
+    CUMO_BIT_DIGIT  x;
+    CUMO_BIT_DIGIT  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, 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, a3, p3, s3, idx3);
     if (s1!=1 || s3!=1 || idx1 || idx3) {
         for (; n--;) {
-            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            CUMO_LOAD_BIT_STEP(a1, p1, s1, idx1, x);
             y = m_<%=name%>(x);
-            STORE_BIT_STEP(a3, p3, s3, idx3, y);
+            CUMO_STORE_BIT_STEP(a3, p3, s3, idx3, y);
         }
     } else {
-        o1 =  p1 % NB;
+        o1 =  p1 % CUMO_NB;
         o1 -= p3;
-        l1 =  NB+o1;
-        r1 =  NB-o1;
-        if (p3>0 || n<NB) {
-            len = NB - p3;
+        l1 =  CUMO_NB+o1;
+        r1 =  CUMO_NB-o1;
+        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++;
             y = m_<%=name%>(x);
-            *a3 = (y & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            *a3 = (y & (CUMO_SLB(len)<<p3)) | (*a3 & ~(CUMO_SLB(len)<<p3));
             a3++;
             n -= len;
         }
         if (o1==0) {
-            for (; n>=NB; n-=NB) {
+            for (; n>=CUMO_NB; n-=CUMO_NB) {
                 x = *(a1++);
                 y = m_<%=name%>(x);
                 *(a3++) = y;
             }
         } 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;
@@ -60,7 +60,7 @@ static void
             x = *a1>>o1;
             if (o1<0)  x |= *(a1-1)>>l1;
             y = m_<%=name%>(x);
-            *a3 = (y & SLB(n)) | (*a3 & BALL<<n);
+            *a3 = (y & CUMO_SLB(n)) | (*a3 & CUMO_BALL<<n);
         }
     }
 }
@@ -73,9 +73,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    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, self);
+    return cumo_na_ndloop(&ndf, 1, self);
 }

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

@@ -8,32 +8,32 @@ typedef struct {
 #define STORE_INT(ptr, esz, x) memcpy(ptr,&(x),esz)
 
 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  p;
     ssize_t s;
     size_t *idx;
-    BIT_DIGIT x=0;
+    CUMO_BIT_DIGIT x=0;
     char   *idx1;
     size_t  count;
     size_t  e;
     where_opt_t *g;
 
     // 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());
 
     g = (where_opt_t*)(lp->opt_ptr);
     count = g->count;
     idx1  = g->idx1;
     e     = g->elmsz;
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a, p, s, idx);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a, p, s, idx);
     if (idx) {
         for (; i--;) {
-            LOAD_BIT(a, p+*idx, x);
+            CUMO_LOAD_BIT(a, p+*idx, x);
             idx++;
             if (x!=0) {
                 STORE_INT(idx1,e,count);
@@ -43,7 +43,7 @@ static void
         }
     } else {
         for (; i--;) {
-            LOAD_BIT(a, p, x);
+            CUMO_LOAD_BIT(a, p, x);
             p+=s;
             if (x!=0) {
                 STORE_INT(idx1,e,count);
@@ -68,23 +68,23 @@ static VALUE
     size_t size, n_1;
     where_opt_t *g;
 
-    ndfunc_arg_in_t ain[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+    cumo_ndfunc_arg_in_t ain[1] = {{cT,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_FULL_LOOP, 1, 0, ain, 0 };
 
-    size = RNARRAY_SIZE(self);
+    size = CUMO_RNARRAY_SIZE(self);
     n_1 = NUM2SIZET(<%=find_tmpl("count_true_cpu").c_func%>(0, NULL, self));
     g = ALLOCA_N(where_opt_t,1);
     g->count = 0;
     if (size>4294967295ul) {
-        idx_1 = nary_new(cumo_cInt64, 1, &n_1);
+        idx_1 = cumo_na_new(cumo_cInt64, 1, &n_1);
         g->elmsz = 8;
     } else {
-        idx_1 = nary_new(cumo_cInt32, 1, &n_1);
+        idx_1 = cumo_na_new(cumo_cInt32, 1, &n_1);
         g->elmsz = 4;
     }
-    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, 1, self);
-    na_release_lock(idx_1);
+    cumo_na_ndloop3(&ndf, g, 1, self);
+    cumo_na_release_lock(idx_1);
     return idx_1;
 }

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

@@ -1,19 +1,19 @@
 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  p;
     ssize_t s;
     size_t *idx;
-    BIT_DIGIT x=0;
+    CUMO_BIT_DIGIT x=0;
     char   *idx0, *idx1;
     size_t  count;
     size_t  e;
     where_opt_t *g;
 
     // 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());
 
     g = (where_opt_t*)(lp->opt_ptr);
@@ -21,11 +21,11 @@ static void
     idx0  = g->idx0;
     idx1  = g->idx1;
     e     = g->elmsz;
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a, p, s, idx);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a, p, s, idx);
     if (idx) {
         for (; i--;) {
-            LOAD_BIT(a, p+*idx, x);
+            CUMO_LOAD_BIT(a, p+*idx, x);
             idx++;
             if (x==0) {
                 STORE_INT(idx0,e,count);
@@ -38,7 +38,7 @@ static void
         }
     } else {
         for (; i--;) {
-            LOAD_BIT(a, p, x);
+            CUMO_LOAD_BIT(a, p, x);
             p+=s;
             if (x==0) {
                 STORE_INT(idx0,e,count);
@@ -69,27 +69,27 @@ static VALUE
     size_t size, n_1, n_0;
     where_opt_t *g;
 
-    ndfunc_arg_in_t ain[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+    cumo_ndfunc_arg_in_t ain[1] = {{cT,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_FULL_LOOP, 1, 0, ain, 0 };
 
-    size = RNARRAY_SIZE(self);
+    size = CUMO_RNARRAY_SIZE(self);
     n_1 = NUM2SIZET(<%=find_tmpl("count_true_cpu").c_func%>(0, NULL, self));
     n_0 = size - n_1;
     g = ALLOCA_N(where_opt_t,1);
     g->count = 0;
     if (size>4294967295ul) {
-        idx_1 = nary_new(cumo_cInt64, 1, &n_1);
-        idx_0 = nary_new(cumo_cInt64, 1, &n_0);
+        idx_1 = cumo_na_new(cumo_cInt64, 1, &n_1);
+        idx_0 = cumo_na_new(cumo_cInt64, 1, &n_0);
         g->elmsz = 8;
     } else {
-        idx_1 = nary_new(cumo_cInt32, 1, &n_1);
-        idx_0 = nary_new(cumo_cInt32, 1, &n_0);
+        idx_1 = cumo_na_new(cumo_cInt32, 1, &n_1);
+        idx_0 = cumo_na_new(cumo_cInt32, 1, &n_0);
         g->elmsz = 4;
     }
-    g->idx1 = na_get_pointer_for_write(idx_1);
-    g->idx0 = na_get_pointer_for_write(idx_0);
-    na_ndloop3(&ndf, g, 1, self);
-    na_release_lock(idx_0);
-    na_release_lock(idx_1);
+    g->idx1 = cumo_na_get_pointer_for_write(idx_1);
+    g->idx0 = cumo_na_get_pointer_for_write(idx_0);
+    cumo_na_ndloop3(&ndf, g, 1, self);
+    cumo_na_release_lock(idx_0);
+    cumo_na_release_lock(idx_1);
     return rb_assoc_new(idx_1,idx_0);
 }