numo-linalg-alt 0.2.0

data/ext/numo/linalg/lapack/hetrf.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LINALG_ALT_LAPACK_HETRF_H
+#define NUMO_LINALG_ALT_LAPACK_HETRF_H 1
+
+#include <lapacke.h>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "../util.h"
+
+void define_linalg_lapack_hetrf(VALUE mLapack);
+
+#endif /* NUMO_LINALG_ALT_LAPACK_HETRF_H */

data/ext/numo/linalg/lapack/lange.c

@@ -0,0 +1,66 @@
+#include "lange.h"
+
+struct _lange_option {
+  int matrix_layout;
+  char norm;
+};
+
+#define DEF_LINALG_FUNC(tDType, tNAryClass, fLapackFunc)                                                   \
+  static void _iter_##fLapackFunc(na_loop_t* const lp) {                                                   \
+    tDType* a = (tDType*)NDL_PTR(lp, 0);                                                                   \
+    tDType* d = (tDType*)NDL_PTR(lp, 1);                                                                   \
+    struct _lange_option* opt = (struct _lange_option*)(lp->opt_ptr);                                      \
+    const lapack_int m = (lapack_int)NDL_SHAPE(lp, 0)[0];                                                  \
+    const lapack_int n = (lapack_int)NDL_SHAPE(lp, 0)[1];                                                  \
+    const lapack_int lda = n;                                                                              \
+    *d = LAPACKE_##fLapackFunc(opt->matrix_layout, opt->norm, m, n, a, lda);                               \
+  }                                                                                                        \
+                                                                                                           \
+  static VALUE _linalg_lapack_##fLapackFunc(int argc, VALUE* argv, VALUE self) {                           \
+    VALUE a_vnary = Qnil;                                                                                  \
+    VALUE kw_args = Qnil;                                                                                  \
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);                                                    \
+    ID kw_table[2] = { rb_intern("order"), rb_intern("norm") };                                            \
+    VALUE kw_values[2] = { Qundef, Qundef };                                                               \
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);                                                     \
+    const int matrix_layout = kw_values[0] != Qundef ? get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR; \
+    const char norm = kw_values[1] != Qundef ? NUM2CHR(kw_values[1]) : 'F';                                \
+                                                                                                           \
+    if (CLASS_OF(a_vnary) != tNAryClass) {                                                                 \
+      a_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, a_vnary);                                     \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(a_vnary))) {                                                          \
+      a_vnary = nary_dup(a_vnary);                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    narray_t* a_nary = NULL;                                                                               \
+    GetNArray(a_vnary, a_nary);                                                                            \
+    if (NA_NDIM(a_nary) != 2) {                                                                            \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                                       \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 2 } };                                                        \
+    size_t shape_out[1] = { 1 };                                                                           \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0, shape_out } };                                           \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 1, 1, ain, aout };                        \
+    struct _lange_option opt = { matrix_layout, norm };                                                    \
+    VALUE ret = na_ndloop3(&ndf, &opt, 1, a_vnary);                                                        \
+                                                                                                           \
+    RB_GC_GUARD(a_vnary);                                                                                  \
+    return ret;                                                                                            \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dlange)
+DEF_LINALG_FUNC(float, numo_cSFloat, slange)
+DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, zlange)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, clange)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_lange(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dlange", RUBY_METHOD_FUNC(_linalg_lapack_dlange), -1);
+  rb_define_module_function(mLapack, "slange", RUBY_METHOD_FUNC(_linalg_lapack_slange), -1);
+  rb_define_module_function(mLapack, "zlange", RUBY_METHOD_FUNC(_linalg_lapack_zlange), -1);
+  rb_define_module_function(mLapack, "clange", RUBY_METHOD_FUNC(_linalg_lapack_clange), -1);
+}

data/ext/numo/linalg/lapack/lange.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LINALG_ALT_LAPACK_LANGE_H
+#define NUMO_LINALG_ALT_LAPACK_LANGE_H 1
+
+#include <lapacke.h>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "../util.h"
+
+void define_linalg_lapack_lange(VALUE mLapack);
+
+#endif /* NUMO_LINALG_ALT_LAPACK_LANGE_H */

data/ext/numo/linalg/lapack/orgqr.c

