numo-narray 0.9.0.5 → 0.9.0.6

data/ext/numo/narray/gen/narray_def.rb

@@ -20,13 +20,13 @@ module NArrayMethod
     def_method("pow", "pow", op:"**")
   end
 
-  def unary2(meth, dtype, tpclass)
-    h = {dtype:dtype, tpclass:tpclass}
+  def unary2(meth, dtype, result_class)
+    h = {dtype:dtype, result_class:result_class}
     def_method(meth, "unary2", **h)
   end
 
-  def set2(meth, dtype, tpclass)
-    h = {dtype:dtype, tpclass:tpclass}
+  def set2(meth, dtype, result_class)
+    h = {dtype:dtype, result_class:result_class}
     def_method(meth, "set2", h)
   end
 
@@ -48,8 +48,8 @@ module NArrayMethod
     def_method(meth, "bit_reduce", **h)
   end
 
-  def accum(meth, dtype, tpclass)
-    h = {dtype:dtype, tpclass:tpclass}
+  def accum(meth, dtype, result_class)
+    h = {dtype:dtype, result_class:result_class}
     def_method(meth, "accum", **h)
   end
 

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

@@ -17,33 +17,32 @@ static void
 /*
   <%=name%> of self.
 <% if is_float %>
-  @overload <%=name%>(axis:nil, nan:false)
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+  @overload <%=name%>(axis:nil, keepdims:false, nan:false)
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
 <% else %>
-  @overload <%=name%>(axis:nil)
+  @overload <%=name%>(axis:nil, keepdims:false)
 <% end %>
-  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @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 [Numo::<%=class_name%>] returns result of <%=name%>.
 */
 static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
-    int ignore_nan = 0;
     VALUE v, reduce;
     ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
-    ndfunc_arg_out_t aout[1] = {{<%=tpclass%>,0}};
+    ndfunc_arg_out_t aout[1] = {{<%=result_class%>,0}};
     ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ignore_nan);
-<% if is_float %>
-    if (ignore_nan) {
-        ndf.func = <%=c_iter%>_nan;
-    }
-<% end %>
+  <% 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 %>
     v =  na_ndloop(&ndf, 2, self, reduce);
-<% if tpclass == "cT" %>
+  <% if result_class == "cT" %>
     return <%=type_name%>_extract(v);
-<% else %>
+  <% else %>
     return rb_funcall(v,rb_intern("extract"),0);
-<% end %>
+  <% end %>
 }

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

@@ -35,7 +35,6 @@ static void
 static VALUE
 <%=c_func%>_self(int argc, VALUE *argv, VALUE self)
 {
-    int ignore_nan = 0;
     VALUE v, reduce;
     VALUE naryv[2];
     ndfunc_arg_in_t ain[4] = {{cT,0},{cT,0},{sym_reduce,0},{sym_init,0}};
@@ -48,12 +47,12 @@ static VALUE
     // should fix below: [self.ndim,other.ndim].max or?
     naryv[0] = self;
     naryv[1] = argv[0];
-    reduce = na_reduce_dimension(argc-1, argv+1, 2, naryv, &ignore_nan);
-<% if is_float %>
-    if (ignore_nan) {
-        ndf.func = <%=c_iter%>_nan;
-    }
-<% end %>
+  <% if is_float %>
+    reduce = na_reduce_dimension(argc-1, argv+1, 2, naryv, &ndf, <%=c_iter%>_nan);
+  <% else %>
+    reduce = na_reduce_dimension(argc-1, argv+1, 2, naryv, &ndf, 0);
+  <% end %>
+
     v =  na_ndloop(&ndf, 4, self, argv[0], reduce, m_<%=name%>_init);
     return <%=type_name%>_extract(v);
 }
@@ -62,15 +61,15 @@ static VALUE
   Binary <%=name%>.
 
 <% if is_float %>
-  @overload <%=op_map%>(other, axis:nil, nan:false)
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+  @overload <%=op_map%>(other, axis:nil, keepdims:false, nan:false)
 <% else %>
-  @overload <%=op_map%>(other, axis:nil)
+  @overload <%=op_map%>(other, axis:nil, keepdims:false)
 <% end %>
   @param [Numo::NArray,Numeric] other
-  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @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.
 <% if is_float %>
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+  @param [TrueClass] nan (keyword) If true, apply NaN-aware algorithm (avoid NaN if exists).
 <% end %>
   @return [Numo::NArray] <%=name%> of self and other.
 */

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

