numo-tiny_linalg 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81e69278b32b0f565e3f5b5e1eae1738a57556773e9306bb3b0c8450c9fb75ea
-  data.tar.gz: de6daa349cd0d16b14f9c133ad451fac8bacbcd42cca682be68509bd5d8fc416
+  metadata.gz: 911223ba40879d779bcc9bc77b840fb7b5e41ed68d6ccf7d26816913c42aed73
+  data.tar.gz: 9dce9c353da5466e1104c604c2749369131cb6640e14ddd33c697cee5d973563
 SHA512:
-  metadata.gz: 72894605f074e09f47a37834ba1c2b3a3e504e149742df3290fd4c4e8042b1ac0c70d11bd50e4ab83e19b07181d8a656ab57afcaa47de53794fc28a298e1e768
-  data.tar.gz: c896b561fcbeb0ff19196548a3a0f2f6a06098d706fbfe95b785ffd850b139e87ea5d62c1144cde4c456a7ef5bb2b79422b5c2e0ab909df76f5ea9fa4a4bd446
+  metadata.gz: 9d666bdd04f48132005a9aee455047c80d83184815fac5c688ec593412ff8e670f1f31ba3376b1ee2985b8e829680590c1dad6a0ec3bf5366e584a82b523d8e4
+  data.tar.gz: 22027c54b56bad7214060ba7d5939b986be660a75afd65d74de7fdae095a6699ceea35422eee56831b621f2132e5bce921cb6b70bc9709e77e3efdf6cfc8a098

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [[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.
+- Add dsyevr, ssyevr, zheevr, and cheevr module functions to TinyLinalg::Lapack.
+- Fix the confirmation processs whether the array b is a square matrix or not on TinyLinalg.eigh.
+
 ## [[0.1.1](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.1.0...v0.1.1)] - 2023-08-07
 - Fix method of getting start and end of eigenvalue range from vals_range arguement of TinyLinalg.eigh.
 
@@ -28,5 +38,4 @@
 - Add inv module function to TinyLinalg.
 
 ## [0.0.1] - 2023-07-14
-
-- Initial release
+- Initial release.

data/README.md

@@ -8,6 +8,8 @@
 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.
 
+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/heev.hpp

@@ -0,0 +1,87 @@
+namespace TinyLinalg {
+
+struct ZHeEv {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda, double* w) {
+    return LAPACKE_zheev(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+struct CHeEv {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda, float* w) {
+    return LAPACKE_cheev(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+template <int nary_dtype_id, int nary_rtype_id, typename dtype, typename rtype, class LapackFn>
+class HeEv {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_heev), -1);
+  }
+
+private:
+  struct heev_opt {
+    int matrix_layout;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_heev(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    rtype* w = (rtype*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    heev_opt* opt = (heev_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = NDL_SHAPE(lp, 0)[0];
+    const lapack_int i = LapackFn().call(opt->matrix_layout, opt->jobz, opt->uplo, n, a, lda, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_heev(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+    VALUE nary_rtype = NaryTypes[nary_rtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);
+    ID kw_table[3] = { rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[3] = { Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 3, kw_values);
+    const char jobz = kw_values[0] != Qundef ? Util().get_jobz(kw_values[0]) : 'V';
+    const char uplo = kw_values[1] != Qundef ? Util().get_uplo(kw_values[1]) : 'U';
+    const int matrix_layout = kw_values[2] != Qundef ? Util().get_matrix_layout(kw_values[2]) : LAPACK_ROW_MAJOR;
+
+    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 = nullptr;
+    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;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_rtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_heev, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };
+    heev_opt opt = { matrix_layout, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);
+    VALUE ret = rb_ary_new3(3, a_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,87 @@
+namespace TinyLinalg {
+
+struct ZHeEvd {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda, double* w) {
+    return LAPACKE_zheevd(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+struct CHeEvd {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda, float* w) {
+    return LAPACKE_cheevd(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+template <int nary_dtype_id, int nary_rtype_id, typename dtype, typename rtype, class LapackFn>
+class HeEvd {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_heevd), -1);
+  }
+
+private:
+  struct heevd_opt {
+    int matrix_layout;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_heevd(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    rtype* w = (rtype*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    heevd_opt* opt = (heevd_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = NDL_SHAPE(lp, 0)[0];
+    const lapack_int i = LapackFn().call(opt->matrix_layout, opt->jobz, opt->uplo, n, a, lda, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_heevd(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+    VALUE nary_rtype = NaryTypes[nary_rtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);
+    ID kw_table[3] = { rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[3] = { Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 3, kw_values);
+    const char jobz = kw_values[0] != Qundef ? Util().get_jobz(kw_values[0]) : 'V';
+    const char uplo = kw_values[1] != Qundef ? Util().get_uplo(kw_values[1]) : 'U';
+    const int matrix_layout = kw_values[2] != Qundef ? Util().get_matrix_layout(kw_values[2]) : LAPACK_ROW_MAJOR;
+
+    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 = nullptr;
+    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;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_rtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_heevd, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };
+    heevd_opt opt = { matrix_layout, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);
+    VALUE ret = rb_ary_new3(3, a_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,133 @@
+namespace TinyLinalg {
+
+struct ZHeEvr {
+  lapack_int call(int matrix_layout, char jobz, char range, char uplo,
+                  lapack_int n, lapack_complex_double* a, lapack_int lda, double vl, double vu, lapack_int il,
+                  lapack_int iu, double abstol, lapack_int* m,
+                  double* w, lapack_complex_double* z, lapack_int ldz, lapack_int* isuppz) {
+    return LAPACKE_zheevr(matrix_layout, jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz);
+  }
+};
+
+struct CHeEvr {
+  lapack_int call(int matrix_layout, char jobz, char range, char uplo,
+                  lapack_int n, lapack_complex_float* a, lapack_int lda, float vl, float vu, lapack_int il,
+                  lapack_int iu, float abstol, lapack_int* m,
+                  float* w, lapack_complex_float* z, lapack_int ldz, lapack_int* isuppz) {
+    return LAPACKE_cheevr(matrix_layout, jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz);
+  }
+};
+
+template <int nary_dtype_id, int nary_rtype_id, typename dtype, typename rtype, class LapackFn>
+class HeEvr {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_heevr), -1);
+  }
+
+private:
+  struct heevr_opt {
+    int matrix_layout;
+    char jobz;
+    char range;
+    char uplo;
+    rtype vl;
+    rtype vu;
+    lapack_int il;
+    lapack_int iu;
+  };
+
+  static void iter_heevr(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    int* m = (int*)NDL_PTR(lp, 1);
+    rtype* w = (rtype*)NDL_PTR(lp, 2);
+    dtype* z = (dtype*)NDL_PTR(lp, 3);
+    int* isuppz = (int*)NDL_PTR(lp, 4);
+    int* info = (int*)NDL_PTR(lp, 5);
+    heevr_opt* opt = (heevr_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = NDL_SHAPE(lp, 0)[0];
+    const lapack_int ldz = opt->range != 'I' ? n : opt->iu - opt->il + 1;
+    const rtype abstol = 0.0;
+    const lapack_int i = LapackFn().call(
+      opt->matrix_layout, opt->jobz, opt->range, opt->uplo, n, a, lda,
+      opt->vl, opt->vu, opt->il, opt->iu, abstol, m, w, z, ldz, isuppz);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_heevr(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+    VALUE nary_rtype = NaryTypes[nary_rtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);
+    ID kw_table[8] = { rb_intern("jobz"), rb_intern("range"), rb_intern("uplo"),
+                       rb_intern("vl"), rb_intern("vu"), rb_intern("il"), rb_intern("iu"), rb_intern("order") };
+    VALUE kw_values[8] = { Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 8, kw_values);
+    const char jobz = kw_values[0] != Qundef ? Util().get_jobz(kw_values[0]) : 'V';
+    const char range = kw_values[1] != Qundef ? Util().get_range(kw_values[1]) : 'A';
+    const char uplo = kw_values[2] != Qundef ? Util().get_uplo(kw_values[2]) : 'U';
+    const rtype vl = kw_values[3] != Qundef ? NUM2DBL(kw_values[3]) : 0.0;
+    const rtype vu = kw_values[4] != Qundef ? NUM2DBL(kw_values[4]) : 0.0;
+    const lapack_int il = kw_values[5] != Qundef ? NUM2INT(kw_values[5]) : 0;
+    const lapack_int iu = kw_values[6] != Qundef ? NUM2INT(kw_values[6]) : 0;
+    const int matrix_layout = kw_values[7] != Qundef ? Util().get_matrix_layout(kw_values[7]) : LAPACK_ROW_MAJOR;
+
+    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 = nullptr;
+    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;
+    }
+
+    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 };
+    size_t isuppz_shape[1] = { 2 * m };
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[5] = { { numo_cInt32, 0 }, { nary_rtype, 1, w_shape }, { nary_dtype, 2, z_shape }, { numo_cInt32, 1, isuppz_shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_heevr, NO_LOOP | NDF_EXTRACT, 1, 5, ain, aout };
+    heevr_opt opt = { matrix_layout, jobz, range, uplo, vl, vu, il, iu };
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);
+    VALUE ret = rb_ary_new3(6, a_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1), rb_ary_entry(res, 2),
+                            rb_ary_entry(res, 3), rb_ary_entry(res, 4));
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -92,7 +92,7 @@ private:
       return Qnil;
     }
     narray_t* b_nary = nullptr;
-    GetNArray(a_vnary, b_nary);
+    GetNArray(b_vnary, b_nary);
     if (NA_NDIM(b_nary) != 2) {
       rb_raise(rb_eArgError, "input array b must be 2-dimensional");
       return Qnil;

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

@@ -92,7 +92,7 @@ private:
       return Qnil;
     }
     narray_t* b_nary = nullptr;
-    GetNArray(a_vnary, b_nary);
+    GetNArray(b_vnary, b_nary);
     if (NA_NDIM(b_nary) != 2) {
       rb_raise(rb_eArgError, "input array b must be 2-dimensional");
       return Qnil;

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

@@ -104,7 +104,7 @@ private:
       return Qnil;
     }
     narray_t* b_nary = nullptr;
-    GetNArray(a_vnary, b_nary);
+    GetNArray(b_vnary, b_nary);
     if (NA_NDIM(b_nary) != 2) {
       rb_raise(rb_eArgError, "input array b must be 2-dimensional");
       return Qnil;
@@ -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/syev.hpp

@@ -0,0 +1,86 @@
+namespace TinyLinalg {
+
+struct DSyEv {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, double* a, lapack_int lda, double* w) {
+    return LAPACKE_dsyev(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+struct SSyEv {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, float* a, lapack_int lda, float* w) {
+    return LAPACKE_ssyev(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class LapackFn>
+class SyEv {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_syev), -1);
+  }
+
+private:
+  struct syev_opt {
+    int matrix_layout;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_syev(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    dtype* w = (dtype*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    syev_opt* opt = (syev_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = NDL_SHAPE(lp, 0)[0];
+    const lapack_int i = LapackFn().call(opt->matrix_layout, opt->jobz, opt->uplo, n, a, lda, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_syev(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[3] = { rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[3] = { Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 3, kw_values);
+    const char jobz = kw_values[0] != Qundef ? Util().get_jobz(kw_values[0]) : 'V';
+    const char uplo = kw_values[1] != Qundef ? Util().get_uplo(kw_values[1]) : 'U';
+    const int matrix_layout = kw_values[2] != Qundef ? Util().get_matrix_layout(kw_values[2]) : LAPACK_ROW_MAJOR;
+
+    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 = nullptr;
+    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;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_dtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_syev, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };
+    syev_opt opt = { matrix_layout, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);
+    VALUE ret = rb_ary_new3(3, a_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,86 @@
+namespace TinyLinalg {
+
+struct DSyEvd {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, double* a, lapack_int lda, double* w) {
+    return LAPACKE_dsyevd(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+struct SSyEvd {
+  lapack_int call(int matrix_layout, char jobz, char uplo, lapack_int n, float* a, lapack_int lda, float* w) {
+    return LAPACKE_ssyevd(matrix_layout, jobz, uplo, n, a, lda, w);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class LapackFn>
+class SyEvd {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_syevd), -1);
+  }
+
+private:
+  struct syevd_opt {
+    int matrix_layout;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_syevd(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    dtype* w = (dtype*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    syevd_opt* opt = (syevd_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = NDL_SHAPE(lp, 0)[0];
+    const lapack_int i = LapackFn().call(opt->matrix_layout, opt->jobz, opt->uplo, n, a, lda, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_syevd(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[3] = { rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[3] = { Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 3, kw_values);
+    const char jobz = kw_values[0] != Qundef ? Util().get_jobz(kw_values[0]) : 'V';
+    const char uplo = kw_values[1] != Qundef ? Util().get_uplo(kw_values[1]) : 'U';
+    const int matrix_layout = kw_values[2] != Qundef ? Util().get_matrix_layout(kw_values[2]) : LAPACK_ROW_MAJOR;
+
+    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 = nullptr;
+    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;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_dtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_syevd, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };
+    syevd_opt opt = { matrix_layout, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);
+    VALUE ret = rb_ary_new3(3, a_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,130 @@
+namespace TinyLinalg {
+
+struct DSyEvr {
+  lapack_int call(int matrix_layout, char jobz, char range, char uplo,
+                  lapack_int n, double* a, lapack_int lda, double vl, double vu, lapack_int il, lapack_int iu,
+                  double abstol, lapack_int* m, double* w, double* z, lapack_int ldz, lapack_int* isuppz) {
+    return LAPACKE_dsyevr(matrix_layout, jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz);
+  }
+};
+
+struct SSyEvr {
+  lapack_int call(int matrix_layout, char jobz, char range, char uplo,
+                  lapack_int n, float* a, lapack_int lda, float vl, float vu, lapack_int il, lapack_int iu,
+                  float abstol, lapack_int* m, float* w, float* z, lapack_int ldz, lapack_int* isuppz) {
+    return LAPACKE_ssyevr(matrix_layout, jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class LapackFn>
+class SyEvr {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_syevr), -1);
+  }
+
+private:
+  struct syevr_opt {
+    int matrix_layout;
+    char jobz;
+    char range;
+    char uplo;
+    dtype vl;
+    dtype vu;
+    lapack_int il;
+    lapack_int iu;
+  };
+
+  static void iter_syevr(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    int* m = (int*)NDL_PTR(lp, 1);
+    dtype* w = (dtype*)NDL_PTR(lp, 2);
+    dtype* z = (dtype*)NDL_PTR(lp, 3);
+    int* isuppz = (int*)NDL_PTR(lp, 4);
+    int* info = (int*)NDL_PTR(lp, 5);
+    syevr_opt* opt = (syevr_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = NDL_SHAPE(lp, 0)[0];
+    const lapack_int ldz = opt->range != 'I' ? n : opt->iu - opt->il + 1;
+    const dtype abstol = 0.0;
+    const lapack_int i = LapackFn().call(
+      opt->matrix_layout, opt->jobz, opt->range, opt->uplo, n, a, lda,
+      opt->vl, opt->vu, opt->il, opt->iu, abstol, m, w, z, ldz, isuppz);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_syevr(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[8] = { rb_intern("jobz"), rb_intern("range"), rb_intern("uplo"),
+                       rb_intern("vl"), rb_intern("vu"), rb_intern("il"), rb_intern("iu"), rb_intern("order") };
+    VALUE kw_values[8] = { Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 8, kw_values);
+    const char jobz = kw_values[0] != Qundef ? Util().get_jobz(kw_values[0]) : 'V';
+    const char range = kw_values[1] != Qundef ? Util().get_range(kw_values[1]) : 'A';
+    const char uplo = kw_values[2] != Qundef ? Util().get_uplo(kw_values[2]) : 'U';
+    const dtype vl = kw_values[3] != Qundef ? NUM2DBL(kw_values[3]) : 0.0;
+    const dtype vu = kw_values[4] != Qundef ? NUM2DBL(kw_values[4]) : 0.0;
+    const lapack_int il = kw_values[5] != Qundef ? NUM2INT(kw_values[5]) : 0;
+    const lapack_int iu = kw_values[6] != Qundef ? NUM2INT(kw_values[6]) : 0;
+    const int matrix_layout = kw_values[7] != Qundef ? Util().get_matrix_layout(kw_values[7]) : LAPACK_ROW_MAJOR;
+
+    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 = nullptr;
+    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;
+    }
+
+    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 };
+    size_t isuppz_shape[1] = { 2 * m };
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[5] = { { numo_cInt32, 0 }, { nary_dtype, 1, w_shape }, { nary_dtype, 2, z_shape }, { numo_cInt32, 1, isuppz_shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_syevr, NO_LOOP | NDF_EXTRACT, 1, 5, ain, aout };
+    syevr_opt opt = { matrix_layout, jobz, range, uplo, vl, vu, il, iu };
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);
+    VALUE ret = rb_ary_new3(6, a_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1), rb_ary_entry(res, 2),
+                            rb_ary_entry(res, 3), rb_ary_entry(res, 4));
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -83,7 +83,7 @@ private:
       return Qnil;
     }
     narray_t* b_nary = nullptr;
-    GetNArray(a_vnary, b_nary);
+    GetNArray(b_vnary, b_nary);
     if (NA_NDIM(b_nary) != 2) {
       rb_raise(rb_eArgError, "input array b must be 2-dimensional");
       return Qnil;

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

@@ -83,7 +83,7 @@ private:
       return Qnil;
     }
     narray_t* b_nary = nullptr;
-    GetNArray(a_vnary, b_nary);
+    GetNArray(b_vnary, b_nary);
     if (NA_NDIM(b_nary) != 2) {
       rb_raise(rb_eArgError, "input array b must be 2-dimensional");
       return Qnil;

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

@@ -103,7 +103,7 @@ private:
       return Qnil;
     }
     narray_t* b_nary = nullptr;
-    GetNArray(a_vnary, b_nary);
+    GetNArray(b_vnary, b_nary);
     if (NA_NDIM(b_nary) != 2) {
       rb_raise(rb_eArgError, "input array b must be 2-dimensional");
       return Qnil;
@@ -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

@@ -44,10 +44,16 @@
 #include "lapack/gesvd.hpp"
 #include "lapack/getrf.hpp"
 #include "lapack/getri.hpp"
+#include "lapack/heev.hpp"
+#include "lapack/heevd.hpp"
+#include "lapack/heevr.hpp"
 #include "lapack/hegv.hpp"
 #include "lapack/hegvd.hpp"
 #include "lapack/hegvx.hpp"
 #include "lapack/orgqr.hpp"
+#include "lapack/syev.hpp"
+#include "lapack/syevd.hpp"
+#include "lapack/syevr.hpp"
 #include "lapack/sygv.hpp"
 #include "lapack/sygvd.hpp"
 #include "lapack/sygvx.hpp"
@@ -312,6 +318,18 @@ extern "C" void Init_tiny_linalg(void) {
   TinyLinalg::OrgQr<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SOrgQr>::define_module_function(rb_mTinyLinalgLapack, "sorgqr");
   TinyLinalg::UngQr<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZUngQr>::define_module_function(rb_mTinyLinalgLapack, "zungqr");
   TinyLinalg::UngQr<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CUngQr>::define_module_function(rb_mTinyLinalgLapack, "cungqr");
+  TinyLinalg::SyEv<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DSyEv>::define_module_function(rb_mTinyLinalgLapack, "dsyev");
+  TinyLinalg::SyEv<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SSyEv>::define_module_function(rb_mTinyLinalgLapack, "ssyev");
+  TinyLinalg::HeEv<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZHeEv>::define_module_function(rb_mTinyLinalgLapack, "zheev");
+  TinyLinalg::HeEv<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CHeEv>::define_module_function(rb_mTinyLinalgLapack, "cheev");
+  TinyLinalg::SyEvd<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DSyEvd>::define_module_function(rb_mTinyLinalgLapack, "dsyevd");
+  TinyLinalg::SyEvd<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SSyEvd>::define_module_function(rb_mTinyLinalgLapack, "ssyevd");
+  TinyLinalg::HeEvd<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZHeEvd>::define_module_function(rb_mTinyLinalgLapack, "zheevd");
+  TinyLinalg::HeEvd<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CHeEvd>::define_module_function(rb_mTinyLinalgLapack, "cheevd");
+  TinyLinalg::SyEvr<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DSyEvr>::define_module_function(rb_mTinyLinalgLapack, "dsyevr");
+  TinyLinalg::SyEvr<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SSyEvr>::define_module_function(rb_mTinyLinalgLapack, "ssyevr");
+  TinyLinalg::HeEvr<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZHeEvr>::define_module_function(rb_mTinyLinalgLapack, "zheevr");
+  TinyLinalg::HeEvr<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CHeEvr>::define_module_function(rb_mTinyLinalgLapack, "cheevr");
   TinyLinalg::SyGv<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DSyGv>::define_module_function(rb_mTinyLinalgLapack, "dsygv");
   TinyLinalg::SyGv<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SSyGv>::define_module_function(rb_mTinyLinalgLapack, "ssygv");
   TinyLinalg::HeGv<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZHeGv>::define_module_function(rb_mTinyLinalgLapack, "zhegv");

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.1'
+    VERSION = '0.2.0'
   end
 end

data/lib/numo/tiny_linalg.rb

@@ -48,35 +48,50 @@ 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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-tiny_linalg
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-07 00:00:00.000000000 Z
+date: 2023-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -52,10 +52,16 @@ files:
 - ext/numo/tiny_linalg/lapack/gesvd.hpp
 - ext/numo/tiny_linalg/lapack/getrf.hpp
 - ext/numo/tiny_linalg/lapack/getri.hpp
+- ext/numo/tiny_linalg/lapack/heev.hpp
+- ext/numo/tiny_linalg/lapack/heevd.hpp
+- ext/numo/tiny_linalg/lapack/heevr.hpp
 - ext/numo/tiny_linalg/lapack/hegv.hpp
 - 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/syev.hpp
+- ext/numo/tiny_linalg/lapack/syevd.hpp
+- ext/numo/tiny_linalg/lapack/syevr.hpp
 - ext/numo/tiny_linalg/lapack/sygv.hpp
 - ext/numo/tiny_linalg/lapack/sygvd.hpp
 - ext/numo/tiny_linalg/lapack/sygvx.hpp