cumo 0.1.0

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

@@ -0,0 +1,121 @@
+typedef struct {
+    dtype mu;
+    rtype sigma;
+} randn_opt_t;
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1;
+    ssize_t  s1;
+    size_t  *idx1;
+    <% if is_complex %>
+    dtype   *a0;
+    <% else %>
+    dtype   *a0, *a1;
+    <% end %>
+    dtype    mu;
+    rtype    sigma;
+    randn_opt_t *g;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    g = (randn_opt_t*)(lp->opt_ptr);
+    mu = g->mu;
+    sigma = g->sigma;
+
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    if (idx1) {
+        <% if is_complex %>
+        for (; i--;) {
+            a0 = (dtype*)(p1+*idx1);
+            m_rand_norm(mu,sigma,a0);
+            idx1 += 1;
+        }
+        <% else %>
+        for (; i>1; i-=2) {
+            a0 = (dtype*)(p1+*idx1);
+            a1 = (dtype*)(p1+*(idx1+1));
+            m_rand_norm(mu,sigma,a0,a1);
+            idx1 += 2;
+        }
+        if (i>0) {
+            a0 = (dtype*)(p1+*idx1);
+            m_rand_norm(mu,sigma,a0,0);
+        }
+        <% end %>
+    } else {
+        <% if is_complex %>
+        for (; i--;) {
+            a0 = (dtype*)(p1);
+            m_rand_norm(mu,sigma,a0);
+            p1 += s1;
+        }
+        <% else %>
+        for (; i>1; i-=2) {
+            a0 = (dtype*)(p1);
+            a1 = (dtype*)(p1+s1);
+            m_rand_norm(mu,sigma,a0,a1);
+            p1 += s1*2;
+        }
+        if (i>0) {
+            a0 = (dtype*)(p1);
+            m_rand_norm(mu,sigma,a0,0);
+        }
+        <% end %>
+    }
+}
+
+/*
+  Generates random numbers from the normal distribution on self narray
+  using Box-Muller Transformation.
+  @overload rand_norm([mu,[sigma]])
+  @param [Numeric] mu  mean of normal distribution. (default=0)
+  @param [Numeric] sigma  standard deviation of normal distribution. (default=1)
+  @return [Cumo::<%=class_name%>] self.
+  @example
+    Cumo::DFloat.new(5,5).rand_norm
+    => Cumo::DFloat#shape=[5,5]
+       [[-0.581255, -0.168354, 0.586895, -0.595142, -0.802802],
+        [-0.326106, 0.282922, 1.68427, 0.918499, -0.0485384],
+        [-0.464453, -0.992194, 0.413794, -0.60717, -0.699695],
+        [-1.64168, 0.48676, -0.875871, -1.43275, 0.812172],
+        [-0.209975, -0.103612, -0.878617, -1.42495, 1.0968]]
+    Cumo::DFloat.new(5,5).rand_norm(10,0.1)
+    => Cumo::DFloat#shape=[5,5]
+       [[9.9019, 9.90339, 10.0826, 9.98384, 9.72861],
+        [9.81507, 10.0272, 9.91445, 10.0568, 9.88923],
+        [10.0234, 9.97874, 9.96011, 9.9006, 9.99964],
+        [10.0186, 9.94598, 9.92236, 9.99811, 9.97003],
+        [9.79266, 9.95044, 9.95212, 9.93692, 10.2027]]
+    Cumo::DComplex.new(3,3).rand_norm(5+5i)
+    => Cumo::DComplex#shape=[3,3]
+       [[5.84303+4.40052i, 4.00984+6.08982i, 5.10979+5.13215i],
+        [4.26477+3.99655i, 4.90052+5.00763i, 4.46607+2.3444i],
+        [4.5528+7.11003i, 5.62117+6.69094i, 5.05443+5.35133i]]
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *args, VALUE self)
+{
+    int n;
+    randn_opt_t g;
+    VALUE v1=Qnil, v2=Qnil;
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
+
+    n = rb_scan_args(argc, args, "02", &v1, &v2);
+    if (n == 0) {
+        g.mu = m_zero;
+    } else {
+        g.mu = m_num_to_data(v1);
+    }
+    if (n == 2) {
+        g.sigma = NUM2DBL(v2);
+    } else {
+        g.sigma = 1;
+    }
+    na_ndloop3(&ndf, &g, 1, self);
+    return self;
+}

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

@@ -0,0 +1,75 @@
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+struct cumo_<%=type_name%>_sum_impl {
+    __device__ <%=dtype%> Identity() { return m_zero; }
+    __device__ dtype MapIn(dtype in, int64_t /*index*/) { return in; }
+    __device__ void Reduce(dtype next, <%=dtype%>& accum) { accum += next; }
+    __device__ <%=dtype%> MapOut(<%=dtype%> accum) { return accum; }
+};
+
+struct cumo_<%=type_name%>_prod_impl {
+    __device__ <%=dtype%> Identity() { return m_one; }
+    __device__ dtype MapIn(dtype in, int64_t /*index*/) { return in; }
+    __device__ void Reduce(dtype next, <%=dtype%>& accum) { accum *= next; }
+    __device__ <%=dtype%> MapOut(<%=dtype%> accum) { return accum; }
+};
+
+struct cumo_<%=type_name%>_min_impl {
+    __device__ dtype Identity() { return DATA_MAX; }
+    __device__ dtype MapIn(dtype in, int64_t /*index*/) { return in; }
+    __device__ void Reduce(dtype next, dtype& accum) { accum = next < accum ? next : accum; }
+    __device__ dtype MapOut(dtype accum) { return accum; }
+};
+
+struct cumo_<%=type_name%>_max_impl {
+    __device__ dtype Identity() { return DATA_MIN; }
+    __device__ dtype MapIn(dtype in, int64_t /*index*/) { return in; }
+    __device__ void Reduce(dtype next, dtype& accum) { accum = next < accum ? accum : next; }
+    __device__ dtype MapOut(dtype accum) { return accum; }
+};
+
+// TODO(sonots): Implement minmax
+__global__ void cumo_<%=type_name%>_ptp_kernel(na_reduction_arg_t arg)
+{
+    dtype min=0,max=1;
+    //<%=type_name%>_minmax_kernel<<<1,1>>>(n,p1,s1,&min,&max);
+    char* p2 = arg.out.ptr;
+    *(dtype*)p2 = m_sub(max,min);
+}
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+void cumo_<%=type_name%>_sum_kernel_launch(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)
+{
+    cumo_reduce<dtype, <%=dtype%>, cumo_<%=type_name%>_prod_impl>(*arg, cumo_<%=type_name%>_prod_impl{});
+}
+
+void cumo_<%=type_name%>_min_kernel_launch(na_reduction_arg_t* arg)
+{
+    cumo_reduce<dtype, dtype, cumo_<%=type_name%>_min_impl>(*arg, cumo_<%=type_name%>_min_impl{});
+}
+
+void cumo_<%=type_name%>_max_kernel_launch(na_reduction_arg_t* arg)
+{
+    cumo_reduce<dtype, dtype, cumo_<%=type_name%>_max_impl>(*arg, cumo_<%=type_name%>_max_impl{});
+}
+
+void cumo_<%=type_name%>_ptp_kernel_launch(na_reduction_arg_t* arg)
+{
+    cumo_<%=type_name%>_ptp_kernel<<<1,1>>>(*arg);
+}

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

