numo-linalg 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 611dd9ee204102a1688b5d199b95b5376d32239b04dfcf69a605da54599a9310
-  data.tar.gz: d999af4188a239e9a78b7f071d850f2b11bf822c1c0237c592c6ebe4979b278d
+  metadata.gz: ef1ecaaf8a71faee9a7cef26bc35fae50230224856ab5dd6186cee93e5cca69d
+  data.tar.gz: f2e5e5944ad4832ef4ad4db05f6e94142fefb780e19282d94ece2a055cf447a0
 SHA512:
-  metadata.gz: 7da7684a72653a7718de5ff51a99ed14ca0dc3770cae735139487cf56ef2610f292cf3e970abd681320d8a1847664dcb7d6e9ac2c936867abb2cae1154bdb053
-  data.tar.gz: 70bb3e22d41fee16e953b53467b709cdd96bd80adceb526123df941335782054823bb84a9d703ca45e73e88c0ad34b7cbf90699a53cc7e7dcb1277251e7fa0e6
+  metadata.gz: 3fcf1506aa63ccbba57208e358102ae0dc537cd80b530e4b359b07d01a7cb1da11261dfd6d7028224175ae0f38014ec0373b99fc339caa2b952ad48c0fb26fd7
+  data.tar.gz: c7a9eb8b65719571120a6a122721e1eaadc240164e182a5095ff45018453a90f4cc48f99ef219305827beace8839bdebb0d27d35dfb5f64ec64f54d5406a8910

data/README.md

@@ -18,7 +18,7 @@ This desgin allows you to change backend libraries without re-compiling.
 * Matrix and vector products
     * dot, matmul
 * Decomposition
-    * lu\_fact, lu\_inv, lu\_solve, cho\_fact, cho\_inv, cho\_solve
+    * lu, lu\_fact, lu\_inv, lu\_solve, ldl, cholesky, cho\_fact, cho\_inv, cho\_solve,
       qr, svd, svdvals
 * Matrix eigenvalues
     * eig, eigh, eigvals, eigvalsh
@@ -78,8 +78,12 @@ require "numo/linalg"
 
 ## Authors
 
-* Masahiro TANAKA
-* Makoto KISHIMOTO
+* Masahiro Tanaka
+* Makoto Kishimoto
+* Atsushi Tatsuma
+
+## Acknowledgement
+
 * This work is partly supported by 2016 Ruby Association Grant.
 
 ## ToDo

data/ext/numo/linalg/blas/extconf.rb

@@ -1,5 +1,4 @@
 require 'mkmf'
-require 'numo/narray'
 require_relative '../mkmf_linalg'
 
 srcs = %w(
@@ -21,7 +20,7 @@ if !have_header("numo/narray.h")
   exit(1)
 end
 
-if RUBY_PLATFORM =~ /cygwin|mingw/
+if RUBY_PLATFORM =~ /mswin|cygwin|mingw/
   find_libnarray_a
   unless have_library("narray","nary_new")
     puts "libnarray.a not found"

data/ext/numo/linalg/blas/numo_blas.h

@@ -31,6 +31,12 @@ extern void numo_cblas_check_func(void **func, const char *name);
 #define SWAP_IFROW(order,a,b,tmp)                               \
     { if ((order)==CblasRowMajor) {(tmp)=(a);(a)=(b);(b)=(tmp);} }
 
+#define SWAP_IFNOTRANS(trans,a,b,tmp)                           \
+    { if ((trans)==CblasNoTrans) {(tmp)=(a);(a)=(b);(b)=(tmp);} }
+
+#define SWAP_IFTRANS(trans,a,b,tmp)                           \
+    { if ((trans)!=CblasNoTrans) {(tmp)=(a);(a)=(b);(b)=(tmp);} }
+
 #define SWAP_IFCOLTR(order,trans,a,b,tmp)                       \
     { if (((order)==CblasRowMajor && (trans)!=CblasNoTrans) ||  \
           ((order)!=CblasRowMajor && (trans)==CblasNoTrans))    \

data/ext/numo/linalg/blas/tmpl/mv.c

@@ -79,7 +79,7 @@ static void
    opt("beta"),
    !is_ge && opt("side"),
    !is_ge && opt("uplo"),
-   is_ge || is_tr && opt("trans"),
+   (is_ge || is_tr) && opt("trans"),
    opt("order")
  ].select{|x| x}.join("\n  ")
 %>
@@ -143,9 +143,10 @@ static VALUE
     CHECK_DIM_GE(na2,1);
     nx = COL_SIZE(na2);
 #if GE
-    SWAP_IFCOLTR(g.order,g.trans, ma,na, tmp);
+    SWAP_IFCOL(g.order, ma, na, tmp);
     g.m = ma;
     g.n = na;
+    SWAP_IFTRANS(g.trans, ma, na, tmp);
 #else
     CHECK_SQUARE("a",na1);
 #endif

data/ext/numo/linalg/lapack/gen/spec.rb

@@ -6,6 +6,9 @@ def_id "jobz"
 def_id "jobvl"
 def_id "jobvr"
 def_id "trans"
+def_id "range"
+def_id "il"
+def_id "iu"
 def_id "rcond"
 def_id "itype"
 def_id "norm"
@@ -58,11 +61,13 @@ when /c|z/
   decl "?heevd", "syev"
   decl "?hegv", "sygv"
   decl "?hegvd", "sygv"
+  decl "?hegvx", "sygvx"
 else
   decl "?syev"
   decl "?syevd", "syev"
   decl "?sygv"
   decl "?sygvd", "sygv"
+  decl "?sygvx"
 end
 
 # factorize

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

@@ -124,6 +124,35 @@ numo_lapacke_option_job(VALUE job, char true_char, char false_char)
     return 0;
 }
 
