numo-linalg 0.1.1 → 0.1.6

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

@@ -0,0 +1,130 @@
+#define args_t <%=func_name%>_args_t
+#define func_p <%=func_name%>_p
+
+typedef struct {
+    int order;
+    int itype;
+    char jobz;
+    char uplo;
+    char range;
+    int il;
+    int iu;
+} args_t;
+
+static <%=func_name%>_t func_p = 0;
+
+static void
+<%=c_iter%>(na_loop_t * const lp)
+{
+    dtype *a, *b, *z;
+    rtype *w;
+    int   *ifail;
+    int   *info;
+    int    m, n, lda, ldb, ldz;
+    rtype  vl = 0, vu = 0;
+    rtype  abstol = 0;
+
+    args_t *g;
+
+    a = (dtype*)NDL_PTR(lp, 0);
+    b = (dtype*)NDL_PTR(lp, 1);
+    w = (rtype*)NDL_PTR(lp, 2);
+    z = (dtype*)NDL_PTR(lp, 3);
+    ifail = (int*)NDL_PTR(lp, 4);
+    info = (int*)NDL_PTR(lp, 5);
+    g = (args_t*)(lp->opt_ptr);
+
+    n = NDL_SHAPE(lp, 0)[1];
+    lda = NDL_STEP(lp, 0) / sizeof(dtype);
+    ldb = NDL_STEP(lp, 1) / sizeof(dtype);
+    ldz = NDL_SHAPE(lp, 3)[1];
+
+    *info = (*func_p)( g->order, g->itype, g->jobz, g->range, g->uplo, n, a, lda, b, ldb,
+                       vl, vu, g->il, g->iu, abstol, &m, w, z, ldz, ifail );
+
+    CHECK_ERROR(*info);
+}
+
+/*
+<%
+params = [
+  mat("a",:inplace),
+  mat("b",:inplace),
+  "@param [Integer] itype Specifies the problem type to be solved.  If 1:  A*x = (lambda)*B*x, If 2:  A*B*x = (lambda)*x, If 3:  B*A*x = (lambda)*x.",
+  jobe("jobz"),
+  opt("uplo"),
+  opt("order"),
+  "@param [String or Symbol] range If 'A': Compute all eigenvalues, if 'I': Compute eigenvalues with indices il to iu (default='A')",
+  "@param [Integer] il Specifies the index of the smallest eigenvalue in ascending order to be returned. If range = 'A', il is not referenced.",
+  "@param [Integer] iu Specifies the index of the largest eigenvalue in ascending order to be returned. Constraint: 1<=il<=iu<=N. If range = 'A', iu is not referenced.",
+].select{|x| x}.join("\n  ")
+return_name="a, b, w, z, ifail, info"
+%>
+  @overload <%=name%>(a, b, [itype:1, jobz:'V', uplo:'U', order:'R', range:'I', il: 1, il: 2])
+  <%=params%>
+  @return [[<%=return_name%>]]
+    Array<<%=real_class_name%>,<%=real_class_name%>,<%=real_class_name%>,<%=real_class_name%>,<%=real_class_name%>,Integer>
+<%=outparam(return_name)%>
+
+<%=description%>
+*/
+
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE const argv[], VALUE UNUSED(mod))
+{
+    VALUE a, b, ans;
+    int   n, nb, m;
+    narray_t *na1, *na2;
+    size_t w_shape[1];
+    size_t z_shape[2];
+    size_t ifail_shape[1];
+
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE, 2}, {OVERWRITE, 2}};
+    ndfunc_arg_out_t aout[4] = {{cRT, 1, w_shape}, {cT, 2, z_shape}, {cI, 1, ifail_shape}, {cInt, 0}};
+    ndfunc_t ndf = {&<%=c_iter%>, NO_LOOP | NDF_EXTRACT, 2, 4, ain, aout};
+
+    args_t g;
+    VALUE opts[7] = {Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef};
+    VALUE kw_hash = Qnil;
+    ID kw_table[7] = {id_order, id_jobz, id_uplo, id_itype, id_range, id_il, id_iu};
+
+    CHECK_FUNC(func_p,"<%=func_name%>");
+
+    rb_scan_args(argc, argv, "2:", &a, &b, &kw_hash);
+    rb_get_kwargs(kw_hash, kw_table, 0, 7, opts);
+    g.order = option_order(opts[0]);
+    g.jobz = option_job(opts[1], 'V', 'N');
+    g.uplo = option_uplo(opts[2]);
+    g.itype = NUM2INT(option_value(opts[3], INT2FIX(1)));
+    g.range = option_range(opts[4], 'A', 'I');
+    g.il = NUM2INT(option_value(opts[5], INT2FIX(1)));
+    g.iu = NUM2INT(option_value(opts[6], INT2FIX(1)));
+
+    COPY_OR_CAST_TO(a, cT);
+    GetNArray(a, na1);
+    CHECK_DIM_GE(na1, 2);
+
+    COPY_OR_CAST_TO(b, cT);
+    GetNArray(b, na2);
+    CHECK_DIM_GE(na2, 2);
+    CHECK_SQUARE("matrix a", na1);
+    n  = COL_SIZE(na1);
+    CHECK_SQUARE("matrix b", na2);
+    nb = COL_SIZE(na2);
+    if (n != nb) {
+        rb_raise(nary_eShapeError, "matrix a and b must have same size");
+    }
+
+    m = g.range == 'I' ? g.iu - g.il + 1 : n;
+    w_shape[0] = m;
+    z_shape[0] = n;
+    z_shape[1] = m;
+    ifail_shape[0] = m;
+
+    ans = na_ndloop3(&ndf, &g, 2, a, b);
+
+    return rb_ary_new3(6, a, b, RARRAY_AREF(ans, 0), RARRAY_AREF(ans, 1), RARRAY_AREF(ans, 2), RARRAY_AREF(ans, 3));
+}
+
+#undef args_t
+#undef func_p

