numo-narray 0.9.0.4 → 0.9.0.5

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

@@ -1,5 +1,3 @@
-# Define ID
-
 def_id "cast"
 def_id "eq"
 def_id "ne"
@@ -15,7 +13,11 @@ if is_float
   def_id "nearly_eq"
   def_id "copysign"
 end
-if is_comparable
+if is_int
+  def_id "<<","left_shift"
+  def_id ">>","right_shift"
+end
+if is_comparable && !is_object
   def_id "gt"
   def_id "ge"
   def_id "lt"
@@ -37,70 +39,96 @@ if is_object
   def_id "nan?"
   def_id "infinite?"
   def_id "finite?"
-  def_id "==","op_eq"
-  def_id "!=","op_ne"
-  def_id ">" ,"op_gt"
-  def_id ">=","op_ge"
-  def_id "<" ,"op_lt"
-  def_id "<=","op_le"
-  def_id "<=>","op_ufo"
+  def_id "==","eq"
+  def_id "!=","ne"
+  def_id ">" ,"gt"
+  def_id ">=","ge"
+  def_id "<" ,"lt"
+  def_id "<=","le"
+  def_id "<=>","ufo"
 end
 
 if is_int && !is_object
   def_id "minlength" # for bincount
 end
 
-# Allocation
+# Constatnts
+
+if is_bit
+  def_const "ELEMENT_BIT_SIZE",  "INT2FIX(1)"
+  def_const "ELEMENT_BYTE_SIZE", "rb_float_new(1.0/8)"
+  def_const "CONTIGUOUS_STRIDE", "INT2FIX(1)"
+else
+  def_const "ELEMENT_BIT_SIZE",  "INT2FIX(sizeof(dtype)*8)"
+  def_const "ELEMENT_BYTE_SIZE", "INT2FIX(sizeof(dtype))"
+  def_const "CONTIGUOUS_STRIDE", "INT2FIX(sizeof(dtype))"
+end
+
+# Un-define
 
 if is_object
-  def_allocate "robj_allocate"
+  undef_singleton_method "from_binary"
+  undef_method "to_binary"
+  undef_method "swap_byte"
+  undef_method "to_network"
+  undef_method "to_vacs"
+  undef_method "to_host"
+  undef_method "to_swapped"
 end
-def_method "allocate", 0
+
+# Allocation
+
+def_alloc_func "alloc_func"
+def_method "allocate"
 
 # Type conversion
 
-def_method "extract", 0
-store_numeric
-store_bit "Bit"
-if is_complex
-  store_from "DComplex","dcomplex","m_from_dcomplex"
-  store_from "SComplex","scomplex","m_from_scomplex"
-end
-store_from "DFloat","double",   "m_from_real"
-store_from "SFloat","float",    "m_from_real"
-store_from "Int64", "int64_t",  "m_from_real"
-store_from "Int32", "int32_t",  "m_from_real"
-store_from "Int16", "int16_t",  "m_from_real"
-store_from "Int8",  "int8_t",   "m_from_real"
-store_from "UInt64","u_int64_t","m_from_real"
-store_from "UInt32","u_int32_t","m_from_real"
-store_from "UInt16","u_int16_t","m_from_real"
-store_from "UInt8", "u_int8_t", "m_from_real"
+def_method "extract"
+def_method "new_dim0"
 
-store_from "RObject", "VALUE",  "m_num_to_data"
+def_method "store" do
+  extend StoreFrom
+  store_numeric
+  store_from "Bit"
+  if is_complex
+    store_from "DComplex","dcomplex","m_from_dcomplex"
+    store_from "SComplex","scomplex","m_from_scomplex"
+  end
+  store_from "DFloat","double",   "m_from_real"
+  store_from "SFloat","float",    "m_from_real"
+  store_from "Int64", "int64_t",  "m_from_real"
+  store_from "Int32", "int32_t",  "m_from_real"
+  store_from "Int16", "int16_t",  "m_from_real"
+  store_from "Int8",  "int8_t",   "m_from_real"
+  store_from "UInt64","u_int64_t","m_from_real"
+  store_from "UInt32","u_int32_t","m_from_real"
+  store_from "UInt16","u_int16_t","m_from_real"
+  store_from "UInt8", "u_int8_t", "m_from_real"
+  store_from "RObject", "VALUE",  "m_num_to_data"
+  store_array
+end
 
-store_array
-cast_array
+def_method "extract_data"
 
-def_method "store", 1
-def_singleton "cast", 1
+def_method "cast_array"
+def_singleton_method "cast"
 
-def_method "aref", -1, "aref", :op=>"[]"
-def_method "aset", -1, "aset", :op=>"[]="
+def_method "aref", op:"[]"
+def_method "aset", op:"[]="
 
