numo-narray 0.9.0.3 → 0.9.0.4

data/ext/numo/narray/gen/tmpl/accum_binary.c

@@ -61,10 +61,15 @@ static VALUE
 static VALUE
 <%=c_func%>(int argc, VALUE *argv, VALUE self)
 {
+    <% if !is_object %>
     VALUE klass, v;
+    <% end %>
     if (argc < 1) {
         rb_raise(rb_eArgError,"wrong number of arguments (%d for >=1)",argc);
     }
+    <% if is_object %>
+    return <%=c_func%>_self(argc, argv, self);
+    <% else %>
     klass = na_upcast(CLASS_OF(self),CLASS_OF(argv[0]));
     if (klass==cT) {
         return <%=c_func%>_self(argc, argv, self);
@@ -72,4 +77,5 @@ static VALUE
         v = rb_funcall(klass, id_cast, 1, self);
         return rb_funcall2(v, rb_intern("<%=method%>"), argc, argv);
     }
+    <% end %>
 }

data/ext/numo/narray/gen/tmpl/aref.c

@@ -9,6 +9,7 @@
   +dim0+, +dim1+, ... includes other than Numeric index, e.g., Range
   or Array or true.
 
+  @example
       a = Numo::DFloat.new(4,5).seq
       => Numo::DFloat#shape=[4,5]
       [[0, 1, 2, 3, 4],
@@ -38,12 +39,13 @@
 static VALUE
 <%=c_func%>(int argc, VALUE *argv, VALUE self)
 {
-    ssize_t pos;
+    int nd;
+    size_t pos;
     char *ptr;
 
-    pos = na_get_scalar_position(self, argc, argv, sizeof(dtype));
-    if (pos == -1) {
-        return na_aref_main(argc, argv, self, 0);
+    nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+    if (nd) {
+        return na_aref_main(argc, argv, self, 0, nd);
     } else {
         ptr = na_get_pointer_for_read(self) + pos;
         return m_extract(ptr);

data/ext/numo/narray/gen/tmpl/aset.c

@@ -8,6 +8,7 @@
   --- Replace element(s) at +dim0+, +dim1+, ... (index/range/array/true
   for each dimention). Broadcasting mechanism is applied.
 
+  @example
       a = Numo::DFloat.new(3,4).seq
       => Numo::DFloat#shape=[3,4]
       [[0, 1, 2, 3],
@@ -39,7 +40,8 @@
 static VALUE
 <%=c_func%>(int argc, VALUE *argv, VALUE self)
 {
-    ssize_t pos;
+    int nd;
+    size_t pos;
     char *ptr;
     VALUE a;
 
@@ -47,9 +49,9 @@ static VALUE
     if (argc==0) {
         <%=c_func.sub(/_aset/,"_store")%>(self, argv[argc]);
     } else {
-        pos = na_get_scalar_position(self, argc, argv, sizeof(dtype));
-        if (pos == -1) {
-            a = na_aref_main(argc, argv, self, 0);
+        nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+        if (nd) {
+            a = na_aref_main(argc, argv, self, 0, nd);
             <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
         } else {
             ptr = na_get_pointer_for_read_write(self) + pos;

data/ext/numo/narray/gen/tmpl/binary.c

@@ -42,6 +42,9 @@ static VALUE
 static VALUE
 <%=c_func%>(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) {
@@ -50,4 +53,5 @@ static VALUE
         v = rb_funcall(klass, id_cast, 1, self);
         return rb_funcall(v, <%=id_op%>, 1, other);
     }
+    <% end %>
 }

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

@@ -44,6 +44,9 @@ static VALUE
 static VALUE
 <%=c_func%>(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) {
@@ -52,4 +55,5 @@ static VALUE
         v = rb_funcall(klass, id_cast, 1, self);
         return rb_funcall(v, <%=id_op%>, 1, other);
     }
+    <% end %>
 }

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

@@ -0,0 +1,180 @@
+// ------- Integer count without weights -------
+<%
+[32,64].each do |bits|
+   cnt_cT = "numo_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;
+    }
+
+    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 = "numo_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 <%=method%>([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
+    Numo::Int32[0..4].bincount
+    => Numo::UInt32#shape=[5]
+       [1, 1, 1, 1, 1]
+
+    Numo::Int32[0, 1, 1, 3, 2, 1, 7].bincount
+    => Numo::UInt32#shape=[8]
+       [1, 3, 1, 1, 0, 0, 0, 1]
+
+    x = Numo::Int32[0, 1, 1, 3, 2, 1, 7, 23]
+    x.bincount.size == x.max+1
+    => true
+
+    w = Numo::DFloat[0.3, 0.5, 0.2, 0.7, 1.0, -0.6]
+    x = Numo::Int32[0, 1, 1, 2, 2, 2]
+    x.bincount(w)
+    => Numo::DFloat#shape=[3]
+       [0.3, 0.7, 1.1]
+
+*/
+static VALUE
+<%=c_func%>(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 = numo_<%=type_name%>_max(0,0,self);
+  <% else %>
+    v = numo_<%=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 == numo_cSFloat) {
+            return <%=c_func%>_sf(self, weight, length);
+        } else {
+            return <%=c_func%>_df(self, weight, length);
+        }
+    }
+}

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

@@ -32,6 +32,10 @@ static VALUE
         }
         return v;
     }
+    <% if is_object %>
+    return numo_robject_new_dim0(obj);
+    <% else %>
     rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
     return Qnil;
+    <% end %>
 }

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

@@ -1,79 +1,18 @@
-static void
-<%=c_iter%>(na_loop_t *const lp)
-{
-    size_t i, n;
-    size_t i1, n1;
-    VALUE  v1, *ptr;
-    char   *p2;
-    size_t s2, *idx2;
-    VALUE  x;
-    double y;
-    dtype  z;
-    size_t len, c;
-    double beg, step;
-
-    v1 = lp->args[0].value;
-    ptr = &v1;
-    INIT_COUNTER(lp, n);
-    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-
-    switch(TYPE(v1)) {
-    case T_ARRAY:
-        n1 = RARRAY_LEN(v1);
-        ptr = RARRAY_PTR(v1);
-        break;
-    case T_NIL:
-        n1 = 0;
-        break;
-    default:
-        n1 = 1;
-    }
-    if (idx2) {
-        <% ["SET_DATA_INDEX(p2, idx2, dtype, z)",
-            "SET_DATA_STRIDE(p2, s2, dtype, z)"].each_with_index do |x,i| %>
-        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);
-                for (c=0; c<len && i<n; c++,i++) {
-                    y = beg + step * c;
-                    z = m_from_double(y);
-                    <%= x %>
-                }
-            }
-            else if (TYPE(x) != T_ARRAY) {
-                if (x == Qnil) x = INT2FIX(0);
-                z = m_num_to_data(x);
-                <%= x %>
-            }
-        }
-        z = m_zero;
-        for (; i<n; i++) {
-            <%= x %>
-        }
-        <% if i<1 %>
-    } else {
-        <% end
-        end %>
-    }
-}
-
 static VALUE
 <%=c_func%>(VALUE rary)
 {
-    volatile VALUE vnc, nary;
+    VALUE vnc, nary;
     narray_t *na;
     na_compose_t *nc;
-    ndfunc_arg_in_t ain[2] = {{rb_cArray,0},{Qnil,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };
 
     vnc = na_ary_composition(rary);
     Data_Get_Struct(vnc, na_compose_t, nc);
     nary = rb_narray_new(cT, nc->ndim, nc->shape);
+    RB_GC_GUARD(vnc);
     GetNArray(nary,na);
     if (na->size > 0) {
         <%=find_tmpl("allocate").c_func%>(nary);
-        na_ndloop_cast_rarray_to_narray(&ndf, rary, nary);
+        <%=find_tmpl("store_array").c_func%>(nary,rary);
     }
     return nary;
 }

data/ext/numo/narray/gen/tmpl/cond_binary.c

@@ -40,6 +40,9 @@ static VALUE
 static VALUE
 <%=c_func%>(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) {
@@ -48,4 +51,5 @@ static VALUE
         v = rb_funcall(klass, id_cast, 1, self);
         return rb_funcall(v, id_<%=method%>, 1, other);
     }
+    <% end %>
 }

