numo-tiny_linalg 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbebba3b506ab283688f9d0935739e14c09106918a98571b9addb64b6689cc75
-  data.tar.gz: 85eaa28da383e21a4503407667baacb95fb5382f20f54804f02e4c2d49c15cd1
+  metadata.gz: '023843b368ce62924768c3341587977e57edb6aca0e6d93b64279d5e7965bf0b'
+  data.tar.gz: fe00ae7b435a94a6ff2790320f89bfef078efafed110e253f8929553480b67d6
 SHA512:
-  metadata.gz: 262e38a4bbbbf6141cca723830f93c80cc9d33ac8a34753e3af1b9b5b239f4576140f18ad43999e8d0568438380f8bb2f6cf3f78c1f5d35402d57fcf55e4e253
-  data.tar.gz: ba6e767f8728022dff634e1a3824a166c5b3f4d17057b65f2e279a2ccda293c2432aea07783708fdd9f1d810e7a9bc9428ae2b9fe559b0bb519d8b1cb828b01e
+  metadata.gz: 36d907834c73b633ae3872ba5fa73f315dd01d79e99487e7fb4f6f2e3f37a7fbcbfa1b25d078b4d44cd66213da545a665c35817d6929d22a8a05fa023791bd2f
+  data.tar.gz: eaab6dbb2835d60ad3432525a830a1a5f19625c7b87d1010db81efeb480892c0807612d8d13cdc23c60abde1d7304594fc4562099102a6738b8cee1aeccb55a6

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [[0.0.3](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.0.3...v0.0.4)] - 2023-08-06
+- Add dsygv, ssygv, zhegv, and chegv module functions to TinyLinalg::Lapack.
+- Add dsygvd, ssygvd, zhegvd, and chegvd module functions to TinyLinalg::Lapack.
+- Add dsygvx, ssygvx, zhegvx, and chegvx module functions to TinyLinalg::Lapack.
+- Add eigh module function to TinyLinalg.
+
 ## [[0.0.3](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.0.2...v0.0.3)] - 2023-08-02
 - Add dgeqrf, sgeqrf, zgeqrf, and cgeqrf module functions to TinyLinalg::Lapack.
 - Add dorgqr, sorgqr, zungqr, and cungqr module functions to TinyLinalg::Lapack.

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

