numo-narray 0.9.0.3 → 0.9.0.4

data/ext/numo/narray/numo/ndloop.h

@@ -2,11 +2,6 @@
   ndloop.h
   Numerical Array Extension for Ruby
     (C) Copyright 1999-2016 by Masahiro TANAKA
-
-  This program is free software.
-  You can distribute/modify this program
-  under the same terms as Ruby itself.
-  NO WARRANTY.
 */
 #ifndef NDLOOP_H
 #define NDLOOP_H

data/ext/numo/narray/numo/template.h

@@ -2,11 +2,6 @@
   template.h
   Numerical Array Extension for Ruby
     (C) Copyright 1999-2016 by Masahiro TANAKA
-
-  This program is free software.
-  You can distribute/modify this program
-  under the same terms as Ruby itself.
-  NO WARRANTY.
 */
 #ifndef TEMPLATE_H
 #define TEMPLATE_H

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

@@ -1,12 +1,7 @@
 /*
   complex.h
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2007 by Masahiro TANAKA
-
-  This program is free software.
-  You can distribute/modify this program
-  under the same terms as Ruby itself.
-  NO WARRANTY.
+    (C) Copyright 1999-2016 by Masahiro TANAKA
 */
 
 

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

@@ -5,7 +5,7 @@ EXTERN double log2(double);
 EXTERN double exp2(double);
 EXTERN double exp10(double);
 
-#define r_abs(x)   abs(x)
+#define r_abs(x)   fabs(x)
 #define r_sqrt(x)  sqrt(x)
 #define r_exp(x)   exp(x)
 #define r_log(x)   log(x)
@@ -73,6 +73,7 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_sign(x)  c_new( \
  ((REAL(x)==0) ? 0.0:((REAL(x)>0) ? 1.0:((REAL(x)<0) ? -1.0:REAL(x)))), \
  ((IMAG(x)==0) ? 0.0:((IMAG(x)>0) ? 1.0:((IMAG(x)<0) ? -1.0:IMAG(x)))))
+#define m_copysign(x,y) c_new(copysign(REAL(x),REAL(y)),copysign(IMAG(x),IMAG(y)))
 
 #define m_im(x)    c_im(x)
 #define m_conj(x)  c_new(REAL(x),-IMAG(x))
@@ -92,8 +93,6 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_mulsum(x,y,z) {z = c_add(c_mul(x,y),z);}
 #define m_mulsum_init INT2FIX(0)
 
-#define m_rand_norm(a) rand_norm(a)
-
 #define m_sprintf(s,x) sprintf(s,"%g%+gi",REAL(x),IMAG(x))
 
 #define m_sqrt(x)    c_sqrt(x)
@@ -134,6 +133,34 @@ static inline dtype f_sum(size_t n, char *p, ssize_t stride)
     return y;
 }
 
+static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x;
+    volatile dtype y,t,r;
+
+    y = c_zero();
+    r = c_zero();
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!c_isnan(x)) {
+            if (fabs(REAL(x)) > fabs(REAL(y))) {
+                double z=REAL(x); REAL(x)=REAL(y); REAL(y)=z;
+            }
+            if (fabs(IMAG(x)) > fabs(IMAG(y))) {
+                double z=IMAG(x); IMAG(x)=IMAG(y); IMAG(y)=z;
+            }
+            r = c_add(x, r);
+            t = y;
+            y = c_add(r, y);
+            t = c_sub(y, t);
+            r = c_sub(r, t);
+        }
+        p += stride;
+    }
+    return y;
+}
+
 static inline dtype f_prod(size_t n, char *p, ssize_t stride)
 {
     size_t i=n;

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

@@ -18,3 +18,21 @@ inline static dtype m_rand(dtype max)
     IMAG(z) = genrand_res53_mix() * IMAG(max);
     return z;
 }