data/ext/numo/linalg/mkmf_linalg.rb

@@ -0,0 +1,84 @@
+require 'mkmf'
+
+def create_site_conf
+  ldirs = [
+    dir_config("mkl")[1],
+    dir_config("openblas")[1],
+    dir_config("atlas")[1],
+    dir_config("blas")[1],
+    dir_config("lapack")[1],
+  ]
+  bked = with_config("backend")
+
+  require 'fiddle'
+
+  message "creating lib/site_conf.rb\n"
+
+  FileUtils.mkdir_p "lib"
+
+  ext = detect_library_extension
+
+  open("lib/site_conf.rb","w"){|f| f.write "
+module Numo
+  module Linalg
+
+    BACKEND = #{bked.inspect}
+    MKL_LIBPATH = #{ldirs[0].inspect}
+    OPENBLAS_LIBPATH = #{ldirs[1].inspect}
+    ATLAS_LIBPATH = #{ldirs[2].inspect}
+    BLAS_LIBPATH = #{ldirs[3].inspect}
+    LAPACK_LIBPATH = #{ldirs[4].inspect}
+
+    module Loader
+      EXT = '#{ext}'
+    end
+
+  end
+end"
+  }
+end
+
+def detect_library_extension
+  case RbConfig::CONFIG['host_os']
+  when /mswin|msys|mingw|cygwin/
+    'dll'
+  when /darwin|mac os/
+    'dylib'
+  else
+    'so'
+  end
+end
+
+require 'numo/narray'
+
+def find_narray_h
+  $LOAD_PATH.each do |x|
+    if File.exist? File.join(x,'numo/numo/narray.h')
+      $INCFLAGS = "-I#{x}/numo " + $INCFLAGS
+      break
+    end
+  end
+end
+
+def find_libnarray_a
+  $LOAD_PATH.each do |x|
+    if File.exist? File.join(x,'numo/libnarray.a')
+      $LDFLAGS = "-L#{x}/numo " + $LDFLAGS
+      break
+    end
+  end
+end
+
+def create_depend(base_dir)
+  require 'erb'
+  message "creating depend\n"
+  dep_path = "#{base_dir}/depend"
+  File.open(dep_path, "w") do |dep|
+    dep_erb_path = "#{base_dir}/depend.erb"
+    File.open(dep_erb_path, "r") do |dep_erb|
+      erb = ERB.new(dep_erb.read)
+      erb.filename = dep_erb_path
+      dep.print(erb.result)
+    end
+  end
+end

data/lib/numo/linalg/autoloader.rb

