numo-narray 0.9.1.4 → 0.9.1.9

data/ext/numo/narray/struct.c

@@ -1,7 +1,7 @@
 /*
   strut.c
-  Numerical Array Extension for Ruby
-    (C) Copyright 1999-2017 by Masahiro TANAKA
+  Ruby/Numo::NArray - Numerical Array class for Ruby
+    Copyright (C) 1999-2020 Masahiro TANAKA
 */
 #include <ruby.h>
 #include "numo/narray.h"
@@ -813,7 +813,7 @@ nst_s_add_type(int argc, VALUE *argv, VALUE mod)
 
 #define NST_TYPEDEF(tpname,tpclass)                 \
 static VALUE                                        \
-nst_s_##tpname(VALUE argc, VALUE *argv, VALUE mod)  \
+nst_s_##tpname(int argc, VALUE *argv, VALUE mod)    \
 {   nstruct_add_type(tpclass,argc,argv,mod);        \
     return Qnil;                                    \
 }

data/lib/numo/narray.rb

@@ -1,8 +1,2 @@
-begin
-  major, minor, _ = RUBY_VERSION.split(/\./)
-  require "#{major}.#{minor}/numo/narray.so"
-rescue LoadError
-  require "numo/narray.so"
-end
-
+require "numo/narray.so"
 require "numo/narray/extra"

data/lib/numo/narray/extra.rb

@@ -43,75 +43,25 @@ module Numo
       reverse(0)
     end
 
-    # Multi-dimensional array indexing.
-    # Same as [] for one-dimensional NArray.
-    # Similar to numpy's tuple indexing, i.e., `a[[1,2,..],[3,4,..]]`
-    # (This method will be rewritten in C)
-    # @return [Numo::NArray] one-dimensional view of self.
-    # @example
-    #   p x = Numo::DFloat.new(3,3,3).seq
-    #   # Numo::DFloat#shape=[3,3,3]
-    #   # [[[0, 1, 2],
-    #   #   [3, 4, 5],
-    #   #   [6, 7, 8]],
-    #   #  [[9, 10, 11],
-    #   #   [12, 13, 14],
-    #   #   [15, 16, 17]],
-    #   #  [[18, 19, 20],
-    #   #   [21, 22, 23],
-    #   #   [24, 25, 26]]]
-    #
-    #   p x.at([0,1,2],[0,1,2],[-1,-2,-3])
-    #   # Numo::DFloat(view)#shape=[3]
-    #   # [2, 13, 24]
-    def at(*indices)
-      if indices.size != ndim
-        raise DimensionError, "argument length does not match dimension size"
-      end
-      idx = nil
-      stride = 1
-      (indices.size-1).downto(0) do |i|
-        ix = Int64.cast(indices[i])
-        if ix.ndim != 1
-          raise DimensionError, "index array is not one-dimensional"
-        end
-        ix[ix < 0] += shape[i]
-        if ((ix < 0) & (ix >= shape[i])).any?
-          raise IndexError, "index array is out of range"
-        end
-        if idx
-          if idx.size != ix.size
-            raise ShapeError, "index array sizes mismatch"
-          end
-          idx += ix * stride
-          stride *= shape[i]
-        else
-          idx = ix
-          stride = shape[i]
-        end
-      end
-      self[idx]
-    end
-
     # Rotate in the plane specified by axes.
     # @example
-    #   p a = Numo::Int32.new(2,2).seq
-    #   # Numo::Int32#shape=[2,2]
+    #   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]
+    #   a.rot90
+    #   # => Numo::Int32(view)#shape=[2,2]
     #   # [[1, 3],
     #   #  [0, 2]]
     #
-    #   p a.rot90(2)
-    #   # Numo::Int32(view)#shape=[2,2]
+    #   a.rot90(2)
+    #   # => Numo::Int32(view)#shape=[2,2]
     #   # [[3, 2],
     #   #  [1, 0]]
     #
-    #   p a.rot90(3)
-    #   # Numo::Int32(view)#shape=[2,2]
+    #   a.rot90(3)
+    #   # => Numo::Int32(view)#shape=[2,2]
     #   # [[2, 0],
     #   #  [3, 1]]
     def rot90(k=1,axes=[0,1])
@@ -156,7 +106,19 @@ module Numo
 
     # 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)
+      case a
+      when NArray
+        a
+      when Array,Numeric
+        NArray.array_type(a).cast(a)
+      else
+        if a.respond_to?(:to_a)
+          a = a.to_a
+          NArray.array_type(a).cast(a)
+        else
+          raise TypeError,"invalid type for NArray"
+        end
+      end
     end
 
     def self.asarray(a)