+
+/* generates random numbers from the normal distribution
+   using Box-Muller Transformation.
+ */
+inline static void m_rand_norm(dtype mu, rtype sigma, dtype *a0)
+{
+    rtype x1, x2, w;
+    do {
+	x1 = genrand_res53_mix();
+	x1 = x1*2-1;
+	x2 = genrand_res53_mix();
+	x2 = x2*2-1;
+	w = x1 * x1 + x2 * x2;
+    } while (w>=1);
+    w = sqrt( (-2*log(w)) / w );
+    REAL(*a0) = x1*w * sigma + REAL(mu);
+    IMAG(*a0) = x2*w * sigma + IMAG(mu);
+}

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

@@ -12,6 +12,24 @@ inline static dtype m_rand(dtype max)
     return genrand_res53_mix() * max;
 }
 
+/* generates random numbers from the normal distribution
+   using Box-Muller Transformation.
+ */
+inline static void m_rand_norm(dtype mu, dtype sigma, dtype *a0, dtype *a1)
+{
+    dtype x1, x2, w;
+    do {
+	x1 = genrand_res53_mix();
+	x1 = x1*2-1;
+	x2 = genrand_res53_mix();
+	x2 = x2*2-1;
+	w = x1 * x1 + x2 * x2;
+    } while (w>=1);
+    w = sqrt( (-2*log(w)) / w );
+    if (a0) {*a0 = x1*w * sigma + mu;}
+    if (a1) {*a1 = x2*w * sigma + mu;}
+}
+
 #define m_min_init numo_dfloat_new_dim0(0.0/0.0)
 #define m_max_init numo_dfloat_new_dim0(0.0/0.0)
 #define m_extract(x) rb_float_new(*(double*)x)

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

@@ -38,6 +38,7 @@ EXTERN double pow(double, double);
 #define m_trunc(x)   trunc(x)
 #define m_rint(x)    rint(x)
 #define m_sign(x)    (((x)==0) ? 0.0:(((x)>0) ? 1.0:(((x)<0) ? -1.0:(x))))
+#define m_copysign(x,y) copysign(x,y)
 
 #define m_eq(x,y) ((x)==(y))
 #define m_ne(x,y) ((x)!=(y))
@@ -53,8 +54,6 @@ EXTERN double pow(double, double);
 #define m_mulsum(x,y,z) {z += x*y;}
 #define m_mulsum_init INT2FIX(0)
 
-#define m_rand_norm(a) rand_norm(a)
-
 #define m_sprintf(s,x) sprintf(s,"%g",x)
 
 #define cmp(a,b)                                                        \
@@ -135,6 +134,30 @@ static inline dtype f_sum(size_t n, char *p, ssize_t stride)
     return y;
 }
 
