numo-narray 0.9.0.4 → 0.9.0.5

data/ext/numo/narray/numo/types/xint_macro.h

@@ -28,10 +28,15 @@
 #define m_ge(x,y) ((x)>=(y))
 #define m_lt(x,y) ((x)<(y))
 #define m_le(x,y) ((x)<=(y))
+#define m_left_shift(x,y) ((x)<<(y))
+#define m_right_shift(x,y) ((x)>>(y))
+
 #define m_isnan(x) 0
 
 #define m_mulsum(x,y,z) {z += x*y;}
 #define m_mulsum_init INT2FIX(0)
+#define m_cumsum(x,y) {x += y;}
+#define m_cumprod(x,y) {x *= y;}
 
 #define cmp(a,b)                                        \
     ((qsort_cast(a)==qsort_cast(b)) ? 0 :               \
@@ -132,6 +137,36 @@ static inline size_t f_max_index(size_t n, char *p, ssize_t stride)
     return j;
 }
 
+static inline void
+f_minmax(size_t n, char *p, ssize_t stride, dtype* amin, dtype* amax)
+{
+    dtype x,min,max;
+    size_t i=n;
+
+    min = max = *(dtype*)p;
+    p += stride;
+    for (i--; i--;) {
+        x = *(dtype*)p;
+        if (m_gt(x,max)) {
+            max = x;
+        }
+        if (m_lt(x,min)) {
+            min = x;
+        }
+        p += stride;
+    }
+    *amin = min;
+    *amax = max;
+    return;
+}
+
+static inline dtype f_ptp(size_t n, char *p, ssize_t stride)
+{
+    dtype min,max;
+    f_minmax(n,p,stride,&min,&max);
+    return m_sub(max,min);
+}
+
 static inline double f_seq(double x, double y, double c)
 {
     return x + y * c;

data/ext/numo/narray/struct.c

@@ -1,7 +1,7 @@
 /*
-  nstrut.c
+  strut.c
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2016 by Masahiro TANAKA
+    (C) Copyright 1999-2017 by Masahiro TANAKA
 */
 #include <ruby.h>
 #include "numo/narray.h"
@@ -136,7 +136,7 @@ na_make_view_struct(VALUE self, VALUE dtype, VALUE offset)
     switch(na->type) {
     case NARRAY_DATA_T:
     case NARRAY_FILEMAP_T:
-        stride = na_get_elmsz(self);
+        stride = nary_element_stride(self);
         for (j=na->ndim; j--;) {
             SDX_SET_STRIDE(na2->stridx[j], stride);
             stride *= na->shape[j];
@@ -357,7 +357,7 @@ nstruct_add_type(VALUE type, int argc, VALUE *argv, VALUE nst)
         ndim = na->ndim;
         shape = na->shape;
     }
-    type = rb_narray_view_new(type,ndim,shape);
+    type = nary_view_new(type,ndim,shape);
     GetNArrayView(type,nt);
 
     nt->stridx = ALLOC_N(stridx_t,ndim);
@@ -419,6 +419,21 @@ iter_nstruct_to_a(na_loop_t *const lp)
     rb_ary_push(lp->args[1].value, vary);
 }
 
+static VALUE
+na_original_data(VALUE self)
+{
+    narray_t *na;
+    narray_view_t *nv;
+
+    GetNArray(self,na);
+    switch(na->type) {
+    case NARRAY_VIEW_T:
+        GetNArrayView(self, nv);
+        return nv->data;
+    }
+    return self;
+}
+
 static VALUE
 nst_create_member_views(VALUE self)
 {
@@ -541,14 +556,16 @@ nst_check_compatibility(VALUE nst, VALUE ary)
             }
         } else {
             // multi-dimension member
-            volatile VALUE vnc;
-            na_compose_t *nc;
+            //volatile VALUE vnc;
+            //na_compose_t *nc;
+            VALUE vnc;
+            narray_t *nc;
             int j;
 
-            //rb_p(item);
-            vnc = na_ary_composition(item);
-            //puts("pass2");
-            Data_Get_Struct(vnc, na_compose_t, nc);
+            //vnc = na_ary_composition(item);
+            //Data_Get_Struct(vnc, na_compose_t, nc);
+            vnc = na_s_new_like(cNArray, item);
+            GetNArray(vnc,nc);
             if (nt->ndim != nc->ndim) {
                 return Qfalse;
             }
@@ -603,9 +620,10 @@ iter_nstruct_from_a(na_loop_t *const lp)
 static VALUE
 nary_struct_cast_array(VALUE klass, VALUE rary)
 {
-    volatile VALUE vnc, nary;
+    //volatile VALUE vnc, nary;
+    VALUE nary;
     narray_t *na;
-    na_compose_t *nc;
+    //na_compose_t *nc;
     VALUE opt;
     ndfunc_arg_in_t ain[3] = {{OVERWRITE,0},{rb_cArray,0},{sym_option}};
     ndfunc_t ndf = {iter_nstruct_from_a, NO_LOOP, 3, 0, ain, 0};
@@ -613,9 +631,10 @@ nary_struct_cast_array(VALUE klass, VALUE rary)
     //fprintf(stderr,"rary:");rb_p(rary);
     //fprintf(stderr,"class_of(rary):");rb_p(CLASS_OF(rary));
 
-    vnc = na_ary_composition_for_struct(klass, rary);
-    Data_Get_Struct(vnc, na_compose_t, nc);
-    nary = rb_narray_new(klass, nc->ndim, nc->shape);
+    //vnc = na_ary_composition_for_struct(klass, rary);
+    //Data_Get_Struct(vnc, na_compose_t, nc);
+    //nary = nary_new(klass, nc->ndim, nc->shape);
+    nary = na_s_new_like(klass, rary);
     GetNArray(nary,na);
     //fprintf(stderr,"na->size=%lu\n",na->size);
     //fprintf(stderr,"na->ndim=%d\n",na->ndim);

data/lib/erbpp.rb

@@ -168,7 +168,10 @@ class Function < ErbPP
   def initialize(parent,tmpl,**opts)
     super
     @aliases = opts[:aliases] || []
-    @erb_path = File.join(parent.tmpl_dir, tmpl+".c")
+    parent.tmpl_dirs.each do |d|
+      @erb_path = File.join(d, tmpl+".c")
+      break if File.exist?(@erb_path)
+    end
     DEFS.push(self)
   end
 
@@ -207,6 +210,7 @@ class Function < ErbPP
   end
 
   def definition
+    return nil if n_arg <= -9
     s = singleton ? "_singleton" : ""
     check_params(:mod_var, :op_map, :c_func, :n_arg)
     m = op_map

data/lib/erbpp/line_number.rb

@@ -7,7 +7,7 @@ class CountLnString < String
     @str = ""
     @countln = 1
     @current = 1
-    super(report_line)
+    super("\n"+report_line)
   end
 
   def report_line
@@ -34,11 +34,14 @@ class CountLnString < String
     end
     return if n == @current
     if @current != @countln || @postpone
-      if /\A\s*\z/ =~ @str || /\A#line / =~ @buf || /\n\z/ !~ self
+      if /\A\s*\z/ =~ @str || /\A#line / =~ @buf
         @postpone = true
       elsif @in_comment
         @postpone = false
       else
+        if self[-1] != "\n"
+          concat("\n")
+        end
         concat(report_line)
         @postpone = false
       end
@@ -83,6 +86,10 @@ class CountLnString < String
     r
   end
 
+  def final
+    concat(@buf)
+  end
+
 end
 
 class ERB
@@ -120,7 +127,7 @@ class ERB
         line.sub!(/^;/,";_erbout.ln(#{num});")
       end
       line
-    end.join
+    end.join+";_erbout.final;"
   end
 
 end

data/lib/erbpp/narray_def.rb

@@ -55,6 +55,7 @@ module DefMethod
   end
 
   def cond_binary(meth,op=nil)
+    op = meth unless op
     def_method(meth, 1, "cond_binary", :op => op)
   end
 
@@ -89,23 +90,33 @@ module DefMethod
     def_method(meth, -1, "accum_binary", :op => ope)
   end
 
-  def qsort(tp, dtype, dcast)
-    h = {:tp => tp, :dtype => dtype, :dcast => dcast}
+  def qsort(tp, dtype, dcast, suffix="")
+    h = {:tp => tp, :dtype => dtype, :dcast => dcast, :suffix => suffix}
     NodefFunction.new(self, "qsort", h)
   end
 
-  def math(meth, n=1)
-    h = {:meth => meth, :mod_var => 'mTM', :n_arg => n}
-    case n
-    when 1
-      ModuleFunction.new(self, "unary_s", h)
-    when 2
-      ModuleFunction.new(self, "binary_s", h)
-    when 3
-      ModuleFunction.new(self, "ternary_s", h)
-    else
-      raise "invalid n=#{n}"
+  def def_mod_func(meth, n_arg, tmpl=nil, opts={})
+    h = {:meth => meth, :n_arg => n_arg}
+    h.merge!(opts)
+    tmpl ||= meth
+    ModuleFunction.new(self, tmpl, h)
+  end
+
+  def math(meth, n=1, tmpl=nil)
+    h = {:mod_var => 'mTM'}
+    if tmpl.nil?
+      case n
+      when 1
+        tmpl = "unary_s"
+      when 2
+        tmpl = "binary_s"
+      when 3
+        tmpl = "ternary_s"
+      else
+        raise "invalid n=#{n}"
+      end
     end
+    def_mod_func(meth, n, tmpl, h)
   end
 
   def store_numeric
@@ -156,11 +167,11 @@ class DataType < ErbPP
     @upcast = []
     @mod_var = "cT"
     load_type(type_file) if type_file
-    dir = template_dir || "tmpl"
-    @tmpl_dir = File.join(File.dirname(erb_path),dir)
+    dirs = template_dir || ["tmpl"]
+    @tmpl_dirs = dirs.map{|d| File.join(File.dirname(erb_path),d)}
   end
 
-  attr_reader :tmpl_dir
+  attr_reader :tmpl_dirs
 
   def load_type(file)
     eval File.read(file)
@@ -299,14 +310,33 @@ class Store < Function
     nil
   end
 
-  def condition
-    "rb_obj_is_kind_of(obj,#{tpclass})"
+  def condition(klass)
+    "#{klass}==#{tpclass}"
+  end
+
+  def extract_data(ptr,pos,x)
+    case tpname
+    when "bit"
+      "{BIT_DIGIT b; LOAD_BIT(#{ptr},#{pos},b); x = m_from_real(b);}"
+    when "robject"
+      "#{x} = m_num_to_data(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /complex/
+      "{#{dtype} *p = (#{dtype}*)(#{ptr}+#{pos}); #{x} = c_new(REAL(*p),IMAG(*p));}"
+    else
+      "#{x} = m_from_real(*(#{dtype}*)(#{ptr}+#{pos}))"
+    end
   end
 
   def self.definitions
     a = []
-    DEFS.each do |i|
-      a.push(i) if i.condition
+    DEFS.each do |x|
+      if x.condition("")
+        if x.tpname == x.parents[0].class_name.downcase
+          a.unshift(x)
+        else
+          a.push(x)
+        end
+      end
     end
     a
   end
@@ -317,8 +347,8 @@ class StoreNum < Store
     super(parent,tmpl,"numeric",nil,nil,nil)
   end
 
-  def condition
-    "FIXNUM_P(obj) || TYPE(obj)==T_FLOAT || TYPE(obj)==T_BIGNUM || rb_obj_is_kind_of(obj,rb_cComplex)"
+  def condition(klass)
+    "IS_INTEGER_CLASS(#{klass}) || #{klass}==rb_cFloat || #{klass}==rb_cComplex"
   end
 end
 
@@ -331,13 +361,13 @@ class StoreArray < Store
     "numo_#{tp}_#{tmpl}"
   end
 
-  def condition
-    "TYPE(obj)==T_ARRAY"
+  def condition(klass)
+    "#{klass}==rb_cArray"
   end
 end
 
 class CastArray < StoreArray
-  def condition
+  def condition(klass)
     nil
   end
 

data/lib/numo/narray/extra.rb

@@ -1,39 +1,342 @@
 module Numo
   class NArray
 
-    # p a = Numo::DFloat[[1, 2], [3, 4]]
-    # # Numo::DFloat#shape=[2,2]
-    # # [[1, 2],
-    # #  [3, 4]]
-    #
-    # p b = Numo::DFloat[[5, 6]]
-    # # Numo::DFloat#shape=[1,2]
-    # # [[5, 6]]
-    #
-    # p Numo::NArray.concatenate([a,b],axis:0)
-    # # Numo::DFloat#shape=[3,2]
-    # # [[1, 2],
-    # #  [3, 4],
-    # #  [5, 6]]
-    #
-    # p Numo::NArray.concatenate([a,b.transpose], axis:1)
-    # # Numo::DFloat#shape=[2,3]
-    # # [[1, 2, 5],
-    # #  [3, 4, 6]]
-
-    def self.concatenate(arrays,axis:0)
+    # Return an unallocated array with the same shape and type as self.
+    def new_narray
+      self.class.new(*shape)
+    end
+
+    # Return an array of zeros with the same shape and type as self.
+    def new_zeros
+      self.class.zeros(*shape)
+    end
+
+    # Return an array of ones with the same shape and type as self.
+    def new_ones
+      self.class.ones(*shape)
+    end
+
+    # Return an array filled with value with the same shape and type as self.
+    def new_fill(value)
+      self.class.new(*shape).fill(value)
+    end
+
+    # Convert angles from radians to degrees.
+    def rad2deg
+      self * (180/Math::PI)
+    end
+
+    # Convert angles from degrees to radians.
+    def deg2rad
+      self * (Math::PI/180)
+    end
+
+    # Flip each row in the left/right direction.
+    # Same as a[true, (-1..0).step(-1), ...].
+    def fliplr
+      reverse(1)
+    end
+
+    # Flip each column in the up/down direction.
+    # Same as a[(-1..0).step(-1), ...].
+    def flipud
+      reverse(0)
+    end
+
+    # Rotate in the plane specified by axes.
+    # @example
+    #   p a = Numo::Int32.new(2,2).seq
+    #   # Numo::Int32#shape=[2,2]
+    #   # [[0, 1],
+    #   #  [2, 3]]
+    #
+    #   p a.rot90
+    #   # Numo::Int32(view)#shape=[2,2]
+    #   # [[1, 3],
+    #   #  [0, 2]]
+    #
+    #   p a.rot90(2)
+    #   # Numo::Int32(view)#shape=[2,2]
+    #   # [[3, 2],
+    #   #  [1, 0]]
+    #
+    #   p a.rot90(3)
+    #   # Numo::Int32(view)#shape=[2,2]
+    #   # [[2, 0],
+    #   #  [3, 1]]
+    def rot90(k=1,axes=[0,1])
+      case k % 4
+      when 0
+        view
+      when 1
+        swapaxes(*axes).reverse(axes[0])
+      when 2
+        reverse(*axes)
+      when 3
+        swapaxes(*axes).reverse(axes[1])
+      end
+    end
+
+    def to_i
+      if size==1
+        self[0].to_i
+      else
+        # convert to Int?
+        raise TypeError, "can't convert #{self.class} into Integer"
+      end
+    end
+
+    def to_f
+      if size==1
+        self[0].to_f
+      else
+        # convert to DFloat?
+        raise TypeError, "can't convert #{self.class} into Float"
+      end
+    end
+
+    def to_c
+      if size==1
+        Complex(self[0])
+      else
+        # convert to DComplex?
+        raise TypeError, "can't convert #{self.class} into Complex"
+      end
+    end
+
+    # Convert the argument to an narray if not an narray.
+    def self.cast(a)
+      a.kind_of?(NArray) ? a : NArray.array_type(a).cast(a)
+    end
+
+    def self.asarray(a)
+      case a
+      when NArray
+        a
+      when Numeric,Range
+        self[a]
+      else
+        cast(a)
+      end
+    end
+
+    # Append values to the end of an narray.
+    # @example
+    #   a = Numo::DFloat[1, 2, 3]
+    #   p a.append([[4, 5, 6], [7, 8, 9]])
+    #   # Numo::DFloat#shape=[9]
+    #   # [1, 2, 3, 4, 5, 6, 7, 8, 9]
+    #
+    #   a = Numo::DFloat[[1, 2, 3]]
+    #   p a.append([[4, 5, 6], [7, 8, 9]],axis:0)
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[1, 2, 3],
+    #   #  [4, 5, 6],
+    #   #  [7, 8, 9]]
+    #
+    #   a = Numo::DFloat[[1, 2, 3], [4, 5, 6]]
+    #   p a.append([7, 8, 9], axis:0)
+    #   # in `append': dimension mismatch (Numo::NArray::DimensionError)
+
+    def append(other,axis:nil)
+      other = self.class.cast(other)
+      if axis
+        if ndim != other.ndim
+          raise DimensionError, "dimension mismatch"
+        end
+        return concatenate(other,axis:axis)
+      else
+        a = self.class.zeros(size+other.size)
+        a[0...size] = self[true]
+        a[size..-1] = other[true]
+        return a
+      end
+    end
+
+    # Return a new array with sub-arrays along an axis deleted.
+    # If axis is not given, obj is applied to the flattened array.
+
+    # @example
+    #   a = Numo::DFloat[[1,2,3,4], [5,6,7,8], [9,10,11,12]]
+    #   p a.delete(1,0)
+    #   # Numo::DFloat(view)#shape=[2,4]
+    #   # [[1, 2, 3, 4],
+    #   #  [9, 10, 11, 12]]
+    #
+    #   p a.delete((0..-1).step(2),1)
+    #   # Numo::DFloat(view)#shape=[3,2]
+    #   # [[2, 4],
+    #   #  [6, 8],
+    #   #  [10, 12]]
+    #
+    #   p a.delete([1,3,5])
+    #   # Numo::DFloat(view)#shape=[9]
+    #   # [1, 3, 5, 7, 8, 9, 10, 11, 12]
+
+    def delete(indice,axis=nil)
+      if axis
+        bit = Bit.ones(shape[axis])
+        bit[indice] = 0
+        idx = [true]*ndim
+        idx[axis] = bit.where
+        return self[*idx].copy
+      else
+        bit = Bit.ones(size)
+        bit[indice] = 0
+        return self[bit.where].copy
+      end
+    end
+
+    # Insert values along the axis before the indices.
+    # @example
+    #   p a = Numo::DFloat[[1, 2], [3, 4]]
+    #   a = Numo::Int32[[1, 1], [2, 2], [3, 3]]
+    #
+    #   p a.insert(1,5)
+    #   # Numo::Int32#shape=[7]
+    #   # [1, 5, 1, 2, 2, 3, 3]
+    #
+    #   p a.insert(1, 5, axis:1)
+    #   # Numo::Int32#shape=[3,3]
+    #   # [[1, 5, 1],
+    #   #  [2, 5, 2],
+    #   #  [3, 5, 3]]
+    #
+    #   p a.insert([1], [[11],[12],[13]], axis:1)
+    #   # Numo::Int32#shape=[3,3]
+    #   # [[1, 11, 1],
+    #   #  [2, 12, 2],
+    #   #  [3, 13, 3]]
+    #
+    #   p a.insert(1, [11, 12, 13], axis:1)
+    #   # Numo::Int32#shape=[3,3]
+    #   # [[1, 11, 1],
+    #   #  [2, 12, 2],
+    #   #  [3, 13, 3]]
+    #
+    #   p a.insert([1], [11, 12, 13], axis:1)
+    #   # Numo::Int32#shape=[3,5]
+    #   # [[1, 11, 12, 13, 1],
+    #   #  [2, 11, 12, 13, 2],
+    #   #  [3, 11, 12, 13, 3]]
+    #
+    #   p b = a.flatten
+    #   # Numo::Int32(view)#shape=[6]
+    #   # [1, 1, 2, 2, 3, 3]
+    #
+    #   p b.insert(2,[15,16])
+    #   # Numo::Int32#shape=[8]
+    #   # [1, 1, 15, 16, 2, 2, 3, 3]
+    #
+    #   p b.insert([2,2],[15,16])
+    #   # Numo::Int32#shape=[8]
+    #   # [1, 1, 15, 16, 2, 2, 3, 3]
+    #
+    #   p b.insert([2,1],[15,16])
+    #   # Numo::Int32#shape=[8]
+    #   # [1, 16, 1, 15, 2, 2, 3, 3]
+    #
+    #   p b.insert([2,0,1],[15,16,17])
+    #   # Numo::Int32#shape=[9]
+    #   # [16, 1, 17, 1, 15, 2, 2, 3, 3]
+    #
+    #   p b.insert(2..3, [15, 16])
+    #   # Numo::Int32#shape=[8]
+    #   # [1, 1, 15, 2, 16, 2, 3, 3]
+    #
+    #   p b.insert(2, [7.13, 0.5])
+    #   # Numo::Int32#shape=[8]
+    #   # [1, 1, 7, 0, 2, 2, 3, 3]
+    #
+    #   p x = Numo::DFloat.new(2,4).seq
+    #   # Numo::DFloat#shape=[2,4]
+    #   # [[0, 1, 2, 3],
+    #   #  [4, 5, 6, 7]]
+    #
+    #   p x.insert([1,3],999,axis:1)
+    #   # Numo::DFloat#shape=[2,6]
+    #   # [[0, 999, 1, 2, 999, 3],
+    #   #  [4, 999, 5, 6, 999, 7]]
+
+    def insert(indice,values,axis:nil)
+      if axis
+        values = self.class.asarray(values)
+        nd = values.ndim
+        midx = [:new]*(ndim-nd) + [true]*nd
+        case indice
+        when Numeric
+          midx[-nd-1] = true
+          midx[axis] = :new
+        end
+        values = values[*midx]
+      else
+        values = self.class.asarray(values).flatten
+      end
+      idx = Int64.asarray(indice)
+      nidx = idx.size
+      if nidx == 1
+        nidx = values.shape[axis||0]
+        idx = idx + Int64.new(nidx).seq
+      else
+        sidx = idx.sort_index
+        idx[sidx] += Int64.new(nidx).seq
+      end
+      if axis
+        bit = Bit.ones(shape[axis]+nidx)
+        bit[idx] = 0
+        new_shape = shape
+        new_shape[axis] += nidx
+        a = self.class.zeros(new_shape)
+        mdidx = [true]*ndim
+        mdidx[axis] = bit.where
+        a[*mdidx] = self
+        mdidx[axis] = idx
+        a[*mdidx] = values
+      else
+        bit = Bit.ones(size+nidx)
+        bit[idx] = 0
+        a = self.class.zeros(size+nidx)
+        a[bit.where] = self.flatten
+        a[idx] = values
+      end
+      return a
+    end
+
+    class << self
+    # @example
+    #   p a = Numo::DFloat[[1, 2], [3, 4]]
+    #   # Numo::DFloat#shape=[2,2]
+    #   # [[1, 2],
+    #   #  [3, 4]]
+    #
+    #   p b = Numo::DFloat[[5, 6]]
+    #   # Numo::DFloat#shape=[1,2]
+    #   # [[5, 6]]
+    #
+    #   p Numo::NArray.concatenate([a,b],axis:0)
+    #   # Numo::DFloat#shape=[3,2]
+    #   # [[1, 2],
+    #   #  [3, 4],
+    #   #  [5, 6]]
+    #
+    #   p Numo::NArray.concatenate([a,b.transpose], axis:1)
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[1, 2, 5],
+    #   #  [3, 4, 6]]
+
+    def concatenate(arrays,axis:0)
       klass = (self==NArray) ? NArray.array_type(arrays) : self
       nd = 0
-      arrays.map! do |a|
+      arrays = arrays.map do |a|
         case a
         when NArray
           # ok
         when Numeric
-          a = klass.new(1).store(a)
+          a = klass[a]
         when Array
           a = klass.cast(a)
         else
-          raise TypeError,"not Numo::NArray"
+          raise TypeError,"not Numo::NArray: #{a.inspect[0..48]}"
         end
         if a.ndim > nd
           nd = a.ndim
@@ -74,97 +377,151 @@ module Numo
       end
       result
     end
-=begin
-    # arrays = 10.times.map{Numo::DFloat.new(3,4).rand(10)}
-    # p Numo::NArray.stack(arrays, axis:0).shape
-    # # [10, 3, 4]
-    # p Numo::NArray.stack(arrays, axis:1).shape
-    # # [3, 10, 4]
-    # p Numo::NArray.stack(arrays, axis:2).shape
-    # # [3, 4, 10]
-    # a = Numo::NArray[1,2,3]
-    # b = Numo::NArray[2,3,4]
-    # p Numo::NArray.stack([a,b])
-    # # Numo::Int32#shape=[2,3]
-    # # [[1, 2, 3],
-    # #  [2, 3, 4]]
-    # p Numo::NArray.stack([a,b],axis:-1)
-    # # Numo::Int32#shape=[3,2]
-    # # [[1, 2],
-    # #  [2, 3],
-    # #  [3, 4]]
-
-    def self.stack(arrays,axis:0)
-      if !arrays.kind_of?(Array)
-        raise TypeError, "argument should be array"
-      end
-      if self == NArray
-        klass = self.array_type(arrays)
-      else
-        klass = self
-      end
-      new_shape = self.array_shape(arrays)[1..-1]
-      nd = new_shape.length + 1
-      if axis < 0
-        axis += nd
-      end
-      if axis < 0 || axis >= nd
-        raise ArgumentError,"axis is out of range"
-      end
-      new_shape.insert(axis, arrays.length)
-      result = klass.zeros(*new_shape)
-      refs = [true] * nd
-      arrays.each_with_index do |a,i|
-        refs[axis] = i
-        result[*refs] = a
+
+    # Stack arrays vertically (row wise).
+    # @example
+    #   a = Numo::Int32[1,2,3]
+    #   b = Numo::Int32[2,3,4]
+    #   p Numo::NArray.vstack([a,b])
+    #   # Numo::Int32#shape=[2,3]
+    #   # [[1, 2, 3],
+    #   #  [2, 3, 4]]
+    #
+    #   a = Numo::Int32[[1],[2],[3]]
+    #   b = Numo::Int32[[2],[3],[4]]
+    #   p Numo::NArray.vstack([a,b])
+    #   # Numo::Int32#shape=[6,1]
+    #   # [[1],
+    #   #  [2],
+    #   #  [3],
+    #   #  [2],
+    #   #  [3],
+    #   #  [4]]
+
+    def vstack(arrays)
+      arys = arrays.map do |a|
+        _atleast_2d(cast(a))
       end
-      result
+      concatenate(arys,axis:0)
     end
 
-    def self.vstack(arrays)
-      self.stack(arrays,axis:0)
-    end
+    # Stack arrays horizontally (column wise).
+    # @example
+    #   a = Numo::Int32[1,2,3]
+    #   b = Numo::Int32[2,3,4]
+    #   p Numo::NArray.hstack([a,b])
+    #   # Numo::Int32#shape=[6]
+    #   # [1, 2, 3, 2, 3, 4]
+    #
+    #   a = Numo::Int32[[1],[2],[3]]
+    #   b = Numo::Int32[[2],[3],[4]]
+    #   p Numo::NArray.hstack([a,b])
+    #   # Numo::Int32#shape=[3,2]
+    #   # [[1, 2],
+    #   #  [2, 3],
+    #   #  [3, 4]]
 
-    def self.hstack(arrays)
-      self.stack(arrays,axis:1)
+    def hstack(arrays)
+      klass = (self==NArray) ? NArray.array_type(arrays) : self
+      nd = 0
+      arys = arrays.map do |a|
+        a = klass.cast(a)
+        nd = a.ndim if a.ndim > nd
+        a
+      end
+      dim = (nd >= 2) ? 1 : 0
+      concatenate(arys,axis:dim)
     end
 
-    def self.dstack(arrays)
-      self.stack(arrays,axis:2)
+    # Stack arrays in depth wise (along third axis).
+    # @example
+    #   a = Numo::Int32[1,2,3]
+    #   b = Numo::Int32[2,3,4]
+    #   p Numo::NArray.dstack([a,b])
+    #   # Numo::Int32#shape=[1,3,2]
+    #   # [[[1, 2],
+    #   #   [2, 3],
+    #   #   [3, 4]]]
+    #
+    #   a = Numo::Int32[[1],[2],[3]]
+    #   b = Numo::Int32[[2],[3],[4]]
+    #   p Numo::NArray.dstack([a,b])
+    #   # Numo::Int32#shape=[3,1,2]
+    #   # [[[1, 2]],
+    #   #  [[2, 3]],
+    #   #  [[3, 4]]]
+
+    def dstack(arrays)
+      arys = arrays.map do |a|
+        _atleast_3d(cast(a))
+      end
+      concatenate(arys,axis:2)
     end
-=end
 
-    def self.vstack(arrays)
-      self.concatenate(arrays,axis:0)
+    # Stack 1-d arrays into columns of a 2-d array.
+    # @example
+    #   x = Numo::Int32[1,2,3]
+    #   y = Numo::Int32[2,3,4]
+    #   p Numo::NArray.column_stack([x,y])
+    #   # Numo::Int32#shape=[3,2]
+    #   # [[1, 2],
+    #   #  [2, 3],
+    #   #  [3, 4]]
+
+    def column_stack(arrays)
+      arys = arrays.map do |a|
+        a = cast(a)
+        case a.ndim
+        when 0; a[:new,:new]
+        when 1; a[true,:new]
+        else; a
+        end
+      end
+      concatenate(arys,axis:1)
     end
 
-    def self.hstack(arrays)
-      self.concatenate(arrays,axis:1)
+    private
+    # Return an narray with at least two dimension.
+    def _atleast_2d(a)
+      case a.ndim
+      when 0; a[:new,:new]
+      when 1; a[:new,true]
+      else;   a
+      end
     end
 
-    def self.dstack(arrays)
-      self.concatenate(arrays,axis:2)
+    # Return an narray with at least three dimension.
+    def _atleast_3d(a)
+      case a.ndim
+      when 0; a[:new,:new,:new]
+      when 1; a[:new,true,:new]
+      when 2; a[true,true,:new]
+      else;   a
+      end
     end
 
-    # p a = Numo::DFloat[[1, 2], [3, 4]]
-    # # Numo::DFloat#shape=[2,2]
-    # # [[1, 2],
-    # #  [3, 4]]
+    end # class << self
+
+    # @example
+    #   p a = Numo::DFloat[[1, 2], [3, 4]]
+    #   # Numo::DFloat#shape=[2,2]
+    #   # [[1, 2],
+    #   #  [3, 4]]
     #
-    # p b = Numo::DFloat[[5, 6]]
-    # # Numo::DFloat#shape=[1,2]
-    # # [[5, 6]]
+    #   p b = Numo::DFloat[[5, 6]]
+    #   # Numo::DFloat#shape=[1,2]
+    #   # [[5, 6]]
     #
-    # p a.concatenate(b,axis:0)
-    # # Numo::DFloat#shape=[3,2]
-    # # [[1, 2],
-    # #  [3, 4],
-    # #  [5, 6]]
+    #   p a.concatenate(b,axis:0)
+    #   # Numo::DFloat#shape=[3,2]
+    #   # [[1, 2],
+    #   #  [3, 4],
+    #   #  [5, 6]]
     #
-    # p a.concatenate(b.transpose, axis:1)
-    # # Numo::DFloat#shape=[2,3]
-    # # [[1, 2, 5],
-    # #  [3, 4, 6]]
+    #   p a.concatenate(b.transpose, axis:1)
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[1, 2, 5],
+    #   #  [3, 4, 6]]
 
     def concatenate(*arrays,axis:0)
       axis = check_axis(axis)
@@ -180,7 +537,7 @@ module Numo
         when Array
           a = self.class.cast(a)
         else
-          raise TypeError,"not Numo::NArray"
+          raise TypeError,"not Numo::NArray: #{a.inspect[0..48]}"
         end
         if a.ndim > ndim
           raise ShapeError,"dimension mismatch"
@@ -207,32 +564,33 @@ module Numo
       result
     end
 
-    # p x = Numo::DFloat.new(9).seq
-    # # Numo::DFloat#shape=[9]
-    # # [0, 1, 2, 3, 4, 5, 6, 7, 8]
-    #
-    # pp x.split(3)
-    # # [Numo::DFloat(view)#shape=[3]
-    # # [0, 1, 2],
-    # #  Numo::DFloat(view)#shape=[3]
-    # # [3, 4, 5],
-    # #  Numo::DFloat(view)#shape=[3]
-    # # [6, 7, 8]]
-    #
-    # p x = Numo::DFloat.new(8).seq
-    # # Numo::DFloat#shape=[8]
-    # # [0, 1, 2, 3, 4, 5, 6, 7]
-    #
-    # pp x.split([3, 5, 6, 10])
-    # # [Numo::DFloat(view)#shape=[3]
-    # # [0, 1, 2],
-    # #  Numo::DFloat(view)#shape=[2]
-    # # [3, 4],
-    # #  Numo::DFloat(view)#shape=[1]
-    # # [5],
-    # #  Numo::DFloat(view)#shape=[2]
-    # # [6, 7],
-    # #  Numo::DFloat(view)#shape=[0][]]
+    # @example
+    #   p x = Numo::DFloat.new(9).seq
+    #   # Numo::DFloat#shape=[9]
+    #   # [0, 1, 2, 3, 4, 5, 6, 7, 8]
+    #
+    #   pp x.split(3)
+    #   # [Numo::DFloat(view)#shape=[3]
+    #   # [0, 1, 2],
+    #   #  Numo::DFloat(view)#shape=[3]
+    #   # [3, 4, 5],
+    #   #  Numo::DFloat(view)#shape=[3]
+    #   # [6, 7, 8]]
+    #
+    #   p x = Numo::DFloat.new(8).seq
+    #   # Numo::DFloat#shape=[8]
+    #   # [0, 1, 2, 3, 4, 5, 6, 7]
+    #
+    #   pp x.split([3, 5, 6, 10])
+    #   # [Numo::DFloat(view)#shape=[3]
+    #   # [0, 1, 2],
+    #   #  Numo::DFloat(view)#shape=[2]
+    #   # [3, 4],
+    #   #  Numo::DFloat(view)#shape=[1]
+    #   # [5],
+    #   #  Numo::DFloat(view)#shape=[2]
+    #   # [6, 7],
+    #   #  Numo::DFloat(view)#shape=[0][]]
 
     def split(indices_or_sections, axis:0)
       axis = check_axis(axis)
@@ -240,12 +598,18 @@ module Numo
       case indices_or_sections
       when Integer
         div_axis, mod_axis = size_axis.divmod(indices_or_sections)
-        if mod_axis != 0
-          raise "not equally divide the axis"
-        end
         refs = [true]*ndim
-        indices_or_sections.times.map do |i|
-          refs[axis] = i*div_axis ... (i+1)*div_axis
+        beg_idx = 0
+        mod_axis.times.map do |i|
+          end_idx = beg_idx + div_axis + 1
+          refs[axis] = beg_idx ... end_idx
+          beg_idx = end_idx
+          self[*refs]
+        end +
+        (indices_or_sections-mod_axis).times.map do |i|
+          end_idx = beg_idx + div_axis
+          refs[axis] = beg_idx ... end_idx
+          beg_idx = end_idx
           self[*refs]
         end
       when NArray
@@ -264,37 +628,38 @@ module Numo
       end
     end
 
-    # p x = Numo::DFloat.new(4,4).seq
-    # # Numo::DFloat#shape=[4,4]
-    # # [[0, 1, 2, 3],
-    # #  [4, 5, 6, 7],
-    # #  [8, 9, 10, 11],
-    # #  [12, 13, 14, 15]]
-    #
-    # pp x.hsplit(2)
-    # # [Numo::DFloat(view)#shape=[4,2]
-    # # [[0, 1],
-    # #  [4, 5],
-    # #  [8, 9],
-    # #  [12, 13]],
-    # #  Numo::DFloat(view)#shape=[4,2]
-    # # [[2, 3],
-    # #  [6, 7],
-    # #  [10, 11],
-    # #  [14, 15]]]
-    #
-    # pp x.hsplit([3, 6])
-    # # [Numo::DFloat(view)#shape=[4,3]
-    # # [[0, 1, 2],
-    # #  [4, 5, 6],
-    # #  [8, 9, 10],
-    # #  [12, 13, 14]],
-    # #  Numo::DFloat(view)#shape=[4,1]
-    # # [[3],
-    # #  [7],
-    # #  [11],
-    # #  [15]],
-    # #  Numo::DFloat(view)#shape=[4,0][]]
+    # @example
+    #   p x = Numo::DFloat.new(4,4).seq
+    #   # Numo::DFloat#shape=[4,4]
+    #   # [[0, 1, 2, 3],
+    #   #  [4, 5, 6, 7],
+    #   #  [8, 9, 10, 11],
+    #   #  [12, 13, 14, 15]]
+    #
+    #   pp x.hsplit(2)
+    #   # [Numo::DFloat(view)#shape=[4,2]
+    #   # [[0, 1],
+    #   #  [4, 5],
+    #   #  [8, 9],
+    #   #  [12, 13]],
+    #   #  Numo::DFloat(view)#shape=[4,2]
+    #   # [[2, 3],
+    #   #  [6, 7],
+    #   #  [10, 11],
+    #   #  [14, 15]]]
+    #
+    #   pp x.hsplit([3, 6])
+    #   # [Numo::DFloat(view)#shape=[4,3]
+    #   # [[0, 1, 2],
+    #   #  [4, 5, 6],
+    #   #  [8, 9, 10],
+    #   #  [12, 13, 14]],
+    #   #  Numo::DFloat(view)#shape=[4,1]
+    #   # [[3],
+    #   #  [7],
+    #   #  [11],
+    #   #  [15]],
+    #   #  Numo::DFloat(view)#shape=[4,0][]]
 
     def vsplit(indices_or_sections)
       split(indices_or_sections, axis:0)
@@ -308,52 +673,52 @@ module Numo
       split(indices_or_sections, axis:2)
     end
 
-
-    # p a = Numo::NArray[0,1,2]
-    # # Numo::Int32#shape=[3]
-    # # [0, 1, 2]
+    # @example
+    #   p a = Numo::NArray[0,1,2]
+    #   # Numo::Int32#shape=[3]
+    #   # [0, 1, 2]
     #
-    # p a.tile(2)
-    # # Numo::Int32#shape=[6]
-    # # [0, 1, 2, 0, 1, 2]
+    #   p a.tile(2)
+    #   # Numo::Int32#shape=[6]
+    #   # [0, 1, 2, 0, 1, 2]
     #
-    # p a.tile(2,2)
-    # # Numo::Int32#shape=[2,6]
-    # # [[0, 1, 2, 0, 1, 2],
-    # #  [0, 1, 2, 0, 1, 2]]
+    #   p a.tile(2,2)
+    #   # Numo::Int32#shape=[2,6]
+    #   # [[0, 1, 2, 0, 1, 2],
+    #   #  [0, 1, 2, 0, 1, 2]]
     #
-    # p a.tile(2,1,2)
-    # # Numo::Int32#shape=[2,1,6]
-    # # [[[0, 1, 2, 0, 1, 2]],
-    # #  [[0, 1, 2, 0, 1, 2]]]
+    #   p a.tile(2,1,2)
+    #   # Numo::Int32#shape=[2,1,6]
+    #   # [[[0, 1, 2, 0, 1, 2]],
+    #   #  [[0, 1, 2, 0, 1, 2]]]
     #
-    # p b = Numo::NArray[[1, 2], [3, 4]]
-    # # Numo::Int32#shape=[2,2]
-    # # [[1, 2],
-    # #  [3, 4]]
+    #   p b = Numo::NArray[[1, 2], [3, 4]]
+    #   # Numo::Int32#shape=[2,2]
+    #   # [[1, 2],
+    #   #  [3, 4]]
     #
-    # p b.tile(2)
-    # # Numo::Int32#shape=[2,4]
-    # # [[1, 2, 1, 2],
-    # #  [3, 4, 3, 4]]
+    #   p b.tile(2)
+    #   # Numo::Int32#shape=[2,4]
+    #   # [[1, 2, 1, 2],
+    #   #  [3, 4, 3, 4]]
     #
-    # p b.tile(2,1)
-    # # Numo::Int32#shape=[4,2]
-    # # [[1, 2],
-    # #  [3, 4],
-    # #  [1, 2],
-    # #  [3, 4]]
+    #   p b.tile(2,1)
+    #   # Numo::Int32#shape=[4,2]
+    #   # [[1, 2],
+    #   #  [3, 4],
+    #   #  [1, 2],
+    #   #  [3, 4]]
     #
-    # p c = Numo::NArray[1,2,3,4]
-    # # Numo::Int32#shape=[4]
-    # # [1, 2, 3, 4]
+    #   p c = Numo::NArray[1,2,3,4]
+    #   # Numo::Int32#shape=[4]
+    #   # [1, 2, 3, 4]
     #
-    # p c.tile(4,1)
-    # # Numo::Int32#shape=[4,4]
-    # # [[1, 2, 3, 4],
-    # #  [1, 2, 3, 4],
-    # #  [1, 2, 3, 4],
-    # #  [1, 2, 3, 4]]
+    #   p c.tile(4,1)
+    #   # Numo::Int32#shape=[4,4]
+    #   # [[1, 2, 3, 4],
+    #   #  [1, 2, 3, 4],
+    #   #  [1, 2, 3, 4],
+    #   #  [1, 2, 3, 4]]
 
     def tile(*arg)
       arg.each do |i|
@@ -391,30 +756,30 @@ module Numo
       self.class.new(*new_shp).store(self[*src_shp]).reshape(*res_shp)
     end
 
-
-    # p Numo::NArray[3].repeat(4)
-    # # Numo::Int32#shape=[4]
-    # # [3, 3, 3, 3]
+    # @example
+    #   p Numo::NArray[3].repeat(4)
+    #   # Numo::Int32#shape=[4]
+    #   # [3, 3, 3, 3]
     #
-    # p x = Numo::NArray[[1,2],[3,4]]
-    # # Numo::Int32#shape=[2,2]
-    # # [[1, 2],
-    # #  [3, 4]]
+    #   p x = Numo::NArray[[1,2],[3,4]]
+    #   # Numo::Int32#shape=[2,2]
+    #   # [[1, 2],
+    #   #  [3, 4]]
     #
-    # p x.repeat(2)
-    # # Numo::Int32#shape=[8]
-    # # [1, 1, 2, 2, 3, 3, 4, 4]
+    #   p x.repeat(2)
+    #   # Numo::Int32#shape=[8]
+    #   # [1, 1, 2, 2, 3, 3, 4, 4]
     #
-    # p x.repeat(3,axis:1)
-    # # Numo::Int32#shape=[2,6]
-    # # [[1, 1, 1, 2, 2, 2],
-    # #  [3, 3, 3, 4, 4, 4]]
+    #   p x.repeat(3,axis:1)
+    #   # Numo::Int32#shape=[2,6]
+    #   # [[1, 1, 1, 2, 2, 2],
+    #   #  [3, 3, 3, 4, 4, 4]]
     #
-    # p x.repeat([1,2],axis:0)
-    # # Numo::Int32#shape=[3,2]
-    # # [[1, 2],
-    # #  [3, 4],
-    # #  [3, 4]]
+    #   p x.repeat([1,2],axis:0)
+    #   # Numo::Int32#shape=[3,2]
+    #   # [[1, 2],
+    #   #  [3, 4],
+    #   #  [3, 4]]
 
     def repeat(arg,axis:nil)
       case axis
@@ -450,7 +815,61 @@ module Numo
       c[*ref].copy
     end
 
+    # Calculate the n-th discrete difference along given axis.
+    # @example
+    #   p x = Numo::DFloat[1, 2, 4, 7, 0]
+    #   # Numo::DFloat#shape=[5]
+    #   # [1, 2, 4, 7, 0]
+    #
+    #   p x.diff
+    #   # Numo::DFloat#shape=[4]
+    #   # [1, 2, 3, -7]
+    #
+    #   p x.diff(2)
+    #   # Numo::DFloat#shape=[3]
+    #   # [1, 1, -10]
+    #
+    #   p x = Numo::DFloat[[1, 3, 6, 10], [0, 5, 6, 8]]
+    #   # Numo::DFloat#shape=[2,4]
+    #   # [[1, 3, 6, 10],
+    #   #  [0, 5, 6, 8]]
+    #
+    #   p x.diff
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[2, 3, 4],
+    #   #  [5, 1, 2]]
+    #
+    #   p x.diff(axis:0)
+    #   # Numo::DFloat#shape=[1,4]
+    #   # [[-1, 2, 0, -2]]
+
+    def diff(n=1,axis:-1)
+      axis = check_axis(axis)
+      if n < 0 || n >= shape[axis]
+        raise ShapeError,"n=#{n} is invalid for shape[#{axis}]=#{shape[axis]}"
+      end
+      # calculate polynomial coefficient
+      c = self.class[-1,1]
+      2.upto(n) do |i|
+        x = self.class.zeros(i+1)
+        x[0..-2] = c
+        y = self.class.zeros(i+1)
+        y[1..-1] = c
+        c = y - x
+      end
+      s = [true]*ndim
+      s[axis] = n..-1
+      result = self[*s].dup
+      sum = result.inplace
+      (n-1).downto(0) do |i|
+        s = [true]*ndim
+        s[axis] = i..-n-1+i
+        sum + self[*s] * c[i] # inplace addition
+      end
+      return result
+    end
 
+    private
     def check_axis(axis)
       if axis < 0
         axis += ndim