@@ -177,10 +139,10 @@ module Numo
     #    4 9 7
     #    2 -1 6
     #   ]
-    #   => Numo::DFloat#shape=[3,3]
-    #   [[2, -3, 5],
-    #    [4, 9, 7],
-    #    [2, -1, 6]]
+    #   # => Numo::DFloat#shape=[3,3]
+    #   # [[2, -3, 5],
+    #   #  [4, 9, 7],
+    #   #  [2, -1, 6]]
 
     def self.parse(str, split1d:/\s+/, split2d:/;?$|;/,
                    split3d:/\s*\n(\s*\n)+/m)
@@ -210,7 +172,7 @@ module Numo
 
 
     # Iterate over an axis
-    # @ example
+    # @example
     #   > a = Numo::DFloat.new(2,2,2).seq
     #   > p a
     #   Numo::DFloat#shape=[2,2,2]
@@ -260,19 +222,19 @@ module Numo
     # 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]
+    #   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]
+    #   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)
+    #   a.append([7, 8, 9], axis:0)
     #   # in `append': dimension mismatch (Numo::NArray::DimensionError)
 
     def append(other,axis:nil)
@@ -295,19 +257,19 @@ module Numo
 
     # @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]
+    #   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]
+    #   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]
+    #   a.delete([1,3,5])
+    #   # => Numo::DFloat(view)#shape=[9]
     #   # [1, 3, 5, 7, 8, 9, 10, 11, 12]
 
     def delete(indice,axis=nil)
@@ -326,72 +288,72 @@ module Numo
 
     # Insert values along the axis before the indices.
     # @example
-    #   p a = Numo::DFloat[[1, 2], [3, 4]]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   b = a.flatten
+    #   # => Numo::Int32(view)#shape=[6]
     #   # [1, 1, 2, 2, 3, 3]
     #
-    #   p b.insert(2,[15,16])
-    #   # Numo::Int32#shape=[8]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   x.insert([1,3],999,axis:1)
+    #   # => Numo::DFloat#shape=[2,6]
     #   # [[0, 999, 1, 2, 999, 3],
     #   #  [4, 999, 5, 6, 999, 7]]
 
@@ -441,23 +403,23 @@ module Numo
 
     class << self
     # @example
-    #   p a = Numo::DFloat[[1, 2], [3, 4]]
-    #   # Numo::DFloat#shape=[2,2]
+    #   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]
+    #   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]
+    #   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]
+    #   Numo::NArray.concatenate([a,b.transpose], axis:1)
+    #   # => Numo::DFloat#shape=[2,3]
     #   # [[1, 2, 5],
     #   #  [3, 4, 6]]
 
@@ -509,8 +471,10 @@ module Numo
       arrays.each do |a|
         fst = lst
         lst = fst + (a.shape[axis-nd]||1)
-        refs[axis] = fst...lst
-        result[*refs] = a
+        if lst > fst
+          refs[axis] = fst...lst
+          result[*refs] = a
+        end
       end
       result
     end
@@ -519,15 +483,15 @@ module Numo
     # @example
     #   a = Numo::Int32[1,2,3]
     #   b = Numo::Int32[2,3,4]
-    #   p Numo::NArray.vstack([a,b])
-    #   # Numo::Int32#shape=[2,3]
+    #   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]
+    #   Numo::NArray.vstack([a,b])
+    #   # => Numo::Int32#shape=[6,1]
     #   # [[1],
     #   #  [2],
     #   #  [3],
@@ -546,14 +510,14 @@ module Numo
     # @example
     #   a = Numo::Int32[1,2,3]
     #   b = Numo::Int32[2,3,4]
-    #   p Numo::NArray.hstack([a,b])
-    #   # Numo::Int32#shape=[6]
+    #   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]
+    #   Numo::NArray.hstack([a,b])
+    #   # => Numo::Int32#shape=[3,2]
     #   # [[1, 2],
     #   #  [2, 3],
     #   #  [3, 4]]
@@ -574,16 +538,16 @@ module Numo
     # @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]
+    #   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]
+    #   Numo::NArray.dstack([a,b])
+    #   # => Numo::Int32#shape=[3,1,2]
     #   # [[[1, 2]],
     #   #  [[2, 3]],
     #   #  [[3, 4]]]
@@ -599,8 +563,8 @@ module Numo
     # @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]
+    #   Numo::NArray.column_stack([x,y])
+    #   # => Numo::Int32#shape=[3,2]
     #   # [[1, 2],
     #   #  [2, 3],
     #   #  [3, 4]]
@@ -640,23 +604,23 @@ module Numo
     end # class << self
 
     # @example
