cumo 0.1.0

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

@@ -0,0 +1,70 @@
+<% unless type_name == 'robject' %>
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, char *p3, char *p4, ssize_t s1, ssize_t s2, ssize_t s3, ssize_t s4, uint64_t n);
+<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i, n;
+    char    *p1, *p2, *p3, *p4;
+    ssize_t  s1, s2, s3, s4;
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    INIT_PTR(lp, 3, p4, s4);
+    for (i=n; i--;) {
+        <% if type_name == 'robject' %>
+        {
+            dtype    x, y, a, b;
+            SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            GET_DATA_STRIDE(p2,s2,dtype,y);
+<% if is_int and %w[divmod].include? name %>
+                if (y==0) {
+                    lp->err_type = rb_eZeroDivError;
+                    return;
+                }
+<% end %>
+            m_<%=name%>(x,y,a,b);
+            SET_DATA_STRIDE(p3,s3,dtype,a);
+            SET_DATA_STRIDE(p4,s4,dtype,b);
+        }
+        <% else %>
+        <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,p2,p3,p4,s1,s2,s3,s4,n);
+        <% end %>
+    }
+}
+
+static VALUE
+<%=c_func%>_self(VALUE self, VALUE other)
+{
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 2, ain, aout };
+
+    return na_ndloop(&ndf, 2, self, other);
+}
+
+/*
+  Binary <%=name%>.
+  @overload <%=op_map%> other
+  @param [Cumo::NArray,Numeric] other
+  @return [Cumo::NArray] <%=name%> of self and other.
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE other)
+{
+    <% if is_object %>
+    return <%=c_func%>_self(self, other);
+    <% else %>
+    VALUE klass, v;
+    klass = na_upcast(CLASS_OF(self),CLASS_OF(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);
+    }
+    <% end %>
+}

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

@@ -0,0 +1,15 @@
+<% unless type_name == 'robject' %>
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, char *p2, char *p3, char *p4, ssize_t s1, ssize_t s2, ssize_t s3, ssize_t s4, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        m_<%=name%>(*(dtype*)(p1+(i*s1)),*(dtype*)(p2+(i*s2)),*(dtype*)(p3+(i*s3)), *(dtype*)(p4+(i*s4)));
+    }
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, char *p3, char *p4, ssize_t s1, ssize_t s2, ssize_t s3, ssize_t s4, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,p3,p4,s1,s2,s3,s4,n);
+}
+<% end %>

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

@@ -0,0 +1,31 @@
+<% unless type_name == 'robject' %>
+
+<% ((0..opt_indexer_ndim).to_a << '').each do |idim| %>
+__global__ void <%="cumo_#{c_iter}_kernel_dim#{idim}"%>(na_iarray_t a1, na_iarray_t a2, na_iarray_t a3, na_indexer_t indexer)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < indexer.total_size; i += blockDim.x * gridDim.x) {
+        cumo_na_indexer_set_dim<%=idim%>(&indexer, i);
+        char* p1 = cumo_na_iarray_at_dim<%=idim%>(&a1, &indexer);
+        char* p2 = cumo_na_iarray_at_dim<%=idim%>(&a2, &indexer);
+        char* p3 = cumo_na_iarray_at_dim<%=idim%>(&a3, &indexer);
+        *(dtype*)(p3) = m_<%=name%>(*(dtype*)(p1),*(dtype*)(p2));
+    }
+}
+<% end %>
+
+void <%="cumo_#{c_iter}_kernel_launch"%>(na_iarray_t* a1, na_iarray_t* a2, na_iarray_t* a3, na_indexer_t* indexer)
+{
+    size_t gridDim = get_gridDim(indexer->total_size);
+    size_t blockDim = get_blockDim(indexer->total_size);
+    switch (indexer->ndim) {
+    <% (0..opt_indexer_ndim).each do |idim| %>
+    case <%=idim%>:
+        <%="cumo_#{c_iter}_kernel_dim#{idim}"%><<<gridDim, blockDim>>>(*a1,*a2,*a3,*indexer);
+        break;
+    <% end %>
+    default:
+        <%="cumo_#{c_iter}_kernel_dim"%><<<gridDim, blockDim>>>(*a1,*a2,*a3,*indexer);
+        break;
+    }
+}
+<% end %>

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

@@ -0,0 +1,45 @@
+<% unless type_name == 'robject' %>
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n);
+<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char    *p1, *p2, *p3;
+    ssize_t s1, s2, s3;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    <% if type_name == 'robject' %>
+    {
+        dtype x, y;
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            GET_DATA_STRIDE(p2,s2,dtype,y);
+            x = m_<%=name%>(x,y);
+            SET_DATA_STRIDE(p3,s3,dtype,x);
+        }
+    }
+    <% else %>
+    <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,p2,p3,s1,s2,s3,i);
+    <% end %>
+}
+
+/*
+  Calculate <%=name%>(a1,a2).
+  @overload <%=name%>(a1,a2)
+  @param [Cumo::NArray,Numeric] a1  first value
+  @param [Cumo::NArray,Numeric] a2  second value
+  @return [Cumo::<%=class_name%>] <%=name%>(a1,a2).
+*/
+static VALUE
+<%=c_func(2)%>(VALUE mod, VALUE a1, VALUE a2)
+{
+    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, 2, 1, ain, aout };
+    return na_ndloop(&ndf, 2, a1, a2);
+}

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