@@ -24,7 +24,7 @@ static void
   <%=name%>. Return an index of result.
 <% if is_float %>
   @overload <%=name%>(axis:nil, nan:false)
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
 <% else %>
   @overload <%=name%>(axis:nil)
 <% end %>
@@ -36,15 +36,12 @@ static void
 static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
-    int ignore_nan = 0;
     narray_t *na;
     VALUE idx, reduce;
     ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{sym_reduce,0}};
     ndfunc_arg_out_t aout[1] = {{0,0,0}};
     ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ignore_nan);
-
     GetNArray(self,na);
     if (na->ndim==0) {
         return INT2FIX(0);
@@ -52,27 +49,21 @@ static VALUE
     if (na->size > (~(u_int32_t)0)) {
         aout[0].type = numo_cInt64;
         idx = nary_new(numo_cInt64, na->ndim, na->shape);
-<% if is_float %>
-        if (ignore_nan) {
-            ndf.func = <%=c_iter%>_index64_nan;
-        } else {
-            ndf.func = <%=c_iter%>_index64;
-        }
-<% else %>
         ndf.func = <%=c_iter%>_index64;
-<% end %>
+      <% if is_float %>
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index64_nan);
+      <% else %>
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+      <% end %>
     } else {
         aout[0].type = numo_cInt32;
         idx = nary_new(numo_cInt32, na->ndim, na->shape);
-<% if is_float %>
-        if (ignore_nan) {
-            ndf.func = <%=c_iter%>_index32_nan;
-        } else {
-            ndf.func = <%=c_iter%>_index32;
-        }
-<% else %>
         ndf.func = <%=c_iter%>_index32;
-<% end %>
+      <% if is_float %>
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index32_nan);
+      <% else %>
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+      <% end %>
     }
     rb_funcall(idx, rb_intern("seq"), 0);
 

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

@@ -28,24 +28,22 @@ static void
   <%=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.
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
   @return [Numo::<%=class_name%>] <%=name%> of self.
 */
 static VALUE
 <%=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|NDF_FLAT_REDUCE|NDF_CUM,
                      2, 1, ain, aout };
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ignore_nan);
-<% if is_float %>
-    if (ignore_nan) {
-        ndf.func = <%=c_iter%>_nan;
-    }
-<% end %>
+  <% 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/numo/narray/gen/tmpl/median.c

@@ -34,34 +34,31 @@ static void
 /*
   <%=name%> of self.
 <% if is_float %>
-  @overload <%=name%>(axis:nil, nan:false)
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+  @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)
+  @overload <%=name%>(axis:nil, keepdims:false)
 <% end %>
-  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @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 [Numo::<%=class_name%>] returns <%=name%> of self.
 */
 
 static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
-    int nan = 0;
     VALUE 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
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &nan); // v[0] = self
-<% if is_float %>
-    if (nan) {
-        ndf.func = <%=c_iter%>_prnan;
-    } else {
-        ndf.func = <%=c_iter%>_ignan;
-    }
-<% else %>
+  <% 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%>;
-<% end %>
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+  <% end %>
     return na_ndloop(&ndf, 2, self, reduce);
 }

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

@@ -20,28 +20,27 @@ static void
 /*
   <%=name%> of self.
 <% if is_float %>
-  @overload <%=name%>(axis:nil, nan:false)
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+  @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)
+  @overload <%=name%>(axis:nil, keepdims:false)
 <% end %>
-  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @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 [Numo::<%=class_name%>,Numo::<%=class_name%>] min and max of self.
 */
 static VALUE
 <%=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[2] = {{cT,0},{cT,0}};
     ndfunc_t ndf = {<%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 2,2, ain,aout};
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ignore_nan);
-<% if is_float %>
-    if (ignore_nan) {
-        ndf.func = <%=c_iter%>_nan;
-    }
-<% end %>
+  <% 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/numo/narray/gen/tmpl/set2.c

@@ -48,7 +48,7 @@ static void
 static VALUE
 <%=c_func(1)%>(VALUE self, VALUE a1)
 {
-    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{<%=tpclass%>,0}};
+    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);

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

@@ -28,7 +28,6 @@ static void
 static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
-    int nan = 0;
     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};
@@ -36,16 +35,13 @@ static VALUE
     if (!TEST_INPLACE(self)) {
         self = na_copy(self);
     }
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &nan); // v[0] = self
-<% if is_float %>
-    if (nan) {
-        ndf.func = <%=c_iter%>_prnan;
-    } else {
-        ndf.func = <%=c_iter%>_ignan;
-    }
-<% else %>
+  <% 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%>;
-<% end %>
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+  <% end %>
     na_ndloop(&ndf, 2, self, reduce);
     return self;
 }

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