-    #   p a = Numo::DFloat[[1, 2], [3, 4]]
-    #   # Numo::DFloat#shape=[2,2]
+    #   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]
+    #   b = Numo::DFloat[[5, 6]]
+    #   # => Numo::DFloat#shape=[1,2]
     #   # [[5, 6]]
     #
-    #   p a.concatenate(b,axis:0)
-    #   # Numo::DFloat#shape=[3,2]
+    #   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]
+    #   a.concatenate(b.transpose, axis:1)
+    #   # => Numo::DFloat#shape=[2,3]
     #   # [[1, 2, 5],
     #   #  [3, 4, 6]]
 
@@ -690,36 +654,40 @@ module Numo
       result = self.class.zeros(*self_shape)
       lst = shape[axis]
       refs = [true] * ndim
-      refs[axis] = 0...lst
-      result[*refs] = self
+      if lst > 0
+        refs[axis] = 0...lst
+        result[*refs] = self
+      end
       arrays.each do |a|
         fst = lst
         lst = fst + (a.shape[axis-ndim] || 1)
-        refs[axis] = fst...lst
-        result[*refs] = a
+        if lst > fst
+          refs[axis] = fst...lst
+          result[*refs] = a
+        end
       end
       result
     end
 
     # @example
-    #   p x = Numo::DFloat.new(9).seq
-    #   # Numo::DFloat#shape=[9]
+    #   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]
+    #   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]
+    #   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]
+    #   x.split([3, 5, 6, 10])
+    #   # => [Numo::DFloat(view)#shape=[3]
     #   # [0, 1, 2],
     #   #  Numo::DFloat(view)#shape=[2]
     #   # [3, 4],
@@ -766,15 +734,15 @@ module Numo
     end
 
     # @example
-    #   p x = Numo::DFloat.new(4,4).seq
-    #   # Numo::DFloat#shape=[4,4]
+    #   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]
+    #   x.hsplit(2)
+    #   # => [Numo::DFloat(view)#shape=[4,2]
     #   # [[0, 1],
     #   #  [4, 5],
     #   #  [8, 9],
@@ -785,8 +753,8 @@ module Numo
     #   #  [10, 11],
     #   #  [14, 15]]]
     #
-    #   pp x.hsplit([3, 6])
-    #   # [Numo::DFloat(view)#shape=[4,3]
+    #   x.hsplit([3, 6])
+    #   # => [Numo::DFloat(view)#shape=[4,3]
     #   # [[0, 1, 2],
     #   #  [4, 5, 6],
     #   #  [8, 9, 10],
@@ -811,47 +779,47 @@ module Numo
     end
 
     # @example
-    #   p a = Numo::NArray[0,1,2]
-    #   # Numo::Int32#shape=[3]
+    #   a = Numo::NArray[0,1,2]
+    #   # => Numo::Int32#shape=[3]
     #   # [0, 1, 2]
     #
-    #   p a.tile(2)
-    #   # Numo::Int32#shape=[6]
+    #   a.tile(2)
+    #   # => Numo::Int32#shape=[6]
     #   # [0, 1, 2, 0, 1, 2]
     #
-    #   p a.tile(2,2)
-    #   # Numo::Int32#shape=[2,6]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   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]
+    #   c.tile(4,1)
+    #   # => Numo::Int32#shape=[4,4]
     #   # [[1, 2, 3, 4],
     #   #  [1, 2, 3, 4],
     #   #  [1, 2, 3, 4],
@@ -894,26 +862,26 @@ module Numo
     end
 
     # @example
-    #   p Numo::NArray[3].repeat(4)
-    #   # Numo::Int32#shape=[4]
+    #   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]
+    #   x = Numo::NArray[[1,2],[3,4]]
+    #   # => Numo::Int32#shape=[2,2]
     #   # [[1, 2],
     #   #  [3, 4]]
     #
-    #   p x.repeat(2)
-    #   # Numo::Int32#shape=[8]
+    #   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]
+    #   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]
+    #   x.repeat([1,2],axis:0)
+    #   # => Numo::Int32#shape=[3,2]
     #   # [[1, 2],
     #   #  [3, 4],
     #   #  [3, 4]]
@@ -954,30 +922,30 @@ module Numo
 
     # Calculate the n-th discrete difference along given axis.
     # @example
-    #   p x = Numo::DFloat[1, 2, 4, 7, 0]
-    #   # Numo::DFloat#shape=[5]
+    #   x = Numo::DFloat[1, 2, 4, 7, 0]
+    #   # => Numo::DFloat#shape=[5]
     #   # [1, 2, 4, 7, 0]
     #
-    #   p x.diff
-    #   # Numo::DFloat#shape=[4]
+    #   x.diff
+    #   # => Numo::DFloat#shape=[4]
     #   # [1, 2, 3, -7]
     #
