numo-narray 0.9.0.4 → 0.9.0.5

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

@@ -0,0 +1,118 @@
+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);
+    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);
+    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);
+    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 [Numo::NArray,Numeric] min
+  @param [Numo::NArray,Numeric] max
+  @return [Numo::NArray] result of clip.
+
+  @example
+      a = Numo::Int32.new(10).seq
+      p a.clip(1,8)
+      # Numo::Int32#shape=[10]
+      # [1, 1, 2, 3, 4, 5, 6, 7, 8, 8]
+
+      p a
+      # Numo::Int32#shape=[10]
+      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      p a.inplace.clip(3,6)
+      # Numo::Int32(view)#shape=[10]
+      # [3, 3, 3, 3, 4, 5, 6, 6, 6, 6]
+
+      p a
+      # Numo::Int32#shape=[10]
+      # [3, 3, 3, 3, 4, 5, 6, 6, 6, 6]
+
+      p a = Numo::Int32.new(10).seq
+      # Numo::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)
+      # Numo::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;
+}

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

@@ -1,8 +1,10 @@
 /*
-   @return [nil]
+  return NArray with cast to the type of self.
+  @overload coerce_cast(type)
+  @return [nil]
 */
 static VALUE
-<%=c_func %>(VALUE value, VALUE type)
+<%=c_func(1)%>(VALUE self, VALUE type)
 {
     return Qnil;
 }

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

@@ -15,7 +15,7 @@ static void
     for (; i--;) {
         GET_DATA_STRIDE(p1,s1,dtype,x);
         GET_DATA_STRIDE(p2,s2,dtype,y);
-        b = (m_<%=method%>(x,y)) ? 1:0;
+        b = (m_<%=name%>(x,y)) ? 1:0;
         STORE_BIT(a3,p3,b);
         p3+=s3;
     }
@@ -32,13 +32,13 @@ static VALUE
 }
 
 /*
-  Comparison <%=method%> other.
+  Comparison <%=name%> other.
   @overload <%=op_map%> other
   @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self <%=method%> other.
+  @return [Numo::Bit] result of self <%=name%> other.
 */
 static VALUE
-<%=c_func%>(VALUE self, VALUE other)
+<%=c_func(1)%>(VALUE self, VALUE other)
 {
     <% if is_object %>
     return <%=c_func%>_self(self, other);
@@ -49,7 +49,7 @@ static VALUE
         return <%=c_func%>_self(self, other);
     } else {
         v = rb_funcall(klass, id_cast, 1, self);
-        return rb_funcall(v, id_<%=method%>, 1, other);
+        return rb_funcall(v, <%=id_op%>, 1, other);
     }
     <% end %>
 }

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

@@ -15,14 +15,14 @@ static void
     if (idx1) {
         for (; i--;) {
             GET_DATA_INDEX(p1,idx1,dtype,x);
-            b = (m_<%=method%>(x)) ? 1:0;
+            b = (m_<%=name%>(x)) ? 1:0;
             STORE_BIT(a2,p2,b);
             p2+=s2;
         }
     } else {
         for (; i--;) {
             GET_DATA_STRIDE(p1,s1,dtype,x);
-            b = (m_<%=method%>(x)) ? 1:0;
+            b = (m_<%=name%>(x)) ? 1:0;
             STORE_BIT(a2,p2,b);
             p2+=s2;
         }
@@ -30,12 +30,12 @@ static void
 }
 
 /*
-  Condition of <%=method%>.
-  @overload <%=method%>
-  @return [Numo::Bit] Condition of <%=method%>.
+  Condition of <%=name%>.
+  @overload <%=name%>
+  @return [Numo::Bit] Condition of <%=name%>.
 */
 static VALUE
