numo-tiny_linalg 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a298eaec7ee7338e4856ac50b22a06bf774073456a01f5ffb2a405cab632f7a
-  data.tar.gz: a44ae42f723ee7c9a1af6c2b1a01e6257f1fc417a5cd2a22cb6be51ac0589c1c
+  metadata.gz: 0aeb68c259f8d4c4dcd44c15caef6926cbe3f26f9dd99e9229721d02a939d7c1
+  data.tar.gz: 5465aebebc07612812b861932fcabf14b66ee0ec389603c9ffcf06694eb69ce4
 SHA512:
-  metadata.gz: fce33aa331257bc37d7a972e09a0cf1d9328046459c9de6b9feaf8341d0d4545d202b90d6bb0e5e6ee097b4c9c58a4bc76fc0224fd87dc10818c8f566259ab7e
-  data.tar.gz: 6da516469d0fdfb47884fea2d9fc2483b5ea066063ce1681afc8e9319d1cfcc6863f59e96a4ce1d7cb22ceb159a8b2f8f6e41478958ea245a5eaaf209753ea2c
+  metadata.gz: 3e1ddd9a4f43d89635d0fc4e07fc3eab0e302b108648e00506deaec106f147f10132b6c28818f6ef054d5fa0ef52bb2c33287dcdeb413fc12268fb35edfde859
+  data.tar.gz: 78903f772d37936f73a69624b3241d43703632f08542a2f57e38a619b6dc1ac012d8885c79056459ef4fd50102d416f996ea54269b64b919ac91a3db46330d8c

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [[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.
+
 ## [[0.1.0](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.0.4...v0.1.0)] - 2023-08-06
 - Refactor codes and update documentations.
 
@@ -25,5 +34,4 @@
 - Add inv module function to TinyLinalg.
 
 ## [0.0.1] - 2023-07-14
-
-- Initial release
+- Initial release.

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,115 @@
+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;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    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;

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,112 @@
+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;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    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;

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.0'
+    VERSION = '0.1.2'
   end
 end

data/lib/numo/tiny_linalg.rb

@@ -39,15 +39,15 @@ module Numo
     #   pp (x - vecs.dot(vals.diag).dot(vecs.transpose)).abs.max
     #   # => 3.3306690738754696e-16
     #
-    # @param a [Numo::NArray] n-by-n symmetric / Hermitian matrix.
-    # @param b [Numo::NArray] n-by-n symmetric / Hermitian matrix. If nil, identity matrix is assumed.
+    # @param a [Numo::NArray] The n-by-n symmetric / Hermitian matrix.
+    # @param b [Numo::NArray] The n-by-n symmetric / Hermitian matrix. If nil, identity matrix is assumed.
     # @param vals_only [Boolean] The flag indicating whether to return only eigenvalues.
     # @param vals_range [Range/Array]
     #   The range of indices of the eigenvalues (in ascending order) and corresponding eigenvectors to be returned.
     #   If nil, all eigenvalues and eigenvectors are computed.
     # @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, Numo::NArray>] The eigenvalues and eigenvectors.
+    # @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
       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]
@@ -70,8 +70,8 @@ module Numo
         vecs, _b, vals, _info = Numo::TinyLinalg::Lapack.send(sy_he_gv.to_sym, a.dup, b.dup, jobz: jobz)
       else
         sy_he_gv << 'x'
-        il = vals_range.first + 1
-        iu = vals_range.last + 1
+        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
         )
@@ -91,7 +91,7 @@ module Numo
     #   pp (3.0 - Numo::Linalg.det(a)).abs
     #   # => 1.3322676295501878e-15
     #
-    # @param a [Numo::NArray] n-by-n square matrix.
+    # @param a [Numo::NArray] The n-by-n square matrix.
     # @return [Float/Complex] The determinant of `a`.
     def det(a)
       raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
@@ -132,7 +132,7 @@ module Numo
     #   pp inv_a.dot(a).sum
     #   # => 5.0
     #
-    # @param a [Numo::NArray] n-by-n square matrix.
+    # @param a [Numo::NArray] The n-by-n square 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 inverse matrix of `a`.
@@ -156,7 +156,7 @@ module Numo
       end
     end
 
-    # Compute the (Moore-Penrose) pseudo-inverse of a matrix using singular value decomposition.
+    # Computes the (Moore-Penrose) pseudo-inverse of a matrix using singular value decomposition.
     #
     # @example
     #   require 'numo/tiny_linalg'
@@ -174,7 +174,7 @@ module Numo
     #   # => 3.0
     #
     # @param a [Numo::NArray] The m-by-n matrix to be pseudo-inverted.
-    # @param driver [String] LAPACK driver to be used ('svd' or 'sdd').
+    # @param driver [String] The LAPACK driver to be used ('svd' or 'sdd').
     # @param rcond [Float] The threshold value for small singular values of `a`, default value is `a.shape.max * EPS`.
     # @return [Numo::NArray] The pseudo-inverse of `a`.
     def pinv(a, driver: 'svd', rcond: nil)
@@ -186,7 +186,7 @@ module Numo
       u.dot(vh[0...rank, true]).conj.transpose
     end
 
-    # Compute QR decomposition of a matrix.
+    # Computes the QR decomposition of a matrix.
     #
     # @example
     #   require 'numo/tiny_linalg'
@@ -222,9 +222,8 @@ module Numo
     #   - "r"        -- returns only R,
     #   - "economic" -- returns both Q [m, n] and R [n, n],
     #   - "raw"      -- returns QR and TAU (LAPACK geqrf results).
-    # @return [Numo::NArray] if mode='r'
-    # @return [Array<Numo::NArray,Numo::NArray>] if mode='reduce' or mode='economic'
-    # @return [Array<Numo::NArray,Numo::NArray>] if mode='raw' (LAPACK geqrf result)
+    # @return [Numo::NArray] if mode='r'.
+    # @return [Array<Numo::NArray>] if mode='reduce' or 'economic' or 'raw'.
     def qr(a, mode: 'reduce')
       raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
       raise ArgumentError, "invalid mode: #{mode}" unless %w[reduce r economic raw].include?(mode)
@@ -295,7 +294,7 @@ module Numo
       Numo::TinyLinalg::Lapack.send(gesv, a.dup, b.dup)[1]
     end
 
-    # Calculates the Singular Value Decomposition (SVD) of a matrix: `A = U * S * V^T`
+    # Computes the Singular Value Decomposition (SVD) of a matrix: `A = U * S * V^T`
     #
     # @example
     #   require 'numo/tiny_linalg'
@@ -328,9 +327,9 @@ module Numo
     #   # => 4.440892098500626e-16
     #
     # @param a [Numo::NArray] Matrix to be decomposed.
-    # @param driver [String] LAPACK driver to be used ('svd' or 'sdd').
-    # @param job [String] Job option ('A', 'S', or 'N').
-    # @return [Array<Numo::NArray>] Singular values and singular vectors ([s, u, vt]).
+    # @param driver [String] The LAPACK driver to be used ('svd' or 'sdd').
+    # @param job [String] The job option ('A', 'S', or 'N').
+    # @return [Array<Numo::NArray>] The singular values and singular vectors ([s, u, vt]).
     def svd(a, driver: 'svd', job: 'A')
       raise ArgumentError, "invalid job: #{job}" unless /^[ASN]/i.match?(job.to_s)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-tiny_linalg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-06 00:00:00.000000000 Z
+date: 2023-08-08 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