@@ -0,0 +1,167 @@
+namespace TinyLinalg {
+
+struct ZHeGv {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, lapack_complex_double* a,
+                  lapack_int lda, lapack_complex_double* b,
+                  lapack_int ldb, double* w) {
+    return LAPACKE_zhegv(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+struct CHeGv {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, float* a, lapack_int lda,
+                  float* b, lapack_int ldb, float* w) {
+    return LAPACKE_ssygv(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, lapack_complex_float* a,
+                  lapack_int lda, lapack_complex_float* b,
+                  lapack_int ldb, float* w) {
+    return LAPACKE_chegv(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+template <int nary_dtype_id, int nary_rtype_id, typename DType, typename RType, typename FncType>
+class HeGv {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_hegv), -1);
+  }
+
+private:
+  struct hegv_opt {
+    int matrix_layout;
+    lapack_int itype;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_hegv(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* b = (DType*)NDL_PTR(lp, 1);
+    RType* w = (RType*)NDL_PTR(lp, 2);
+    int* info = (int*)NDL_PTR(lp, 3);
+    hegv_opt* opt = (hegv_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 ldb = NDL_SHAPE(lp, 1)[0];
+    const lapack_int i = FncType().call(opt->matrix_layout, opt->itype, opt->jobz, opt->uplo, n, a, lda, b, ldb, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_hegv(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 b_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "2:", &a_vnary, &b_vnary, &kw_args);
+    ID kw_table[4] = { rb_intern("itype"), rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[4] = { Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 4, kw_values);
+    const lapack_int itype = kw_values[0] != Qundef ? get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? get_matrix_layout(kw_values[3]) : 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);
+    }
+    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 = 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;
+    }
+    narray_t* b_nary = nullptr;
+    GetNArray(a_vnary, b_nary);
+    if (NA_NDIM(b_nary) != 2) {
+      rb_raise(rb_eArgError, "input array b must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(b_nary)[0] != NA_SHAPE(b_nary)[1]) {
+      rb_raise(rb_eArgError, "input array b must be square");
+      return Qnil;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_rtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_hegv, NO_LOOP | NDF_EXTRACT, 2, 2, ain, aout };
+    hegv_opt opt = { matrix_layout, itype, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(4, a_vnary, b_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+
+  static lapack_int get_itype(VALUE val) {
+    const lapack_int itype = NUM2INT(val);
+
+    if (itype != 1 && itype != 2 && itype != 3) {
+      rb_raise(rb_eArgError, "itype must be 1, 2 or 3");
+    }
+
+    return itype;
+  }
+
+  static char get_jobz(VALUE val) {
+    const char jobz = NUM2CHR(val);
+
+    if (jobz != 'n' && jobz != 'N' && jobz != 'v' && jobz != 'V') {
+      rb_raise(rb_eArgError, "jobz must be 'N' or 'V'");
+    }
+
+    return jobz;
+  }
+
+  static char get_uplo(VALUE val) {
+    const char uplo = NUM2CHR(val);
+
+    if (uplo != 'u' && uplo != 'U' && uplo != 'l' && uplo != 'L') {
+      rb_raise(rb_eArgError, "uplo must be 'U' or 'L'");
+    }
+
+    return uplo;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char option = NUM2CHR(val);
+
+    switch (option) {
+    case 'r':
+    case 'R':
+      break;
+    case 'c':
+    case 'C':
+      rb_warn("Numo::TinyLinalg::Lapack.sygv does not support column major.");
+      break;
+    }
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,167 @@
+namespace TinyLinalg {
+
+struct ZHeGvd {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, lapack_complex_double* a,
+                  lapack_int lda, lapack_complex_double* b,
+                  lapack_int ldb, double* w) {
+    return LAPACKE_zhegvd(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+struct CHeGvd {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, float* a, lapack_int lda,
+                  float* b, lapack_int ldb, float* w) {
+    return LAPACKE_ssygvd(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, lapack_complex_float* a,
+                  lapack_int lda, lapack_complex_float* b,
+                  lapack_int ldb, float* w) {
+    return LAPACKE_chegvd(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+template <int nary_dtype_id, int nary_rtype_id, typename DType, typename RType, typename FncType>
+class HeGvd {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_hegvd), -1);
+  }
+
+private:
+  struct hegvd_opt {
+    int matrix_layout;
+    lapack_int itype;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_hegvd(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* b = (DType*)NDL_PTR(lp, 1);
+    RType* w = (RType*)NDL_PTR(lp, 2);
+    int* info = (int*)NDL_PTR(lp, 3);
+    hegvd_opt* opt = (hegvd_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 ldb = NDL_SHAPE(lp, 1)[0];
+    const lapack_int i = FncType().call(opt->matrix_layout, opt->itype, opt->jobz, opt->uplo, n, a, lda, b, ldb, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_hegvd(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 b_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "2:", &a_vnary, &b_vnary, &kw_args);
+    ID kw_table[4] = { rb_intern("itype"), rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[4] = { Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 4, kw_values);
+    const lapack_int itype = kw_values[0] != Qundef ? get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? get_matrix_layout(kw_values[3]) : 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);
+    }
+    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 = 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;
+    }
+    narray_t* b_nary = nullptr;
+    GetNArray(a_vnary, b_nary);
+    if (NA_NDIM(b_nary) != 2) {
+      rb_raise(rb_eArgError, "input array b must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(b_nary)[0] != NA_SHAPE(b_nary)[1]) {
+      rb_raise(rb_eArgError, "input array b must be square");
+      return Qnil;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_rtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_hegvd, NO_LOOP | NDF_EXTRACT, 2, 2, ain, aout };
+    hegvd_opt opt = { matrix_layout, itype, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(4, a_vnary, b_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+
+  static lapack_int get_itype(VALUE val) {
+    const lapack_int itype = NUM2INT(val);
+
+    if (itype != 1 && itype != 2 && itype != 3) {
+      rb_raise(rb_eArgError, "itype must be 1, 2 or 3");
+    }
+
+    return itype;
+  }
+
+  static char get_jobz(VALUE val) {
+    const char jobz = NUM2CHR(val);
+
+    if (jobz != 'n' && jobz != 'N' && jobz != 'v' && jobz != 'V') {
+      rb_raise(rb_eArgError, "jobz must be 'N' or 'V'");
+    }
+
+    return jobz;
+  }
+
+  static char get_uplo(VALUE val) {
+    const char uplo = NUM2CHR(val);
+
+    if (uplo != 'u' && uplo != 'U' && uplo != 'l' && uplo != 'L') {
+      rb_raise(rb_eArgError, "uplo must be 'U' or 'L'");
+    }
+
+    return uplo;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char option = NUM2CHR(val);
+
+    switch (option) {
+    case 'r':
+    case 'R':
+      break;
+    case 'c':
+    case 'C':
+      rb_warn("Numo::TinyLinalg::Lapack.sygvd does not support column major.");
+      break;
+    }
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,193 @@
+namespace TinyLinalg {
+
+struct ZHeGvx {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz, char range, char uplo,
+                  lapack_int n, lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
+                  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* ifail) {
+    return LAPACKE_zhegvx(matrix_layout, itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, ifail);
+  }
+};
+
+struct CHeGvx {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz, char range, char uplo,
+                  lapack_int n, lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
+                  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* ifail) {
+    return LAPACKE_chegvx(matrix_layout, itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, ifail);
+  }
+};
+
+template <int nary_dtype_id, int nary_rtype_id, typename DType, typename RType, typename FncType>
+class HeGvx {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_hegvx), -1);
+  }
+
+private:
+  struct hegvx_opt {
+    int matrix_layout;
+    lapack_int itype;
+    char jobz;
+    char range;
+    char uplo;
+    RType vl;
+    RType vu;
+    lapack_int il;
+    lapack_int iu;
+  };
+
+  static void iter_hegvx(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* b = (DType*)NDL_PTR(lp, 1);
+    int* m = (int*)NDL_PTR(lp, 2);
+    RType* w = (RType*)NDL_PTR(lp, 3);
+    DType* z = (DType*)NDL_PTR(lp, 4);
+    int* ifail = (int*)NDL_PTR(lp, 5);
+    int* info = (int*)NDL_PTR(lp, 6);
+    hegvx_opt* opt = (hegvx_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 ldb = NDL_SHAPE(lp, 1)[0];
+    const lapack_int ldz = opt->range != 'I' ? n : opt->iu - opt->il + 1;
+    const RType abstol = 0.0;
+    const lapack_int i = FncType().call(
+      opt->matrix_layout, opt->itype, opt->jobz, opt->range, opt->uplo, n, a, lda, b, ldb,
+      opt->vl, opt->vu, opt->il, opt->iu, abstol, m, w, z, ldz, ifail);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_hegvx(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 b_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "2:", &a_vnary, &b_vnary, &kw_args);
+    ID kw_table[9] = { rb_intern("itype"), 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[9] = { Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 9, kw_values);
+    const lapack_int itype = kw_values[0] != Qundef ? get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? get_jobz(kw_values[1]) : 'V';
+    const char range = kw_values[2] != Qundef ? get_range(kw_values[2]) : 'A';
+    const char uplo = kw_values[3] != Qundef ? get_uplo(kw_values[3]) : 'U';
+    const RType vl = kw_values[4] != Qundef ? NUM2DBL(kw_values[4]) : 0.0;
+    const RType vu = kw_values[5] != Qundef ? NUM2DBL(kw_values[5]) : 0.0;
+    const lapack_int il = kw_values[6] != Qundef ? NUM2INT(kw_values[6]) : 0;
+    const lapack_int iu = kw_values[7] != Qundef ? NUM2INT(kw_values[7]) : 0;
+    const int matrix_layout = kw_values[8] != Qundef ? get_matrix_layout(kw_values[8]) : 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);
+    }
+    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 = 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;
+    }
+    narray_t* b_nary = nullptr;
+    GetNArray(a_vnary, b_nary);
+    if (NA_NDIM(b_nary) != 2) {
+      rb_raise(rb_eArgError, "input array b must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(b_nary)[0] != NA_SHAPE(b_nary)[1]) {
+      rb_raise(rb_eArgError, "input array b 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 ifail_shape[1] = { n };
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[5] = { { numo_cInt32, 0 }, { nary_rtype, 1, w_shape }, { nary_dtype, 2, z_shape }, { numo_cInt32, 1, ifail_shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_hegvx, NO_LOOP | NDF_EXTRACT, 2, 5, ain, aout };
+    hegvx_opt opt = { matrix_layout, itype, jobz, range, uplo, vl, vu, il, iu };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(7, a_vnary, b_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);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+
+  static lapack_int get_itype(VALUE val) {
+    const lapack_int itype = NUM2INT(val);
+
+    if (itype != 1 && itype != 2 && itype != 3) {
+      rb_raise(rb_eArgError, "itype must be 1, 2 or 3");
+    }
+
+    return itype;
+  }
+
+  static char get_jobz(VALUE val) {
+    const char jobz = NUM2CHR(val);
+
+    if (jobz != 'N' && jobz != 'V') {
+      rb_raise(rb_eArgError, "jobz must be 'N' or 'V'");
+    }
+
+    return jobz;
+  }
+
+  static char get_range(VALUE val) {
+    const char range = NUM2CHR(val);
+
+    if (range != 'A' && range != 'V' && range != 'I') {
+      rb_raise(rb_eArgError, "range must be 'A', 'V' or 'I'");
+    }
+
+    return range;
+  }
+
+  static char get_uplo(VALUE val) {
+    const char uplo = NUM2CHR(val);
+
+    if (uplo != 'U' && uplo != 'L') {
+      rb_raise(rb_eArgError, "uplo must be 'U' or 'L'");
+    }
+
+    return uplo;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char option = NUM2CHR(val);
+
+    switch (option) {
+    case 'r':
+    case 'R':
+      break;
+    case 'c':
+    case 'C':
+      rb_warn("Numo::TinyLinalg::Lapack.hegvx does not support column major.");
+      break;
+    }
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,158 @@
+namespace TinyLinalg {
+
+struct DSyGv {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, double* a, lapack_int lda,
+                  double* b, lapack_int ldb, double* w) {
+    return LAPACKE_dsygv(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+struct SSyGv {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, float* a, lapack_int lda,
+                  float* b, lapack_int ldb, float* w) {
+    return LAPACKE_ssygv(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class SyGv {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_sygv), -1);
+  }
+
+private:
+  struct sygv_opt {
+    int matrix_layout;
+    lapack_int itype;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_sygv(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* b = (DType*)NDL_PTR(lp, 1);
+    DType* w = (DType*)NDL_PTR(lp, 2);
+    int* info = (int*)NDL_PTR(lp, 3);
+    sygv_opt* opt = (sygv_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 ldb = NDL_SHAPE(lp, 1)[0];
+    const lapack_int i = FncType().call(opt->matrix_layout, opt->itype, opt->jobz, opt->uplo, n, a, lda, b, ldb, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_sygv(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[4] = { rb_intern("itype"), rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[4] = { Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 4, kw_values);
+    const lapack_int itype = kw_values[0] != Qundef ? get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? get_matrix_layout(kw_values[3]) : 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);
+    }
+    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 = 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;
+    }
+    narray_t* b_nary = nullptr;
+    GetNArray(a_vnary, b_nary);
+    if (NA_NDIM(b_nary) != 2) {
+      rb_raise(rb_eArgError, "input array b must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(b_nary)[0] != NA_SHAPE(b_nary)[1]) {
+      rb_raise(rb_eArgError, "input array b must be square");
+      return Qnil;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_dtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_sygv, NO_LOOP | NDF_EXTRACT, 2, 2, ain, aout };
+    sygv_opt opt = { matrix_layout, itype, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(4, a_vnary, b_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+
+  static lapack_int get_itype(VALUE val) {
+    const lapack_int itype = NUM2INT(val);
+
+    if (itype != 1 && itype != 2 && itype != 3) {
+      rb_raise(rb_eArgError, "itype must be 1, 2 or 3");
+    }
+
+    return itype;
+  }
+
+  static char get_jobz(VALUE val) {
+    const char jobz = NUM2CHR(val);
+
+    if (jobz != 'n' && jobz != 'N' && jobz != 'v' && jobz != 'V') {
+      rb_raise(rb_eArgError, "jobz must be 'N' or 'V'");
+    }
+
+    return jobz;
+  }
+
+  static char get_uplo(VALUE val) {
+    const char uplo = NUM2CHR(val);
+
+    if (uplo != 'u' && uplo != 'U' && uplo != 'l' && uplo != 'L') {
+      rb_raise(rb_eArgError, "uplo must be 'U' or 'L'");
+    }
+
+    return uplo;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char option = NUM2CHR(val);
+
+    switch (option) {
+    case 'r':
+    case 'R':
+      break;
+    case 'c':
+    case 'C':
+      rb_warn("Numo::TinyLinalg::Lapack.sygv does not support column major.");
+      break;
+    }
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,158 @@
+namespace TinyLinalg {
+
+struct DSyGvd {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, double* a, lapack_int lda,
+                  double* b, lapack_int ldb, double* w) {
+    return LAPACKE_dsygvd(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+struct SSyGvd {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz,
+                  char uplo, lapack_int n, float* a, lapack_int lda,
+                  float* b, lapack_int ldb, float* w) {
+    return LAPACKE_ssygvd(matrix_layout, itype, jobz, uplo, n, a, lda, b, ldb, w);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class SyGvd {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_sygvd), -1);
+  }
+
+private:
+  struct sygvd_opt {
+    int matrix_layout;
+    lapack_int itype;
+    char jobz;
+    char uplo;
+  };
+
+  static void iter_sygvd(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* b = (DType*)NDL_PTR(lp, 1);
+    DType* w = (DType*)NDL_PTR(lp, 2);
+    int* info = (int*)NDL_PTR(lp, 3);
+    sygvd_opt* opt = (sygvd_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 ldb = NDL_SHAPE(lp, 1)[0];
+    const lapack_int i = FncType().call(opt->matrix_layout, opt->itype, opt->jobz, opt->uplo, n, a, lda, b, ldb, w);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_sygvd(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[4] = { rb_intern("itype"), rb_intern("jobz"), rb_intern("uplo"), rb_intern("order") };
+    VALUE kw_values[4] = { Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 4, kw_values);
+    const lapack_int itype = kw_values[0] != Qundef ? get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? get_matrix_layout(kw_values[3]) : 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);
+    }
+    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 = 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;
+    }
+    narray_t* b_nary = nullptr;
+    GetNArray(a_vnary, b_nary);
+    if (NA_NDIM(b_nary) != 2) {
+      rb_raise(rb_eArgError, "input array b must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(b_nary)[0] != NA_SHAPE(b_nary)[1]) {
+      rb_raise(rb_eArgError, "input array b must be square");
+      return Qnil;
+    }
+
+    const size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { n };
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_dtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_sygvd, NO_LOOP | NDF_EXTRACT, 2, 2, ain, aout };
+    sygvd_opt opt = { matrix_layout, itype, jobz, uplo };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(4, a_vnary, b_vnary, rb_ary_entry(res, 0), rb_ary_entry(res, 1));
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+
+  static lapack_int get_itype(VALUE val) {
+    const lapack_int itype = NUM2INT(val);
+
+    if (itype != 1 && itype != 2 && itype != 3) {
+      rb_raise(rb_eArgError, "itype must be 1, 2 or 3");
+    }
+
+    return itype;
+  }
+
+  static char get_jobz(VALUE val) {
+    const char jobz = NUM2CHR(val);
+
+    if (jobz != 'n' && jobz != 'N' && jobz != 'v' && jobz != 'V') {
+      rb_raise(rb_eArgError, "jobz must be 'N' or 'V'");
+    }
+
+    return jobz;
+  }
+
+  static char get_uplo(VALUE val) {
+    const char uplo = NUM2CHR(val);
+
+    if (uplo != 'u' && uplo != 'U' && uplo != 'l' && uplo != 'L') {
+      rb_raise(rb_eArgError, "uplo must be 'U' or 'L'");
+    }
+
+    return uplo;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char option = NUM2CHR(val);
+
+    switch (option) {
+    case 'r':
+    case 'R':
+      break;
+    case 'c':
+    case 'C':
+      rb_warn("Numo::TinyLinalg::Lapack.sygvd does not support column major.");
+      break;
+    }
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,192 @@
+namespace TinyLinalg {
+
+struct DSyGvx {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz, char range, char uplo,
+                  lapack_int n, double* a, lapack_int lda, double* b, lapack_int ldb,
+                  double vl, double vu, lapack_int il, lapack_int iu,
+                  double abstol, lapack_int* m, double* w, double* z, lapack_int ldz, lapack_int* ifail) {
+    return LAPACKE_dsygvx(matrix_layout, itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, ifail);
+  }
+};
+
+struct SSyGvx {
+  lapack_int call(int matrix_layout, lapack_int itype, char jobz, char range, char uplo,
+                  lapack_int n, float* a, lapack_int lda, float* b, lapack_int ldb,
+                  float vl, float vu, lapack_int il, lapack_int iu,
+                  float abstol, lapack_int* m, float* w, float* z, lapack_int ldz, lapack_int* ifail) {
+    return LAPACKE_ssygvx(matrix_layout, itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, ifail);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class SyGvx {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_sygvx), -1);
+  }
+
+private:
+  struct sygvx_opt {
+    int matrix_layout;
+    lapack_int itype;
+    char jobz;
+    char range;
+    char uplo;
+    DType vl;
+    DType vu;
+    lapack_int il;
+    lapack_int iu;
+  };
+
+  static void iter_sygvx(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* b = (DType*)NDL_PTR(lp, 1);
+    int* m = (int*)NDL_PTR(lp, 2);
+    DType* w = (DType*)NDL_PTR(lp, 3);
+    DType* z = (DType*)NDL_PTR(lp, 4);
+    int* ifail = (int*)NDL_PTR(lp, 5);
+    int* info = (int*)NDL_PTR(lp, 6);
+    sygvx_opt* opt = (sygvx_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 ldb = NDL_SHAPE(lp, 1)[0];
+    const lapack_int ldz = opt->range != 'I' ? n : opt->iu - opt->il + 1;
+    const DType abstol = 0.0;
+    const lapack_int i = FncType().call(
+      opt->matrix_layout, opt->itype, opt->jobz, opt->range, opt->uplo, n, a, lda, b, ldb,
+      opt->vl, opt->vu, opt->il, opt->iu, abstol, m, w, z, ldz, ifail);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_sygvx(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[9] = { rb_intern("itype"), 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[9] = { Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 9, kw_values);
+    const lapack_int itype = kw_values[0] != Qundef ? get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? get_jobz(kw_values[1]) : 'V';
+    const char range = kw_values[2] != Qundef ? get_range(kw_values[2]) : 'A';
+    const char uplo = kw_values[3] != Qundef ? get_uplo(kw_values[3]) : 'U';
+    const DType vl = kw_values[4] != Qundef ? NUM2DBL(kw_values[4]) : 0.0;
+    const DType vu = kw_values[5] != Qundef ? NUM2DBL(kw_values[5]) : 0.0;
+    const lapack_int il = kw_values[6] != Qundef ? NUM2INT(kw_values[6]) : 0;
+    const lapack_int iu = kw_values[7] != Qundef ? NUM2INT(kw_values[7]) : 0;
+    const int matrix_layout = kw_values[8] != Qundef ? get_matrix_layout(kw_values[8]) : 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);
+    }
+    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 = 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;
+    }
+    narray_t* b_nary = nullptr;
+    GetNArray(a_vnary, b_nary);
+    if (NA_NDIM(b_nary) != 2) {
+      rb_raise(rb_eArgError, "input array b must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(b_nary)[0] != NA_SHAPE(b_nary)[1]) {
+      rb_raise(rb_eArgError, "input array b 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 ifail_shape[1] = { n };
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[5] = { { numo_cInt32, 0 }, { nary_dtype, 1, w_shape }, { nary_dtype, 2, z_shape }, { numo_cInt32, 1, ifail_shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_sygvx, NO_LOOP | NDF_EXTRACT, 2, 5, ain, aout };
+    sygvx_opt opt = { matrix_layout, itype, jobz, range, uplo, vl, vu, il, iu };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(7, a_vnary, b_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);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+
+  static lapack_int get_itype(VALUE val) {
+    const lapack_int itype = NUM2INT(val);
+
+    if (itype != 1 && itype != 2 && itype != 3) {
+      rb_raise(rb_eArgError, "itype must be 1, 2 or 3");
+    }
+
+    return itype;
+  }
+
+  static char get_jobz(VALUE val) {
+    const char jobz = NUM2CHR(val);
+
+    if (jobz != 'N' && jobz != 'V') {
+      rb_raise(rb_eArgError, "jobz must be 'N' or 'V'");
+    }
+
+    return jobz;
+  }
+
+  static char get_range(VALUE val) {
+    const char range = NUM2CHR(val);
+
+    if (range != 'A' && range != 'V' && range != 'I') {
+      rb_raise(rb_eArgError, "range must be 'A', 'V' or 'I'");
+    }
+
+    return range;
+  }
+
+  static char get_uplo(VALUE val) {
+    const char uplo = NUM2CHR(val);
+
+    if (uplo != 'U' && uplo != 'L') {
+      rb_raise(rb_eArgError, "uplo must be 'U' or 'L'");
+    }
+
+    return uplo;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char option = NUM2CHR(val);
+
+    switch (option) {
+    case 'r':
+    case 'R':
+      break;
+    case 'c':
+    case 'C':
+      rb_warn("Numo::TinyLinalg::Lapack.sygvx does not support column major.");
+      break;
+    }
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

data/ext/numo/tiny_linalg/tiny_linalg.cpp

@@ -11,7 +11,13 @@
 #include "lapack/gesvd.hpp"
 #include "lapack/getrf.hpp"
 #include "lapack/getri.hpp"
+#include "lapack/hegv.hpp"
+#include "lapack/hegvd.hpp"
+#include "lapack/hegvx.hpp"
 #include "lapack/orgqr.hpp"
+#include "lapack/sygv.hpp"
+#include "lapack/sygvd.hpp"
+#include "lapack/sygvx.hpp"
 #include "lapack/ungqr.hpp"
 
 VALUE rb_mTinyLinalg;
@@ -271,6 +277,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::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");
+  TinyLinalg::HeGv<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CHeGv>::define_module_function(rb_mTinyLinalgLapack, "chegv");
+  TinyLinalg::SyGvd<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DSyGvd>::define_module_function(rb_mTinyLinalgLapack, "dsygvd");
+  TinyLinalg::SyGvd<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SSyGvd>::define_module_function(rb_mTinyLinalgLapack, "ssygvd");
+  TinyLinalg::HeGvd<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZHeGvd>::define_module_function(rb_mTinyLinalgLapack, "zhegvd");
+  TinyLinalg::HeGvd<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CHeGvd>::define_module_function(rb_mTinyLinalgLapack, "chegvd");
+  TinyLinalg::SyGvx<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DSyGvx>::define_module_function(rb_mTinyLinalgLapack, "dsygvx");
+  TinyLinalg::SyGvx<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SSyGvx>::define_module_function(rb_mTinyLinalgLapack, "ssygvx");
+  TinyLinalg::HeGvx<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZHeGvx>::define_module_function(rb_mTinyLinalgLapack, "zhegvx");
+  TinyLinalg::HeGvx<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CHeGvx>::define_module_function(rb_mTinyLinalgLapack, "chegvx");
 
   rb_define_alias(rb_singleton_class(rb_mTinyLinalgBlas), "znrm2", "dznrm2");
   rb_define_alias(rb_singleton_class(rb_mTinyLinalgBlas), "cnrm2", "scnrm2");

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.0.3'
+    VERSION = '0.0.4'
   end
 end

data/lib/numo/tiny_linalg.rb

@@ -10,6 +10,50 @@ module Numo
   module TinyLinalg # rubocop:disable Metrics/ModuleLength
     module_function
 
+    # Computes the eigenvalues and eigenvectors of a symmetric / Hermitian matrix
+    # by solving an ordinary or generalized eigenvalue problem.
+    #
+    # @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 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.
+    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]
+
+      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)
+      else
+        sy_he_gv << 'x'
+        il = vals_range.first + 1
+        iu = vals_range.last + 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
+        )
+      end
+      vecs = nil if vals_only
+      [vals, vecs]
+    end
+
     # Computes the determinant of matrix.
     #
     # @param a [Numo::NArray] n-by-n square matrix.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-tiny_linalg
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-02 00:00:00.000000000 Z
+date: 2023-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -52,7 +52,13 @@ 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/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/sygv.hpp
+- ext/numo/tiny_linalg/lapack/sygvd.hpp
+- ext/numo/tiny_linalg/lapack/sygvx.hpp
 - ext/numo/tiny_linalg/lapack/ungqr.hpp
 - ext/numo/tiny_linalg/tiny_linalg.cpp
 - ext/numo/tiny_linalg/tiny_linalg.hpp