+char
+numo_lapacke_option_range(VALUE job, char true_char, char false_char)
+{
+    char *ptr, c;
+
+    switch(TYPE(job)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_TRUE:
+        return true_char;
+    case T_FALSE:
+        return false_char;
+    case T_SYMBOL:
+        job = rb_sym2str(job);
+    case T_STRING:
+        ptr = RSTRING_PTR(job);
+        if (RSTRING_LEN(job) > 0) {
+            c = ptr[0];
+            if (c >= 'a' && c <= 'z') {
+                c -= 'a'-'A';
+            }
+            return c;
+        }
+        break;
+    }
+    rb_raise(rb_eArgError,"invalid value for JOB option");
+    return 0;
+}
+
 char
 numo_lapacke_option_trans(VALUE trans)
 {

data/ext/numo/linalg/lapack/numo_lapack.h

@@ -15,6 +15,9 @@ extern int numo_lapacke_option_order(VALUE order);
 #define option_job numo_lapacke_option_job
 extern char numo_lapacke_option_job(VALUE job, char true_char, char false_char);
 
+#define option_range numo_lapacke_option_range
+extern char numo_lapacke_option_range(VALUE range, char true_char, char false_char);
+
 #define option_trans numo_lapacke_option_trans
 extern char numo_lapacke_option_trans(VALUE trans);
 

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

@@ -30,7 +30,7 @@ static void
     SWAP_IFCOL(g->order,m,n);
     lda = NDL_STEP(lp,0) / sizeof(dtype);
 
-    printf("order=%d m=%d n=%d k=%d lda=%d \n",g->order,m,n,k,lda);
+    //printf("order=%d m=%d n=%d k=%d lda=%d \n",g->order,m,n,k,lda);
 
     *info = (*func_p)(g->order, m, n, k, a, lda, tau);
     CHECK_ERROR(*info);

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

@@ -17,24 +17,6 @@ def create_site_conf
   FileUtils.mkdir_p "lib"
 
   ext = detect_library_extension
-  need_version = false
-  if ext == 'so'
-    begin
-      Fiddle.dlopen "libm.so"
-    rescue
-      (5..7).each do |i|
-        begin
-          Fiddle.dlopen "libm.so.#{i}"
-          need_version = true
-          break
-        rescue
-        end
-      end
-      if !need_version
-        raise "failed to check whether dynamically linked shared object needs version suffix"
-      end
-    end
-  end
 
   open("lib/site_conf.rb","w"){|f| f.write "
 module Numo
@@ -49,7 +31,6 @@ module Numo
 
     module Loader
       EXT = '#{ext}'
-      NEED_VERSION_SUFFIX = #{need_version}
     end
 
   end
@@ -68,6 +49,8 @@ def detect_library_extension
   end
 end
 
+require 'numo/narray'
+
 def find_narray_h
   $LOAD_PATH.each do |x|
     if File.exist? File.join(x,'numo/numo/narray.h')

data/lib/numo/linalg/function.rb

@@ -65,7 +65,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,7 +86,8 @@ 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')
       end
@@ -194,10 +195,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 +296,38 @@ module Numo; module Linalg
     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 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 +341,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 +366,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 +386,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 +487,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 +557,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 +611,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 +892,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 +925,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)