cumo 0.1.0

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

@@ -0,0 +1,24 @@
+#include "cumo/narray_kernel.h"
+<% unless type_name == 'robject' %>
+#include "cumo/indexer.h"
+#include "cumo/reduce_kernel.h"
+<% end %>
+#include <<%="cumo/types/#{type_name}_kernel.h"%>>
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+<% children.each do |c|%>
+<%= "#{c.result}\n\n" %>
+<% end %>
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif

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

@@ -0,0 +1,102 @@
+typedef struct {
+    seq_data_t beg;
+    seq_data_t step;
+    seq_data_t base;
+    seq_count_t count;
+} logseq_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_data_t base, 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_data_t base, 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, base;
+    seq_count_t c;
+    logseq_opt_t *g;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    g = (logseq_opt_t*)(lp->opt_ptr);
+    beg  = g->beg;
+    step = g->step;
+    base = g->base;
+    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) = m_pow(base,x);
+                idx1++;
+            }
+        } else {
+            for (; i--;) {
+                x = f_seq(beg,step,c++);
+                *(dtype*)(p1) = m_pow(base,x);
+                p1 += s1;
+            }
+        }
+        g->count = c;
+    }
+    <% else %>
+    {
+        size_t n = i;
+        if (idx1) {
+            <%="cumo_#{c_iter}_index_kernel_launch"%>(p1,idx1,beg,step,base,c,n);
+        } else {
+            <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,s1,beg,step,base,c,n);
+        }
+        g->count += n;
+    }
+    <% end %>
+}
+
+/*
+  Set logarithmic sequence of numbers to self. The sequence is obtained from
+     base**(beg+i*step)
+  where i is 1-dimensional index.
+  Applicable classes: DFloat, SFloat, DComplex, SCopmplex.
+
+  @overload logseq(beg,step,[base])
+  @param [Numeric] beg  The begining of sequence.
+  @param [Numeric] step  The step of sequence.
+  @param [Numeric] base  The base of log space. (default=10)
+  @return [Cumo::<%=class_name%>] self.
+
+  @example
+    Cumo::DFloat.new(5).logseq(4,-1,2)
+    => Cumo::DFloat#shape=[5]
+      [16, 8, 4, 2, 1]
+    Cumo::DComplex.new(5).logseq(0,1i*Math::PI/3,Math::E)
+    => Cumo::DComplex#shape=[5]
+      [1+7.26156e-310i, 0.5+0.866025i, -0.5+0.866025i, -1+1.22465e-16i, ...]
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *args, VALUE self)
+{
+    logseq_opt_t *g;
+    VALUE vbeg, vstep, vbase;
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
+
+    g = ALLOCA_N(logseq_opt_t,1);
+    rb_scan_args(argc, args, "21", &vbeg, &vstep, &vbase);
+    g->beg = m_num_to_data(vbeg);
+    g->step = m_num_to_data(vstep);
+    if (vbase==Qnil) {
+        g->base = m_from_real(10);
+    } else {
+        g->base = m_num_to_data(vbase);
+    }
+    na_ndloop3(&ndf, g, 1, self);
+    return self;
+}

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

@@ -0,0 +1,31 @@
+<% unless is_object %>
+__global__ void <%="cumo_#{c_iter}_index_kernel"%>(char *p1, size_t* idx1, seq_data_t beg, seq_data_t step, seq_data_t base, 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]) = m_pow(base,x);
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, size_t s1, seq_data_t beg, seq_data_t step, seq_data_t base, 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)) = m_pow(base,x);
+    }
+}
+
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(char *p1, size_t* idx1, seq_data_t beg, seq_data_t step, seq_data_t base, 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,base,c,n);
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, ssize_t s1, seq_data_t beg, seq_data_t step, seq_data_t base, 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,base,c,n);
+}
+<% end %>

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

@@ -0,0 +1,98 @@
+static inline dtype
+yield_map_with_index(dtype x, size_t *c, VALUE *a, int nd, int md)
+{
+    int j;
+    VALUE y;
+
+    a[0] = m_data_to_num(x);
+    for (j=0; j<=nd; j++) {
+        a[j+1] = SIZET2NUM(c[j]);
+    }
+    y = rb_yield(rb_ary_new4(md,a));
+    return m_num_to_data(y);
+}
+
+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;
+    VALUE *a;
+    size_t *c;
+    int nd, md;
+
+    c = (size_t*)(lp->opt_ptr);
+    nd = lp->ndim;
+    if (nd > 0) {nd--;}
+    md = nd + 2;
+    a = ALLOCA_N(VALUE,md);
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    c[nd] = 0;
+    if (idx1) {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA_INDEX(p1,idx1,dtype,x);
+                x = yield_map_with_index(x,c,a,nd,md);
+                SET_DATA_INDEX(p2,idx2,dtype,x);
+                c[nd]++;
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_INDEX(p1,idx1,dtype,x);
+                x = yield_map_with_index(x,c,a,nd,md);
+                SET_DATA_STRIDE(p2,s2,dtype,x);
+                c[nd]++;
+            }
+        }
+    } else {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA_STRIDE(p1,s1,dtype,x);
+                x = yield_map_with_index(x,c,a,nd,md);
+                SET_DATA_INDEX(p2,idx2,dtype,x);
+                c[nd]++;
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_STRIDE(p1,s1,dtype,x);
+                x = yield_map_with_index(x,c,a,nd,md);
+                SET_DATA_STRIDE(p2,s2,dtype,x);
+                c[nd]++;
+            }
+        }
+    }
+}
+
+/*
+  Invokes the given block once for each element of self,
+  passing that element and indices along each axis as parameters.
+  Creates a new NArray containing the values returned by the block.
+  Inplace option is allowed, i.e., `nary.inplace.map` overwrites `nary`.
+
+  @overload <%=name%>
+
+  For a block {|x,i,j,...| ... }
+  @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
+
+  @return [Cumo::NArray] mapped array
+
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,1, ain,aout};
+
+    return na_ndloop_with_index(&ndf, 1, self);
+}

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

@@ -0,0 +1,66 @@
+<% (is_float ? ["_ignan","_prnan"] : [""]).each do |j| %>
+static void
+<%=c_iter%><%=j%>(na_loop_t *const lp)
+{
+    size_t n;
+    char *p1, *p2;
+    dtype *buf;
+
+    INIT_COUNTER(lp, n);
+    p1 = (lp->args[0]).ptr + (lp->args[0].iter[0]).pos;
+    p2 = (lp->args[1]).ptr + (lp->args[1].iter[0]).pos;
+    buf = (dtype*)p1;
+
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
+    <%=type_name%>_qsort<%=j%>(buf, n, sizeof(dtype));
+
+    <% if is_float %>
+    for (; n; n--) {
+        if (!isnan(buf[n-1])) break;
+    }
+    <% end %>
+
+    if (n==0) {
+        *(dtype*)p2 = buf[0];
+    }
+    else if (n%2==0) {
+        *(dtype*)p2 = (buf[n/2-1]+buf[n/2])/2;
+    }
+    else {
+        *(dtype*)p2 = buf[(n-1)/2];
+    }
+}
+<% end %>
+
+/*
+  <%=name%> of self.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, keepdims:false, nan:false)
+  @param [TrueClass] nan (keyword) If true, propagete NaN. If false, ignore NaN.
+<% else %>
+  @overload <%=name%>(axis:nil, keepdims:false)
+<% end %>
+  @param [Numeric,Array,Range] axis (keyword) Affected dimensions.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+  @return [Cumo::<%=class_name%>] returns <%=name%> of self.
+*/
+
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
+    ndfunc_t ndf = {0, NDF_HAS_LOOP|NDF_FLAT_REDUCE, 2,1, ain,aout};
+
+    self = na_copy(self); // as temporary buffer
+  <% 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 %>
+    v = na_ndloop(&ndf, 2, self, reduce);
+    return <%=type_name%>_extract(v);
+}

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