data/ext/numo/narray/gen/tmpl/inspect.c

@@ -1,7 +1,11 @@
 static VALUE
 <%=c_iter%>(char *ptr, size_t pos, VALUE fmt)
 {
+<% if is_object %>
+    return rb_inspect(*(VALUE*)(ptr+pos));
+<% else %>
     return format_<%=tp%>(fmt, (dtype*)(ptr+pos));
+<% end %>
 }
 
 /*

data/ext/numo/narray/gen/tmpl/pow.c

@@ -63,6 +63,9 @@ static VALUE
 static VALUE
 <%=c_func%>(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) {
@@ -71,4 +74,5 @@ static VALUE
         v = rb_funcall(klass, id_cast, 1, self);
         return rb_funcall(v, id_pow, 1, other);
     }
+    <% end %>
 }

data/ext/numo/narray/gen/tmpl/qsort.c

@@ -1,12 +1,7 @@
 /*
   qsort.c
   Numerical Array Extension for Ruby
-    (C) Copyright 2007-2011 by Masahiro TANAKA
-
-  This program is free software.
-  You can distribute/modify this program
-  under the same terms as Ruby itself.
-  NO WARRANTY.
+    (C) Copyright 2007-2016 by Masahiro TANAKA
 */
 
 /*
@@ -146,4 +141,3 @@ void
         goto loop;
     }
 }
-