numo-linalg 0.0.1

data/ext/numo/linalg/lapack/tmpl/trf.c

@@ -0,0 +1,276 @@
+<%
+ has_rhs  = (/trs$/ =~ name)
+ has_trans = (/^.(g|l|t).trs$/ =~ name)
+ has_uplo = (/^.(g|pt)/ !~ name)
+ has_ipiv = (/p[bfopt]tr.$/ !~ name)
+ ipiv_out = (has_ipiv && /trf$/ =~ name)
+ ipiv_in  = (has_ipiv && /tr[is]$/ =~ name)
+ is_sym   = (has_uplo || /getr[is]/=~name)
+%>
+#define RHS  <%= has_rhs ? "1":"0" %>
+#define TRANS <%= has_trans ? "1":"0" %>
+#define UPLO <%= has_uplo ? "1":"0" %>
+#define IPIV <%= has_ipiv ? "1":"0" %>
+#define IPIV_OUT <%= ipiv_out ? "1":"0" %>
+#define IPIV_IN <%= ipiv_in ? "1":"0" %>
+#define SYM  <%= is_sym ? "1":"0" %>
+#define args_t <%=func_name%>_args_t
+#define func_p <%=func_name%>_p
+
+typedef struct {
+    int order;
+    char uplo;
+    char trans;
+} args_t;
+
+static <%=func_name%>_t func_p = 0;
+
+static void
+<%=c_iter%>(na_loop_t * const lp)
+{
+    dtype *a;
+#if RHS
+    dtype *b;
+    int    nb, nrhs, ldb;
+#endif
+#if IPIV
+    int   *pv;
+#endif
+    int   *info;
+    int    m, n, lda;
+    args_t *g;
+
+    a = (dtype*)NDL_PTR(lp,0);
+#if IPIV
+    pv = (int*)NDL_PTR(lp,1);
+#endif
+#if RHS
+    b = (dtype*)NDL_PTR(lp,1+IPIV);
+#endif
+    info = (int*)NDL_PTR(lp,1+IPIV+RHS);
+    g = (args_t*)(lp->opt_ptr);
+
+    n = NDL_SHAPE(lp,0)[0];
+    m = NDL_SHAPE(lp,0)[1];
+    lda = NDL_STEP(lp,0) / sizeof(dtype);
+
+#if RHS
+    // same as gels.c
+    if (lp->args[1+IPIV].ndim == 1) {
+        nrhs = 1;
+        nb = NDL_SHAPE(lp,1+IPIV)[0];
+        ldb = (g->order==LAPACK_COL_MAJOR) ? nb : 1;
+    } else {
+        nb = NDL_SHAPE(lp,1+IPIV)[0];
+        nrhs = NDL_SHAPE(lp,1+IPIV)[1];
+        ldb = nrhs;
+        { int tmp; SWAP_IFCOL(g->order,nb,nrhs); }
+    }
+    //printf("order=%d m=%d n=%d nb=%d nrhs=%d lda=%d ldb=%d\n",g->order,m,n,nb,nrhs,lda,ldb);
+#else
+    //printf("order=%d m=%d n=%d lda=%d \n",g->order,m,n,lda);
+#endif
+
+#if SYM
+    n = min_(m,n);
+#else
+    { int tmp; SWAP_IFCOL(g->order,m,n); }
+#endif
+
+    <%
+    func_args = [  "g->order",
+      has_uplo  && "g->uplo",
+      has_trans && "g->trans",
+                   "n",
+      has_rhs   ?  "nrhs" : (!is_sym && "m"),
+                   "a, lda",
+      has_ipiv  && "pv",
+      has_rhs   && "b, ldb",
+    ].select{|x| x}.join(", ")
+    %>
+    *info = (*func_p)(<%=func_args%>);
+    CHECK_ERROR(*info);
+}
+
+/*<%
+ args_v = [
+   "a",
+   ipiv_in && "ipiv",
+   has_rhs && "b",
+ ].select{|x| x}.join(", ")
+
+ args_opt = [
+   has_uplo && "uplo:'U'",
+   has_trans && "trans:'N'",
+   "order:'R'",
+ ].select{|x| x}.join(", ")
+
+ trf = name.sub(/.$/,"f")
+
+ params = [
+   has_rhs ? "@param a [#{class_name}] LU matrix computed by "+trf :
+             mat("a",:inplace),
+   ipiv_in && "@param ipiv [Numo::Int] pivot computed by "+trf,
+   has_rhs && mat("b",:inplace),
+   has_uplo && opt("uplo"),
+   has_trans && opt("trans"),
+   opt("order"),
+ ].select{|x| x}.join("\n  ")
+
+ return_type = [
+   class_name,
+   ipiv_out && "Numo::Int",
+   "Integer"
+ ].select{|x| x}.join(", ")
+
+ return_name = [
+   has_rhs  ?  "b" : "a",
+   ipiv_out && "ipiv",
+   "info"
+ ].select{|x| x}.join(", ")
+%>
+  @overload <%=name%>(<%=args_v%>, [<%=args_opt%>])
+  <%=params%>
+  @return [[<%=return_name%>]] Array<<%=return_type%>>
+<%=outparam(return_name)%>
+
+<%=description%>
+
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE const argv[], VALUE UNUSED(mod))
+{
+<% %>
+    VALUE a, ans;
+#if IPIV_IN
+    VALUE ipiv;
+#endif
+#if RHS
+    VALUE b;
+    size_t n, nb, nrhs;
+    narray_t *na2;
+#endif
+    narray_t *na1;
+    <%
+    aout = [
+      ipiv_out && "{cInt,1,shape_piv}",
+                  "{cInt,0}",
+    ].select{|x| x}.join(",")
+    %>
+#if IPIV_OUT
+    size_t shape_piv[1];
+#endif
+#if IPIV_IN
+# if RHS
+    ndfunc_arg_in_t ain[3] = {{cT,2},{cInt,1},{OVERWRITE,2}};
+# else
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,2},{cInt,1}};
+# endif
+#else
+# if RHS
+    ndfunc_arg_in_t ain[2] = {{cT,2},{OVERWRITE,2}};
+# else
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,2}};
+# endif
+#endif
+    ndfunc_arg_out_t aout[1+IPIV_OUT] = {<%=aout%>};
+    ndfunc_t ndf = {&<%=c_iter%>, NO_LOOP|NDF_EXTRACT,
+                    1+IPIV_IN+RHS, IPIV_OUT+1, ain,aout};
+
+    args_t g = {0,0};
+    VALUE opts[2] = {Qundef,Qundef};
+    VALUE kw_hash = Qnil;
+    ID kw_table[2] = {id_order,id_uplo};
+
+    CHECK_FUNC(func_p,"<%=func_name%>");
+
+#if IPIV_IN
+# if RHS
+    rb_scan_args(argc, argv, "3:", &a, &ipiv, &b, &kw_hash);
+# else
+    rb_scan_args(argc, argv, "2:", &a, &ipiv, &kw_hash);
+# endif
+#else
+# if RHS
+    rb_scan_args(argc, argv, "2:", &a, &b, &kw_hash);
+# else
+    rb_scan_args(argc, argv, "1:", &a, &kw_hash);
+# endif
+#endif
+#if TRANS
+    kw_table[1] = id_trans;
+    rb_get_kwargs(kw_hash, kw_table, 0, 2, opts);
+    g.trans = option_trans(opts[1]);
+#elif UPLO
+    rb_get_kwargs(kw_hash, kw_table, 0, 2, opts);
+    g.uplo = option_uplo(opts[1]);
+#else
+    rb_get_kwargs(kw_hash, kw_table, 0, 1, opts);
+#endif
+    g.order = option_order(opts[0]);
+
+#if !RHS
+    COPY_OR_CAST_TO(a,cT);
+#endif
+    GetNArray(a, na1);
+    CHECK_DIM_GE(na1, 2);
+#if IPIV_OUT
+    shape_piv[0] = min_(ROW_SIZE(na1),COL_SIZE(na1));
+#endif
+
+#if RHS
+    COPY_OR_CAST_TO(b,cT);
+    GetNArray(b, na2);
+    CHECK_DIM_GE(na2, 1);
+    n = COL_SIZE(na1);
+#if SYM
+    n = min_(n,ROW_SIZE(na1));
+#endif
+    // same as gesv.c
+    if (NA_NDIM(na2) == 1) {
+        ain[1+IPIV_IN].dim = 1;
+        nb = COL_SIZE(na2);
+        nrhs = 1;
+    } else {
+        nb = ROW_SIZE(na2);
+        nrhs = COL_SIZE(na2);
+        { int tmp; SWAP_IFCOL(g.order,nb,nrhs); }
+    }
+    if (n != nb) {
+        rb_raise(nary_eShapeError, "matrix dimension mismatch: "
+                 "a.col(or a.row)=%"SZF"u b.row=%"SZF"u", n, nb);
+    }
+#endif
+
+#if IPIV_IN
+# if RHS
+    ans = na_ndloop3(&ndf, &g, 3, a, ipiv, b);
+    return rb_assoc_new(b, ans);
+# else
+    ans = na_ndloop3(&ndf, &g, 2, a, ipiv);
+    return rb_assoc_new(a, ans);
+# endif
+#else
+# if RHS
+    ans = na_ndloop3(&ndf, &g, 2, a, b);
+    return rb_assoc_new(b, ans);
+# else
+    ans = na_ndloop3(&ndf, &g, 1, a);
+#  if IPIV_OUT
+    return rb_ary_unshift(ans, a);
+#  else
+    return rb_assoc_new(a, ans);
+#  endif
+# endif
+#endif
+}
+
+#undef args_t
+#undef func_p
+#undef RHS
+#undef TRANS
+#undef UPLO
+#undef IPIV
+#undef IPIV_OUT
+#undef IPIV_IN
+#undef SYM

data/ext/numo/linalg/numo_linalg.h

@@ -0,0 +1,115 @@
+#if defined __clang__
+#  define UNUSED(name) __unused name
+#else
+#  define UNUSED(name) name
+#endif
+
+#if SIZEOF_INT == 4
+#define cI numo_cInt32
+#define cUI numo_cUInt32
+#elif SIZEOF_INT==8
+#define cI numo_cInt64
+#define cUI numo_cUInt64
+#endif
+
+#if SIZEOF_SIZE_T == 4
+#define cSZ numo_cUInt32
+#define cSSZ numo_cInt32
+#elif SIZEOF_SIZE_T == 8
+#define cSZ numo_cUInt64
+#define cSSZ numo_cInt64
+#endif
+
+#define cDF numo_cDFloat
+#define cDC numo_cDComplex
+#define cSF numo_cSFloat
+#define cSC numo_cSComplex
+#define cInt cI
+#define cUInt cUI
+
+extern VALUE na_expand_dims(VALUE self, VALUE vdim);
+
+#define max_(m,n) (((m)>(n)) ? (m):(n))
+#define min_(m,n) (((m)<(n)) ? (m):(n))
+
+#define ROW_SIZE(na) ((na)->shape[(na)->ndim-2])
+#define COL_SIZE(na) ((na)->shape[(na)->ndim-1])
+
+#define CHECK_NARRAY_TYPE(x,t)                                 \
+    if (CLASS_OF(x)!=(t)) {                                    \
+        rb_raise(rb_eTypeError,"invalid NArray type (class)"); \
+    }
+
+// Error Class ??
+#define CHECK_DIM_GE(na,nd)                                     \
+    if ((na)->ndim<(nd)) {                                      \
+        rb_raise(nary_eShapeError,                              \
+                 "n-dimension=%d, but >=%d is expected",        \
+                 (na)->ndim, (nd));                             \
+    }
+
+#define CHECK_DIM_EQ(na1,nd)                                    \
+    if ((na1)->ndim != (nd)) {                                  \
+        rb_raise(nary_eShapeError,                              \
+                 "dimention mismatch: %d != %d",                \
+                 (na1)->ndim, (nd));                            \
+    }
+
+#define CHECK_SQUARE(name,na)                                           \
+    if ((na)->shape[(na)->ndim-1] != (na)->shape[(na)->ndim-2]) {       \
+        rb_raise(nary_eShapeError,"%s is not square matrix",name);      \
+    }
+
+#define CHECK_SIZE_GE(na,sz)                                    \
+    if ((na)->size < (size_t)(sz)) {                            \
+        rb_raise(nary_eShapeError,                              \
+                 "NArray size must be >= %"SZF"u",(size_t)(sz));\
+    }
+
+#define CHECK_NON_EMPTY(na)                                     \
+    if ((na)->size==0) {                                        \
+        rb_raise(nary_eShapeError,"empty NArray");              \
+    }
+
+#define CHECK_SIZE_EQ(n,m)                                      \
+    if ((n)!=(m)) {                                             \
+        rb_raise(nary_eShapeError,                              \
+                 "size mismatch: %"SZF"d != %"SZF"d",           \
+                 (size_t)(n),(size_t)(m));                      \
+    }
+
+#define CHECK_SAME_SHAPE(na1,na2)                                \
+    {   int i;                                                   \
+        CHECK_DIM_EQ(na1,na2->ndim);                             \
+        for (i=0; i<na1->ndim; i++) {                            \
+            CHECK_SIZE_EQ(na1->shape[i],na2->shape[i]);          \
+        }                                                        \
+    }
+
+#define CHECK_INT_EQ(sm,m,sn,n)                          \
+    if ((m) != (n)) {                                    \
+        rb_raise(nary_eShapeError,                       \
+                 "%s must be == %s: %s=%d %s=%d",        \
+                 sm,sn,sm,m,sn,n);                       \
+    }
+
+// Error Class ??
+#define CHECK_LEADING_GE(sld,ld,sn,n)                    \
+    if ((ld) < (n)) {                                    \
+        rb_raise(nary_eShapeError,                       \
+                 "%s must be >= max(%s,1): %s=%d %s=%d", \
+                 sld,sn,sld,ld,sn,n);                    \
+    }
+
+#define COPY_OR_CAST_TO(a,T)                            \
+    {                                                   \
+        if (CLASS_OF(a) == (T)) {                       \
+            if (!TEST_INPLACE(a)) {                     \
+                a = na_copy(a);                         \
+            }                                           \
+        } else {                                        \
+            a = rb_funcall(T,rb_intern("cast"),1,a);    \
+        }                                               \
+    }
+
+#define swap(a,b) {tmp=a;a=b;b=tmp;}

data/lib/numo/linalg.rb

@@ -0,0 +1,3 @@
+require "numo/linalg/linalg"
+
+Numo::Linalg::Loader.load_library

data/lib/numo/linalg/function.rb

@@ -0,0 +1,1008 @@
+module Numo; module Linalg
+
+  module Blas
+
+    FIXNAME =
+    {
+     cnrm2: :csnrm2,
+     znrm2: :dznrm2,
+    }
+
+    # Call BLAS function prefixed with BLAS char ([sdcz])
+    # defined from data-types of arguments.
+    # @param [Symbol] func  function name without BLAS char.
+    # @param args  arguments passed to Blas function.
+    # @example
+    #      c = Numo::Linalg::Blas.call(:gemm, a, b)
+    def self.call(func,*args)
+      fn = (Linalg.blas_char(*args) + func.to_s).to_sym
+      fn = FIXNAME[fn] || fn
+      send(fn,*args)
+    end
+
+  end
+
+  module Lapack
+
+    FIXNAME =
+    {
+     corgqr: :cungqr,
+     zorgqr: :zungqr,
+    }
+
+    # Call LAPACK function prefixed with BLAS char ([sdcz])
+    # defined from data-types of arguments.
+    # @param [Symbol,String] func  function name without BLAS char.
+    # @param args  arguments passed to Lapack function.
+    # @example
+    #      s = Numo::Linalg::Lapack.call(:gesv, a)
+    def self.call(func,*args)
+      fn = (Linalg.blas_char(*args) + func.to_s).to_sym
+      fn = FIXNAME[fn] || fn
+      send(fn,*args)
+    end
+
+  end
+
+  BLAS_CHAR =
+  {
+   SFloat => "s",
+   DFloat => "d",
+   SComplex => "c",
+   DComplex => "z",
+  }
+
+  module_function
+
+  def blas_char(*args)
+    t = Float
+    args.each do |a|
+      k =
+        case a
+        when NArray
+          a.class
+        when Array
+          NArray.array_type(a)
+        end
+      if k && k < NArray
+        t = k::UPCAST[t]
+      end
+    end
+    BLAS_CHAR[t] || raise(TypeError,"invalid data type for BLAS/LAPACK")
+  end
+
+  # module methods
+
+  ## Matrix and vector products
+
+  # Dot product.
+  # @param a [Numo::NArray] matrix or vector (>= 1-dimensinal NArray)
+  # @param b [Numo::NArray] matrix or vector (>= 1-dimensinal NArray)
+  # @return [Numo::NArray] result of dot product
+  def dot(a, b)
+    a = NArray.asarray(a)
+    b = NArray.asarray(b)
+    case a.ndim
+    when 1
+      case b.ndim
+      when 1
+        Blas.call(:dot, a, b)
+      else
+        Blas.call(:gemv, b, a, trans:'t')
+      end
+    else
+      case b.ndim
+      when 1
+        Blas.call(:gemv, a, b)
+      else
+        Blas.call(:gemm, a, b)
+      end
+    end
+  end
+
+  # Matrix product.
+  # @param a [Numo::NArray] matrix (>= 2-dimensinal NArray)
+  # @param b [Numo::NArray] matrix (>= 2-dimensinal NArray)
+  # @return [Numo::NArray] result of matrix product
+  def matmul(a, b)
+    Blas.call(:gemm, a, b)
+  end
+
+  # Compute a square matrix `a` to the power `n`.
+  #
+  #  * If n > 0: return `a**n`.
+  #  * If n == 0: return identity matrix.
+  #  * If n < 0: return `(a*\*-1)*\*n.abs`.
+  #
+  # @param a [Numo::NArray] square matrix (>= 2-dimensinal NArray).
+  # @param n [Integer] the exponent.
+  # @example
+  #     i = Numo::DFloat[[0, 1], [-1, 0]]
+  #     => Numo::DFloat#shape=[2,2]
+  #     [[0, 1],
+  #      [-1, 0]]
+  #     Numo::Linalg.matrix_power(i,3)
+  #     => Numo::DFloat#shape=[2,2]
+  #     [[0, -1],
+  #      [1, 0]]
+  #     Numo::Linalg.matrix_power(i,0)
+  #     => Numo::DFloat#shape=[2,2]
+  #     [[1, 0],
+  #      [0, 1]]
+  #     Numo::Linalg.matrix_power(i,-3)
+  #     => Numo::DFloat#shape=[2,2]
+  #     [[0, 1],
+  #      [-1, 0]]
+  #
+  #     q = Numo::DFloat.zeros(4,4)
+  #     q[0..1,0..1] = -i
+  #     q[2..3,2..3] = i
+  #     q
+  #     => Numo::DFloat#shape=[4,4]
+  #     [[-0, -1, 0, 0],
+  #      [1, -0, 0, 0],
+  #      [0, 0, 0, 1],
+  #      [0, 0, -1, 0]]
+  #     Numo::Linalg.matrix_power(q,2)
+  #     => Numo::DFloat#shape=[4,4]
+  #     [[-1, 0, 0, 0],
+  #      [0, -1, 0, 0],
+  #      [0, 0, -1, 0],
+  #      [0, 0, 0, -1]]
+
+  def matrix_power(a, n)
+    a = NArray.asarray(a)
+    m,k = a.shape[-2..-1]
+    unless m==k
+      raise NArray::ShapeError, "input must be a square array"
+    end
+    unless Integer===n
+      raise ArgumentError, "exponent must be an integer"
+    end
+    if n == 0
+      return a.class.eye(m)
+    elsif n < 0
+      a = inv(a)
+      n = n.abs
+    end
+    if n <= 3
+      r = a
+      (n-1).times do
+        r = matmul(r,a)
+      end
+    else
+      while (n & 1) == 0
+        a = matmul(a,a)
+        n >>= 1
+      end
+      r = a
+      while n != 0
+        a = matmul(a,a)
+        n >>= 1
+        if (n & 1) != 0
+          r = matmul(r,a)
+        end
+      end
+    end
+    r
+  end
+
+
+  ## factorization
+
+  # Computes a QR factorization of a complex M-by-N matrix A: A = Q \* R.
+  #
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensinal NArray)
+  # @param mode [String]
+  #   - "reduce"  -- returns both Q and R,
+  #   - "r"       -- returns only R,
+  #   - "economy" -- returns both Q and R but computed in economy-size,
+  #   - "raw"     -- returns QR and TAU used in LAPACK.
+  # @return [r]        if mode:"r"
+  # @return [[q,r]]    if mode:"reduce" or "economic"
+  # @return [[qr,tau]] if mode:"raw" (LAPACK geqrf result)
+
+  def qr(a, mode:"reduce")
+    qr,tau, = Lapack.call(:geqrf, a)
+    *shp,m,n = qr.shape
+    r = (m >= n && %w[economic raw].include?(mode)) ?
+      qr[false, 0...n, true].triu : qr.triu
+    mode = mode.to_s.downcase
+    case mode
+    when "r"
+      return r
+    when "raw"
+      return [qr,tau]
+    when "reduce","economic"
+      # skip
+    else
+      raise ArgumentError, "invalid mode:#{mode}"
+    end
+    if m < n
+      q, = Lapack.call(:orgqr, qr[false, 0...m], tau)
+    elsif mode == "economic"
+      q, = Lapack.call(:orgqr, qr, tau)
+    else
+      qqr = qr.class.zeros(*(shp+[m,m]))
+      qqr[false,0...n] = qr
+      q, = Lapack.call(:orgqr, qqr, tau)
+    end
+    return [q,r]
+  end
+
+
+  # Computes the Singular Value Decomposition (SVD) of a M-by-N matrix A,
+  # and the left and/or right singular vectors.  The SVD is written
+  #
+  #     A = U * SIGMA * transpose(V)
+  #
+  # where SIGMA is an M-by-N matrix which is zero except for its
+  # min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
+  # V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA
+  # are the singular values of A; they are real and non-negative, and
+  # are returned in descending order. The first min(m,n) columns of U
+  # and V are the left and right singular vectors of A. Note that the
+  # routine returns V**T, not V.
+  #
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensinal NArray)
+  # @param driver [String or Symbol] choose LAPACK solver from 'svd',
+  #   'sdd'. (optional, default='svd')
+  # @param job [String or Symbol]
+  #   - 'A': all M columns of U and all N rows of V\*\*T are returned in
+  #     the arrays U and VT.
+  #   - 'S': the first min(M,N) columns of U and the first min(M,N)
+  #     rows of V\*\*T are returned in the arrays U and VT.
+  #   - 'N':  no columns of U or rows of V\*\*T are computed.
+  # @return [[sigma,u,vt]] SVD result. Array<Numo::NArray>
+
+  def svd(a, driver:'svd', job:'A')
+    unless /^[ASN]/i =~ job
+      raise ArgumentError, "invalid job: #{job.inspect}"
+    end
+    case driver.to_s
+    when /^(ge)?sdd$/i, "turbo"
+      Lapack.call(:gesdd, a, jobz:job)[0..2]
+    when /^(ge)?svd$/i
+      Lapack.call(:gesvd, a, jobu:job, jobvt:job)[0..2]
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+  end
+
+  # Computes the Singular Values of a M-by-N matrix A.
+  # The SVD is written
+  #
+  #     A = U * SIGMA * transpose(V)
+  #
+  # where SIGMA is an M-by-N matrix which is zero except for its
+  # min(m,n) diagonal elements. The diagonal elements of SIGMA
+  # are the singular values of A; they are real and non-negative, and
+  # are returned in descending order.
+  #
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensinal NArray)
+  # @param driver [String or Symbol] choose LAPACK solver from 'svd',
+  #   'sdd'. (optional, default='svd')
+  # @return [Numo::NArray] returns SIGMA (singular values).
+
+  def svdvals(a, driver:'svd')
+    case driver.to_s
+    when /^(ge)?sdd$/i, "turbo"
+      Lapack.call(:gesdd, a, jobz:'N')[0]
+    when /^(ge)?svd$/i
+      Lapack.call(:gesvd, a, jobu:'N', jobvt:'N')[0]
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+  end
+
+
+  # Computes an LU factorization of a M-by-N matrix A
+  # using partial pivoting with row interchanges.
+  #
+  # The factorization has the form
+  #
+  #     A = P * L * U
+  #
+  # where P is a permutation matrix, L is lower triangular with unit
+  # diagonal elements (lower trapezoidal if m > n), and U is upper
+  # triangular (upper trapezoidal if m < n).
+  #
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensinal NArray)
+  # @param driver [String or Symbol] choose LAPACK diriver from
+  #   'gen','sym','her'. (optional, default='gen')
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle. (omitted when driver:"gen")
+  # @return [[lu, ipiv]]
+  #   - **lu** [Numo::NArray] -- The factors L and U from the factorization
+  #     `A = P*L*U`; the unit diagonal elements of L are not stored.
+  #   - **ipiv** [Numo::NArray] -- The pivot indices; for 1 <= i <= min(M,N),
+  #      row i of the matrix was interchanged with row IPIV(i).
+
+  def lu_fact(a, driver:"gen", uplo:"U")
+    case driver.to_s
+    when /^gen?(trf)?$/i
+      Lapack.call(:getrf, a)[0..1]
+    when /^(sym?|her?)(trf)?$/i
+      func = driver[0..2].downcase+"trf"
+      Lapack.call(func, a, uplo:uplo)[0..1]
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+  end
+
+  # Computes the inverse of a matrix using the LU factorization
+  # computed by Numo::Linalg.lu_fact.
+  #
+  # This method inverts U and then computes inv(A) by solving the system
+  #
+  #     inv(A)*L = inv(U)
+  #
+  # for inv(A).
+  #
+  # @param lu [Numo::NArray] matrix containing the factors L and U
+  #   from the factorization `A = P*L*U` as computed by
+  #   Numo::Linalg.lu_fact.
+  # @param ipiv [Numo::NArray] The pivot indices from
+  #   Numo::Linalg.lu_fact; for 1<=i<=N, row i of the matrix was
+  #   interchanged with row IPIV(i).
+  # @param driver [String or Symbol] choose LAPACK diriver from
+  #   'gen','sym','her'. (optional, default='gen')
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle. (omitted when driver:"gen")
+  # @return [Numo::NArray]  the inverse of the original matrix A.
+
+  def lu_inv(lu, ipiv, driver:"gen", uplo:"U")
+    case driver.to_s
+    when /^gen?(tri)?$/i
+      Lapack.call(:getri, lu, ipiv)[0]
+    when /^(sym?|her?)(tri)?$/i
+      func = driver[0..2].downcase+"tri"
+      Lapack.call(func, lu, ipiv, uplo:uplo)[0]
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+  end
+
+  # Solves a system of linear equations
+  #
+  #     A * X = B  or  A**T * X = B
+  #
+  # with a N-by-N matrix A using the LU factorization computed by
+  # Numo::Linalg.lu_fact
+  #
+  # @param lu [Numo::NArray] matrix containing the factors L and U
+  #   from the factorization `A = P*L*U` as computed by
+  #   Numo::Linalg.lu_fact.
+  # @param ipiv [Numo::NArray] The pivot indices from
+  #   Numo::Linalg.lu_fact; for 1<=i<=N, row i of the matrix was
+  #   interchanged with row IPIV(i).
+  # @param b [Numo::NArray] the right hand side matrix B.
+  # @param driver [String or Symbol] choose LAPACK diriver from
+  #   'gen','sym','her'. (optional, default='gen')
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle. (omitted when driver:"gen")
+  # @param trans [String or Symbol]
+  #   Specifies the form of the system of equations
+  #   (omitted if not driver:"gen"):
+  #
+  #     - If 'N': `A * X = B` (No transpose).
+  #     - If 'T': `A*\*T* X = B` (Transpose).
+  #     - If 'C': `A*\*T* X = B` (Conjugate transpose = Transpose).
+  # @return [Numo::NArray]  the solution matrix X.
+
+  def lu_solve(lu, ipiv, b, driver:"gen", uplo:"U", trans:"N")
+    case driver.to_s
+    when /^gen?(trs)?$/i
+      Lapack.call(:getrs, lu, ipiv, b, trans:trans)[0]
+    when /^(sym?|her?)(trs)?$/i
+      func = driver[0..2].downcase+"trs"
+      Lapack.call(func, lu, ipiv, b, uplo:uplo)[0]
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+  end
+
+
+  # Computes the Cholesky factorization of a symmetric/Hermitian
+  # positive definite matrix A. The factorization has the form
+  #
+  #     A = U**H * U,  if UPLO = 'U', or
+  #     A = L  * L**H,  if UPLO = 'L',
+  #
+  # where U is an upper triangular matrix and L is lower triangular
+  # @param a [Numo::NArray] n-by-n symmetric matrix A (>= 2-dimensinal NArray)
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle.
+  # @return [Numo::NArray] the factor U or L.
+
+  def cho_fact(a, uplo:'U')
+    Lapack.call(:potrf, a, uplo:uplo)[0]
+  end
+  #alias cholesky cho_fact
+
+  # Computes the inverse of a symmetric/Hermitian
+  # positive definite matrix A using the Cholesky factorization
+  # `A = U**T*U` or `A = L*L**T` computed by Linalg.cho_fact.
+  #
+  # @param a [Numo::NArray] the triangular factor U or L from the
+  #   Cholesky factorization, as computed by Linalg.cho_fact.
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle.
+  # @return [Numo::NArray] the upper or lower triangle of the
+  #   (symmetric) inverse of A.
+
+  def cho_inv(a, uplo:'U')
+    Lapack.call(:potri, a, uplo:uplo)[0]
+  end
+
+  # Solves a system of linear equations
+  #     A*X = B
+  # with a symmetric/Hermitian positive definite matrix A
+  # using the Cholesky factorization
+  # `A = U**T*U` or `A = L*L**T` computed by Linalg.cho_fact.
+  # @param a [Numo::NArray] the triangular factor U or L from the
+  #   Cholesky factorization, as computed by Linalg.cho_fact.
+  # @param b [Numo::NArray] the right hand side matrix B.
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle.
+  # @return [Numo::NArray] the solution matrix X.
+
+  def cho_solve(a, b, uplo:'U')
+    Lapack.call(:potrs, a, b, uplo:uplo)[0]
+  end
+
+
+  ## Matrix eigenvalues
+
+  # Computes the eigenvalues and, optionally, the left and/or right
+  # eigenvectors for a square nonsymmetric matrix A.
+  #
+  # @param a [Numo::NArray] square nonsymmetric matrix (>= 2-dimensinal NArray)
+  # @param left [Bool] (optional) If true, left eigenvectors are computed.
+  # @param right [Bool] (optional) If true, right eigenvectors are computed.
+  # @return [[w,vl,vr]]
+  #   - **w**  [Numo::NArray] -- The eigenvalues.
+  #   - **vl** [Numo::NArray] -- The left eigenvectors if left is true, otherwise nil.
+  #   - **vr** [Numo::NArray] -- The right eigenvectors if right is true, otherwise nil.
+
+  def eig(a, left:false, right:true)
+    jobvl, jobvr = left, right
+    case blas_char(a)
+    when /c|z/
+      w, vl, vr, info = Lapack.call(:geev, a, jobvl:jobvl, jobvr:jobvr)
+    else
+      wr, wi, vl, vr, info = Lapack.call(:geev, a, jobvl:jobvl, jobvr:jobvr)
+      w  = wr + wi * Complex::I
+      vl = _make_complex_eigvecs(w,vl) if left
+      vr = _make_complex_eigvecs(w,vr) if right
+    end
+    [w,vl,vr] #.compact
+  end
+
+  # Computes the eigenvalues and, optionally, the left and/or right
+  # eigenvectors for a square symmetric/hermitian matrix A.
+  #
+  # @param a [Numo::NArray] square nonsymmetric matrix (>= 2-dimensinal NArray)
+  # @param values_only [Bool] (optional) If false, eigenvectors are computed.
+  # @param uplo [String or Symbol] (optional, default='U')
+  #   Access upper ('U') or lower ('L') triangle.
+  # @return [[w,v]]
+  #   - **w** [Numo::NArray] -- The eigenvalues.
+  #   - **v** [Numo::NArray] -- The eigenvectors if vals_only is false, otherwise nil.
+
+  def eigh(a, vals_only:false, uplo:false, turbo:false)
+    jobz = vals_only ? 'N' : 'V' # jobz: Compute eigenvalues and eigenvectors.
+    case blas_char(a)
+    when /c|z/
+      func = turbo ? :hegv : :heev
+    else
+      func = turbo ? :sygv : :syev
+    end
+    w, v, = Lapack.call(func, a, uplo:uplo, jobz:jobz)
+    [w,v] #.compact
+  end
+
+  # Computes the eigenvalues only for a square nonsymmetric matrix A.
+  #
+  # @param a [Numo::NArray] square nonsymmetric matrix (>= 2-dimensinal NArray)
+  # @return [Numo::NArray] eigenvalues
+
+  def eigvals(a)
+    jobvl, jobvr = 'N','N'
+    case blas_char(a)
+    when /c|z/
+      w, = Lapack.call(:geev, a, jobvl:jobvl, jobvr:jobvr)
+    else
+      wr, wi, = Lapack.call(:geev, a, jobvl:jobvl, jobvr:jobvr)
+      w  = wr + wi * Complex::I
+    end
+    w
+  end
+
+  # Computes the eigenvalues for a square symmetric/hermitian matrix A.
+  #
+  # @param a [Numo::NArray] square symmetric/hermitian matrix
+  #   (>= 2-dimensinal NArray)
+  # @param uplo [String or Symbol] (optional, default='U')
+  #   Access upper ('U') or lower ('L') triangle.
+  # @return [Numo::NArray] eigenvalues
+
+  def eigvalsh(a, uplo:false, turbo:false)
+    jobz = 'N' # jobz: Compute eigenvalues and eigenvectors.
+    case blas_char(a)
+    when /c|z/
+      func = turbo ? :hegv : :heev
+    else
+      func = turbo ? :sygv : :syev
+    end
+    Lapack.call(func, a, uplo:uplo, jobz:jobz)[0]
+  end
+
+
+  ## Norms and other numbers
+
+  # Compute matrix or vector norm.
+  #
+  #     |  ord  |  matrix norm           | vector norm                 |
+  #     | ----- | ---------------------- | --------------------------- |
+  #     |  nil  | Frobenius norm         | 2-norm                      |
+  #     | 'fro' | Frobenius norm         |  -                          |
+  #     | 'inf' | x.abs.sum(axis:-1).max | x.abs.max                   |
+  #     |    0  |  -                     | (x.ne 0).sum                |
+  #     |    1  | x.abs.sum(axis:-2).max | same as below               |
+  #     |    2  | 2-norm (max sing_vals) | same as below               |
+  #     | other |  -                     | (x.abs**ord).sum**(1.0/ord) |
+  #
+  # @param a [Numo::NArray] matrix or vector (>= 1-dimensinal NArray)
+  # @param ord [String or Symbol] Order of the norm .
+  # @param axis [Integer or Array] Applied axes (optional).
+  # @param keepdims [Bool] If true, the applied axes are left in
+  #   result with size one (optional).
+  # @return [Numo::NArray] norm result
+
+  def norm(a, ord=nil, axis:nil, keepdims:false)
+    a = Numo::NArray.asarray(a)
+
+    # check axis
+    if axis
+      case axis
+      when Integer
+        axis = [axis]
+      when Array
+        if axis.size < 1 || axis.size > 2
+          raise ArgmentError, "axis option should be 1- or 2-element array"
+        end
+      else
+        raise ArgumentError, "invalid option for axis: #{axis}"
+      end
+      # swap axes
+      if a.ndim > 1
+        idx = (0...a.ndim).to_a
+        tmp = []
+        axis.each do |i|
+          x = idx[i]
+          if x.nil?
+            raise ArgmentError, "axis contains same dimension"
+          end
+          tmp << x
+          idx[i] = nil
+        end
+        idx.compact!
+        idx.concat(tmp)
+        a = a.transpose(*idx)
+      end
+    else
+      case a.ndim
+      when 0
+        raise ArgumentError, "zero-dimensional array"
+      when 1
+        axis = [-1]
+      else
+        axis = [-2,-1]
+      end
+    end
+
+    # calculate norm
+    case axis.size
+
+    when 1  # vector
+      k = keepdims
+      ord ||= 2  # default
+      case ord.to_s
+      when "0"
+        r = a.class.cast(a.ne(0)).sum(axis:-1, keepdims:k)
+      when "1"
+        r = a.abs.sum(axis:-1, keepdims:k)
+      when "2"
+        r = Blas.call(:nrm2, a, keepdims:k)
+      when /^-?\d+$/
+        o = ord.to_i
+        r = (a.abs**o).sum(axis:-1, keepdims:k)**(1.0/o)
+      when /^inf(inity)?$/i
+        r = a.abs.max(axis:-1, keepdims:k)
+      when /^-inf(inity)?$/i
+        r = a.abs.min(axis:-1, keepdims:k)
+      else
+        raise ArgumentError, "ord (#{ord}) is invalid for vector norm"
+      end
+
+    when 2  # matrix
+      if keepdims
+        fixdims = [true] * a.ndim
+        axis.each do |i|
+          if i < -a.ndim || i >= a.ndim
+            raise ArgmentError, "axis (%d) is out of range", i
+          end
+          fixdims[i] = :new
+        end
+      end
+      ord ||= "fro"  # default
+      case ord.to_s
+      when "1"
+        r, = Lapack.call(:lange, a, '1')
+      when "-1"
+        r = a.abs.sum(axis:-2).min(axis:-1)
+      when "2"
+        svd, = Lapack.call(:gesvd, a, jobu:'N', jobvt:'N')
+        r = svd.max(axis:-1)
+      when "-2"
+        svd, = Lapack.call(:gesvd, a, jobu:'N', jobvt:'N')
+        r = svd.min(axis:-1)
+      when /^f(ro)?$/i
+        r, = Lapack.call(:lange, a, 'F')
+      when /^inf(inity)?$/i
+        r, = Lapack.call(:lange, a, 'I')
+      when /^-inf(inity)?$/i
+        r = a.abs.sum(axis:-1).min(axis:-1)
+      else
+        raise ArgumentError, "ord (#{ord}) is invalid for matrix norm"
+      end
+      if keepdims
+        if NArray===r
+          r = r[*fixdims]
+        else
+          r = a.class.new(1,1).store(r)
+        end
+      end
+    end
+    return r
+  end
+
+  # Compute the condition number of a matrix
+  # using the norm with one of the following order.
+  #
+  #     |  ord  |  matrix norm           |
+  #     | ----- | ---------------------- |
+  #     |  nil  | 2-norm using SVD       |
+  #     | 'fro' | Frobenius norm         |
+  #     | 'inf' | x.abs.sum(axis:-1).max |
+  #     |    1  | x.abs.sum(axis:-2).max |
+  #     |    2  | 2-norm (max sing_vals) |
+  #
+  # @param a [Numo::NArray] matrix or vector (>= 1-dimensinal NArray)
+  # @param ord [String or Symbol] Order of the norm.
+  # @return [Numo::NArray] cond result
+  # @example
+  #     a = Numo::DFloat[[1, 0, -1], [0, 1, 0], [1, 0, 1]]
+  #     => Numo::DFloat#shape=[3,3]
+  #     [[1, 0, -1],
+  #      [0, 1, 0],
+  #      [1, 0, 1]]
+  #     LA = Numo::Linalg
+  #     LA.cond(a)
+  #     => 1.4142135623730951
+  #     LA.cond(a, 'fro')
+  #     => 3.1622776601683795
+  #     LA.cond(a, 'inf')
+  #     => 2.0
+  #     LA.cond(a, '-inf')
+  #     => 1.0
+  #     LA.cond(a, 1)
+  #     => 2.0
+  #     LA.cond(a, -1)
+  #     => 1.0
+  #     LA.cond(a, 2)
+  #     => 1.4142135623730951
+  #     LA.cond(a, -2)
+  #     => 0.7071067811865475
+  #     (LA.svdvals(a)).min*(LA.svdvals(LA.inv(a))).min
+  #     => 0.7071067811865475
+
+  def cond(a,ord=nil)
+    if ord.nil?
+      s = svdvals(a)
+      s[false, 0]/s[false, -1]
+    else
+      norm(a, ord, axis:[-2,-1]) * norm(inv(a), ord, axis:[-2,-1])
+    end
+  end
+
+  # Determinant of a matrix
+  #
+  # @param a [Numo::NArray] matrix (>= 2-dimensional NArray)
+  # @return [Float or Complex or Numo::NArray]
+
+  def det(a)
+    lu, piv, = Lapack.call(:getrf, a)
+    idx = piv.new_narray.store(piv.class.new(piv.shape[-1]).seq(1))
+    m = piv.eq(idx).count_false(axis:-1) % 2
+    sign = m * -2 + 1
+    lu.diagonal.prod(axis:-1) * sign
+  end
+
+  # Natural logarithm of the determinant of a matrix
+  #
+  # @param a [Numo::NArray] matrix (>= 2-dimensional NArray)
+  # @return [[sign,logdet]]
+  #   - **sign** -- A number representing the sign of the determinant.
+  #   - **logdet** -- The natural log of the absolute value of the determinant.
+
+  def slogdet(a)
+    lu, piv, = Lapack.call(:getrf, a)
+    idx = piv.new_narray.store(piv.class.new(piv.shape[-1]).seq(1))
+    m = piv.eq(idx).count_false(axis:-1) % 2
+    sign = m * -2 + 1
+
+    lud = lu.diagonal
+    if (lud.eq 0).any?
+      return 0, (-Float::INFINITY)
+    end
+    lud_abs = lud.abs
+    sign *= (lud/lud_abs).prod
+    [sign, NMath.log(lud_abs).sum(axis:-1)]
+  end
+
+  # Compute matrix rank of array using SVD
+  # *Rank* is the number of singular values greater than *tol*.
+  #
+  # @param m [Numo::NArray] matrix (>= 2-dimensional NArray)
+  # @param tol [Float] threshold below which singular values are
+  #   considered to be zero. If *tol* is nil,
+  #   `tol = sing_vals.max() * m.shape.max * EPSILON`.
+  # @param driver [String or Symbol] choose LAPACK solver from 'svd',
+  #   'sdd'. (optional, default='svd')
+
+  def matrix_rank(m, tol:nil, driver:'svd')
+    m = Numo::NArray.asarray(m)
+    if m.ndim < 2
+      m.ne(0).any? ? 1 : 0
+    else
+      case driver.to_s
+      when /^(ge)?sdd$/, "turbo"
+        s = Lapack.call(:gesdd, m, jobz:'N')[0]
+      when /^(ge)?svd$/
+        s = Lapack.call(:gesvd, m, jobu:'N', jobvt:'N')[0]
+      else
+        raise ArgumentError, "invalid driver: #{driver}"
+      end
+      tol ||= s.max(axis:-1, keepdims:true) *
+        (m.shape[-2..-1].max * s.class::EPSILON)
+      (s > tol).count(axis:-1)
+    end
+  end
+
+
+  ## Solving equations and inverting matrices
+
+  # Solves linear equation `a * x = b` for `x`
+  # from square matrix `a`
+  # @param a [Numo::NArray] n-by-n square matrix  (>= 2-dimensinal NArray)
+  # @param b [Numo::NArray] n-by-nrhs right-hand-side matrix (>=
+  #  1-dimensinal NArray)
+  # @param driver [String or Symbol] choose LAPACK diriver from
+  #   'gen','sym','her' or 'pos'. (optional, default='gen')
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle. (omitted when driver:"gen")
+  # @return [Numo::NArray] The solusion matrix/vector X.
+
+  def solve(a, b, driver:"gen", uplo:'U')
+    case driver.to_s
+    when /^gen?(sv)?$/i
+      # returns lu, x, ipiv, info
+      Lapack.call(:gesv, a, b)[1]
+    when /^(sym?|her?|pos?)(sv)?$/i
+      func = driver[0..2].downcase+"sv"
+      Lapack.call(func, a, b, uplo:uplo)[1]
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+  end
+
+  # Inverse matrix from square matrix `a`
+  # @param a [Numo::NArray] n-by-n square matrix  (>= 2-dimensinal NArray)
+  # @param driver [String or Symbol] choose LAPACK diriver
+  #   ('ge'|'sy'|'he'|'po') + ("sv"|"trf")
+  #   (optional, default='getrf')
+  # @param uplo [String or Symbol] optional, default='U'. Access upper
+  #   or ('U') lower ('L') triangle. (omitted when driver:"ge")
+  # @return [Numo::NArray] The inverse matrix.
+  # @example
+  #   Numo::Linalg.inv(a,driver:'getrf')
+  #   => Numo::DFloat#shape=[2,2]
+  #   [[-2, 1],
+  #    [1.5, -0.5]]
+  #   a.dot(Numo::Linalg.inv(a,driver:'getrf'))
+  #   => Numo::DFloat#shape=[2,2]
+  #   [[1, 0],
+  #    [8.88178e-16, 1]]
+
+  def inv(a, driver:"getrf", uplo:'U')
+    case driver
+    when /(ge|sy|he|po)sv$/
+      d = $1
+      b = a.new_zeros.eye
+      solve(a, b, driver:d, uplo:uplo)
+    when /(ge|sy|he)tr[fi]$/
+      d = $1
+      lu, piv = lu_fact(a, driver:d, uplo:uplo)
+      lu_inv(lu, piv, driver:d, uplo:uplo)
+    when /potr[fi]$/
+      lu = cho_fact(a, uplo:uplo)
+      cho_inv(lu, uplo:uplo)
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+  end
+
+  # Computes the minimum-norm solution to a linear least squares
+  # problem:
+  #
+  #         minimize 2-norm(| b - A*x |)
+  #
+  # using the singular value decomposition (SVD) of A.
+  # A is an M-by-N matrix which may be rank-deficient.
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensinal NArray)
+  # @param b [Numo::NArray] m-by-nrhs right-hand-side matrix b
+  #   (>= 1-dimensinal NArray)
+  # @param driver [String or Symbol] choose LAPACK driver from
+  #   'lsd','lss','lsy' (optional, default='lsd')
+  # @param rcond [Float] (optional, default=-1)
+  #   RCOND is used to determine the effective rank of A.
+  #   Singular values `S(i) <= RCOND*S(1)` are treated as zero.
+  #   If RCOND < 0, machine precision is used instead.
+  # @return [[x, resids, rank, s]]
+  #   - **x** -- The solution matrix/vector X.
+  #   - **resids** -- Sums of residues, squared 2-norm for each column in
+  #     `b - a x`. If matrix_rank(a) < N or > M, or 'gelsy' is used,
+  #     this is an empty array.
+  #   - **rank** --  The effective rank of A, i.e.,
+  #     the number of singular values which are greater than RCOND*S(1).
+  #   - **s** --  The singular values of A in decreasing order.
+  #     Returns nil if 'gelsy' is used.
+
+  def lstsq(a, b, driver:'lsd', rcond:-1)
+    a = NArray.asarray(a)
+    b = NArray.asarray(b)
+    b_orig = nil
+    if b.shape.size==1
+      b_orig = b
+      b = b_orig[true,:new]
+    end
+    m = a.shape[-2]
+    n = a.shape[-1]
+    #nrhs = b.shape[-1]
+    if m != b.shape[-2]
+      raise NArray::ShapeError, "size mismatch: A-row and B-row"
+    end
+    if m < n   # need to extend b matrix
+      shp = b.shape
+      shp[-2] = n
+      b2 = b.class.zeros(*shp)
+      b2[false,0...m,true] = b
+      b = b2
+    end
+    case driver.to_s
+    when /^(ge)?lsd$/i
+      # x, s, rank, info
+      x, s, rank, = Lapack.call(:gelsd, a, b, rcond:rcond)
+    when /^(ge)?lss$/i
+      # v, x, s, rank, info
+      _, x, s, rank, = Lapack.call(:gelss, a, b, rcond:rcond)
+    when /^(ge)?lsy$/i
+      jpvt = Int32.zeros(*a[false,0,true].shape)
+      # v, x, jpvt, rank, info
+      _, x, _, rank, = Lapack.call(:gelsy, a, b, jpvt, rcond:rcond)
+      s = nil
+    else
+      raise ArgumentError, "invalid driver: #{driver}"
+    end
+    resids = nil
+    if m > n
+      if /ls(d|s)$/i =~ driver
+        case rank
+        when n
+          resids = (x[n..-1,true].abs**2).sum(axis:0)
+        when NArray
+          if true
+            resids = (x[false,n..-1,true].abs**2).sum(axis:-2)
+          else
+            resids = x[false,0,true].new_zeros
+            mask = rank.eq(n)
+            # NArray does not suppurt this yet.
+            resids[mask,true] = (x[mask,n..-1,true].abs**2).sum(axis:-2)
+          end
+        end
+      end
+      x = x[false,0...n,true]
+    end
+    if b_orig && b_orig.shape.size==1
+      x = x[true,0]
+      resids &&= resids[false,0]
+    end
+    [x, resids, rank, s]
+  end
+
+  # Compute the (Moore-Penrose) pseudo-inverse of a matrix
+  # using svd or lstsq.
+  #
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensinal NArray)
+  # @param driver [String or Symbol] choose LAPACK driver from
+  #   SVD ('svd', 'sdd') or Least square ('lsd','lss','lsy')
+  #   (optional, default='svd')
+  # @param rcond [Float] (optional, default=-1)
+  #   RCOND is used to determine the effective rank of A.
+  #   Singular values `S(i) <= RCOND*S(1)` are treated as zero.
+  #   If RCOND < 0, machine precision is used instead.
+  # @return [Numo::NArray]
+  # @example
+  #   a = Numo::DFloat.new(5,3).rand_norm
+  #   => Numo::DFloat#shape=[5,3]
+  #   [[-0.581255, -0.168354, 0.586895],
+  #    [-0.595142, -0.802802, -0.326106],
+  #    [0.282922, 1.68427, 0.918499],
+  #    [-0.0485384, -0.464453, -0.992194],
+  #    [0.413794, -0.60717, -0.699695]]
+  #   b = Numo::Linalg.pinv(a,driver:"svd")
+  #   => Numo::DFloat(view)#shape=[3,5]
+  #   [[-0.360863, -0.813125, -0.353367, -0.891963, 0.877253],
+  #    [-0.227645, 0.162939, 0.696655, 0.787685, -0.469346],
+  #    [0.408671, -0.308323, -0.337807, -1.13833, 0.228051]]
+  #   (a-a.dot(b.dot(a))).abs.max
+  #   => 5.551115123125783e-16
+
+  def pinv(a, driver:"svd", rcond:nil)
+    a = NArray.asarray(a)
+    if a.ndim < 2
+      raise NArray::ShapeError, "2-d array is required"
+    end
+    case driver
+    when /^(ge)?s[dv]d$/
+      s, u, vh = svd(a, driver:driver, job:'S')
+      if rcond.nil? || rcond < 0
+        rcond = ((SFloat===s) ? 1e3 : 1e6) * s.class::EPSILON
+      elsif ! Numeric === rcond
+        raise ArgumentError, "rcond must be Numeric"
+      end
+      cond = (s > rcond * s.max(axis:-1, keepdims:true))
+      if cond.all?
+        r = s.reciprocal
+      else
+        r = s.new_zeros
+        r[cond] = s[cond].reciprocal
+      end
+      u *= r[false,:new,true]
+      dot(u,vh).conj.swapaxes(-2,-1)
+    when /^(ge)?ls[dsy]$/
+      b = a.class.eye(a.shape[-2])
+      x, = lstsq(a, b, driver:driver, rcond:rcond)
+      x
+    else
+      raise ArgumentError, "#{driver.inspect} is not one of drivers: "+
+        "svd, sdd, lsd, lss, lsy"
+    end
+  end
+
+  private
+
+  # @!visibility private
+  def _make_complex_eigvecs(w, vin) # :nodoc:
+    v = w.class.cast(vin)
+    # broadcast to vin.shape
+    m = (w.imag > 0 | Bit.zeros(*vin.shape)).where
+    v[m].imag = vin[m+1]
+    v[m+1] = v[m].conj
+    v
+  end
+
+end
+end