@@ -0,0 +1,47 @@
+<% (is_float ? ["","_nan"] : [""]).each do |j| %>
+static void
+<%=c_iter%><%=j%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1;
+    ssize_t  s1;
+    dtype    xmin,xmax;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    f_<%=name%><%=j%>(n,p1,s1,&xmin,&xmax);
+
+    *(dtype*)(lp->args[1].ptr + lp->args[1].iter[0].pos) = xmin;
+    *(dtype*)(lp->args[2].ptr + lp->args[2].iter[0].pos) = xmax;
+}
+<% end %>
+
+/*
+  <%=name%> of self.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, keepdims:false, nan:false)
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+<% else %>
+  @overload <%=name%>(axis:nil, keepdims:false)
+<% end %>
+  @param [Numeric,Array,Range] axis (keyword) Affected dimensions.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+  @return [Cumo::<%=class_name%>,Cumo::<%=class_name%>] min and max of self.
+*/
+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[2] = {{cT,0},{cT,0}};
+    ndfunc_t ndf = {<%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 2,2, ain,aout};
+
+  <% if is_float %>
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_nan);
+  <% else %>
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+  <% end %>
+    return na_ndloop(&ndf, 2, self, reduce);
+}

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

@@ -0,0 +1,9 @@
+/*
+  module definition: <%= full_module_name %>
+*/
+
+<%  if module_var != ns_var %>
+VALUE <%=module_var%>;
+<%  end %>
+
+<%= method_code %>

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