-def_method "coerce_cast", 1
-def_method "to_a", 0
-def_method "fill", 1
-def_method "format", -1
-def_method "format_to_a", -1
-def_method "inspect", 0
+def_method "coerce_cast"
+def_method "to_a"
+def_method "fill"
+def_method "format"
+def_method "format_to_a"
+def_method "inspect"
 
 
 # Array manipulation
 
-def_method "each", 0
+def_method "each"
 unary "map" if !is_bit
-def_method "each_with_index", 0
+def_method "each_with_index"
 
 if is_bit
   unary  "copy"
@@ -116,12 +144,13 @@ if is_bit
   def_alias "count_0","count_false"
   bit_reduce "all?", 1
   bit_reduce "any?", 0
-  def_method "none?", -1, "none_p"
-  def_method "where", 0
-  def_method "where2", 0
-  def_method "mask", 1
+  def_method "none?", "none_p"
+  def_method "where"
+  def_method "where2"
+  def_method "mask"
 else
-def_method "map_with_index", 0
+
+def_method "map_with_index"
 
 # Arithmetic
 
@@ -142,6 +171,7 @@ pow
 unary "minus", "-@"
 unary "reciprocal"
 unary "sign"
+unary "square"
 
 # Complex
 
@@ -157,8 +187,8 @@ if is_complex
   def_alias "imag=","set_imag"
   def_alias "real=","set_real"
 else
-  def_alias "conj", "copy"
-  def_alias "im", "copy"
+  def_alias "conj", "view"
+  def_alias "im", "view"
 end
 
 def_alias "conjugate","conj"
@@ -182,12 +212,14 @@ if is_int
   binary "bit_or" , "|"
   binary "bit_xor", "^"
   unary  "bit_not", "~"
+  binary "left_shift", "<<"
+  binary "right_shift", ">>"
   if !is_object
-    def_alias "floor", "copy"
-    def_alias "round", "copy"
-    def_alias "ceil",  "copy"
-    def_alias "trunc", "copy"
-    def_alias "rint",  "copy"
+    def_alias "floor", "view"
+    def_alias "round", "view"
+    def_alias "ceil",  "view"
+    def_alias "trunc", "view"
+    def_alias "rint",  "view"
   end
 end
 
@@ -199,6 +231,10 @@ if is_float
   if !is_object
     unary "rint"
     binary "copysign"
+    if !is_complex
+      cond_unary "signbit"
+      def_method "modf", "unary_ret2"
+    end
   end
 end
 
@@ -211,6 +247,7 @@ if is_comparable
   def_alias ">=","ge"
   def_alias "<", "lt"
   def_alias "<=","le"
+  def_method "clip"
 end
 
 # Float
@@ -218,6 +255,8 @@ end
 if is_float
   cond_unary "isnan"
   cond_unary "isinf"
+  cond_unary "isposinf"
+  cond_unary "isneginf"
   cond_unary "isfinite"
 end
 
@@ -237,13 +276,14 @@ end
 if is_comparable
   accum "min","dtype","cT"
   accum "max","dtype","cT"
+  accum "ptp","dtype","cT"
   accum_index "max_index"
   accum_index "min_index"
-  def_method "minmax",-1
+  def_method "minmax"
 end
 
 if is_int && !is_object
-  def_method "bincount",-1
+  def_method "bincount"
 end
 
 cum "cumsum","add"
@@ -258,33 +298,57 @@ accum_binary "mulsum"
 # shuffle
 # histogram
 
-def_method "seq",-1
+def_method "seq"
 if is_float
-  def_method "logseq",-1
+  def_method "logseq"
 end
-def_method "eye",-1
+def_method "eye"
 def_alias  "indgen", "seq"
 
-def_method "rand", -1
+def_method "rand"
 if is_float && !is_object
-  def_method "rand_norm", -1
+  def_method "rand_norm"
 end
 
 # y = a[0] + a[1]*x + a[2]*x^2 + a[3]*x^3 + ... + a[n]*x^n
-def_method "poly",-2
+def_method "poly"
 
 if is_comparable && !is_object
-  qsort type_name,"dtype","*(dtype*)"
-  def_method "sort",-1
-  qsort type_name+"_index","dtype*","**(dtype**)"
-  def_method "sort_index",-1
-  def_method "median",-1
+  if is_float
+    qsort type_name,"dtype","*(dtype*)","_prnan"
+    qsort type_name,"dtype","*(dtype*)","_ignan"
+  else
+    qsort type_name,"dtype","*(dtype*)"
+  end
+  def_method "sort"
+  if is_float
+    qsort type_name+"_index","dtype*","**(dtype**)","_prnan"
+    qsort type_name+"_index","dtype*","**(dtype**)","_ignan"
+  else
+    qsort type_name+"_index","dtype*","**(dtype**)"
+  end
+  def_method "sort_index"
+  def_method "median"
 end
 
 # Math
 # histogram
 
 if has_math