@@ -19,15 +19,23 @@ module Numo
       # @return [String] name of loaded backend library (mkl/openblas/lapack)
       def load_library
         mkl_dirs = ['/opt/intel/lib', '/opt/intel/lib64', '/opt/intel/mkl/lib', '/opt/intel/mkl/lib64']
-        openblas_dirs = ['/opt/openblas/lib', '/opt/openblas/lib64', '/usr/local/opt/openblas/lib']
+        openblas_dirs = ['/opt/OpenBLAS/lib', '/opt/OpenBLAS/lib64', '/opt/openblas/lib', '/opt/openblas/lib64',
+                         '/usr/local/opt/openblas/lib']
         atlas_dirs = ['/opt/atlas/lib', '/opt/atlas/lib64',
                       '/usr/lib/atlas', '/usr/lib64/atlas', '/usr/local/opt/atlas/lib']
         lapacke_dirs = ['/opt/lapack/lib', '/opt/lapack/lib64', '/opt/local/lib/lapack',
                         '/usr/local/opt/lapack/lib']
         opt_dirs =  ['/opt/local/lib', '/opt/local/lib64', '/opt/lib', '/opt/lib64']
         base_dirs = ['/usr/local/lib', '/usr/local/lib64', '/usr/lib', '/usr/lib64']
+        base_dirs.concat(Dir["/usr/lib/#{RbConfig::CONFIG['host_cpu']}-*"])
         base_dirs.unshift(*ENV['LD_LIBRARY_PATH'].split(':')) unless ENV['LD_LIBRARY_PATH'].nil?
 
+        select_dirs(base_dirs)
+        select_dirs(opt_dirs)
+        select_dirs(lapacke_dirs)
+        select_dirs(atlas_dirs)
+        select_dirs(mkl_dirs)
+
         mkl_libs = find_mkl_libs([*base_dirs, *opt_dirs, *mkl_dirs])
         openblas_libs = find_openblas_libs([*base_dirs, *opt_dirs, *openblas_dirs])
         atlas_libs = find_atlas_libs([*base_dirs, *opt_dirs, *atlas_dirs, *lapacke_dirs])
@@ -66,11 +74,18 @@ module Numo
         end
       end
 
+      def select_dirs(dirs)
+        dirs.select!{|d| Dir.exist?(d)}
+      end
+
       def find_libs(lib_names, lib_dirs)
         lib_ext = detect_library_extension
         lib_arr = lib_names.map do |l|
-          [l.to_sym, lib_dirs.map { |d| "#{d}/lib#{l}.#{lib_ext}" }
-                             .keep_if { |f| File.exist?(f) }.first]
+          x = nil
+          lib_dirs.each do |d|
+            break if x = Dir.glob("#{d}/lib#{l}{,64}.#{lib_ext}{,.*}").last
+          end
+          [l.to_sym, x]
         end
         Hash[*lib_arr.flatten]
       end

data/lib/numo/linalg/function.rb

@@ -12,12 +12,19 @@ module Numo; module Linalg
     # defined from data-types of arguments.
     # @param [Symbol] func  function name without BLAS char.
     # @param args  arguments passed to Blas function.
+    # @param kwargs  keyword arguments passed to Blas function.
     # @example
     #      c = Numo::Linalg::Blas.call(:gemm, a, b)
-    def self.call(func,*args)
+    def self.call(func, *args, **kwargs)
       fn = (Linalg.blas_char(*args) + func.to_s).to_sym
       fn = FIXNAME[fn] || fn
-      send(fn,*args)
+      if kwargs.empty?
+        # This conditional branch is necessary to prevent ArgumentError
+        # that occurs in Ruby 2.6 or earlier.
+        send(fn, *args)
+      else
+        send(fn, *args, **kwargs)
+      end
     end
 
   end
@@ -34,12 +41,19 @@ module Numo; module Linalg
     # defined from data-types of arguments.
     # @param [Symbol,String] func  function name without BLAS char.
     # @param args  arguments passed to Lapack function.
+    # @param kwargs  keyword arguments passed to Lapack function.
     # @example
     #      s = Numo::Linalg::Lapack.call(:gesv, a)
-    def self.call(func,*args)
+    def self.call(func, *args, **kwargs)
       fn = (Linalg.blas_char(*args) + func.to_s).to_sym
       fn = FIXNAME[fn] || fn
