numo-linalg-alt 0.2.0

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

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

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

@@ -0,0 +1,72 @@
+#include "sytrf.h"
+
+struct _sytrf_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);                                                                                           \
+    lapack_int* ipiv = (lapack_int*)NDL_PTR(lp, 1);                                                                                \
+    int* info = (int*)NDL_PTR(lp, 2);                                                                                              \
+    struct _sytrf_option* opt = (struct _sytrf_option*)(lp->opt_ptr);                                                              \
+    const lapack_int n = (lapack_int)NDL_SHAPE(lp, 0)[0];                                                                          \
+    const lapack_int lda = n;                                                                                                      \
+    const lapack_int i = LAPACKE_##fLapackFunc(opt->matrix_layout, opt->uplo, n, a, lda, ipiv);                                    \
+    *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_tables[2] = { rb_intern("matrix_layout"), rb_intern("uplo") };                                                           \
+    VALUE kw_values[2] = { Qundef, Qundef };                                                                                       \
+    rb_get_kwargs(kw_args, kw_tables, 0, 2, kw_values);                                                                            \
+    const int matrix_layout = kw_values[0] != Qundef && kw_values[0] != Qnil ? get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR; \
+    const char uplo = kw_values[1] != Qundef && kw_values[1] != Qnil ? 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;                                                                                                                 \
+    }                                                                                                                              \
+                                                                                                                                   \
+    const size_t n = NA_SHAPE(a_nary)[0];                                                                                          \
+    size_t shape[1] = { n };                                                                                                       \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };                                                                                 \
+    ndfunc_arg_out_t aout[2] = { { numo_cInt32, 1, shape }, { numo_cInt32, 0 } };                                                  \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };                                                \
+    struct _sytrf_option opt = { matrix_layout, uplo };                                                                            \
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);                                                                                \
+                                                                                                                                   \
+    RB_GC_GUARD(a_vnary);                                                                                                          \
+    return res;                                                                                                                    \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dsytrf)
+DEF_LINALG_FUNC(float, numo_cSFloat, ssytrf)
+DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, zsytrf)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, csytrf)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_sytrf(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dsytrf", RUBY_METHOD_FUNC(_linalg_lapack_dsytrf), -1);
+  rb_define_module_function(mLapack, "ssytrf", RUBY_METHOD_FUNC(_linalg_lapack_ssytrf), -1);
+  rb_define_module_function(mLapack, "zsytrf", RUBY_METHOD_FUNC(_linalg_lapack_zsytrf), -1);
+  rb_define_module_function(mLapack, "csytrf", RUBY_METHOD_FUNC(_linalg_lapack_csytrf), -1);
+}

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

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

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

@@ -0,0 +1,99 @@
+#include "trtrs.h"
+
+struct _trtrs_option {
+  int matrix_layout;
+  char uplo;
+  char trans;
+  char diag;
+};
+
+#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 _trtrs_option* opt = (struct _trtrs_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, opt->trans, opt->diag, 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[4] = { rb_intern("order"), rb_intern("uplo"), rb_intern("trans"), rb_intern("diag") };                         \
+    VALUE kw_values[4] = { Qundef, Qundef, Qundef, Qundef };                                                                   \
+    rb_get_kwargs(kw_args, kw_table, 0, 4, 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';                                                   \
+    const char trans = kw_values[2] != Qundef ? NUM2CHR(kw_values[2]) : 'N';                                                   \
+    const char diag = kw_values[3] != Qundef ? NUM2CHR(kw_values[3]) : 'N';                                                    \
+                                                                                                                               \
+    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 _trtrs_option opt = { matrix_layout, uplo, trans, diag };                                                           \
+    VALUE info = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);                                                                  \
+    VALUE ret = rb_ary_new3(2, b_vnary, info);                                                                                 \
+                                                                                                                               \
+    RB_GC_GUARD(a_vnary);                                                                                                      \
+    RB_GC_GUARD(b_vnary);                                                                                                      \
+    return ret;                                                                                                                \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dtrtrs)
+DEF_LINALG_FUNC(float, numo_cSFloat, strtrs)
+DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, ztrtrs)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, ctrtrs)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_trtrs(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dtrtrs", RUBY_METHOD_FUNC(_linalg_lapack_dtrtrs), -1);
+  rb_define_module_function(mLapack, "strtrs", RUBY_METHOD_FUNC(_linalg_lapack_strtrs), -1);
+  rb_define_module_function(mLapack, "ztrtrs", RUBY_METHOD_FUNC(_linalg_lapack_ztrtrs), -1);
+  rb_define_module_function(mLapack, "ctrtrs", RUBY_METHOD_FUNC(_linalg_lapack_ctrtrs), -1);
+}

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

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

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