+static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x;
+    volatile dtype y=0;
+    volatile dtype t,r=0;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            if (fabs(x) > fabs(y)) {
+                dtype z=x; x=y; y=z;
+            }
+            r += x;
+            t = y;
+            y += r;
+            t = y-t;
+            r -= t;
+        }
+        p += stride;
+    }
+    return y;
+}
+
 static inline dtype f_prod(size_t n, char *p, ssize_t stride)
 {
     size_t i=n;

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

@@ -28,8 +28,8 @@
 #define m_trunc(x)     rb_funcall(x,id_truncate,0)
 #define m_sign(x)      rb_funcall(x,id_op_ufo,1,INT2FIX(0))
 
-#define m_eq(x,y)      RTEST(rb_funcall(x,id_eq,1,y))
-#define m_ne(x,y)      RTEST(rb_funcall(x,id_ne,1,y))
+#define m_eq(x,y)      RTEST(rb_funcall(x,id_op_eq,1,y))
+#define m_ne(x,y)      RTEST(rb_funcall(x,id_op_ne,1,y))
 #define m_gt(x,y)      RTEST(rb_funcall(x,id_op_gt,1,y))
 #define m_ge(x,y)      RTEST(rb_funcall(x,id_op_ge,1,y))
 #define m_lt(x,y)      RTEST(rb_funcall(x,id_op_lt,1,y))
@@ -47,8 +47,6 @@
 #define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
 #define m_mulsum_init INT2FIX(0)
 
-#define m_rand_norm(a) rand_norm(a)
-
 #define m_sprintf(s,x) robj_sprintf(s,x)
 
 static inline int robj_sprintf(char *s, VALUE x) {

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

@@ -18,3 +18,21 @@ inline static dtype m_rand(dtype max)
     IMAG(z) = to_real2(gen_rand32()) * IMAG(max);
     return z;
 }
+
+/* generates random numbers from the normal distribution
+   using Box-Muller Transformation.
+ */
+inline static void m_rand_norm(dtype mu, rtype sigma, dtype *a0)
+{
+    rtype x1, x2, w;
+    do {
+	x1 = to_real2(gen_rand32());
+	x1 = x1*2-1;
+	x2 = to_real2(gen_rand32());
+	x2 = x2*2-1;
+	w = x1 * x1 + x2 * x2;
+    } while (w>=1);
+    w = sqrt( (-2*log(w)) / w );
+    REAL(*a0) = x1*w * sigma + REAL(mu);
+    IMAG(*a0) = x2*w * sigma + IMAG(mu);
+}

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

@@ -12,6 +12,24 @@ inline static dtype m_rand(dtype max)
     return to_real2(gen_rand32()) * max;
 }
 
+/* generates random numbers from the normal distribution
+   using Box-Muller Transformation.
+ */
+inline static void m_rand_norm(dtype mu, dtype sigma, dtype *a0, dtype *a1)
+{
+    dtype x1, x2, w;
+    do {
+	x1 = to_real2(gen_rand32());
+	x1 = x1*2-1;
+	x2 = to_real2(gen_rand32());
+	x2 = x2*2-1;
+	w = x1 * x1 + x2 * x2;
+    } while (w>=1);
+    w = sqrt( (-2*log(w)) / w );
+    if (a0) {*a0 = x1*w * sigma + mu;}
+    if (a1) {*a1 = x2*w * sigma + mu;}
+}
+
 #define m_min_init numo_sfloat_new_dim0(0.0/0.0)
 #define m_max_init numo_sfloat_new_dim0(0.0/0.0)
 

data/ext/numo/narray/rand.c

@@ -37,21 +37,6 @@ int n_bits(u_int64_t a)
     return xl;
 }
 