-      send(fn,*args)
+      if kwargs.empty?
+        # This conditional branch is necessary to prevent ArgumentError
+        # that occurs in Ruby 2.6 or earlier.
+        send(fn, *args)
+      else
+        send(fn, *args, **kwargs)
+      end
     end
 
   end
@@ -65,7 +79,7 @@ module Numo; module Linalg
           NArray.array_type(a)
         end
       if k && k < NArray
-        t = k::UPCAST[t]
+        t = k::UPCAST[t] || t::UPCAST[k]
       end
     end
     BLAS_CHAR[t] || raise(TypeError,"invalid data type for BLAS/LAPACK")
@@ -86,16 +100,61 @@ module Numo; module Linalg
     when 1
       case b.ndim
       when 1
-        Blas.call(:dot, a, b)
+        func = blas_char(a, b) =~ /c|z/ ? :dotu : :dot
+        Blas.call(func, a, b)
       else
-        Blas.call(:gemv, b, a, trans:'t')
+        if b.contiguous?
+          trans = 't'
+        else
+          if b.fortran_contiguous?
+            trans = 'n'
+            b = b.transpose
+          else
+            trans = 't'
+            b = b.dup
+          end
+        end
+        Blas.call(:gemv, b, a, trans:trans)
       end
     else
       case b.ndim
       when 1
-        Blas.call(:gemv, a, b)
+        if a.contiguous?
+          trans = 'n'
+        else
+          if a.fortran_contiguous?
+            trans = 't'
+            a = a.transpose
+          else
+            trans = 'n'
+            a = a.dup
+          end
+        end
+        Blas.call(:gemv, a, b, trans:trans)
       else
-        Blas.call(:gemm, a, b)
+        if a.contiguous?
+          transa = 'n'
+        else
+          if a.fortran_contiguous?
+            transa = 't'
+            a = a.transpose
+          else
+            transa = 'n'
+            a = a.dup
+          end
+        end
+        if b.contiguous?
+          transb = 'n'
+        else
+          if b.fortran_contiguous?
+            transb='t'
+            b = b.transpose
+          else
+            transb='n'
+            b = b.dup
+          end
+        end
+        Blas.call(:gemm, a, b, transa:transa, transb:transb)
       end
     end
   end
@@ -194,10 +253,10 @@ module Numo; module Linalg
   #
   # @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.
+  #   - "reduce"   -- returns both Q and R,
+  #   - "r"        -- returns only R,
+  #   - "economic" -- 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)
@@ -295,6 +354,74 @@ module Numo; module Linalg
     end
   end
 
+  # Computes an orthonormal basis for the range of matrix A.
+  #
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensional NArray).
+  # @param rcond [Float] (optional)
+  #   rcond is used to determine the effective rank of A.
+  #   Singular values `s[i] <= rcond * s.max` are treated as zero.
+  #   If rcond < 0, machine precision is used instead.
+  # @return [Numo::NArray] The orthonormal basis for the range of matrix A.
+
+  def orth(a, rcond: -1)
+    raise NArray::ShapeError, '2-d array is required' if a.ndim < 2
+    s, u, = svd(a)
+    tol = s.max * (rcond.nil? || rcond < 0 ? a.class::EPSILON * a.shape.max : rcond)
+    k = (s > tol).count
+    u[true, 0...k]
+  end
+
+  # Computes an orthonormal basis for the null space of matrix A.
+  #
+  # @param a [Numo::NArray] m-by-n matrix A (>= 2-dimensional NArray).
+  # @param rcond [Float] (optional)
+  #   rcond is used to determine the effective rank of A.
+  #   Singular values `s[i] <= rcond * s.max` are treated as zero.
+  #   If rcond < 0, machine precision is used instead.
+  # @return [Numo::NArray] The orthonormal basis for the null space of matrix A.
+
+  def null_space(a, rcond: -1)
+    raise NArray::ShapeError, '2-d array is required' if a.ndim < 2
+    s, _u, vh = svd(a)
+    tol = s.max * (rcond.nil? || rcond < 0 ? a.class::EPSILON * a.shape.max : rcond)
+    k = (s > tol).count
+    return a.class.new if k == vh.shape[0]
+    r = vh[k..-1, true].transpose.dup
+    blas_char(vh) =~ /c|z/ ? r.conj : r
+  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 permute_l [Bool] (optional) If true, perform the matrix product of P and L.
+  # @return [[p,l,u]] if permute_l == false
+  # @return [[pl,u]]  if permute_l == true
+  #
+  #   - **p** [Numo::NArray] -- The permutation matrix P.
+  #   - **l** [Numo::NArray] -- The factor L.
+  #   - **u** [Numo::NArray] -- The factor U.
+
+  def lu(a, permute_l: false)
+    raise NArray::ShapeError, '2-d array is required' if a.ndim < 2
+    m, n = a.shape
+    k = [m, n].min
+    lu, ip = lu_fact(a)
+    l = lu.tril.tap { |mat| mat[mat.diag_indices(0)] = 1.0 }[true, 0...k]
+    u = lu.triu[0...k, 0...n]
+    p = Numo::DFloat.eye(m).tap do |mat|
+          ip.to_a.each_with_index { |i, j| mat[true, [i - 1, j]] = mat[true, [j, i - 1]].dup }
+        end
+    permute_l ? [p.dot(l), u] : [p, l, u]
+  end
 
   # Computes an LU factorization of a M-by-N matrix A
   # using partial pivoting with row interchanges.