@@ -0,0 +1 @@
+<%= method_code %>

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

@@ -0,0 +1,15 @@
+void <%="cumo_#{c_func(:nodef)}_kernel_launch"%>(dtype *ptr, dtype x);
+
+static VALUE
+<%=c_func(:nodef)%>(dtype x)
+{
+    VALUE v;
+    dtype *ptr;
+
+    v = nary_new(cT, 0, NULL);
+    ptr = (dtype*)na_get_pointer_for_write(v);
+    <%="cumo_#{c_func(:nodef)}_kernel_launch"%>(ptr, x);
+
+    na_release_lock(v);
+    return v;
+}

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

@@ -0,0 +1,8 @@
+__global__ void <%="cumo_#{c_func(:nodef)}_kernel"%>(dtype *ptr, dtype x)
+{
+    *ptr = x;
+}
+void <%="cumo_#{c_func(:nodef)}_kernel_launch"%>(dtype *ptr, dtype x)
+{
+    <%="cumo_#{c_func(:nodef)}_kernel"%><<<1,1>>>(ptr,x);
+}

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

@@ -0,0 +1,50 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    dtype  x, y, a;
+
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    x = *(dtype*)(lp->args[0].ptr + lp->args[0].iter[0].pos);
+    i = lp->narg - 2;
+    y = *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos);
+    for (; --i;) {
+        y = m_mul(x,y);
+        a = *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos);
+        y = m_add(y,a);
+    }
+    i = lp->narg - 1;
+    *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos) = y;
+}
+
+/*
+  Polynomial.: a0 + a1*x + a2*x**2 + a3*x**3 + ... + an*x**n
+  @overload <%=name%> a0, a1, ...
+  @param [Cumo::NArray,Numeric] a0
+  @param [Cumo::NArray,Numeric] a1 , ...
+  @return [Cumo::<%=class_name%>]
+*/
+static VALUE
+<%=c_func(-2)%>(VALUE self, VALUE args)
+{
+    int argc, i;
+    VALUE *argv;
+    volatile VALUE v, a;
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, NO_LOOP, 0, 1, 0, aout };
+
+    argc = RARRAY_LEN(args);
+    ndf.nin = argc+1;
+    ndf.ain = ALLOCA_N(ndfunc_arg_in_t,argc+1);
+    for (i=0; i<argc+1; i++) {
+        ndf.ain[i].type = cT;
+    }
+    argv = ALLOCA_N(VALUE,argc+1);
+    argv[0] = self;
+    for (i=0; i<argc; i++) {
+        argv[i+1] = RARRAY_PTR(args)[i];
+    }
+    a = rb_ary_new4(argc+1, argv);
+    v = na_ndloop2(&ndf, a);
+    return <%=type_name%>_extract(v);
+}