@@ -0,0 +1,79 @@
+#include "orgqr.h"
+
+struct _orgqr_option {
+  int matrix_layout;
+};
+
+#define DEF_LINALG_FUNC(tDType, tNAryClass, fLapackFunc)                                                   \
+  static void _iter_##fLapackFunc(na_loop_t* const lp) {                                                   \
+    tDType* a = (tDType*)NDL_PTR(lp, 0);                                                                   \
+    tDType* tau = (tDType*)NDL_PTR(lp, 1);                                                                 \
+    int* info = (int*)NDL_PTR(lp, 2);                                                                      \
+    struct _orgqr_option* opt = (struct _orgqr_option*)(lp->opt_ptr);                                      \
+    const lapack_int m = (lapack_int)NDL_SHAPE(lp, 0)[0];                                                  \
+    const lapack_int n = (lapack_int)NDL_SHAPE(lp, 0)[1];                                                  \
+    const lapack_int k = (lapack_int)NDL_SHAPE(lp, 1)[0];                                                  \
+    const lapack_int lda = n;                                                                              \
+    const lapack_int i = LAPACKE_##fLapackFunc(opt->matrix_layout, m, n, k, a, lda, tau);                  \
+    *info = (int)i;                                                                                        \
+  }                                                                                                        \
+                                                                                                           \
+  static VALUE _linalg_lapack_##fLapackFunc(int argc, VALUE* argv, VALUE self) {                           \
+    VALUE a_vnary = Qnil;                                                                                  \
+    VALUE tau_vnary = Qnil;                                                                                \
+    VALUE kw_args = Qnil;                                                                                  \
+    rb_scan_args(argc, argv, "2:", &a_vnary, &tau_vnary, &kw_args);                                        \
+    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; \
+                                                                                                           \
+    if (CLASS_OF(a_vnary) != tNAryClass) {                                                                 \
+      a_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, a_vnary);                                     \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(a_vnary))) {                                                          \
+      a_vnary = nary_dup(a_vnary);                                                                         \
+    }                                                                                                      \
+    if (CLASS_OF(tau_vnary) != tNAryClass) {                                                               \
+      tau_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, tau_vnary);                                 \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(tau_vnary))) {                                                        \
+      tau_vnary = nary_dup(tau_vnary);                                                                     \
+    }                                                                                                      \
+                                                                                                           \
+    narray_t* a_nary = NULL;                                                                               \
+    GetNArray(a_vnary, a_nary);                                                                            \
+    if (NA_NDIM(a_nary) != 2) {                                                                            \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                                       \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+    narray_t* tau_nary = NULL;                                                                             \
+    GetNArray(tau_vnary, tau_nary);                                                                        \
+    if (NA_NDIM(tau_nary) != 1) {                                                                          \
+      rb_raise(rb_eArgError, "input array tau must be 1-dimensional");                                     \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { tNAryClass, 1 } };                                      \
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };                                                     \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 2, 1, ain, aout };                        \
+    struct _orgqr_option opt = { matrix_layout };                                                          \
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, tau_vnary);                                             \
+                                                                                                           \
+    VALUE ret = rb_ary_new3(2, a_vnary, res);                                                              \
+                                                                                                           \
+    RB_GC_GUARD(a_vnary);                                                                                  \
+    RB_GC_GUARD(tau_vnary);                                                                                \
+                                                                                                           \
+    return ret;                                                                                            \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dorgqr)
+DEF_LINALG_FUNC(float, numo_cSFloat, sorgqr)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_orgqr(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dorgqr", RUBY_METHOD_FUNC(_linalg_lapack_dorgqr), -1);
+  rb_define_module_function(mLapack, "sorgqr", RUBY_METHOD_FUNC(_linalg_lapack_sorgqr), -1);
+}

data/ext/numo/linalg/lapack/orgqr.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LINALG_ALT_LAPACK_ORGQR_H
+#define NUMO_LINALG_ALT_LAPACK_ORGQR_H 1
+
+#include <lapacke.h>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "../util.h"
+
+void define_linalg_lapack_orgqr(VALUE mLapack);
+
+#endif /* NUMO_LINALG_ALT_LAPACK_ORGQR_H */

data/ext/numo/linalg/lapack/potrf.c