-<%=c_func%>(VALUE self)
+<%=c_func(0)%>(VALUE self)
 {
     ndfunc_arg_in_t ain[1] = {{cT,0}};
     ndfunc_arg_out_t aout[1] = {{numo_cBit,0}};

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

@@ -1,5 +1,6 @@
+<% (is_float ? ["","_nan"] : [""]).each do |j| %>
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%><%=j%>(na_loop_t *const lp)
 {
     size_t   i;
     char    *p1, *p2;
@@ -16,27 +17,35 @@ static void
     //printf("i=%lu x=%f\n",i,x);
     for (i--; i--;) {
         GET_DATA_STRIDE(p1,s1,dtype,y);
-        x = m_<%=cmacro%>(x,y);
+        m_<%=name%><%=j%>(x,y);
         SET_DATA_STRIDE(p2,s2,dtype,x);
         //printf("i=%lu x=%f\n",i,x);
     }
 }
+<% end %>
 
 /*
-  <%=method.capitalize%> of self.
-  @overload <%=method%>(*args)
-  @param [Array of Numeric,Range] args  Affected dimensions.
-  @return [Numo::<%=class_name%>] <%=method%> of self.
+  <%=name%> of self.
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+  @return [Numo::<%=class_name%>] <%=name%> of self.
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
+    int ignore_nan = 0;
     VALUE reduce;
     ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
     ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP|NDF_INPLACE|NDF_FLAT_REDUCE|NDF_CUM,
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP|NDF_FLAT_REDUCE|NDF_CUM,
                      2, 1, ain, aout };
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self);
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ignore_nan);
+<% if is_float %>
+    if (ignore_nan) {
+        ndf.func = <%=c_iter%>_nan;
+    }
+<% end %>
     return na_ndloop(&ndf, 2, self, reduce);
 }

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

@@ -27,13 +27,13 @@ void
 /*
   Calls the given block once for each element in self,
   passing that element as a parameter.
-  @overload <%=method%>
+  @overload <%=name%>
   @return [Numo::NArray] self
   For a block {|x| ... }
   @yield [x]  x is element of NArray.
 */
 static VALUE
-<%=c_func%>(VALUE self)
+<%=c_func(0)%>(VALUE self)
 {
     ndfunc_arg_in_t ain[1] = {{Qnil,0}};
     ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};

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

@@ -48,13 +48,13 @@ void
 /*
   Invokes the given block once for each element of self,
   passing that element and indices along each axis as parameters.
-  @overload <%=method%>
+  @overload <%=name%>
   @return [Numo::NArray] self
   For a block {|x,i,j,...| ... }
   @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
 */
 static VALUE
-<%=c_func%>(VALUE self)
+<%=c_func(0)%>(VALUE self)
 {
     ndfunc_arg_in_t ain[1] = {{Qnil,0}};
     ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};

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

@@ -5,8 +5,8 @@
   --- Extract element value as Ruby Object if self is a dimensionless NArray,
   otherwise returns self.
 */
-VALUE
-numo_<%=tp%>_extract(VALUE self)
+static VALUE
+<%=c_func(0)%>(VALUE self)
 {
     volatile VALUE v;
     char *ptr;

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

@@ -0,0 +1,48 @@
+/*
+  Convert a data value of obj (with a single element) to dtype.
+*/
+static dtype
+<%=c_func(:nodef)%>(VALUE obj)
+{
+    narray_t *na;
+    dtype  x;
+    char  *ptr;
+    size_t pos;
+    VALUE  r, klass;
+
+    if (IsNArray(obj)) {
+        GetNArray(obj,na);
+        if (na->size != 1) {
+            rb_raise(nary_eShapeError,"narray size should be 1");
+        }
+        klass = CLASS_OF(obj);
+        ptr = na_get_pointer_for_read(obj);
+        pos = na_get_offset(obj);
+        <% find_tmpl("store").definitions.select{|x| x.class==Store}.each do |x| %>
+        if (<%=x.condition("klass")%>) {
+            <%=x.extract_data("ptr","pos","x")%>;
+            return x;
+        }
+        <% end %>
+
+        // coerce
+        r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
+        if (CLASS_OF(r)==cT) {
+            return <%=c_func%>(r);
+        }
+        <% if is_object %>
+        return obj;
+        <% else %>
+        rb_raise(nary_eCastError, "unknown conversion from %s to %s",
+                 rb_class2name(CLASS_OF(obj)),
+                 rb_class2name(cT));
+        <% end %>
+    }
+    if (TYPE(obj)==T_ARRAY) {
+        if (RARRAY_LEN(obj) != 1) {
+            rb_raise(nary_eShapeError,"array size should be 1");
+        }
+        return m_num_to_data(RARRAY_AREF(obj,0));
+    }
+    return m_num_to_data(obj);
+}

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

@@ -31,15 +31,15 @@ static void
 
 /*
   Eye: Set a value to diagonal components, set 0 to non-diagonal components.
-  @overload <%=method%>([element,offset])
+  @overload <%=name%>([element,offset])
   @param [Numeric] element  Diagonal element to be stored. Default is 1.
   @param [Integer] offset Diagonal offset from the main diagonal.  The
       default is 0. k>0 for diagonals above the main diagonal, and k<0
       for diagonals below the main diagonal.
-  @return [Numo::<%=class_name%>] <%=method%> of self.
+  @return [Numo::<%=class_name%>] <%=name%> of self.
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     ndfunc_arg_in_t ain[1] = {{OVERWRITE,2}};
     ndfunc_t ndf = {<%=c_iter%>, NO_LOOP, 1,0, ain,0};

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

@@ -23,12 +23,12 @@ static void
 
 /*
   Fill elements with other.
-  @overload <%=method%> other
+  @overload <%=name%> other
   @param [Numeric] other
   @return [Numo::<%=class_name%>] self.
 */
 static VALUE
-<%=c_func%>(VALUE self, VALUE val)
+<%=c_func(1)%>(VALUE self, VALUE val)
 {
     ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_option}};
     ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };

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

