numo-tiny_linalg 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aeb68c259f8d4c4dcd44c15caef6926cbe3f26f9dd99e9229721d02a939d7c1
-  data.tar.gz: 5465aebebc07612812b861932fcabf14b66ee0ec389603c9ffcf06694eb69ce4
+  metadata.gz: dd5b3d90b9c0bc323420f2eed5363490ec7c2ec4a3b0950573f54f234d534eaf
+  data.tar.gz: cd0a71621d1e3e935faba0a40036b3950c0f6ac32a74cdaad46b0e313b5dfa2f
 SHA512:
-  metadata.gz: 3e1ddd9a4f43d89635d0fc4e07fc3eab0e302b108648e00506deaec106f147f10132b6c28818f6ef054d5fa0ef52bb2c33287dcdeb413fc12268fb35edfde859
-  data.tar.gz: 78903f772d37936f73a69624b3241d43703632f08542a2f57e38a619b6dc1ac012d8885c79056459ef4fd50102d416f996ea54269b64b919ac91a3db46330d8c
+  metadata.gz: f904406ce9c883d59d93afc061bfc65c96073dc9660cb65e6eefa97e2be32cc8c79ac26970a8b181cd3acbdbd412cf97c08153017956c4cc4f2b29bf28bcda46
+  data.tar.gz: 8f3ee9b0e0e9c3789f61148db03d43c245dab66fc4cb428488cbe668dad00b0d7fb73ef825e5dc0c5772ba817d41bb90d5fce843ece1f1adf6fe81857b9917ff

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [[0.3.0](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.2.0...v0.3.0)] - 2023-08-13
+- Add cholesky and cho_solve module functions to TinyLinalg.
+
+**Breaking change**
+- Change to raise NotImplementedError when calling a method not yet implemented in Numo::TinyLinalg.
+
+## [[0.2.0](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.1.2...v0.2.0)] - 2023-08-11
+**Breaking change**
+- Change LAPACK function to call when array b is not given to TinyLinalg.eigh method.
+
 ## [[0.1.2](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.1.1...v0.1.2)] - 2023-08-09
 - Add dsyev, ssyev, zheev, and cheev module functions to TinyLinalg::Lapack.
 - Add dsyevd, ssyevd, zheevd, and cheevd module functions to TinyLinalg::Lapack.

data/README.md

@@ -6,7 +6,9 @@
 [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/numo-tiny_linalg/doc/)
 
 Numo::TinyLinalg is a subset library from [Numo::Linalg](https://github.com/ruby-numo/numo-linalg) consisting only of methods used in Machine Learning algorithms.
-The functions Numo::TinyLinalg supports are dot, det, eigh, inv, pinv, qr, solve, and svd.
+The functions Numo::TinyLinalg supports are dot, det, eigh, inv, pinv, qr, solve, cholesky, cho_solve and svd.
+
+Note that the version numbering rule of Numo::TinyLinalg is not compatible with that of Numo::Linalg.
 
 ## Installation
 Unlike Numo::Linalg, Numo::TinyLinalg only supports OpenBLAS as a backend library for BLAS and LAPACK.

data/ext/numo/tiny_linalg/lapack/heevr.hpp

@@ -93,7 +93,25 @@ private:
       return Qnil;
     }
 
+    if (range == 'V' && vu <= vl) {
+      rb_raise(rb_eArgError, "vu must be greater than vl");
+      return Qnil;
+    }
+
     const size_t n = NA_SHAPE(a_nary)[1];
+    if (range == 'I' && (il < 1 || il > n)) {
+      rb_raise(rb_eArgError, "il must satisfy 1 <= il <= n");
+      return Qnil;
+    }
+    if (range == 'I' && (iu < 1 || iu > n)) {
+      rb_raise(rb_eArgError, "iu must satisfy 1 <= iu <= n");
+      return Qnil;
+    }
+    if (range == 'I' && iu < il) {
+      rb_raise(rb_eArgError, "iu must be greater than or equal to il");
+      return Qnil;
+    }
+
     size_t m = range != 'I' ? n : iu - il + 1;
     size_t w_shape[1] = { m };
     size_t z_shape[2] = { n, m };

data/ext/numo/tiny_linalg/lapack/hegvx.hpp

@@ -114,7 +114,25 @@ private:
       return Qnil;
     }
 