@@ -0,0 +1,70 @@
+#include "potrf.h"
+
+struct _potrf_option {
+  int matrix_layout;
+  char uplo;
+};
+
+#define DEF_LINALG_FUNC(tDType, tNAryClass, fLapackFunc)                                                   \
+  static void _iter_##fLapackFunc(na_loop_t* const lp) {                                                   \
+    tDType* a = (tDType*)NDL_PTR(lp, 0);                                                                   \
+    int* info = (int*)NDL_PTR(lp, 1);                                                                      \
+    struct _potrf_option* opt = (struct _potrf_option*)(lp->opt_ptr);                                      \
+    const lapack_int n = (lapack_int)NDL_SHAPE(lp, 0)[0];                                                  \
+    const lapack_int lda = (lapack_int)NDL_SHAPE(lp, 0)[1];                                                \
+    const lapack_int i = LAPACKE_##fLapackFunc(opt->matrix_layout, opt->uplo, n, a, lda);                  \
+    *info = (int)i;                                                                                        \
+  }                                                                                                        \
+                                                                                                           \
+  static VALUE _linalg_lapack_##fLapackFunc(int argc, VALUE* argv, VALUE self) {                           \
+    VALUE a_vnary = Qnil;                                                                                  \
+    VALUE kw_args = Qnil;                                                                                  \
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);                                                    \
+    ID kw_table[2] = { rb_intern("order"), rb_intern("uplo") };                                            \
+    VALUE kw_values[2] = { Qundef, Qundef };                                                               \
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);                                                     \
+    const int matrix_layout = kw_values[0] != Qundef ? get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR; \
+    const char uplo = kw_values[1] != Qundef ? get_uplo(kw_values[1]) : 'U';                               \
+                                                                                                           \
+    if (CLASS_OF(a_vnary) != tNAryClass) {                                                                 \
+      a_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, a_vnary);                                     \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(a_vnary))) {                                                          \
+      a_vnary = nary_dup(a_vnary);                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    narray_t* a_nary = NULL;                                                                               \
+    GetNArray(a_vnary, a_nary);                                                                            \
+    if (NA_NDIM(a_nary) != 2) {                                                                            \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                                       \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+    if (NA_SHAPE(a_nary)[0] != NA_SHAPE(a_nary)[1]) {                                                      \
+      rb_raise(rb_eArgError, "input array a must be square");                                              \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };                                                         \
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };                                                     \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 1, 1, ain, aout };                        \
+    struct _potrf_option opt = { matrix_layout, uplo };                                                    \
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);                                                        \
+    VALUE ret = rb_ary_new3(2, a_vnary, res);                                                              \
+                                                                                                           \
+    RB_GC_GUARD(a_vnary);                                                                                  \
+    return ret;                                                                                            \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dpotrf)
+DEF_LINALG_FUNC(float, numo_cSFloat, spotrf)
+DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, zpotrf)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cpotrf)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_potrf(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dpotrf", RUBY_METHOD_FUNC(_linalg_lapack_dpotrf), -1);
+  rb_define_module_function(mLapack, "spotrf", RUBY_METHOD_FUNC(_linalg_lapack_spotrf), -1);
+  rb_define_module_function(mLapack, "zpotrf", RUBY_METHOD_FUNC(_linalg_lapack_zpotrf), -1);
+  rb_define_module_function(mLapack, "cpotrf", RUBY_METHOD_FUNC(_linalg_lapack_cpotrf), -1);
+}

data/ext/numo/linalg/lapack/potrf.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LINALG_ALT_LAPACK_POTRF_H
+#define NUMO_LINALG_ALT_LAPACK_POTRF_H 1
+
+#include <lapacke.h>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "../util.h"
+
+void define_linalg_lapack_potrf(VALUE mLapack);
+
+#endif /* NUMO_LINALG_ALT_LAPACK_POTRF_H */

data/ext/numo/linalg/lapack/potri.c