@@ -0,0 +1,15 @@
+<% unless type_name == 'robject' %>
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, char *p2, char *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*)(p3+(i*s3)) = m_<%=name%>(*(dtype*)(p1+(i*s1)),*(dtype*)(p2+(i*s2)));
+    }
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, char *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,p3,s1,s2,s3,n);
+}
+<% end %>

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

@@ -0,0 +1,181 @@
+// ------- Integer count without weights -------
+<%
+[32,64].each do |bits|
+   cnt_cT = "cumo_cUInt#{bits}"
+   cnt_type = "u_int#{bits}_t"
+%>
+static void
+<%=c_iter%>_<%=bits%>(na_loop_t *const lp)
+{
+    size_t   i, x, n;
+    char    *p1, *p2;
+    ssize_t  s1, s2;
+    size_t  *idx1;
+
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR(lp, 1, p2, s2);
+    i = lp->args[0].shape[0];
+    n = lp->args[1].shape[0];
+
+    // initialize
+    for (x=0; x < n; x++) {
+        *(<%=cnt_type%>*)(p2 + s2*x) = 0;
+    }
+
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>_<%=bits%>", "<%=type_name%>");
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            (*(<%=cnt_type%>*)(p2 + s2*x))++;
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            (*(<%=cnt_type%>*)(p2 + s2*x))++;
+        }
+    }
+}
+
+static VALUE
+<%=c_func%>_<%=bits%>(VALUE self, size_t length)
+{
+    size_t shape_out[1] = {length};
+    ndfunc_arg_in_t ain[1] = {{cT,1}};
+    ndfunc_arg_out_t aout[1] = {{<%=cnt_cT%>,1,shape_out}};
+    ndfunc_t ndf = {<%=c_iter%>_<%=bits%>, NO_LOOP|NDF_STRIDE_LOOP|NDF_INDEX_LOOP,
+                    1, 1, ain, aout};
+
+    return na_ndloop(&ndf, 1, self);
+}
+<% end %>
+// ------- end of Integer count without weights -------
+
+// ------- Float count with weights -------
+<%
+[["SF","float"],
+ ["DF","double"]].each do |fn,cnt_type|
+  cnt_cT = "cumo_c#{fn}loat"
+  fn = fn.downcase
+%>
+static void
+<%=c_iter%>_<%=fn%>(na_loop_t *const lp)
+{
+    <%=cnt_type%> w;
+    size_t   i, x, n, m;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    i = lp->args[0].shape[0];
+    m = lp->args[1].shape[0];
+    n = lp->args[2].shape[0];
+
+    if (i != m) {
+        rb_raise(nary_eShapeError,
+                 "size mismatch along last axis between self and weight");
+    }
+
+    // initialize
+    for (x=0; x < n; x++) {
+        *(<%=cnt_type%>*)(p3 + s3*x) = 0;
+    }
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,<%=cnt_type%>,w);
+        (*(<%=cnt_type%>*)(p3 + s3*x)) += w;
+    }
+}
+
+static VALUE
+<%=c_func%>_<%=fn%>(VALUE self, VALUE weight, size_t length)
+{
+    size_t shape_out[1] = {length};
+    ndfunc_arg_in_t ain[2] = {{cT,1},{<%=cnt_cT%>,1}};
+    ndfunc_arg_out_t aout[1] = {{<%=cnt_cT%>,1,shape_out}};
+    ndfunc_t ndf = {<%=c_iter%>_<%=fn%>, NO_LOOP|NDF_STRIDE_LOOP,
+                    2, 1, ain, aout};
+
+    return na_ndloop(&ndf, 2, self, weight);
+}
+<% end %>
+// ------- end of Float count with weights -------
+
+/*
+  Count the number of occurrences of each non-negative integer value.
+  Only Integer-types has this method.
+
+  @overload <%=name%>([weight], minlength:nil)
+  @param [SFloat or DFloat or Array] weight (optional) Array of
+    float values. Its size along last axis should be same as that of self.
+  @param [Integer] minlength (keyword, optional) Minimum size along
+    last axis for the output array.
+  @return [UInt32 or UInt64 or SFloat or DFloat]
+    Returns Float NArray if weight array is supplied,
+    otherwise returns UInt32 or UInt64 depending on the size along last axis.
+  @example
+    Cumo::Int32[0..4].bincount
+    => Cumo::UInt32#shape=[5]
+       [1, 1, 1, 1, 1]
+
+    Cumo::Int32[0, 1, 1, 3, 2, 1, 7].bincount
+    => Cumo::UInt32#shape=[8]
+       [1, 3, 1, 1, 0, 0, 0, 1]
+
+    x = Cumo::Int32[0, 1, 1, 3, 2, 1, 7, 23]
+    x.bincount.size == x.max+1
+    => true
+
+    w = Cumo::DFloat[0.3, 0.5, 0.2, 0.7, 1.0, -0.6]
+    x = Cumo::Int32[0, 1, 1, 2, 2, 2]
+    x.bincount(w)
+    => Cumo::DFloat#shape=[3]
+       [0.3, 0.7, 1.1]
+
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE weight=Qnil, kw=Qnil;
+    VALUE opts[1] = {Qundef};
+    VALUE v, wclass;
+    ID table[1] = {id_minlength};
+    size_t length, minlength;
+
+    rb_scan_args(argc, argv, "01:", &weight, &kw);
+    rb_get_kwargs(kw, table, 0, 1, opts);
+
+  <% if is_unsigned %>
+    v = <%=type_name%>_max(0,0,self);
+  <% else %>
+    v = <%=type_name%>_minmax(0,0,self);
+    if (m_num_to_data(RARRAY_AREF(v,0)) < 0) {
+        rb_raise(rb_eArgError,"array items must be non-netagive");
+    }
+    v = RARRAY_AREF(v,1);
+  <% end %>
+    length = NUM2SIZET(v) + 1;
+
+    if (opts[0] != Qundef) {
+        minlength = NUM2SIZET(opts[0]);
+        if (minlength > length) {
+            length = minlength;
+        }
+    }
+
+    if (NIL_P(weight)) {
+        if (length > 4294967295ul) {
+            return <%=c_func%>_64(self, length);
+        } else {
+            return <%=c_func%>_32(self, length);
+        }
+    } else {
+        wclass = CLASS_OF(weight);
+        if (wclass == cumo_cSFloat) {
+            return <%=c_func%>_sf(self, weight, length);
+        } else {
+            return <%=c_func%>_df(self, weight, length);
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+<% children.each do |c|%>
+<%= c.result %>
+
+<% end %>
+/*
+  Cast object to Cumo::<%=class_name%>.
+  @overload [](elements)
+  @overload <%=name%>(array)
+  @param [Numeric,Array] elements
+  @param [Array] array
+  @return [Cumo::<%=class_name%>]
+*/
+static VALUE
+<%=c_func(1)%>(VALUE type, VALUE obj)
+{
+    VALUE v;
+    narray_t *na;
+    dtype x;
+
+    if (CLASS_OF(obj)==cT) {
+        return obj;
+    }
+    if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
+        x = m_num_to_data(obj);
+        return <%=type_name%>_new_dim0(x);
+    }
+    if (RTEST(rb_obj_is_kind_of(obj,rb_cArray))) {
+        return <%=find_tmpl("cast_array").c_func%>(obj);
+    }
+    if (IsNArray(obj)) {
+        GetNArray(obj,na);
+        v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
+        if (NA_SIZE(na) > 0) {
+            <%=find_tmpl("store").c_func%>(v,obj);
+        }
+        return v;
+    }
+    <% if is_object %>
+    return robject_new_dim0(obj);
+    <% else %>
+    rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
+    return Qnil;
+    <% end %>
+}

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