+    if (range == 'V' && vu <= vl) {
+      rb_raise(rb_eArgError, "vu must be greater than vl");
+      return Qnil;
+    }
+
     const size_t n = NA_SHAPE(a_nary)[1];
+    if (range == 'I' && (il < 1 || il > n)) {
+      rb_raise(rb_eArgError, "il must satisfy 1 <= il <= n");
+      return Qnil;
+    }
+    if (range == 'I' && (iu < 1 || iu > n)) {
+      rb_raise(rb_eArgError, "iu must satisfy 1 <= iu <= n");
+      return Qnil;
+    }
+    if (range == 'I' && iu < il) {
+      rb_raise(rb_eArgError, "il must be less than or equal to iu");
+      return Qnil;
+    }
+
     size_t m = range != 'I' ? n : iu - il + 1;
     size_t w_shape[1] = { m };
     size_t z_shape[2] = { n, m };

data/ext/numo/tiny_linalg/lapack/potrf.hpp

@@ -0,0 +1,93 @@
+namespace TinyLinalg {
+
+struct DPoTrf {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, double* a, lapack_int lda) {
+    return LAPACKE_dpotrf(matrix_layout, uplo, n, a, lda);
+  }
+};
+
+struct SPoTrf {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, float* a, lapack_int lda) {
+    return LAPACKE_spotrf(matrix_layout, uplo, n, a, lda);
+  }
+};
+
+struct ZPoTrf {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda) {
+    return LAPACKE_zpotrf(matrix_layout, uplo, n, a, lda);
+  }
+};
+
+struct CPoTrf {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda) {
+    return LAPACKE_cpotrf(matrix_layout, uplo, n, a, lda);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class LapackFn>
+class PoTrf {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_potrf), -1);
+  }
+
+private:
+  struct potrf_opt {
+    int matrix_layout;
+    char uplo;
+  };
+
+  static void iter_potrf(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    int* info = (int*)NDL_PTR(lp, 1);
+    potrf_opt* opt = (potrf_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[0];
+    const lapack_int lda = NDL_SHAPE(lp, 0)[1];
+    const lapack_int i = LapackFn().call(opt->matrix_layout, opt->uplo, n, a, lda);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_potrf(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);
+    ID kw_table[2] = { rb_intern("order"), rb_intern("uplo") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);
+    const int matrix_layout = kw_values[0] != Qundef ? Util().get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR;
+    const char uplo = kw_values[1] != Qundef ? Util().get_uplo(kw_values[1]) : 'U';
+
+    if (CLASS_OF(a_vnary) != nary_dtype) {
+      a_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, a_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(a_vnary))) {
+      a_vnary = nary_dup(a_vnary);
+    }
+
+    narray_t* a_nary = NULL;
+    GetNArray(a_vnary, a_nary);
+    if (NA_NDIM(a_nary) != 2) {
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(a_nary)[0] != NA_SHAPE(a_nary)[1]) {
+      rb_raise(rb_eArgError, "input array a must be square");
+      return Qnil;
+    }
+
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_potrf, NO_LOOP | NDF_EXTRACT, 1, 1, ain, aout };
+    potrf_opt opt = { matrix_layout, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);
+    VALUE ret = rb_ary_new3(2, a_vnary, res);
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

data/ext/numo/tiny_linalg/lapack/potrs.hpp