@@ -0,0 +1,70 @@
+#include "potri.h"
+
+struct _potri_option {
+  int matrix_layout;
+  char uplo;
+};
+
+#define DEF_LINALG_FUNC(tDType, tNAryClass, fLapackFunc)                                                   \
+  static void _iter_##fLapackFunc(na_loop_t* const lp) {                                                   \
+    tDType* a = (tDType*)NDL_PTR(lp, 0);                                                                   \
+    int* info = (int*)NDL_PTR(lp, 1);                                                                      \
+    struct _potri_option* opt = (struct _potri_option*)(lp->opt_ptr);                                      \
+    const lapack_int n = (lapack_int)NDL_SHAPE(lp, 0)[0];                                                  \
+    const lapack_int lda = (lapack_int)NDL_SHAPE(lp, 0)[1];                                                \
+    const lapack_int i = LAPACKE_##fLapackFunc(opt->matrix_layout, opt->uplo, n, a, lda);                  \
+    *info = (int)i;                                                                                        \
+  }                                                                                                        \
+                                                                                                           \
+  static VALUE _linalg_lapack_##fLapackFunc(int argc, VALUE* argv, VALUE self) {                           \
+    VALUE a_vnary = Qnil;                                                                                  \
+    VALUE kw_args = Qnil;                                                                                  \
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);                                                    \
+    ID kw_table[2] = { rb_intern("order"), rb_intern("uplo") };                                            \
+    VALUE kw_values[2] = { Qundef, Qundef };                                                               \
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);                                                     \
+    const int matrix_layout = kw_values[0] != Qundef ? get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR; \
+    const char uplo = kw_values[1] != Qundef ? get_uplo(kw_values[1]) : 'U';                               \
+                                                                                                           \
+    if (CLASS_OF(a_vnary) != tNAryClass) {                                                                 \
+      a_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, a_vnary);                                     \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(a_vnary))) {                                                          \
+      a_vnary = nary_dup(a_vnary);                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    narray_t* a_nary = NULL;                                                                               \
+    GetNArray(a_vnary, a_nary);                                                                            \
+    if (NA_NDIM(a_nary) != 2) {                                                                            \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                                       \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+    if (NA_SHAPE(a_nary)[0] != NA_SHAPE(a_nary)[1]) {                                                      \
+      rb_raise(rb_eArgError, "input array a must be square");                                              \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };                                                         \
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };                                                     \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 1, 1, ain, aout };                        \
+    struct _potri_option opt = { matrix_layout, uplo };                                                    \
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);                                                        \
+    VALUE ret = rb_ary_new3(2, a_vnary, res);                                                              \
+                                                                                                           \
+    RB_GC_GUARD(a_vnary);                                                                                  \
+    return ret;                                                                                            \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dpotri)
+DEF_LINALG_FUNC(float, numo_cSFloat, spotri)
+DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, zpotri)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cpotri)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_potri(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dpotri", RUBY_METHOD_FUNC(_linalg_lapack_dpotri), -1);
+  rb_define_module_function(mLapack, "spotri", RUBY_METHOD_FUNC(_linalg_lapack_spotri), -1);
+  rb_define_module_function(mLapack, "zpotri", RUBY_METHOD_FUNC(_linalg_lapack_zpotri), -1);
+  rb_define_module_function(mLapack, "cpotri", RUBY_METHOD_FUNC(_linalg_lapack_cpotri), -1);
+}

data/ext/numo/linalg/lapack/potri.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LINALG_ALT_LAPACK_POTRI_H
+#define NUMO_LINALG_ALT_LAPACK_POTRI_H 1
+
+#include <lapacke.h>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "../util.h"
+
+void define_linalg_lapack_potri(VALUE mLapack);
+
+#endif /* NUMO_LINALG_ALT_LAPACK_POTRI_H */

data/ext/numo/linalg/lapack/potrs.c