@@ -55,7 +55,6 @@ static void
 static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
-    int nan = 0;
     size_t size;
     narray_t *na;
     VALUE idx, tmp, reduce, res;
@@ -64,8 +63,6 @@ static VALUE
     ndfunc_arg_out_t aout[1] = {{0,0,0}};
     ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_CUM, 3,1, ain,aout};
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &nan); // v[0] = self
-
     GetNArray(self,na);
     if (na->ndim==0) {
         return INT2FIX(0);
@@ -74,28 +71,26 @@ static VALUE
         ain[1].type =
         aout[0].type = numo_cInt64;
         idx = nary_new(numo_cInt64, na->ndim, na->shape);
-<% if is_float %>
-        if (nan) {
-            ndf.func = <%=type_name%>_index64_qsort_prnan;
-        } else {
-            ndf.func = <%=type_name%>_index64_qsort_ignan;
-        }
-<% else %>
-        ndf.func = <%=type_name%>_index64_qsort;
-<% end %>
+       <% if is_float %>
+         ndf.func = <%=type_name%>_index64_qsort_ignan;
+         reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf,
+                                      <%=type_name%>_index64_qsort_prnan);
+       <% else %>
+         ndf.func = <%=type_name%>_index64_qsort;
+         reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+       <% end %>
     } else {
         ain[1].type =
         aout[0].type = numo_cInt32;
         idx = nary_new(numo_cInt32, na->ndim, na->shape);
-<% if is_float %>
-        if (nan) {
-            ndf.func = <%=type_name%>_index32_qsort_prnan;
-        } else {
-            ndf.func = <%=type_name%>_index32_qsort_ignan;
-        }
-<% else %>
-        ndf.func = <%=type_name%>_index32_qsort;
-<% end %>
+       <% if is_float %>
+         ndf.func = <%=type_name%>_index32_qsort_ignan;
+         reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf,
+                                      <%=type_name%>_index32_qsort_prnan);
+       <% else %>
+         ndf.func = <%=type_name%>_index32_qsort;
+         reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+       <% end %>
     }
     rb_funcall(idx, rb_intern("seq"), 0);
 

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

@@ -51,7 +51,7 @@ static VALUE
 <%=c_func(0)%>(VALUE self)
 {
     ndfunc_arg_in_t ain[1] = {{cT,0}};
-    ndfunc_arg_out_t aout[1] = {{<%=tpclass%>,0}};
+    ndfunc_arg_out_t aout[1] = {{<%=result_class%>,0}};
     ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 1, ain, aout };
 
     return na_ndloop(&ndf, 1, self);

data/ext/numo/narray/gen/tmpl_bit/bit_count.c

@@ -66,8 +66,9 @@ static void
 /*
   Returns the number of bits.
   If argument is supplied, return Int-array counted along the axes.
-  @overload <%=op_map%>(axis:nil)
-  @param [Integer,Array,Range] axis  axes to be counted.
+  @overload <%=op_map%>(axis:nil, keepdims:false)
+  @param [Integer,Array,Range] axis (keyword) axes to be counted.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
   @return [Numo::Int64]
 */
 static VALUE
@@ -78,7 +79,7 @@ static VALUE
     ndfunc_arg_out_t aout[1] = {{numo_cInt64,0}};
     ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, 0);
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
     v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
     return rb_funcall(v,rb_intern("extract"),0);
 }

data/ext/numo/narray/gen/tmpl_bit/bit_reduce.c

@@ -98,8 +98,9 @@ static void
   Return true if all of bits are one (true).
 <% end %>
   If argument is supplied, return Bit-array reduced along the axes.
-  @overload <%=op_map%>(axis:nil)
-  @param [Integer,Array,Range] axis  axes to be reduced.
+  @overload <%=op_map%>(axis:nil, keepdims:false)
+  @param [Integer,Array,Range] axis (keyword) axes to be reduced.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
   @return [Numo::Bit] .
 */
 static VALUE
@@ -110,7 +111,7 @@ static VALUE
     ndfunc_arg_out_t aout[1] = {{numo_cBit,0}};
     ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 3,1, ain,aout};
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, 0);
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
     v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(<%=init_bit%>));
     if (argc > 0) {
         return v;