-void rand_norm(double *a)
-{
-    double x1, x2, w;
-    do {
-	x1 = genrand_res53_mix();
-	x1 = x1*2-1;
-	x2 = genrand_res53_mix();
-	x2 = x2*2-1;
-	w = x1 * x1 + x2 * x2;
-    } while (w>=1);
-    w = sqrt( (-2*log(w)) / w );
-    a[0] = x1*w;
-    a[1] = x2*w;
-}
-
 static u_int64_t
  random_seed()
 {

data/ext/numo/narray/step.c

@@ -2,11 +2,6 @@
   step.c
   Numerical Array Extension for Ruby
     (C) Copyright 2007,2013 by Masahiro TANAKA
-
-  This program is free software.
-  You can distribute/modify this program
-  under the same terms as Ruby itself.
-  NO WARRANTY.
 */
 #include <ruby.h>
 #include <math.h>

data/ext/numo/narray/struct.c

@@ -2,11 +2,6 @@
   nstrut.c
   Numerical Array Extension for Ruby
     (C) Copyright 1999-2016 by Masahiro TANAKA
-
-  This program is free software.
-  You can distribute/modify this program
-  under the same terms as Ruby itself.
-  NO WARRANTY.
 */
 #include <ruby.h>
 #include "numo/narray.h"
@@ -454,7 +449,7 @@ nary_struct_to_a(VALUE self)
     volatile VALUE opt;
     ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
     ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
-    ndfunc_t ndf = { iter_nstruct_to_a, NO_LOOP, 3, 1, ain, aout };
+    ndfunc_t ndf = {iter_nstruct_to_a, NO_LOOP, 3, 1, ain, aout};
 
     opt = nst_create_member_views(self);
     return na_ndloop_cast_narray_to_rarray(&ndf, self, opt);
@@ -587,7 +582,7 @@ iter_nstruct_from_a(na_loop_t *const lp)
     defs = RARRAY_AREF(lp->option,1);
 
     len = RARRAY_LEN(types);
-    ary = lp->args[0].value;
+    ary = lp->args[1].value;
     //rb_p(CLASS_OF(ary));rb_p(ary);
 
     for (i=0; i<len; i++) {
@@ -595,7 +590,7 @@ iter_nstruct_from_a(na_loop_t *const lp)
         ofs  = NUM2SIZET(RARRAY_AREF(def,2));
         elmt = RARRAY_AREF(types,i);
         GetNArrayView(elmt,ne);
-        ne->offset = lp->args[1].iter[0].pos + ofs;
+        ne->offset = lp->args[0].iter[0].pos + ofs;
         item = RARRAY_AREF(ary,i);
         //rb_p(ary);
         //rb_p(item);
@@ -612,8 +607,8 @@ nary_struct_cast_array(VALUE klass, VALUE rary)
     narray_t *na;
     na_compose_t *nc;
     VALUE opt;
-    ndfunc_arg_in_t ain[3] = {{rb_cArray,0},{Qnil,0},{sym_option}};
-    ndfunc_t ndf = { iter_nstruct_from_a, NO_LOOP, 3, 0, ain, 0 };
+    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};
 
     //fprintf(stderr,"rary:");rb_p(rary);
     //fprintf(stderr,"class_of(rary):");rb_p(CLASS_OF(rary));
@@ -627,7 +622,7 @@ nary_struct_cast_array(VALUE klass, VALUE rary)
     if (na->size>0) {
         opt = nst_create_member_views(nary);
         rb_funcall(nary, rb_intern("allocate"), 0);
-        na_ndloop_cast_rarray_to_narray2(&ndf, rary, nary, opt);
+        na_ndloop_store_rarray2(&ndf, nary, rary, opt);
     }
     return nary;
 }
@@ -689,7 +684,7 @@ static VALUE
 nary_struct_store_struct(VALUE self, VALUE obj)
 {
     ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
-    ndfunc_t ndf = { iter_struct_store_struct, FULL_LOOP, 2, 0, ain, 0 };
+    ndfunc_t ndf = {iter_struct_store_struct, FULL_LOOP, 2, 0, ain, 0};
 
     na_ndloop(&ndf, 2, self, obj);
     return self;

data/lib/erbpp/line_number.rb

@@ -34,7 +34,7 @@ class CountLnString < String
     end
     return if n == @current
     if @current != @countln || @postpone
-      if /^\s*$/ =~ @str || /\A#line / =~ @buf
+      if /\A\s*\z/ =~ @str || /\A#line / =~ @buf || /\n\z/ !~ self
         @postpone = true
       elsif @in_comment
         @postpone = false
@@ -79,9 +79,9 @@ class CountLnString < String
   end
 
   def d(s)
-  p [s, [x,y], r]
-  r
-end
+    p [s, [x,y], r]
+    r
+  end
 
 end
 

data/lib/erbpp/narray_def.rb

@@ -178,11 +178,13 @@ class DataType < ErbPP
     has_math
     is_bit
     is_int
+    is_unsigned
     is_float
     is_real
     is_complex
     is_object
     is_comparable
+    is_double_precision
     mod_var
   ]
   define_attrs attrs
@@ -248,13 +250,12 @@ class DataType < ErbPP
       t = "cT"
     end
     if c=="Integer"
