numo-tiny_linalg 0.0.3 → 0.1.0

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

@@ -0,0 +1,121 @@
+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, class LapackFn>
+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 = LapackFn().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 ? Util().get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? Util().get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? Util().get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? Util().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;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,121 @@
+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, class LapackFn>
+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 = LapackFn().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 ? Util().get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? Util().get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? Util().get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? Util().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;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,137 @@
+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, class LapackFn>
+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 = LapackFn().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 ? Util().get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? Util().get_jobz(kw_values[1]) : 'V';
+    const char range = kw_values[2] != Qundef ? Util().get_range(kw_values[2]) : 'A';
+    const char uplo = kw_values[3] != Qundef ? Util().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 ? Util().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;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -14,7 +14,7 @@ struct SOrgQr {
   }
 };
 
-template <int nary_dtype_id, typename DType, typename FncType>
+template <int nary_dtype_id, typename dtype, class LapackFn>
 class OrgQr {
 public:
   static void define_module_function(VALUE mLapack, const char* fnc_name) {
@@ -27,15 +27,15 @@ private:
   };
 
   static void iter_orgqr(na_loop_t* const lp) {
-    DType* a = (DType*)NDL_PTR(lp, 0);
-    DType* tau = (DType*)NDL_PTR(lp, 1);
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    dtype* tau = (dtype*)NDL_PTR(lp, 1);
     int* info = (int*)NDL_PTR(lp, 2);
     orgqr_opt* opt = (orgqr_opt*)(lp->opt_ptr);
     const lapack_int m = NDL_SHAPE(lp, 0)[0];
     const lapack_int n = NDL_SHAPE(lp, 0)[1];
     const lapack_int k = NDL_SHAPE(lp, 1)[0];
     const lapack_int lda = n;
-    const lapack_int i = FncType().call(opt->matrix_layout, m, n, k, a, lda, tau);
+    const lapack_int i = LapackFn().call(opt->matrix_layout, m, n, k, a, lda, tau);
     *info = static_cast<int>(i);
   }
 
@@ -49,7 +49,7 @@ private:
     ID kw_table[1] = { rb_intern("order") };
     VALUE kw_values[1] = { Qundef };
     rb_get_kwargs(kw_args, kw_table, 0, 1, kw_values);
-    const int matrix_layout = kw_values[0] != Qundef ? get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR;
+    const int matrix_layout = kw_values[0] != Qundef ? Util().get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR;
 
     if (CLASS_OF(a_vnary) != nary_dtype) {
       a_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, a_vnary);
@@ -90,26 +90,6 @@ private:
 
     return ret;
   }
-
-  static int get_matrix_layout(VALUE val) {
-    const char* option_str = StringValueCStr(val);
-
-    if (std::strlen(option_str) > 0) {
-      switch (option_str[0]) {
-      case 'r':
-      case 'R':
-        break;
-      case 'c':
-      case 'C':
-        rb_warn("Numo::TinyLinalg::Lapack.getrf does not support column major.");
-        break;
-      }
-    }
-
-    RB_GC_GUARD(val);
-
-    return LAPACK_ROW_MAJOR;
-  }
 };
 
 } // namespace TinyLinalg

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

@@ -0,0 +1,112 @@
+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, class LapackFn>
+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 = LapackFn().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 ? Util().get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? Util().get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? Util().get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? Util().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;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,112 @@
+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, class LapackFn>
+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 = LapackFn().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 ? Util().get_itype(kw_values[0]) : 1;
+    const char jobz = kw_values[1] != Qundef ? Util().get_jobz(kw_values[1]) : 'V';
+    const char uplo = kw_values[2] != Qundef ? Util().get_uplo(kw_values[2]) : 'U';
+    const int matrix_layout = kw_values[3] != Qundef ? Util().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;
+  }
+};
+
+} // namespace TinyLinalg