numo-narray 0.9.1.4 → 0.9.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aba2ab60aae2fbf24973f75a9b17c9f35bd7fec15c58e110b6711a62773b2de0
-  data.tar.gz: feae74cc5b9d5dfbe238f78f60b22f017a4558b241fe772b0615ac3fa0c80b68
+  metadata.gz: 2723cec3e04deedc561c54a0d4f6af799dd93fc8a32079d06a074f00f07f466c
+  data.tar.gz: 5548cfa23b0ac7227b62ab8edd00ba040805c0563befeb32591179dc090eff66
 SHA512:
-  metadata.gz: f7af93ba0ac1b6732fa9bbe22f72572ecdd8c9142861c0a12ca9124eb2094fef512923ce6040a52576c835ebde4b9a697af973e68c97a9703430f92ad5d6442b
-  data.tar.gz: b413079a3a924e698b074183d462397bd306bad255e619d1e58b52c623c175d93ca5ad72dbf17a84becc21172f10cc0cba4ea6c5d8c291cc706e20e0ff867d2e
+  metadata.gz: 19a91712b943da6f57f2cda4fa178adcb5a0c845c2b0ce8190f46c5c1a0d83a331fd32d71e9b2b85c960222f4a01940926bacba63eb882ea1b27aebb7a09c7a3
+  data.tar.gz: 4ee3a88369439ccf964fd23358a84530973c5355d4c71b35eda516bd655966ce127d494159c942bf0a82045b3f05a6be7ed16f4d9d30b96916df651c9a5ec0cb

data/README.md