-    #   p x.diff(2)
-    #   # Numo::DFloat#shape=[3]
+    #   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]
+    #   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]
+    #   x.diff
+    #   # => Numo::DFloat#shape=[2,3]
     #   # [[2, 3, 4],
     #   #  [5, 1, 2]]
     #
-    #   p x.diff(axis:0)
-    #   # Numo::DFloat#shape=[1,4]
+    #   x.diff(axis:0)
+    #   # => Numo::DFloat#shape=[1,4]
     #   # [[-1, 2, 0, -2]]
 
     def diff(n=1,axis:-1)
@@ -1182,18 +1150,20 @@ module Numo
     # @return [Numo::NArray]  return outer product
     # @example
     #   a = Numo::DFloat.ones(5)
-    #   => Numo::DFloat#shape=[5]
-    #   [1, 1, 1, 1, 1]
+    #   # => Numo::DFloat#shape=[5]
+    #   # [1, 1, 1, 1, 1]
+    #
     #   b = Numo::DFloat.linspace(-2,2,5)
-    #   => Numo::DFloat#shape=[5]
-    #   [-2, -1, 0, 1, 2]
+    #   # => Numo::DFloat#shape=[5]
+    #   # [-2, -1, 0, 1, 2]
+    #
     #   a.outer(b)
-    #   => Numo::DFloat#shape=[5,5]
-    #   [[-2, -1, 0, 1, 2],
-    #    [-2, -1, 0, 1, 2],
-    #    [-2, -1, 0, 1, 2],
-    #    [-2, -1, 0, 1, 2],
-    #    [-2, -1, 0, 1, 2]]
+    #   # => Numo::DFloat#shape=[5,5]
+    #   # [[-2, -1, 0, 1, 2],
+    #   #  [-2, -1, 0, 1, 2],
+    #   #  [-2, -1, 0, 1, 2],
+    #   #  [-2, -1, 0, 1, 2],
+    #   #  [-2, -1, 0, 1, 2]]
 
     def outer(b, axis:nil)
       b = NArray.cast(b)
@@ -1213,6 +1183,35 @@ module Numo
       end
     end
 
+    # Percentile
+    #
+    # @param q [Numo::NArray]
+    # @param axis [Integer] applied axis
+    # @return [Numo::NArray]  return percentile
+    def percentile(q, axis: nil)
+      raise ArgumentError, "q is out of range" if q < 0 || q > 100
+
+      x = self
+      unless axis
+        axis = 0
+        x = x.flatten
+      end
+
+      sorted = x.sort(axis: axis)
+      x = q / 100.0 * (sorted.shape[axis] - 1)
+      r = x % 1
+      i = x.floor
+      refs = [true] * sorted.ndim
+      refs[axis] = i
+      if i == sorted.shape[axis] - 1
+        sorted[*refs]
+      else
+        refs_upper = refs.dup
+        refs_upper[axis] = i + 1
+        sorted[*refs] + r * (sorted[*refs_upper] - sorted[*refs])
+      end
+    end
+
     # Kronecker product of two arrays.
     #
     #     kron(a,b)[k_0, k_1, ...] = a[i_0, i_1, ...] * b[j_0, j_1, ...]
@@ -1222,17 +1221,19 @@ module Numo
     # @return [Numo::NArray]  return Kronecker product
     # @example
     #   Numo::DFloat[1,10,100].kron([5,6,7])
-    #   => Numo::DFloat#shape=[9]
-    #   [5, 6, 7, 50, 60, 70, 500, 600, 700]
+    #   # => Numo::DFloat#shape=[9]
+    #   # [5, 6, 7, 50, 60, 70, 500, 600, 700]
+    #
     #   Numo::DFloat[5,6,7].kron([1,10,100])
-    #   => Numo::DFloat#shape=[9]
-    #   [5, 50, 500, 6, 60, 600, 7, 70, 700]
+    #   # => Numo::DFloat#shape=[9]
+    #   # [5, 50, 500, 6, 60, 600, 7, 70, 700]
+    #
     #   Numo::DFloat.eye(2).kron(Numo::DFloat.ones(2,2))
-    #   => Numo::DFloat#shape=[4,4]
-    #   [[1, 1, 0, 0],
-    #    [1, 1, 0, 0],
-    #    [0, 0, 1, 1],
-    #    [0, 0, 1, 1]]
+    #   # => Numo::DFloat#shape=[4,4]
+    #   # [[1, 1, 0, 0],
+    #   #  [1, 1, 0, 0],
+    #   #  [0, 0, 1, 1],
+    #   #  [0, 0, 1, 1]]
 
     def kron(b)
       b = NArray.cast(b)