@@ -0,0 +1,94 @@
+#include "potrs.h"
+
+struct _potrs_option {
+  int matrix_layout;
+  char uplo;
+};
+
+#define DEF_LINALG_FUNC(tDType, tNAryClass, fLapackFunc)                                                   \
+  static void _iter_##fLapackFunc(na_loop_t* const lp) {                                                   \
+    tDType* a = (tDType*)NDL_PTR(lp, 0);                                                                   \
+    tDType* b = (tDType*)NDL_PTR(lp, 1);                                                                   \
+    int* info = (int*)NDL_PTR(lp, 2);                                                                      \
+    struct _potrs_option* opt = (struct _potrs_option*)(lp->opt_ptr);                                      \
+    const lapack_int n = (lapack_int)NDL_SHAPE(lp, 0)[0];                                                  \
+    const lapack_int nrhs = lp->args[1].ndim == 1 ? 1 : (lapack_int)NDL_SHAPE(lp, 1)[1];                   \
+    const lapack_int lda = n;                                                                              \
+    const lapack_int ldb = nrhs;                                                                           \
+    const lapack_int i = LAPACKE_##fLapackFunc(opt->matrix_layout, opt->uplo, n, nrhs, a, lda, b, ldb);    \
+    *info = (int)i;                                                                                        \
+  }                                                                                                        \
+                                                                                                           \
+  static VALUE _linalg_lapack_##fLapackFunc(int argc, VALUE* argv, VALUE self) {                           \
+    VALUE a_vnary = Qnil;                                                                                  \
+    VALUE b_vnary = Qnil;                                                                                  \
+    VALUE kw_args = Qnil;                                                                                  \
+    rb_scan_args(argc, argv, "2:", &a_vnary, &b_vnary, &kw_args);                                          \
+    ID kw_table[2] = { rb_intern("order"), rb_intern("uplo") };                                            \
+    VALUE kw_values[2] = { Qundef, Qundef };                                                               \
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);                                                     \
+    const int matrix_layout = kw_values[0] != Qundef ? get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR; \
+    const char uplo = kw_values[1] != Qundef ? get_uplo(kw_values[1]) : 'U';                               \
+                                                                                                           \
+    if (CLASS_OF(a_vnary) != tNAryClass) {                                                                 \
+      a_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, a_vnary);                                     \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(a_vnary))) {                                                          \
+      a_vnary = nary_dup(a_vnary);                                                                         \
+    }                                                                                                      \
+    if (CLASS_OF(b_vnary) != tNAryClass) {                                                                 \
+      b_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, b_vnary);                                     \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(b_vnary))) {                                                          \
+      b_vnary = nary_dup(b_vnary);                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    narray_t* a_nary = NULL;                                                                               \
+    GetNArray(a_vnary, a_nary);                                                                            \
+    if (NA_NDIM(a_nary) != 2) {                                                                            \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                                       \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+    if (NA_SHAPE(a_nary)[0] != NA_SHAPE(a_nary)[1]) {                                                      \
+      rb_raise(rb_eArgError, "input array a must be square");                                              \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+    narray_t* b_nary = NULL;                                                                               \
+    GetNArray(b_vnary, b_nary);                                                                            \
+    const int b_n_dims = NA_NDIM(b_nary);                                                                  \
+    if (b_n_dims != 1 && b_n_dims != 2) {                                                                  \
+      rb_raise(rb_eArgError, "input array b must be 1- or 2-dimensional");                                 \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    lapack_int n = (lapack_int)NA_SHAPE(a_nary)[0];                                                        \
+    lapack_int nb = (lapack_int)NA_SHAPE(b_nary)[0];                                                       \
+    if (n != nb) {                                                                                         \
+      rb_raise(nary_eShapeError, "shape1[0](=%d) != shape2[0](=%d)", n, nb);                               \
+    }                                                                                                      \
+                                                                                                           \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 2 }, { OVERWRITE, b_n_dims } };                               \
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };                                                     \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 2, 1, ain, aout };                        \
+    struct _potrs_option opt = { matrix_layout, uplo };                                                    \
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);                                               \
+    VALUE ret = rb_ary_new3(2, b_vnary, res);                                                              \
+                                                                                                           \
+    RB_GC_GUARD(a_vnary);                                                                                  \
+    RB_GC_GUARD(b_vnary);                                                                                  \
+    return ret;                                                                                            \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dpotrs)
+DEF_LINALG_FUNC(float, numo_cSFloat, spotrs)
+DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, zpotrs)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cpotrs)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_potrs(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dpotrs", RUBY_METHOD_FUNC(_linalg_lapack_dpotrs), -1);
+  rb_define_module_function(mLapack, "spotrs", RUBY_METHOD_FUNC(_linalg_lapack_spotrs), -1);
+  rb_define_module_function(mLapack, "zpotrs", RUBY_METHOD_FUNC(_linalg_lapack_zpotrs), -1);
+  rb_define_module_function(mLapack, "cpotrs", RUBY_METHOD_FUNC(_linalg_lapack_cpotrs), -1);
+}