@@ -1,5 +1,5 @@
 static VALUE
-format_<%=tp%>(VALUE fmt, dtype* x)
+format_<%=type_name%>(VALUE fmt, dtype* x)
 {
     // fix-me
     char s[48];
@@ -28,13 +28,13 @@ static void
     if (idx1) {
         for (; i--;) {
             x = (dtype*)(p1+*idx1); idx1++;
-            y = format_<%=tp%>(fmt, x);
+            y = format_<%=type_name%>(fmt, x);
             SET_DATA_STRIDE(p2, s2, VALUE, y);
         }
     } else {
         for (; i--;) {
             x = (dtype*)p1;         p1+=s1;
-            y = format_<%=tp%>(fmt, x);
+            y = format_<%=type_name%>(fmt, x);
             SET_DATA_STRIDE(p2, s2, VALUE, y);
         }
     }
@@ -42,12 +42,12 @@ static void
 
 /*
   Format elements into strings.
-  @overload <%=method%> format
+  @overload <%=name%> format
   @param [String] format
   @return [Numo::RObject] array of formated strings.
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE fmt=Qnil;
 

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

@@ -16,13 +16,13 @@ static void
     if (idx1) {
         for (; i--;) {
             x = (dtype*)(p1 + *idx1);  idx1++;
-            y = format_<%=tp%>(fmt, x);
+            y = format_<%=type_name%>(fmt, x);
             rb_ary_push(a,y);
         }
     } else {
         for (; i--;) {
             x = (dtype*)p1;  p1+=s1;
-            y = format_<%=tp%>(fmt, x);
+            y = format_<%=type_name%>(fmt, x);
             rb_ary_push(a,y);
         }
     }
@@ -30,12 +30,12 @@ static void
 
 /*
   Format elements into strings.
-  @overload <%=method%> format
+  @overload <%=name%> format
   @param [String] format
   @return [Array] array of formated strings.
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     volatile VALUE fmt=Qnil;
     ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};