@@ -0,0 +1,79 @@
+#include "ungqr.h"
+
+struct _ungqr_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 _ungqr_option* opt = (struct _ungqr_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 _ungqr_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(lapack_complex_double, numo_cDComplex, zungqr)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cungqr)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_ungqr(VALUE mLapack) {
+  rb_define_module_function(mLapack, "zungqr", RUBY_METHOD_FUNC(_linalg_lapack_zungqr), -1);
+  rb_define_module_function(mLapack, "cungqr", RUBY_METHOD_FUNC(_linalg_lapack_cungqr), -1);
+}

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

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

data/ext/numo/linalg/linalg.c

@@ -0,0 +1,290 @@
+/**
+ * Copyright (c) 2025 Atsushi Tatsuma
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "linalg.h"
+
+VALUE rb_mLinalg;
+VALUE rb_mLinalgBlas;
+VALUE rb_mLinalgLapack;
+
+char blas_char(VALUE nary_arr) {
+  char type = 'n';
+  const size_t n = RARRAY_LEN(nary_arr);
+  for (size_t i = 0; i < n; i++) {
+    VALUE arg = rb_ary_entry(nary_arr, i);
+    if (RB_TYPE_P(arg, T_ARRAY)) {
+      arg = rb_funcall(numo_cNArray, rb_intern("asarray"), 1, arg);
+    }
+    if (CLASS_OF(arg) == numo_cBit || CLASS_OF(arg) == numo_cInt64 || CLASS_OF(arg) == numo_cInt32 ||
+        CLASS_OF(arg) == numo_cInt16 || CLASS_OF(arg) == numo_cInt8 || CLASS_OF(arg) == numo_cUInt64 ||
+        CLASS_OF(arg) == numo_cUInt32 || CLASS_OF(arg) == numo_cUInt16 || CLASS_OF(arg) == numo_cUInt8) {
+      if (type == 'n') {
+        type = 'd';
+      }
+    } else if (CLASS_OF(arg) == numo_cDFloat) {
+      if (type == 'c' || type == 'z') {
+        type = 'z';
+      } else {
+        type = 'd';
+      }
+    } else if (CLASS_OF(arg) == numo_cSFloat) {
+      if (type == 'n') {
+        type = 's';
+      }
+    } else if (CLASS_OF(arg) == numo_cDComplex) {
+      type = 'z';
+    } else if (CLASS_OF(arg) == numo_cSComplex) {
+      if (type == 'n' || type == 's') {
+        type = 'c';
+      } else if (type == 'd') {
+        type = 'z';
+      }
+    }
+  }
+  return type;
+}
+
+static VALUE linalg_blas_char(int argc, VALUE* argv, VALUE self) {
+  VALUE nary_arr = Qnil;
+  rb_scan_args(argc, argv, "*", &nary_arr);
+
+  const char type = blas_char(nary_arr);
+  if (type == 'n') {
+    rb_raise(rb_eTypeError, "invalid data type for BLAS/LAPACK");
+    return Qnil;
+  }
+
+  return rb_str_new(&type, 1);
+}
+
+static VALUE linalg_blas_call(int argc, VALUE* argv, VALUE self) {
+  VALUE fn_name = Qnil;
+  VALUE nary_arr = Qnil;
+  VALUE kw_args = Qnil;
+  rb_scan_args(argc, argv, "1*:", &fn_name, &nary_arr, &kw_args);
+
+  const char type = blas_char(nary_arr);
+  if (type == 'n') {
+    rb_raise(rb_eTypeError, "invalid data type for BLAS/LAPACK");
+    return Qnil;
+  }
+
+  char fn_str[256];
+  snprintf(fn_str, sizeof(fn_str), "%c%s",
+           type, rb_id2name(rb_to_id(rb_to_symbol(fn_name))));
+  ID fn_id = rb_intern(fn_str);
+  size_t n = RARRAY_LEN(nary_arr);
+  VALUE ret = Qnil;
+
+  if (NIL_P(kw_args)) {
+    VALUE* args = ALLOCA_N(VALUE, n);
+    for (size_t i = 0; i < n; i++) {
+      args[i] = rb_ary_entry(nary_arr, i);
+    }
+    ret = rb_funcallv(self, fn_id, (int)n, args);
+  } else {
+    VALUE* args = ALLOCA_N(VALUE, n + 1);
+    for (size_t i = 0; i < n; i++) {
+      args[i] = rb_ary_entry(nary_arr, i);
+    }
+    args[n] = kw_args;
+    ret = rb_funcallv_kw(self, fn_id, (int)(n + 1), args, RB_PASS_KEYWORDS);
+  }
+
+  return ret;
+}
+
+static VALUE linalg_dot(VALUE self, VALUE a_, VALUE b_) {
+  VALUE a = IsNArray(a_) ? a_ : rb_funcall(numo_cNArray, rb_intern("asarray"), 1, a_);
+  VALUE b = IsNArray(b_) ? b_ : rb_funcall(numo_cNArray, rb_intern("asarray"), 1, b_);
+
+  VALUE arg_arr = rb_ary_new3(2, a, b);
+  const char type = blas_char(arg_arr);
+  if (type == 'n') {
+    rb_raise(rb_eTypeError, "invalid data type for BLAS/LAPACK");
+    return Qnil;
+  }
+
+  VALUE ret = Qnil;
+  narray_t* a_nary = NULL;
+  narray_t* b_nary = NULL;
+  GetNArray(a, a_nary);
+  GetNArray(b, b_nary);
+  const int a_ndim = NA_NDIM(a_nary);
+  const int b_ndim = NA_NDIM(b_nary);
+
+  if (a_ndim == 1) {
+    if (b_ndim == 1) {
+      ID fn_id = type == 'c' || type == 'z' ? rb_intern("dotu") : rb_intern("dot");
+      ret = rb_funcall(rb_mLinalgBlas, rb_intern("call"), 3, ID2SYM(fn_id), a, b);
+    } else {
+      VALUE kw_args = rb_hash_new();
+      if (!RTEST(nary_check_contiguous(b)) && RTEST(rb_funcall(b, rb_intern("fortran_contiguous?"), 0))) {
+        b = rb_funcall(b, rb_intern("transpose"), 0);
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("trans")), rb_str_new_cstr("N"));
+      } else {
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("trans")), rb_str_new_cstr("T"));
+      }
+      char fn_name[] = "xgemv";
+      fn_name[0] = type;
+      VALUE argv[3] = { b, a, kw_args };
+      ret = rb_funcallv_kw(rb_mLinalgBlas, rb_intern(fn_name), 3, argv, RB_PASS_KEYWORDS);
+    }
+  } else {
+    if (b_ndim == 1) {
+      VALUE kw_args = rb_hash_new();
+      if (!RTEST(nary_check_contiguous(a)) && RTEST(rb_funcall(b, rb_intern("fortran_contiguous?"), 0))) {
+        a = rb_funcall(a, rb_intern("transpose"), 0);
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("trans")), rb_str_new_cstr("T"));
+      } else {
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("trans")), rb_str_new_cstr("N"));
+      }
+      char fn_name[] = "xgemv";
+      fn_name[0] = type;
+      VALUE argv[3] = { a, b, kw_args };
+      ret = rb_funcallv_kw(rb_mLinalgBlas, rb_intern(fn_name), 3, argv, RB_PASS_KEYWORDS);
+    } else {
+      VALUE kw_args = rb_hash_new();
+      if (!RTEST(nary_check_contiguous(a)) && RTEST(rb_funcall(b, rb_intern("fortran_contiguous?"), 0))) {
+        a = rb_funcall(a, rb_intern("transpose"), 0);
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("transa")), rb_str_new_cstr("T"));
+      } else {
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("transa")), rb_str_new_cstr("N"));
+      }
+      if (!RTEST(nary_check_contiguous(b)) && RTEST(rb_funcall(b, rb_intern("fortran_contiguous?"), 0))) {
+        b = rb_funcall(b, rb_intern("transpose"), 0);
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("transb")), rb_str_new_cstr("T"));
+      } else {
+        rb_hash_aset(kw_args, ID2SYM(rb_intern("transb")), rb_str_new_cstr("N"));
+      }
+      char fn_name[] = "xgemm";
+      fn_name[0] = type;
+      VALUE argv[3] = { a, b, kw_args };
+      ret = rb_funcallv_kw(rb_mLinalgBlas, rb_intern(fn_name), 3, argv, RB_PASS_KEYWORDS);
+    }
+  }
+
+  RB_GC_GUARD(a);
+  RB_GC_GUARD(b);
+
+  return ret;
+}
+
+void Init_linalg(void) {
+  rb_require("numo/narray");
+
+  /**
+   * Document-module: Numo::Linalg
+   * Numo::Linalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
+   */
+  rb_mLinalg = rb_define_module_under(rb_mNumo, "Linalg");
+  /**
+   * Document-module: Numo::Linalg::Blas
+   * Numo::Linalg::Blas is wrapper module of BLAS functions.
+   * @!visibility private
+   */
+  rb_mLinalgBlas = rb_define_module_under(rb_mLinalg, "Blas");
+  /**
+   * Document-module: Numo::Linalg::Lapack
+   * Numo::Linalg::Lapack is wrapper module of LAPACK functions.
+   * @!visibility private
+   */
+  rb_mLinalgLapack = rb_define_module_under(rb_mLinalg, "Lapack");
+
+  /* The version of OpenBLAS used in background library. */
+  rb_define_const(rb_mLinalg, "OPENBLAS_VERSION", rb_str_new_cstr(OPENBLAS_VERSION));
+
+  /**
+   * Returns BLAS char ([sdcz]) defined by data-type of arguments.
+   *
+   * @overload blas_char(a, ...) -> String
+   *   @param [Numo::NArray] a
+   *   @return [String]
+   */
+  rb_define_module_function(rb_mLinalg, "blas_char", RUBY_METHOD_FUNC(linalg_blas_char), -1);
+  /**
+   * Calculates dot product of two vectors / matrices.
+   *
+   * @overload dot(a, b) -> [Float|Complex|Numo::NArray]
+   *   @param [Numo::NArray] a
+   *   @param [Numo::NArray] b
+   *   @return [Float|Complex|Numo::NArray]
+   */
+  rb_define_module_function(rb_mLinalg, "dot", RUBY_METHOD_FUNC(linalg_dot), 2);
+  /**
+   * Calls BLAS function prefixed with BLAS char.
+   *
+   * @overload call(func, *args)
+   *   @param func [Symbol] BLAS function name without BLAS char.
+   *   @param args arguments of BLAS function.
+   * @example
+   *   Numo::Linalg::Blas.call(:gemv, a, b)
+   */
+  rb_define_singleton_method(rb_mLinalgBlas, "call", RUBY_METHOD_FUNC(linalg_blas_call), -1);
+
+  define_linalg_blas_dot(rb_mLinalgBlas);
+  define_linalg_blas_dot_sub(rb_mLinalgBlas);
+  define_linalg_blas_gemm(rb_mLinalgBlas);
+  define_linalg_blas_gemv(rb_mLinalgBlas);
+  define_linalg_blas_nrm2(rb_mLinalgBlas);
+  define_linalg_lapack_geqrf(rb_mLinalgLapack);
+  define_linalg_lapack_orgqr(rb_mLinalgLapack);
+  define_linalg_lapack_ungqr(rb_mLinalgLapack);
+  define_linalg_lapack_geev(rb_mLinalgLapack);
+  define_linalg_lapack_gesv(rb_mLinalgLapack);
+  define_linalg_lapack_gesvd(rb_mLinalgLapack);
+  define_linalg_lapack_gesdd(rb_mLinalgLapack);
+  define_linalg_lapack_getrf(rb_mLinalgLapack);
+  define_linalg_lapack_getri(rb_mLinalgLapack);
+  define_linalg_lapack_getrs(rb_mLinalgLapack);
+  define_linalg_lapack_trtrs(rb_mLinalgLapack);
+  define_linalg_lapack_potrf(rb_mLinalgLapack);
+  define_linalg_lapack_potri(rb_mLinalgLapack);
+  define_linalg_lapack_potrs(rb_mLinalgLapack);
+  define_linalg_lapack_syev(rb_mLinalgLapack);
+  define_linalg_lapack_heev(rb_mLinalgLapack);
+  define_linalg_lapack_syevd(rb_mLinalgLapack);
+  define_linalg_lapack_heevd(rb_mLinalgLapack);
+  define_linalg_lapack_syevr(rb_mLinalgLapack);
+  define_linalg_lapack_heevr(rb_mLinalgLapack);
+  define_linalg_lapack_sygv(rb_mLinalgLapack);
+  define_linalg_lapack_hegv(rb_mLinalgLapack);
+  define_linalg_lapack_sygvd(rb_mLinalgLapack);
+  define_linalg_lapack_hegvd(rb_mLinalgLapack);
+  define_linalg_lapack_sygvx(rb_mLinalgLapack);
+  define_linalg_lapack_hegvx(rb_mLinalgLapack);
+  define_linalg_lapack_lange(rb_mLinalgLapack);
+  define_linalg_lapack_gelsd(rb_mLinalgLapack);
+  define_linalg_lapack_sytrf(rb_mLinalgLapack);
+  define_linalg_lapack_hetrf(rb_mLinalgLapack);
+
+  rb_define_alias(rb_singleton_class(rb_mLinalgBlas), "znrm2", "dznrm2");
+  rb_define_alias(rb_singleton_class(rb_mLinalgBlas), "cnrm2", "scnrm2");
+}