@@ -308,26 +435,14 @@ module Numo; module Linalg
   # 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
+  def lu_fact(a)
+    Lapack.call(:getrf, a)[0..1]
   end
 
   # Computes the inverse of a matrix using the LU factorization
@@ -345,22 +460,10 @@ module Numo; module Linalg
   # @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
+  def lu_inv(lu, ipiv)
+    Lapack.call(:getri, lu, ipiv)[0]
   end
 
   # Solves a system of linear equations
@@ -377,31 +480,100 @@ module Numo; module Linalg
   #   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"):
-  #
+  #   Specifies the form of the system of equations:
   #     - 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}"
+  def lu_solve(lu, ipiv, b, trans:"N")
+    Lapack.call(:getrs, lu, ipiv, b, trans:trans)[0]
+  end
+
+  # Computes the LDLt or Bunch-Kaufman factorization of a symmetric/Hermitian matrix A.
+  # The factorization has the form
+  #
+  #     A = U*D*U**T  or  A = L*D*L**T
+  #
+  # where U (or L) is a product of permutation and unit upper (lower) triangular matrices
+  # and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
+  #
+  # @param a [Numo::NArray] m-by-m matrix A (>= 2-dimensinal NArray)
+  # @param uplo [String or Symbol] optional, default='U'. Access upper or ('U') lower ('L') triangle.
+  # @param hermitian [Bool] optional, default=true. If true, hermitian matrix is assumed.
+  #   (omitted when real-value matrix is given)
+  #
+  # @return [[lu,d,perm]]
+  #
+  #   - **lu** [Numo::NArray] -- The permutated upper (lower) triangular matrix U (L).
+  #   - **d** [Numo::NArray] -- The block diagonal matrix D.
+  #   - **perm** [Numo::NArray] -- The row-permutation index for changing lu into triangular form.
+
+  def ldl(a, uplo: 'U', hermitian: true)
+    raise NArray::ShapeError, '2-d array is required' if a.ndim < 2
+    raise NArray::ShapeError, 'matrix a is not square matrix' if a.shape[0] != a.shape[1]
+
+    is_complex = blas_char(a) =~ /c|z/
+    func = is_complex && hermitian ? 'hetrf' : 'sytrf'
+    lud, ipiv, = Lapack.call(func.to_sym, a, uplo: uplo)
+
+    lu = (uplo == 'U' ? lud.triu : lud.tril).tap { |mat| mat[mat.diag_indices(0)] = 1.0 }
+    d = lud[lud.diag_indices(0)].diag
+
+    m = a.shape[0]
+    n = m - 1
+    changed_2x2 = false
+    perm = Numo::Int32.new(m).seq
+    m.times do |t|
+      i = uplo == 'U' ? t : n - t
+      j = uplo == 'U' ? i - 1 : i + 1;
+      r = uplo == 'U' ? 0..i : i..n;
+      if ipiv[i] > 0
+        k = ipiv[i] - 1
+        lu[[k, i], r] = lu[[i, k], r].dup
+        perm[[k, i]] = perm[[i, k]].dup
+      elsif j.between?(0, n) && ipiv[i] == ipiv[j] && !changed_2x2
+        k = ipiv[i].abs - 1
+        d[j, i] = lud[j, i]
+        d[i, j] = is_complex && hermitian ? lud[j, i].conj : lud[j, i]
+        lu[j, i] = 0.0
+        lu[[k, j], r] = lu[[j, k], r].dup
+        perm[[k, j]] = perm[[j, k]].dup
+        changed_2x2 = true
+        next
+      end
+      changed_2x2 = false
     end