-      if defined?(Fixnum) && Fixnum != Integer
-        @upcast << "rb_hash_aset(hCast, rb_cFixnum, #{t});"
-        @upcast << "rb_hash_aset(hCast, rb_cBignum, #{t});"
-      else
-        # RUBY_VERSION >= "2.4.0"
-        @upcast << "rb_hash_aset(hCast, rb_cInteger, #{t});"
-      end
+      @upcast << "#ifdef RUBY_INTEGER_UNIFICATION"
+      @upcast << "rb_hash_aset(hCast, rb_cInteger, #{t});"
+      @upcast << "#else"
+      @upcast << "rb_hash_aset(hCast, rb_cFixnum, #{t});"
+      @upcast << "rb_hash_aset(hCast, rb_cBignum, #{t});"
+      @upcast << "#endif"
     else
       @upcast << "rb_hash_aset(hCast, rb_c#{c}, #{t});"
     end
@@ -339,4 +340,12 @@ class CastArray < StoreArray
   def condition
     nil
   end
+
+  def c_func
+    "numo_#{tp}_cast_#{tpname}"
+  end
+
+  def c_iter
+    "iter_#{tp}_cast_#{tpname}"
+  end
 end

data/lib/numo/narray.rb

@@ -4,3 +4,5 @@ begin
 rescue LoadError
   require "numo/narray.so"
 end
+
+require "numo/narray/extra"

data/lib/numo/narray/extra.rb