+fn = get(:full_class_name)
+cn = get(:class_name)
+nm = get(:name)
+is_c = is_complex
+
+def_module do
+  extend NMathMethod
+  set ns_var: "cT"
+  set class_name: cn
+  set name: "#{nm}_math"
+  set full_module_name: fn+"::NMath"
+  set module_name: "Math"
+  set module_var: "mTM"
+
   math "sqrt"
   math "cbrt"
   math "log"
@@ -305,12 +369,18 @@ if has_math
   math "asinh"
   math "acosh"
   math "atanh"
-  if !is_complex
+  math "sinc"
+  if !is_c
     math "atan2",2
     math "hypot",2
     math "erf"
     math "erfc"
+    math "log1p"
+    math "expm1"
     math "ldexp",2
+    math "frexp",1,"frexp"
   end
 end
 end
+
+end # other than Bit

data/ext/numo/narray/gen/tmpl/accum.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   n;
     char    *p1, *p2;
@@ -9,27 +10,39 @@ static void
     INIT_PTR(lp, 0, p1, s1);
     p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
 
-    *(<%=dtype%>*)p2 = f_<%=method%>(n,p1,s1);
+    *(<%=dtype%>*)p2 = f_<%=name%><%=j%>(n,p1,s1);
 }
+<% 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.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+<% else %>
+  @overload <%=name%>(axis:nil)
+<% end %>
+  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @return [Numo::<%=class_name%>] returns result of <%=name%>.
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=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_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 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 %>
     v =  na_ndloop(&ndf, 2, self, reduce);
 <% if tpclass == "cT" %>
-    return numo_<%=tp%>_extract(v);
+    return <%=type_name%>_extract(v);
 <% else %>
     return rb_funcall(v,rb_intern("extract"),0);
 <% end %>

data/ext/numo/narray/gen/tmpl/accum_binary.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, *p3;
@@ -16,7 +17,7 @@ static void
         for (; i--;) {
             GET_DATA_STRIDE(p1,s1,dtype,x);
             GET_DATA_STRIDE(p2,s2,dtype,y);
-            m_<%=method%>(x,y,z);
+            m_<%=name%><%=j%>(x,y,z);
         }
         SET_DATA(p3,dtype,z);
     } else {
@@ -24,16 +25,17 @@ static void
             GET_DATA_STRIDE(p1,s1,dtype,x);
             GET_DATA_STRIDE(p2,s2,dtype,y);
             GET_DATA(p3,dtype,z);
-            m_<%=method%>(x,y,z);
+            m_<%=name%><%=j%>(x,y,z);
             SET_DATA_STRIDE(p3,s3,dtype,z);
         }
     }
 }
-
+<% end %>
 
 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}};
@@ -46,20 +48,34 @@ 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);
-    v =  na_ndloop(&ndf, 4, self, argv[0], reduce, m_<%=method%>_init);
-    return numo_<%=tp%>_extract(v);
+    reduce = na_reduce_dimension(argc-1, argv+1, 2, naryv, &ignore_nan);
+<% if is_float %>
+    if (ignore_nan) {
+        ndf.func = <%=c_iter%>_nan;
+    }
+<% end %>
+    v =  na_ndloop(&ndf, 4, self, argv[0], reduce, m_<%=name%>_init);
+    return <%=type_name%>_extract(v);
 }
 
-
 /*
-  Binary <%=method%>.
-  @overload <%=op_map%> other
+  Binary <%=name%>.
+
+<% if is_float %>
+  @overload <%=op_map%>(other, axis:nil, nan:false)
+  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+<% else %>
+  @overload <%=op_map%>(other, axis:nil)
+<% end %>
   @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] <%=method%> of self and other.
+  @param [Numeric,Array,Range] axis  Affected dimensions.
+<% if is_float %>
+  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+<% end %>
+  @return [Numo::NArray] <%=name%> of self and other.
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     <% if !is_object %>
     VALUE klass, v;
@@ -75,7 +91,7 @@ static VALUE
         return <%=c_func%>_self(argc, argv, self);
     } else {
         v = rb_funcall(klass, id_cast, 1, self);
-        return rb_funcall2(v, rb_intern("<%=method%>"), argc, argv);
+        return rb_funcall2(v, rb_intern("<%=name%>"), argc, argv);
     }
     <% end %>
 }