@@ -0,0 +1,121 @@
+namespace TinyLinalg {
+
+struct DPoTrs {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, lapack_int nrhs,
+                  const double* a, lapack_int lda, double* b, lapack_int ldb) {
+    return LAPACKE_dpotrs(matrix_layout, uplo, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+struct SPoTrs {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, lapack_int nrhs,
+                  const float* a, lapack_int lda, float* b, lapack_int ldb) {
+    return LAPACKE_spotrs(matrix_layout, uplo, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+struct ZPoTrs {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, lapack_int nrhs,
+                  const lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb) {
+    return LAPACKE_zpotrs(matrix_layout, uplo, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+struct CPoTrs {
+  lapack_int call(int matrix_layout, char uplo, lapack_int n, lapack_int nrhs,
+                  const lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb) {
+    return LAPACKE_cpotrs(matrix_layout, uplo, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class LapackFn>
+class PoTrs {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_potrs), -1);
+  }
+
+private:
+  struct potrs_opt {
+    int matrix_layout;
+    char uplo;
+  };
+
+  static void iter_potrs(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    dtype* b = (dtype*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    potrs_opt* opt = (potrs_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[0];
+    const lapack_int nrhs = lp->args[1].ndim == 1 ? 1 : NDL_SHAPE(lp, 1)[1];
+    const lapack_int lda = n;
+    const lapack_int ldb = nrhs;
+    const lapack_int i = LapackFn().call(opt->matrix_layout, opt->uplo, n, nrhs, a, lda, b, ldb);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_potrs(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE b_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "2:", &a_vnary, &b_vnary, &kw_args);
+    ID kw_table[2] = { rb_intern("order"), rb_intern("uplo") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);
+    const int matrix_layout = kw_values[0] != Qundef ? Util().get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR;
+    const char uplo = kw_values[1] != Qundef ? Util().get_uplo(kw_values[1]) : 'U';
+
+    if (CLASS_OF(a_vnary) != nary_dtype) {
+      a_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, a_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(a_vnary))) {
+      a_vnary = nary_dup(a_vnary);
+    }
+    if (CLASS_OF(b_vnary) != nary_dtype) {
+      b_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, b_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(b_vnary))) {
+      b_vnary = nary_dup(b_vnary);
+    }
+
+    narray_t* a_nary = NULL;
+    GetNArray(a_vnary, a_nary);
+    if (NA_NDIM(a_nary) != 2) {
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(a_nary)[0] != NA_SHAPE(a_nary)[1]) {
+      rb_raise(rb_eArgError, "input array a must be square");
+      return Qnil;
+    }
+    narray_t* b_nary = NULL;
+    GetNArray(b_vnary, b_nary);
+    const int b_n_dims = NA_NDIM(b_nary);
+    if (b_n_dims != 1 && b_n_dims != 2) {
+      rb_raise(rb_eArgError, "input array b must be 1- or 2-dimensional");
+      return Qnil;
+    }
+
+    lapack_int n = NA_SHAPE(a_nary)[0];
+    lapack_int nb = NA_SHAPE(b_nary)[0];
+    if (n != nb) {
+      rb_raise(nary_eShapeError, "shape1[0](=%d) != shape2[0](=%d)", n, nb);
+    }
+
+    ndfunc_arg_in_t ain[2] = { { nary_dtype, 2 }, { OVERWRITE, b_n_dims } };
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_potrs, NO_LOOP | NDF_EXTRACT, 2, 1, ain, aout };
+    potrs_opt opt = { matrix_layout, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(2, b_vnary, res);
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

data/ext/numo/tiny_linalg/lapack/syevr.hpp

@@ -90,7 +90,25 @@ private:
       return Qnil;
     }
 
+    if (range == 'V' && vu <= vl) {
+      rb_raise(rb_eArgError, "vu must be greater than vl");
+      return Qnil;
+    }
+
     const size_t n = NA_SHAPE(a_nary)[1];
+    if (range == 'I' && (il < 1 || il > n)) {
+      rb_raise(rb_eArgError, "il must satisfy 1 <= il <= n");
+      return Qnil;
+    }
+    if (range == 'I' && (iu < 1 || iu > n)) {
+      rb_raise(rb_eArgError, "iu must satisfy 1 <= iu <= n");
+      return Qnil;
+    }
+    if (range == 'I' && iu < il) {
+      rb_raise(rb_eArgError, "iu must be greater than or equal to il");
+      return Qnil;
+    }
+
     size_t m = range != 'I' ? n : iu - il + 1;
     size_t w_shape[1] = { m };
     size_t z_shape[2] = { n, m };

data/ext/numo/tiny_linalg/lapack/sygvx.hpp

@@ -113,7 +113,25 @@ private:
       return Qnil;
     }
 
+    if (range == 'V' && vu <= vl) {
+      rb_raise(rb_eArgError, "vu must be greater than vl");
+      return Qnil;
+    }
+
     const size_t n = NA_SHAPE(a_nary)[1];
+    if (range == 'I' && (il < 1 || il > n)) {
+      rb_raise(rb_eArgError, "il must satisfy 1 <= il <= n");
+      return Qnil;
+    }
+    if (range == 'I' && (iu < 1 || iu > n)) {
+      rb_raise(rb_eArgError, "iu must satisfy 1 <= iu <= n");
+      return Qnil;
+    }
+    if (range == 'I' && iu < il) {
+      rb_raise(rb_eArgError, "iu must be greater than or equal to il");
+      return Qnil;
+    }
+
     size_t m = range != 'I' ? n : iu - il + 1;
     size_t w_shape[1] = { m };
     size_t z_shape[2] = { n, m };

data/ext/numo/tiny_linalg/tiny_linalg.cpp

@@ -51,6 +51,8 @@
 #include "lapack/hegvd.hpp"
 #include "lapack/hegvx.hpp"
 #include "lapack/orgqr.hpp"
+#include "lapack/potrf.hpp"
+#include "lapack/potrs.hpp"
 #include "lapack/syev.hpp"
 #include "lapack/syevd.hpp"
 #include "lapack/syevr.hpp"
@@ -310,6 +312,14 @@ extern "C" void Init_tiny_linalg(void) {
   TinyLinalg::GeTri<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGeTri>::define_module_function(rb_mTinyLinalgLapack, "sgetri");
   TinyLinalg::GeTri<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZGeTri>::define_module_function(rb_mTinyLinalgLapack, "zgetri");
   TinyLinalg::GeTri<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CGeTri>::define_module_function(rb_mTinyLinalgLapack, "cgetri");
+  TinyLinalg::PoTrf<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DPoTrf>::define_module_function(rb_mTinyLinalgLapack, "dpotrf");
+  TinyLinalg::PoTrf<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SPoTrf>::define_module_function(rb_mTinyLinalgLapack, "spotrf");
+  TinyLinalg::PoTrf<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZPoTrf>::define_module_function(rb_mTinyLinalgLapack, "zpotrf");
+  TinyLinalg::PoTrf<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CPoTrf>::define_module_function(rb_mTinyLinalgLapack, "cpotrf");
+  TinyLinalg::PoTrs<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DPoTrs>::define_module_function(rb_mTinyLinalgLapack, "dpotrs");
+  TinyLinalg::PoTrs<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SPoTrs>::define_module_function(rb_mTinyLinalgLapack, "spotrs");
+  TinyLinalg::PoTrs<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZPoTrs>::define_module_function(rb_mTinyLinalgLapack, "zpotrs");
+  TinyLinalg::PoTrs<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CPoTrs>::define_module_function(rb_mTinyLinalgLapack, "cpotrs");
   TinyLinalg::GeQrf<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DGeQrf>::define_module_function(rb_mTinyLinalgLapack, "dgeqrf");
   TinyLinalg::GeQrf<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGeQrf>::define_module_function(rb_mTinyLinalgLapack, "sgeqrf");
   TinyLinalg::GeQrf<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZGeQrf>::define_module_function(rb_mTinyLinalgLapack, "zgeqrf");

data/lib/numo/tiny_linalg/version.rb

@@ -5,6 +5,6 @@ module Numo
   # Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
   module TinyLinalg
     # The version of Numo::TinyLinalg you install.
-    VERSION = '0.1.2'
+    VERSION = '0.3.0'
   end
 end

data/lib/numo/tiny_linalg.rb

@@ -48,38 +48,143 @@ module Numo
     # @param uplo [String] This argument is for compatibility with Numo::Linalg.solver, and is not used.
     # @param turbo [Bool] The flag indicating whether to use a divide and conquer algorithm. If vals_range is given, this flag is ignored.
     # @return [Array<Numo::NArray>] The eigenvalues and eigenvectors.
-    def eigh(a, b = nil, vals_only: false, vals_range: nil, uplo: 'U', turbo: false) # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists, Lint/UnusedMethodArgument
+    def eigh(a, b = nil, vals_only: false, vals_range: nil, uplo: 'U', turbo: false) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
       raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
       raise ArgumentError, 'input array a must be square' if a.shape[0] != a.shape[1]
 
+      b_given = !b.nil?
+      raise ArgumentError, 'input array b must be 2-dimensional' if b_given && b.ndim != 2
+      raise ArgumentError, 'input array b must be square' if b_given && b.shape[0] != b.shape[1]
+      raise ArgumentError, "invalid array type: #{b.class}" if b_given && blas_char(b) == 'n'
+
       bchr = blas_char(a)
       raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
 
-      unless b.nil?
-        raise ArgumentError, 'input array b must be 2-dimensional' if b.ndim != 2
-        raise ArgumentError, 'input array b must be square' if b.shape[0] != b.shape[1]
-        raise ArgumentError, "invalid array type: #{b.class}" if blas_char(b) == 'n'
-      end
-
       jobz = vals_only ? 'N' : 'V'
-      b = a.class.eye(a.shape[0]) if b.nil?
-      sy_he_gv = %w[d s].include?(bchr) ? "#{bchr}sygv" : "#{bchr}hegv"
 
-      if vals_range.nil?
-        sy_he_gv << 'd' if turbo
-        vecs, _b, vals, _info = Numo::TinyLinalg::Lapack.send(sy_he_gv.to_sym, a.dup, b.dup, jobz: jobz)
+      if b_given
+        fnc = %w[d s].include?(bchr) ? "#{bchr}sygv" : "#{bchr}hegv"
+        if vals_range.nil?
+          fnc << 'd' if turbo
+          vecs, _b, vals, _info = Numo::TinyLinalg::Lapack.send(fnc.to_sym, a.dup, b.dup, jobz: jobz)
+        else
+          fnc << 'x'
+          il = vals_range.first(1)[0] + 1
+          iu = vals_range.last(1)[0] + 1
+          _a, _b, _m, vals, vecs, _ifail, _info = Numo::TinyLinalg::Lapack.send(
+            fnc.to_sym, a.dup, b.dup, jobz: jobz, range: 'I', il: il, iu: iu
+          )
+        end
       else
-        sy_he_gv << 'x'
-        il = vals_range.first(1)[0] + 1
-        iu = vals_range.last(1)[0] + 1
-        _a, _b, _m, vals, vecs, _ifail, _info = Numo::TinyLinalg::Lapack.send(
-          sy_he_gv.to_sym, a.dup, b.dup, jobz: jobz, range: 'I', il: il, iu: iu
-        )
+        fnc = %w[d s].include?(bchr) ? "#{bchr}syev" : "#{bchr}heev"
+        if vals_range.nil?
+          fnc << 'd' if turbo
+          vecs, vals, _info = Numo::TinyLinalg::Lapack.send(fnc.to_sym, a.dup, jobz: jobz)
+        else
+          fnc << 'r'
+          il = vals_range.first(1)[0] + 1
+          iu = vals_range.last(1)[0] + 1
+          _a, _m, vals, vecs, _isuppz, _info = Numo::TinyLinalg::Lapack.send(
+            fnc.to_sym, a.dup, jobz: jobz, range: 'I', il: il, iu: iu
+          )
+        end
       end
+
       vecs = nil if vals_only
+
       [vals, vecs]
     end
 
+    # Computes the Cholesky decomposition of a symmetric / Hermitian positive-definite matrix.
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #
+    #   Numo::Linalg = Numo::TinyLinalg unless defined?(Numo::Linalg)
+    #
+    #   s = Numo::DFloat.new(3, 3).rand - 0.5
+    #   a = s.transpose.dot(s)
+    #   u = Numo::Linalg.cholesky(a)
+    #
+    #   pp u
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[0.532006, 0.338183, -0.18036],
+    #   #  [0, 0.325153, 0.011721],
+    #   #  [0, 0, 0.436738]]
+    #
+    #   pp (a - u.transpose.dot(u)).abs.max
+    #   # => 1.3877787807814457e-17
+    #
+    #   l = Numo::Linalg.cholesky(a, uplo: 'L')
+    #
+    #   pp l
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[0.532006, 0, 0],
+    #   #  [0.338183, 0.325153, 0],
+    #   #  [-0.18036, 0.011721, 0.436738]]
+    #
+    #   pp (a - l.dot(l.transpose)).abs.max
+    #   # => 1.3877787807814457e-17
+    #
+    # @param a [Numo::NArray] The n-by-n symmetric matrix.
+    # @param uplo [String] Whether to compute the upper- or lower-triangular Cholesky factor ('U' or 'L').
+    # @return [Numo::NArray] The upper- or lower-triangular Cholesky factor of a.
+    def cholesky(a, uplo: 'U')
+      raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise ArgumentError, 'input array a must be square' if a.shape[0] != a.shape[1]
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      fnc = "#{bchr}potrf".to_sym
+      c, _info = Numo::TinyLinalg::Lapack.send(fnc, a.dup, uplo: uplo)
+
+      case uplo
+      when 'U'
+        c.triu
+      when 'L'
+        c.tril
+      else
+        raise ArgumentError, "invalid uplo: #{uplo}"
+      end
+    end
+
+    # Solves linear equation `A * x = b` or `A * X = B` for `x` with the Cholesky factorization of `A`.
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #
+    #   Numo::Linalg = Numo::TinyLinalg unless defined?(Numo::Linalg)
+    #
+    #   s = Numo::DFloat.new(3, 3).rand - 0.5
+    #   a = s.transpose.dot(s)
+    #   u = Numo::Linalg.cholesky(a)
+    #
+    #   b = Numo::DFloat.new(3).rand
+    #   x = Numo::Linalg.cho_solve(u, b)
+    #
+    #   puts (b - a.dot(x)).abs.max
+    #   => 0.0
+    #
+    # @param a [Numo::NArray] The n-by-n cholesky factor.
+    # @param b [Numo::NArray] The n right-hand side vector, or n-by-nrhs right-hand side matrix.
+    # @param uplo [String] Whether to compute the upper- or lower-triangular Cholesky factor ('U' or 'L').
+    # @return [Numo::NArray] The solution vector or matrix `X`.
+    def cho_solve(a, b, uplo: 'U')
+      raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise ArgumentError, 'input array a must be square' if a.shape[0] != a.shape[1]
+      raise ArgumentError, "incompatible dimensions: a.shape[0] = #{a.shape[0]} != b.shape[0] = #{b.shape[0]}" if a.shape[0] != b.shape[0]
+
+      bchr = blas_char(a, b)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      fnc = "#{bchr}potrs".to_sym
+      x, _info = Numo::TinyLinalg::Lapack.send(fnc, a, b.dup, uplo: uplo)
+      x
+    end
+
     # Computes the determinant of matrix.
     #
     # @example
@@ -256,7 +361,7 @@ module Numo
       [q, r]
     end
 
-    # Solves linear equation `A * x = b` or `A * X = B` for `x` from square matrix `a`.
+    # Solves linear equation `A * x = b` or `A * X = B` for `x` from square matrix `A`.
     #
     # @example
     #   require 'numo/tiny_linalg'
@@ -279,10 +384,10 @@ module Numo
     #   # => 2.1081041547796492e-16
     #
     # @param a [Numo::NArray] The n-by-n square matrix.
-    # @param b [Numo::NArray] The n right-hand side vector, or n-by-nrhs right-hand side matrix (>= 1-dimensinal NArray).
+    # @param b [Numo::NArray] The n right-hand side vector, or n-by-nrhs right-hand side matrix.
     # @param driver [String] This argument is for compatibility with Numo::Linalg.solver, and is not used.
     # @param uplo [String] This argument is for compatibility with Numo::Linalg.solver, and is not used.
-    # @return [Numo::NArray] The solusion vector / matrix `x`.
+    # @return [Numo::NArray] The solusion vector / matrix `X`.
     def solve(a, b, driver: 'gen', uplo: 'U') # rubocop:disable Lint/UnusedMethodArgument
       raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
       raise ArgumentError, 'input array a must be square' if a.shape[0] != a.shape[1]
@@ -353,5 +458,110 @@ module Numo
 
       [s, u, vt]
     end
+
+    # @!visibility private
+    def matmul(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def matrix_power(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def svdvals(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def orth(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def null_space(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def lu(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def lu_fact(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def lu_inv(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def lu_solve(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def ldl(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def cho_fact(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def cho_inv(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def eig(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def eigvals(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def eigvalsh(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def norm(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def cond(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def slogdet(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def matrix_rank(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def lstsq(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
+
+    # @!visibility private
+    def expm(*args)
+      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-tiny_linalg
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-08 00:00:00.000000000 Z
+date: 2023-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -59,6 +59,8 @@ files:
 - ext/numo/tiny_linalg/lapack/hegvd.hpp
 - ext/numo/tiny_linalg/lapack/hegvx.hpp
 - ext/numo/tiny_linalg/lapack/orgqr.hpp
+- ext/numo/tiny_linalg/lapack/potrf.hpp
+- ext/numo/tiny_linalg/lapack/potrs.hpp
 - ext/numo/tiny_linalg/lapack/syev.hpp
 - ext/numo/tiny_linalg/lapack/syevd.hpp
 - ext/numo/tiny_linalg/lapack/syevr.hpp