+
+    [lu, d, perm.sort_index]
   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 a lower triangular matrix.
+  # @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 cholesky(a, uplo: 'U')
+    raise NArray::ShapeError, '2-d array is required' if a.ndim < 2
+    raise NArray::ShapeError, 'matrix a is not square matrix' if a.shape[0] != a.shape[1]
+    factor = Lapack.call(:potrf, a, uplo: uplo)[0]
+    if uplo == 'U'
+      factor.triu
+    else
+      # TODO: Use the tril method if the verision of Numo::NArray
+      #       in the runtime dependency list becomes 0.9.1.3 or higher.
+      m, = a.shape
+      factor * Numo::DFloat.ones(m, m).triu.transpose
+    end
+  end
 
   # Computes the Cholesky factorization of a symmetric/Hermitian
   # positive definite matrix A. The factorization has the form
@@ -409,16 +581,16 @@ module Numo; module Linalg
   #     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
+  # where U is an upper triangular matrix and L is a lower triangular matrix.
   # @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.
+  # @return [Numo::NArray] The matrix which has the Cholesky factor in upper or lower triangular part.
+  #   Remain part consists of random values.
 
   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
@@ -479,27 +651,41 @@ module Numo; module Linalg
     [w,vl,vr] #.compact
   end
 
-  # Computes the eigenvalues and, optionally, the left and/or right
-  # eigenvectors for a square symmetric/hermitian matrix A.
+  # Obtains the eigenvalues and, optionally, the eigenvectors
+  # by solving an ordinary or generalized eigenvalue problem
+  # for a square symmetric / Hermitian matrix.
   #
-  # @param a [Numo::NArray] square nonsymmetric matrix (>= 2-dimensinal NArray)
-  # @param values_only [Bool] (optional) If false, eigenvectors are computed.
+  # @param a [Numo::NArray] square symmetric matrix (>= 2-dimensinal NArray)
+  # @param b [Numo::NArray] (optional) square symmetric matrix (>= 2-dimensinal NArray)
+  #   If nil, identity matrix is assumed.
+  # @param vals_only [Bool] (optional) If false, eigenvectors are computed.
+  # @param vals_range [Range] (optional)
+  #   The range of indices of the eigenvalues (in ascending order) and corresponding eigenvectors to be returned.
+  #   If nil or 0...N (N is the size of the matrix a), all eigenvalues and eigenvectors are returned.
   # @param uplo [String or Symbol] (optional, default='U')
   #   Access upper ('U') or lower ('L') triangle.
+  # @param turbo [Bool] (optional) If true, divide and conquer algorithm is used.
   # @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)
+  def eigh(a, b=nil, vals_only:false, vals_range:nil, uplo:'U', turbo:false)
     jobz = vals_only ? 'N' : 'V' # jobz: Compute eigenvalues and eigenvectors.
-    case blas_char(a)
-    when /c|z/
-      func = turbo ? :hegv : :heev
+    b = a.class.eye(a.shape[0]) if b.nil?
+    func = blas_char(a, b) =~ /c|z/ ? 'hegv' : 'sygv'
+    if vals_range.nil?
+      func << 'd' if turbo
+      v, u_, w, = Lapack.call(func.to_sym, a, b, uplo: uplo, jobz: jobz)
+      v = nil if vals_only
+      [w, v]
     else
-      func = turbo ? :sygv : :syev
+      func << 'x'
+      il = vals_range.first(1)[0]
+      iu = vals_range.last(1)[0]
+      a_, b_, w, v, = Lapack.call(func.to_sym, a, b, uplo: uplo, jobz: jobz, range: 'I', il: il + 1, iu: iu + 1)
+      v = nil if vals_only
+      [w, v]
     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.