@@ -0,0 +1,13 @@
+static VALUE
+<%=c_func(:nodef)%>(VALUE rary)
+{
+    VALUE nary;
+    narray_t *na;
+
+    nary = na_s_new_like(cT, rary);
+    GetNArray(nary,na);
+    if (na->size > 0) {
+        <%=find_tmpl("store").find("array").c_func%>(nary,rary);
+    }
+    return nary;
+}

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

@@ -0,0 +1,9 @@
+/*
+  class definition: <%= full_class_name %>
+*/
+
+VALUE <%=class_var%>;
+
+static VALUE <%= find('store').c_func %>(VALUE,VALUE);
+
+<%= method_code %>

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

@@ -0,0 +1,6 @@
+/*
+  class definition: <%= full_class_name %>
+*/
+
+<%= method_code %>
+

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

@@ -0,0 +1,121 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2, *p3, *p4;
+    ssize_t s1, s2, s3, s4;
+    dtype   x, min, max;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    INIT_PTR(lp, 3, p4, s4);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,dtype,min);
+        GET_DATA_STRIDE(p3,s3,dtype,max);
+        if (m_gt(min,max)) {rb_raise(nary_eOperationError,"min is greater than max");}
+        if (m_lt(x,min)) {x=min;}
+        if (m_gt(x,max)) {x=max;}
+        SET_DATA_STRIDE(p4,s4,dtype,x);
+    }
+}
+
+static void
+<%=c_iter%>_min(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2, *p3;
+    ssize_t s1, s2, s3;
+    dtype   x, min;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>_min", "<%=type_name%>");
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,dtype,min);
+        if (m_lt(x,min)) {x=min;}
+        SET_DATA_STRIDE(p3,s3,dtype,x);
+    }
+}
+
+static void
+<%=c_iter%>_max(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2, *p3;
+    ssize_t s1, s2, s3;
+    dtype   x, max;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>_max", "<%=type_name%>");
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,dtype,max);
+        if (m_gt(x,max)) {x=max;}
+        SET_DATA_STRIDE(p3,s3,dtype,x);
+    }
+}
+
+/*
+  Clip array elements by [min,max].
+  If either of min or max is nil, one side is clipped.
+  @overload <%=name%>(min,max)
+  @param [Cumo::NArray,Numeric] min
+  @param [Cumo::NArray,Numeric] max
+  @return [Cumo::NArray] result of clip.
+
+  @example
+      a = Cumo::Int32.new(10).seq
+      p a.clip(1,8)
+      # Cumo::Int32#shape=[10]
+      # [1, 1, 2, 3, 4, 5, 6, 7, 8, 8]
+
+      p a
+      # Cumo::Int32#shape=[10]
+      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      p a.inplace.clip(3,6)
+      # Cumo::Int32(view)#shape=[10]
+      # [3, 3, 3, 3, 4, 5, 6, 6, 6, 6]
+
+      p a
+      # Cumo::Int32#shape=[10]
+      # [3, 3, 3, 3, 4, 5, 6, 6, 6, 6]
+
+      p a = Cumo::Int32.new(10).seq
+      # Cumo::Int32#shape=[10]
+      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      p a.clip([3,4,1,1,1,4,4,4,4,4], 8)
+      # Cumo::Int32#shape=[10]
+      # [3, 4, 2, 3, 4, 5, 6, 7, 8, 8]
+*/
+static VALUE
+<%=c_func(2)%>(VALUE self, VALUE min, VALUE max)
+{
+    ndfunc_arg_in_t ain[3] = {{Qnil,0},{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf_min = { <%=c_iter%>_min, STRIDE_LOOP, 2, 1, ain, aout };
+    ndfunc_t ndf_max = { <%=c_iter%>_max, STRIDE_LOOP, 2, 1, ain, aout };
+    ndfunc_t ndf_both = { <%=c_iter%>, STRIDE_LOOP, 3, 1, ain, aout };
+
+    if (RTEST(min)) {
+        if (RTEST(max)) {
+            return na_ndloop(&ndf_both, 3, self, min, max);
+        } else {
+            return na_ndloop(&ndf_min, 2, self, min);
+        }
+    } else {
+        if (RTEST(max)) {
+            return na_ndloop(&ndf_max, 2, self, max);
+        }
+    }
+    rb_raise(rb_eArgError,"min and max are not given");
+    return Qnil;
+}