@@ -11,17 +11,17 @@ for fast processing and easy manipulation of multi-dimensional numerical data,
 similar to numpy.ndaray.
 This project is the successor to [Ruby/NArray](http://masa16.github.io/narray/).
 
-under development
-
 ## Documentation
+
 All documents are primitive.
 
-* [Numo::NArray API Doc](http://ruby-numo.github.io/narray/narray/frames.html)
+* [Numo::NArray API Doc](http://ruby-numo.github.io/numo-narray/yard/index.html)
 * [Numo::NArray vs numpy](https://github.com/ruby-numo/numo-narray/wiki/Numo-vs-numpy)
 * [Numo::NArray vs ndarray](https://github.com/ruby-numo/numo-narray/wiki/Numo-vs-ndarray)
 * [Numo::NArray Overview](https://github.com/ruby-numo/numo-narray/wiki/Numo::NArray%E6%A6%82%E8%A6%81) (in Japanese)
 
 ## Related Projects
+
 * [Numo::Linalg](https://github.com/ruby-numo/numo-linalg) - Linear Algebra library with [LAPACK](http://www.netlib.org/lapack/).
 * [Numo::GSL](https://github.com/ruby-numo/numo-gsl) - Ruby interface for [GSL (GNU Scientific Library)](http://www.gnu.org/software/gsl/).
 * [Numo::FFTW](https://github.com/ruby-numo/numo-fftw) - Ruby/Numo interface to [FFTW (A Discrete Fourier Transform library](http://www.fftw.org/).
@@ -29,10 +29,13 @@ All documents are primitive.
 * [Numo::Gnuplot](https://github.com/ruby-numo/numo-gnuplot) - Simple and easy-to-use Gnuplot interface.
 
 ## Installation
+
 ### Requirement
-Ruby ver 2.1 and later.
+
+Ruby ver 2.2 and later.
 
 ### Ubuntu, Debian, Bash on Windows
+
 ```shell
 apt install -y git ruby gcc ruby-dev rake make
 gem install specific_install
@@ -40,7 +43,9 @@ gem specific_install https://github.com/ruby-numo/numo-narray.git
 ```
 
 ## Quick start
+
 An example
+
 ```ruby
 [1] pry(main)> require "numo/narray"
 => true
@@ -58,6 +63,7 @@ An example
 [6] pry(main)> a.size
 => 15
 ```
+
 For more examples, check out this [narray version of 100 numpy exercises](https://github.com/ruby-numo/numo-narray/wiki/100-narray-exercises) (and the [IRuby Notebook](https://github.com/ruby-numo/numo-narray/blob/master/100-narray-exercises.ipynb)).
 
 ## Development

data/ext/numo/narray/array.c

@@ -1,7 +1,7 @@
 /*
   array.c
-  Numerical Array Extension for Ruby
-    (C) Copyright 1999-2017 by Masahiro TANAKA
+  Ruby/Numo::NArray - Numerical Array class for Ruby
+    Copyright (C) 1999-2019 Masahiro TANAKA
 */
 #include <ruby.h>
 #include "numo/narray.h"
@@ -122,10 +122,12 @@ static int na_mdai_object_type(int type, VALUE v)
     if (rb_obj_is_kind_of(v, rb_cRange)) {
         MDAI_ATTR_TYPE(type,v,begin);
         MDAI_ATTR_TYPE(type,v,end);
-    } else if (rb_obj_is_kind_of(v, na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+    } else if (rb_obj_is_kind_of(v, rb_cArithSeq)) {
         MDAI_ATTR_TYPE(type,v,begin);
         MDAI_ATTR_TYPE(type,v,end);
         MDAI_ATTR_TYPE(type,v,step);
+#endif
     } else {
         type = na_object_type(type,v);
     }
@@ -210,7 +212,13 @@ na_mdai_investigate(na_mdai_t *mdai, int ndim)
             }
         }
         else
-        if (rb_obj_is_kind_of(v, rb_cRange) || rb_obj_is_kind_of(v, na_cStep)) {
+        if (rb_obj_is_kind_of(v, rb_cRange)
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+            || rb_obj_is_kind_of(v, rb_cArithSeq)
+#else
+            || rb_obj_is_kind_of(v, rb_cEnumerator)
+#endif
+            ) {
             nary_step_sequence(v,&length,&dbeg,&dstep);
             len += length-1;
             mdai->type = na_mdai_object_type(mdai->type, v);
@@ -465,11 +473,13 @@ na_s_array_shape(VALUE mod, VALUE ary)
   @return [Numo::NArray]
   @example
     Numo::NArray.new_like([[1,2,3],[4,5,6]])
-    => Numo::Int32#shape=[2,3](empty)
+    # => Numo::Int32#shape=[2,3](empty)
+
     Numo::DFloat.new_like([[1,2],[3,4]])
-    => Numo::DFloat#shape=[2,2](empty)
+    # => Numo::DFloat#shape=[2,2](empty)
+
     Numo::NArray.new_like([1,2i,3])
-    => Numo::DComplex#shape=[3](empty)
+    # => Numo::DComplex#shape=[3](empty)
 */
 VALUE
 na_s_new_like(VALUE type, VALUE obj)

data/ext/numo/narray/data.c

@@ -1,7 +1,7 @@
 /*
   data.c
-  Numerical Array Extension for Ruby
-    (C) Copyright 1999-2017 by Masahiro TANAKA
+  Ruby/Numo::NArray - Numerical Array class for Ruby
+    Copyright (C) 1999-2019 Masahiro TANAKA
 */
 
 #include <ruby.h>
@@ -186,21 +186,21 @@ check_axis(int axis, int ndim)
   @example
     x = Numo::Int32[[1,2,3]]
 
-    p x.swapaxes(0,1)
-    # Numo::Int32(view)#shape=[3,1]
+    x.swapaxes(0,1)
+    # => Numo::Int32(view)#shape=[3,1]
     # [[1],
     #  [2],
     #  [3]]
 
-    p x = Numo::Int32[[[0,1],[2,3]],[[4,5],[6,7]]]
-    # Numo::Int32#shape=[2,2,2]
+    x = Numo::Int32[[[0,1],[2,3]],[[4,5],[6,7]]]
+    # => Numo::Int32#shape=[2,2,2]
     # [[[0, 1],
     #   [2, 3]],
     #  [[4, 5],
     #   [6, 7]]]
 
-    p x.swapaxes(0,2)
-    # Numo::Int32(view)#shape=[2,2,2]
+    x.swapaxes(0,2)
+    # => Numo::Int32(view)#shape=[2,2,2]
     # [[[0, 4],
     #   [2, 6]],
     #  [[1, 5],
@@ -457,7 +457,7 @@ VALUE
 na_flatten_dim(VALUE self, int sd)
 {
     int i, nd, fd;
-    size_t j;
+    size_t j, ofs;
     size_t *c, *pos, *idx1, *idx2;
     size_t stride;
     size_t  *shape, size;
@@ -501,7 +501,6 @@ na_flatten_dim(VALUE self, int sd)
     case NARRAY_FILEMAP_T:
         stride = nary_element_stride(self);
         for (i=sd+1; i--; ) {
-            //printf("data: i=%d shpae[i]=%ld stride=%ld\n",i,shape[i],stride);
             SDX_SET_STRIDE(na2->stridx[i],stride);
             stride *= shape[i];
         }
@@ -522,32 +521,35 @@ na_flatten_dim(VALUE self, int sd)
                 SDX_SET_INDEX(na2->stridx[i],idx2);
             } else {
                 na2->stridx[i] = na1->stridx[i];
-                //printf("view: i=%d stridx=%d\n",i,SDX_GET_STRIDE(sdx));
             }
         }
         // flat dimenion == last dimension
         if (RTEST(na_check_ladder(self,sd))) {
-        //if (0) {
             na2->stridx[sd] = na1->stridx[nd-1];
         } else {
             // set index
-            idx2 = ALLOC_N(size_t, shape[sd]);
+            idx2 = ALLOC_N(size_t, (shape[sd]==0) ? 1 : shape[sd]);
             SDX_SET_INDEX(na2->stridx[sd],idx2);
             // init for md-loop
             fd = nd-sd;
-            c = ALLOC_N(size_t, fd);
+            c = ALLOCA_N(size_t, fd);
             for (i=0; i<fd; i++) c[i]=0;
-            pos = ALLOC_N(size_t, fd+1);
+            pos = ALLOCA_N(size_t, fd+1);
             pos[0] = 0;
             // md-loop
             for (i=j=0;;) {
                 for (; i<fd; i++) {
                     sdx = na1->stridx[i+sd];
                     if (SDX_IS_INDEX(sdx)) {
-                        pos[i+1] = pos[i] + SDX_GET_INDEX(sdx)[c[i]];
+                        if (SDX_GET_INDEX(sdx)) {
+                            ofs = SDX_GET_INDEX(sdx)[c[i]];
+                        } else {
+                            ofs = 0;
+                        }
                     } else {
-                        pos[i+1] = pos[i] + SDX_GET_STRIDE(sdx)*c[i];
+                        ofs = SDX_GET_STRIDE(sdx)*c[i];
                     }
+                    pos[i+1] = pos[i] + ofs;
                 }
                 idx2[j++] = pos[i];
                 for (;;) {
@@ -559,8 +561,7 @@ na_flatten_dim(VALUE self, int sd)
                 }
             }
         loop_end:
-            xfree(pos);
-            xfree(c);
+            ;
         }
         break;
     }
@@ -589,28 +590,30 @@ na_flatten(VALUE self)
   @return [Numo::NArray]  diagonal view of NArray.
   @example
     a = Numo::DFloat.new(4,5).seq
-    => Numo::DFloat#shape=[4,5]
-    [[0, 1, 2, 3, 4],
-     [5, 6, 7, 8, 9],
-     [10, 11, 12, 13, 14],
-     [15, 16, 17, 18, 19]]
+    # => Numo::DFloat#shape=[4,5]
+    # [[0, 1, 2, 3, 4],
+    #  [5, 6, 7, 8, 9],
+    #  [10, 11, 12, 13, 14],
+    #  [15, 16, 17, 18, 19]]
     b = a.diagonal(1)
-    => Numo::DFloat(view)#shape=[4]
-    [1, 7, 13, 19]
+    # => Numo::DFloat(view)#shape=[4]
+    # [1, 7, 13, 19]
+
     b.store(0)
     a
-    => Numo::DFloat#shape=[4,5]
-    [[0, 0, 2, 3, 4],
-     [5, 6, 0, 8, 9],
-     [10, 11, 12, 0, 14],
-     [15, 16, 17, 18, 0]]
+    # => Numo::DFloat#shape=[4,5]
+    # [[0, 0, 2, 3, 4],
+    #  [5, 6, 0, 8, 9],
+    #  [10, 11, 12, 0, 14],
+    #  [15, 16, 17, 18, 0]]
+
     b.store([1,2,3,4])
     a
-    => Numo::DFloat#shape=[4,5]
-    [[0, 1, 2, 3, 4],
-     [5, 6, 2, 8, 9],
-     [10, 11, 12, 3, 14],
-     [15, 16, 17, 18, 4]]
+    # => Numo::DFloat#shape=[4,5]
+    # [[0, 1, 2, 3, 4],
+    #  [5, 6, 2, 8, 9],
+    #  [10, 11, 12, 3, 14],
+    #  [15, 16, 17, 18, 4]]
  */
 static VALUE
 na_diagonal(int argc, VALUE *argv, VALUE self)

data/ext/numo/narray/extconf.rb

@@ -83,6 +83,7 @@ unless have_type("u_int64_t", stdint)
   have_type("uint64_t", stdint)
 end
 have_func("exp10")
+have_func("rb_arithmetic_sequence_extract")
 
 have_var("rb_cComplex")
 

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

@@ -57,6 +57,10 @@ module NArrayMethod
     def_method(meth, "accum_index")
   end
 
+  def accum_arg(meth)
+    def_method(meth, "accum_arg")
+  end
+
   def cum(meth, cmacro)
     def_method(meth, "cum", cmacro:cmacro)
   end

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

@@ -303,6 +303,8 @@ if is_comparable
   accum "ptp","dtype","cT"
   accum_index "max_index"
   accum_index "min_index"
+  accum_arg   "argmax"
+  accum_arg   "argmin"
   def_method "minmax"
   def_module_function "maximum", "ewcomp", n_arg:2
   def_module_function "minimum", "ewcomp", n_arg:2
@@ -366,6 +368,7 @@ cn = get(:class_name)
 nm = get(:name)
 st = get(:simd_type)
 dp = get(:is_double_precision)
+algn = get(:need_align)
 is_c = is_complex
 
 def_module do
@@ -377,8 +380,9 @@ def_module do
   set module_name: "Math"
   set module_var: "mTM"
   set simd_type: st
-  set is_double_precision: dp 
+  set is_double_precision: dp
   set is_complex: is_c
+  set need_align: algn
 
   math "sqrt"
   math "cbrt"

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

@@ -22,8 +22,8 @@ static void
 <% else %>
   @overload <%=name%>(axis:nil, keepdims:false)
 <% end %>
-  @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.
+  @param [Numeric,Array,Range] axis  Performs <%=name%> along the axis.
+  @param [TrueClass] keepdims  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

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

@@ -0,0 +1,88 @@
+<% (is_float ? ["","_nan"] : [""]).each do |j|
+   [64,32].each do |i| %>
+#define idx_t int<%=i%>_t
+static void
+<%=c_iter%>_arg<%=i%><%=j%>(na_loop_t *const lp)
+{
+    size_t   n, idx;
+    char    *d_ptr, *o_ptr;
+    ssize_t  d_step;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, d_ptr, d_step);
+
+    idx = f_<%=name[3..5]%>_index<%=j%>(n,d_ptr,d_step);
+
+    o_ptr = NDL_PTR(lp,1);
+    *(idx_t*)o_ptr = (idx_t)idx;
+}
+#undef idx_t
+<% end;end %>
+
+/*
+  Index of the <%=name[3..5]%>imum value.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
+<% else %>
+  @overload <%=name%>(axis:nil)
+<% end %>
+  @param [Numeric,Array,Range] axis  Finds <%=name[3..5]%>imum values along the axis and returns **indices along the axis**.
+  @return [Integer,Numo::Int] returns the result indices.
+  @see #<%=name[3..5]%>_index
+  @see #<%=name[3..5]%>
+
+  @example
+<% case name; when /min/ %>
+      a = Numo::NArray[3,4,1,2]
+      a.argmin  #=> 2
+
+      b = Numo::NArray[[3,4,1],[2,0,5]]
+      b.argmin                       #=> 4
+      b.argmin(axis:1)               #=> [2, 1]
+      b.argmin(axis:0)               #=> [1, 1, 0]
+      b.at(b.argmin(axis:0), 0..-1)  #=> [2, 0, 1]
+<% when /max/ %>
+      a = Numo::NArray[3,4,1,2]
+      a.argmax  #=> 1
+
+      b = Numo::NArray[[3,4,1],[2,0,5]]
+      b.argmax                       #=> 5
+      b.argmax(axis:1)               #=> [1, 2]
+      b.argmax(axis:0)               #=> [0, 0, 1]
+      b.at(b.argmax(axis:0), 0..-1)  #=> [3, 4, 5]
+<% end %>
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    narray_t *na;
+    VALUE reduce;
+    ndfunc_arg_in_t ain[2] = {{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, 2,1, ain,aout};
+
+    GetNArray(self,na);
+    if (na->ndim==0) {
+        return INT2FIX(0);
+    }
+    if (na->size > (~(u_int32_t)0)) {
+        aout[0].type = numo_cInt64;
+        ndf.func = <%=c_iter%>_arg64;
+      <% if is_float %>
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_arg64_nan);
+      <% else %>
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+      <% end %>
+    } else {
+        aout[0].type = numo_cInt32;
+        ndf.func = <%=c_iter%>_arg32;
+      <% if is_float %>
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_arg32_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/accum_binary.c

@@ -70,7 +70,7 @@ static VALUE
   @overload <%=op_map%>(other, axis:nil, keepdims:false)
 <% end %>
   @param [Numo::NArray,Numeric] other
-  @param [Numeric,Array,Range] axis (keyword) Affected dimensions.
+  @param [Numeric,Array,Range] axis  Performs <%=name%> along the axis.
   @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 (keyword) If true, apply NaN-aware algorithm (avoid NaN if exists).

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

@@ -21,27 +21,38 @@ static void
 <% end;end %>
 
 /*
-  <%=name%>. Return an index of result.
+  Index of the <%=name[0..2]%>imum value.
 <% if is_float %>
   @overload <%=name%>(axis:nil, nan:false)
   @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
 <% else %>
   @overload <%=name%>(axis:nil)
 <% end %>
-  @param [Numeric,Array,Range] axis  Affected dimensions.
-  @return [Integer,Numo::Int] returns result index of <%=name%>.
+  @param [Numeric,Array,Range] axis  Finds <%=name[0..2]%>imum values along the axis and returns **flat 1-d indices**.
+  @return [Integer,Numo::Int] returns result indices.
+  @see #arg<%=name[0..2]%>
+  @see #<%=name[0..2]%>
+
   @example
-  <% if name == 'min_index' %>
-      Numo::NArray[3,4,1,2].min_index => 2
-      Numo::NArray[[3,4,1],[2,0,5]].min_index => 4
-      Numo::NArray[[3,4,1],[2,0,5]].min_index(axis: 1) => [2, 4]
-      Numo::NArray[[3,4,1],[2,0,5]].min_index(axis: 0) => [3, 4, 2]
-  <% else %>
-      Numo::NArray[3,4,1,2].max_index => 1
-      Numo::NArray[[3,4,1],[2,0,5]].max_index => 5
-      Numo::NArray[[3,4,1],[2,0,5]].max_index(axis: 1) => [1, 5]
-      Numo::NArray[[3,4,1],[2,0,5]].max_index(axis: 0) => [0, 1, 5]
-  <% end %>
+<% case name; when /min/ %>
+      a = Numo::NArray[3,4,1,2]
+      a.min_index  #=> 2
+
+      b = Numo::NArray[[3,4,1],[2,0,5]]
+      b.min_index             #=> 4
+      b.min_index(axis:1)     #=> [2, 4]
+      b.min_index(axis:0)     #=> [3, 4, 2]
+      b[b.min_index(axis:0)]  #=> [2, 0, 1]
+<% when /max/ %>
+      a = Numo::NArray[3,4,1,2]
+      a.max_index  #=> 1
+
+      b = Numo::NArray[[3,4,1],[2,0,5]]
+      b.max_index             #=> 5
+      b.max_index(axis:1)     #=> [1, 5]
+      b.max_index(axis:0)     #=> [0, 1, 5]
+      b[b.max_index(axis:0)]  #=> [3, 4, 5]
+<% end %>
  */
 static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)