@@ -519,23 +705,22 @@ module Numo; module Linalg
     w
   end
 
-  # Computes the eigenvalues for a square symmetric/hermitian matrix A.
+  # Obtains the eigenvalues by solving an ordinary or generalized eigenvalue problem
+  # for a square symmetric / Hermitian matrix.
   #
   # @param a [Numo::NArray] square symmetric/hermitian matrix
   #   (>= 2-dimensinal NArray)
+  # @param b [Numo::NArray] (optional) square symmetric matrix (>= 2-dimensinal NArray)
+  #   If nil, identity matrix is assumed.
+  # @param vals_range [Range] (optional)
+  #   The range of indices of the eigenvalues (in ascending order) to be returned.
+  #   If nil or 0...N (N is the size of the matrix a), all eigenvalues are returned.
   # @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]
+  def eigvalsh(a, b=nil, vals_range:nil, uplo:'U', turbo:false)
+    eigh(a, b, vals_only: true, vals_range: vals_range, uplo: uplo, turbo: turbo).first
   end
 
 
@@ -801,7 +986,7 @@ module Numo; module Linalg
       # returns lu, x, ipiv, info
       Lapack.call(:gesv, a, b)[1]
     when /^(sym?|her?|pos?)(sv)?$/i
-      func = driver[0..2].downcase+"sv"
+      func = driver[0..1].downcase+"sv"
       Lapack.call(func, a, b, uplo:uplo)[1]
     else
       raise ArgumentError, "invalid driver: #{driver}"
@@ -834,8 +1019,8 @@ module Numo; module Linalg
       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)
+      lu, piv = lu_fact(a)
+      lu_inv(lu, piv)
     when /potr[fi]$/
       lu = cho_fact(a, uplo:uplo)
       cho_inv(lu, uplo:uplo)
@@ -913,14 +1098,11 @@ module Numo; module Linalg
         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
+          resids = (x[false,n..-1,true].abs**2).sum(axis:-2)
+          ## NArray does not suppurt this yet.
+          # resids = x[false,0,true].new_zeros
+          # mask = rank.eq(n)
+          # resids[mask,true] = (x[mask,n..-1,true].abs**2).sum(axis:-2)
         end
       end
       x = x[false,0...n,true]
@@ -992,6 +1174,49 @@ module Numo; module Linalg
     end
   end
 
+  # Compute the matrix exponential using Pade approximation method.
+  #
+  # @param a [Numo::NArray] square matrix (>= 2-dimensinal NArray)
+  # @param ord [Integer] order of approximation
+  # @return [Numo::NArray]
+  # @example
+  #   a = Numo::Linalg.expm(Numo::DFloat.zeros([2,2]))
+  #   => Numo::DFloat#shape=[2,2]
+  #   [[1, 0],
+  #    [0, 1]]
+  #   b = Numo::Linalg.expm(Numo::DFloat[[1, 2], [-1, 3]] * Complex::I)
+  #   => Numo::DComplex#shape=[2,2]
+  #   [[0.426459+1.89218i, -2.13721-0.978113i],
+  #    [1.06861+0.489056i, -1.71076+0.914063i]]
+
+  def expm(a, ord=8)
+    raise NArray::ShapeError, 'matrix a is not square matrix' if a.shape[0] != a.shape[1]
+
+    inf_norm = norm(a, 'inf')
+    n_squarings = inf_norm.zero? ? 0 : [0, Math.log2(inf_norm).ceil.to_i].max
+    a = a / (2**n_squarings)
+
+    sz_mat = a.shape[0]
+    c = 1
+    s = -1
+    x = Numo::DFloat.eye(sz_mat)
+    n = Numo::DFloat.eye(sz_mat)
+    d = Numo::DFloat.eye(sz_mat)
+
+    (1..ord).each do |k|
+      c *= (ord - k + 1).fdiv((2 * ord - k + 1) * k)
+      x = a.dot(x)
+      cx = c * x
+      n += cx
+      d += s * cx
+      s *= -1
+    end
+
+    res = solve(d, n)
+    n_squarings.times { res = res.dot(res) }
+    res
+  end
+
   # @!visibility private
   def _make_complex_eigvecs(w, vin) # :nodoc:
     v = w.class.cast(vin)