@@ -0,0 +1,465 @@
+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)
+      klass = (self==NArray) ? NArray.array_type(arrays) : self
+      nd = 0
+      arrays.map! do |a|
+        case a
+        when NArray
+          # ok
+        when Numeric
+          a = klass.new(1).store(a)
+        when Array
+          a = klass.cast(a)
+        else
+          raise TypeError,"not Numo::NArray"
+        end
+        if a.ndim > nd
+          nd = a.ndim
+        end
+        a
+      end
+      if axis < 0
+        axis += nd
+      end
+      if axis < 0 || axis >= nd
+        raise ArgumentError,"axis is out of range"
+      end
+      new_shape = nil
+      sum_size = 0
+      arrays.each do |a|
+        a_shape = a.shape
+        if nd != a_shape.size
+          a_shape = [1]*(nd-a_shape.size) + a_shape
+        end
+        sum_size += a_shape.delete_at(axis)
+        if new_shape
+          if new_shape != a_shape
+            raise ShapeError,"shape mismatch"
+          end
+        else
+          new_shape = a_shape
+        end
+      end
+      new_shape.insert(axis,sum_size)
+      result = klass.zeros(*new_shape)
+      lst = 0
+      refs = [true] * nd
+      arrays.each do |a|
+        fst = lst
+        lst = fst + (a.shape[axis-nd]||1)
+        refs[axis] = fst...lst
+        result[*refs] = a
+      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
+      end
+      result
+    end
+
+    def self.vstack(arrays)
+      self.stack(arrays,axis:0)
+    end
+
+    def self.hstack(arrays)
+      self.stack(arrays,axis:1)
+    end
+
+    def self.dstack(arrays)
+      self.stack(arrays,axis:2)
+    end
+=end
+
+    def self.vstack(arrays)
+      self.concatenate(arrays,axis:0)
+    end
+
+    def self.hstack(arrays)
+      self.concatenate(arrays,axis:1)
+    end
+
+    def self.dstack(arrays)
+      self.concatenate(arrays,axis:2)
+    end
+
+    # 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 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]]
+
+    def concatenate(*arrays,axis:0)
+      axis = check_axis(axis)
+      self_shape = shape
+      self_shape.delete_at(axis)
+      sum_size = shape[axis]
+      arrays.map! do |a|
+        case a
+        when NArray
+          # ok
+        when Numeric
+          a = self.class.new(1).store(a)
+        when Array
+          a = self.class.cast(a)
+        else
+          raise TypeError,"not Numo::NArray"
+        end
+        if a.ndim > ndim
+          raise ShapeError,"dimension mismatch"
+        end
+        a_shape = a.shape
+        sum_size += a_shape.delete_at(axis-ndim) || 1
+        if self_shape != a_shape
+          raise ShapeError,"shape mismatch"
+        end
+        a
+      end
+      self_shape.insert(axis,sum_size)
+      result = self.class.zeros(*self_shape)
+      lst = shape[axis]
+      refs = [true] * ndim
+      refs[axis] = 0...lst
+      result[*refs] = self
+      arrays.each do |a|
+        fst = lst
+        lst = fst + (a.shape[axis-ndim] || 1)
+        refs[axis] = fst...lst
+        result[*refs] = a
+      end
+      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][]]
+
+    def split(indices_or_sections, axis:0)
+      axis = check_axis(axis)
+      size_axis = shape[axis]
+      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
+          self[*refs]
+        end
+      when NArray
+        split(indices_or_sections.to_a,axis:axis)
+      when Array
+        refs = [true]*ndim
+        fst = 0
+        (indices_or_sections + [size_axis]).map do |lst|
+          lst = size_axis if lst > size_axis
+          refs[axis] = (fst < size_axis) ? fst...lst : -1...-1
+          fst = lst
+          self[*refs]
+        end
+      else
+        raise TypeError,"argument must be Integer or Array"
+      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][]]
+
+    def vsplit(indices_or_sections)
+      split(indices_or_sections, axis:0)
+    end
+
+    def hsplit(indices_or_sections)
+      split(indices_or_sections, axis:1)
+    end
+
+    def dsplit(indices_or_sections)
+      split(indices_or_sections, axis:2)
+    end
+
+
+    # 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,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 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,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.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|
+        if !i.kind_of?(Integer) || i<1
+          raise ArgumentError,"argument should be positive integer"
+        end
+      end
+      ns = arg.size
+      nd = self.ndim
+      shp = self.shape
+      new_shp = []
+      src_shp = []
+      res_shp = []
+      (nd-ns).times do
+        new_shp << 1
+        new_shp << (n = shp.shift)
+        src_shp << :new
+        src_shp << true
+        res_shp << n
+      end
+      (ns-nd).times do
+        new_shp << (m = arg.shift)
+        new_shp << 1
+        src_shp << :new
+        src_shp << :new
+        res_shp << m
+      end
+      [nd,ns].min.times do
+        new_shp << (m = arg.shift)
+        new_shp << (n = shp.shift)
+        src_shp << :new
+        src_shp << true
+        res_shp << n*m
+      end
+      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]
+    #
+    # 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(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]]
+
+    def repeat(arg,axis:nil)
+      case axis
+      when Integer
+        axis = check_axis(axis)
+        c = self
+      when NilClass
+        c = self.flatten
+        axis = 0
+      else
+        raise ArgumentError,"invalid axis"
+      end
+      case arg
+      when Integer
+        if !arg.kind_of?(Integer) || arg<1
+          raise ArgumentError,"argument should be positive integer"
+        end
+        idx = c.shape[axis].times.map{|i| [i]*arg}.flatten
+      else
+        arg = arg.to_a
+        if arg.size != c.shape[axis]
+          raise ArgumentError,"repeat size shoud be equal to size along axis"
+        end
+        arg.each do |i|
+          if !i.kind_of?(Integer) || i<0
+            raise ArgumentError,"argument should be non-negative integer"
+          end
+        end
+        idx = arg.each_with_index.map{|a,i| [i]*a}.flatten
+      end
+      ref = [true] * c.ndim
+      ref[axis] = idx
+      c[*ref].copy
+    end
+
+
+    def check_axis(axis)
+      if axis < 0
+        axis += ndim
+      end
+      if axis < 0 || axis >= ndim
+        raise ArgumentError,"invalid axis"
+      end
+      axis
+    end
+
+  end
+end