data/ext/numo/linalg/lapack/potrs.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LINALG_ALT_LAPACK_POTRS_H
+#define NUMO_LINALG_ALT_LAPACK_POTRS_H 1
+
+#include <lapacke.h>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "../util.h"
+
+void define_linalg_lapack_potrs(VALUE mLapack);
+
+#endif /* NUMO_LINALG_ALT_LAPACK_POTRS_H */

data/ext/numo/linalg/lapack/syev.c

@@ -0,0 +1,71 @@
+#include "syev.h"
+
+struct _syev_option {
+  int matrix_layout;
+  char jobz;
+  char uplo;
+};
+
+#define DEF_LINALG_FUNC(tDType, tNAryClass, fLapackFunc)                                                   \
+  static void _iter_##fLapackFunc(na_loop_t* const lp) {                                                   \
+    tDType* a = (tDType*)NDL_PTR(lp, 0);                                                                   \
+    tDType* w = (tDType*)NDL_PTR(lp, 1);                                                                   \
+    int* info = (int*)NDL_PTR(lp, 2);                                                                      \
+    struct _syev_option* opt = (struct _syev_option*)(lp->opt_ptr);                                        \
+    const lapack_int n = (lapack_int)NDL_SHAPE(lp, 0)[1];                                                  \
+    const lapack_int lda = (lapack_int)NDL_SHAPE(lp, 0)[0];                                                \
+    const lapack_int i = LAPACKE_##fLapackFunc(opt->matrix_layout, opt->jobz, opt->uplo, n, a, lda, w);    \
+    *info = (int)i;                                                                                        \
+  }                                                                                                        \
+                                                                                                           \
+  static VALUE _linalg_lapack_##fLapackFunc(int argc, VALUE* argv, VALUE self) {                           \
+    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 ? get_jobz(kw_values[0]) : 'V';                               \
+    const char uplo = kw_values[1] != Qundef ? get_uplo(kw_values[1]) : 'U';                               \
+    const int matrix_layout = kw_values[2] != Qundef ? get_matrix_layout(kw_values[2]) : LAPACK_ROW_MAJOR; \
+                                                                                                           \
+    if (CLASS_OF(a_vnary) != tNAryClass) {                                                                 \
+      a_vnary = rb_funcall(tNAryClass, rb_intern("cast"), 1, a_vnary);                                     \
+    }                                                                                                      \
+    if (!RTEST(nary_check_contiguous(a_vnary))) {                                                          \
+      a_vnary = nary_dup(a_vnary);                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    narray_t* a_nary = NULL;                                                                               \
+    GetNArray(a_vnary, a_nary);                                                                            \
+    if (NA_NDIM(a_nary) != 2) {                                                                            \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                                       \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+    if (NA_SHAPE(a_nary)[0] != NA_SHAPE(a_nary)[1]) {                                                      \
+      rb_raise(rb_eArgError, "input array a must be square");                                              \
+      return Qnil;                                                                                         \
+    }                                                                                                      \
+                                                                                                           \
+    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] = { { tNAryClass, 1, shape }, { numo_cInt32, 0 } };                           \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };                        \
+    struct _syev_option 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;                                                                                            \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dsyev)
+DEF_LINALG_FUNC(float, numo_cSFloat, ssyev)
+
+#undef DEFINE_LINALG_FUNC
+
+void define_linalg_lapack_syev(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dsyev", RUBY_METHOD_FUNC(_linalg_lapack_dsyev), -1);
+  rb_define_module_function(mLapack, "ssyev", RUBY_METHOD_FUNC(_linalg_lapack_ssyev), -1);
+}

data/ext/numo/linalg/lapack/syev.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LINALG_ALT_LAPACK_SYEV_H
+#define NUMO_LINALG_ALT_LAPACK_SYEV_H 1
+
+#include <lapacke.h>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "../util.h"
+
+void define_linalg_lapack_syev(VALUE mLapack);
+
+#endif /* NUMO_LINALG_ALT_LAPACK_SYEV_H */