@@ -0,0 +1,112 @@
+<% if is_int && !is_object %>
+typedef double seq_data_t;
+<% else %>
+typedef dtype seq_data_t;
+<% end %>
+
+<% if is_object %>
+typedef size_t seq_count_t;
+<% else %>
+typedef double seq_count_t;
+<% end %>
+
+typedef struct {
+    seq_data_t beg;
+    seq_data_t step;
+    seq_count_t count;
+} seq_opt_t;
+
+<% unless is_object %>
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(char *p1, size_t* idx1, seq_data_t beg, seq_data_t step, seq_count_t c, uint64_t n);
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, ssize_t s1, seq_data_t beg, seq_data_t step, seq_count_t c, uint64_t n);
+<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1;
+    ssize_t s1;
+    size_t *idx1;
+    seq_data_t beg, step;
+    seq_count_t c;
+    seq_opt_t *g;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    g = (seq_opt_t*)(lp->opt_ptr);
+    beg  = g->beg;
+    step = g->step;
+    c    = g->count;
+    <% if is_object %>
+    {
+        dtype x;
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        if (idx1) {
+            for (; i--;) {
+                x = f_seq(beg,step,c++);
+                *(dtype*)(p1+*idx1) = x;
+                idx1++;
+            }
+        } else {
+            for (; i--;) {
+                x = f_seq(beg,step,c++);
+                *(dtype*)(p1) = x;
+                p1 += s1;
+            }
+        }
+        g->count = c;
+    }
+    <% else %>
+    {
+        size_t n = i;
+        if (idx1) {
+            <%="cumo_#{c_iter}_index_kernel_launch"%>(p1,idx1,beg,step,c,n);
+        } else {
+            <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,s1,beg,step,c,n);
+        }
+        g->count += n;
+    }
+    <% end %>
+}
+
+/*
+  Set linear sequence of numbers to self. The sequence is obtained from
+     beg+i*step
+  where i is 1-dimensional index.
+  @overload seq([beg,[step]])
+  @param [Numeric] beg  begining of sequence. (default=0)
+  @param [Numeric] step  step of sequence. (default=1)
+  @return [Cumo::<%=class_name%>] self.
+  @example
+    Cumo::DFloat.new(6).seq(1,-0.2)
+    => Cumo::DFloat#shape=[6]
+       [1, 0.8, 0.6, 0.4, 0.2, 0]
+    Cumo::DComplex.new(6).seq(1,-0.2+0.2i)
+    => Cumo::DComplex#shape=[6]
+       [1+0i, 0.8+0.2i, 0.6+0.4i, 0.4+0.6i, 0.2+0.8i, 0+1i]
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *args, VALUE self)
+{
+    seq_opt_t *g;
+    VALUE vbeg=Qnil, vstep=Qnil;
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
+
+    g = ALLOCA_N(seq_opt_t,1);
+    g->beg = m_zero;
+    g->step = m_one;
+    g->count = 0;
+    rb_scan_args(argc, args, "02", &vbeg, &vstep);
+<% if is_int && !is_object %>
+    if (vbeg!=Qnil) {g->beg = NUM2DBL(vbeg);}
+    if (vstep!=Qnil) {g->step = NUM2DBL(vstep);}
+<% else %>
+    if (vbeg!=Qnil) {g->beg = m_num_to_data(vbeg);}
+    if (vstep!=Qnil) {g->step = m_num_to_data(vstep);}
+<% end %>
+
+    na_ndloop3(&ndf, g, 1, self);
+    return self;
+}

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

@@ -0,0 +1,43 @@
+<% if is_int && !is_object %>
+typedef double seq_data_t;
+<% else %>
+typedef dtype seq_data_t;
+<% end %>
+
+<% if is_object %>
+typedef size_t seq_count_t;
+<% else %>
+typedef double seq_count_t;
+<% end %>
+
+<% unless is_object %>
+__global__ void <%="cumo_#{c_iter}_index_kernel"%>(char *p1, size_t* idx1, seq_data_t beg, seq_data_t step, seq_count_t c, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        dtype x = f_seq(beg,step,c+i);
+        *(dtype*)(p1+idx1[i]) = x;
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, size_t s1, seq_data_t beg, seq_data_t step, seq_count_t c, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        dtype x = f_seq(beg,step,c+i);
+        *(dtype*)(p1+(i*s1)) = x;
+    }
+}
+
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(char *p1, size_t* idx1, seq_data_t beg, seq_data_t step, seq_count_t c, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_kernel"%><<<gridDim, blockDim>>>(p1,idx1,beg,step,c,n);
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, ssize_t s1, seq_data_t beg, seq_data_t step, seq_count_t c, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(p1,s1,beg,step,c,n);
+}
+<% end %>

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

@@ -0,0 +1,57 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2;
+    ssize_t s1, s2;
+    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%>");
+    if (idx1) {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA(p1+*idx1,dtype,x);
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+                x = m_<%=name%>(x,y);
+                SET_DATA_INDEX(p1,idx1,dtype,x);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA(p1+*idx1,dtype,x);
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+                x = m_<%=name%>(x,y);
+                SET_DATA_INDEX(p1,idx1,dtype,x);
+            }
+        }
+    } else {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA(p1,dtype,x);
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+                x = m_<%=name%>(x,y);
+                SET_DATA_STRIDE(p1,s1,dtype,x);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA(p1,dtype,x);
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+                x = m_<%=name%>(x,y);
+                SET_DATA_STRIDE(p1,s1,dtype,x);
+            }
+        }
+    }
+}
+
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE a1)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{<%=result_class%>,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };
+
+    na_ndloop(&ndf, 2, self, a1);
+    return a1;
+}

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

@@ -0,0 +1,48 @@
+<% (is_float ? ["_ignan","_prnan"] : [""]).each do |j| %>
+static void
+<%=c_iter%><%=j%>(na_loop_t *const lp)
+{
+    size_t n;
+    char *ptr;
+    ssize_t step;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, ptr, step);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    <%=type_name%>_qsort<%=j%>(ptr, n, step);
+}
+<% end %>
+
+/*
+  <%=name%> of self.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+<% else %>
+  @overload <%=name%>(axis:nil)
+<% end %>
+  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @return [Cumo::<%=class_name%>] returns result of <%=name%>.
+  @example
+      Cumo::DFloat[3,4,1,2].sort => Cumo::DFloat[1,2,3,4]
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE reduce;
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_reduce,0}};
+    ndfunc_t ndf = {0, STRIDE_LOOP|NDF_FLAT_REDUCE, 2,0, ain,0};
+
+    if (!TEST_INPLACE(self)) {
+        self = na_copy(self);
+    }
+  <% if is_float %>
+    ndf.func = <%=c_iter%>_ignan;
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_prnan);
+  <% else %>
+    ndf.func = <%=c_iter%>;
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+  <% end %>
+    na_ndloop(&ndf, 2, self, reduce);
+    return self;
+}