numo-linalg-alt 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38d36b0f9d79ba30d90825df434ff9b7c4bdd44d71a120e65a75b7474017c04d
-  data.tar.gz: ea9c959067a82b0acf3c1990317657dfea6b055a2c4244d7cdfb7fa76b1d298b
+  metadata.gz: 25f768b7f68b0526d390891b70e65e41ef16ef61a31614100c53250bb3d29baa
+  data.tar.gz: ebeb6d483949b617d5567f0265b2cd2cdee992fe8494006875595aa2dbb80adf
 SHA512:
-  metadata.gz: 71004a21081aec907f9142dfbbed991d662c11639450d691f3c4322bfe5a68d66279c48259c9cb1a8a33704d08c9033cc675a7370a00c402c31b68cf6848fea5
-  data.tar.gz: 667a1f392aa95e2681b40575ea53c18669596ee62d77f1e01a470b25691963111b8632a967acf6eef42be0544d99206bcf0fa1407de093a2d225a0aeaf21afe3
+  metadata.gz: bba4f496a60bd9fe7aad51f07c6123855d8cbf4c1f1d2d4bb2858482c8ad3daeea5de8425176b242c5d84376874a0d0f93e80e46b0e39a2ff671721acb083fb3
+  data.tar.gz: 40d7100c495cad8021d5678ba1a0a3a3a9bdcfb53262e985234c653d207270c5d88f4a8d67ae8d00caab578f94142b1bdae198cf5ee3799cfc997f55486525cc

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [[0.5.0](https://github.com/yoshoku/numo-linalg-alt/compare/v0.4.1...v0.5.0)] - 2025-10-25
+
+- FIX: correct Numo::Linalg::Lapack.xlange return type to Float for Numo::DComplex and Numo::SComplex.
+- add `coshm`, `sinhm`, and `tanhm` module functions to Numo::Linalg.
+- add `hessenberg` module function to Numo::Linalg.
+
+## [[0.4.1](https://github.com/yoshoku/numo-linalg-alt/compare/v0.4.0...v0.4.1)] - 2025-10-19
+
+- FIX: remove incorrect usage of RUBY_METHOD_FUNC macro: [#2](https://github.com/yoshoku/numo-linalg-alt/pull/2)
+- add `matrix_balance` moudle function to Numo::Linalg.
+
 ## [[0.4.0](https://github.com/yoshoku/numo-linalg-alt/compare/v0.3.0...v0.4.0)] - 2025-10-16
 
 - add `rq`, `qz`, and `tanm` module functions to Numo::Linalg.

data/README.md

@@ -63,6 +63,11 @@ Ubuntu:
 $ gem install numo-linalg-alt
 ```
 
+## Documentation
+
+- [API Documentation](https://gemdocs.org/gems/numo-linalg-alt/0.4.1/)
+- [Comparison with scipy.linalg and numpy.linalg](https://github.com/yoshoku/numo-linalg-alt/wiki/Comparison-with-scipy.linalg-and-numpy.linalg)
+
 ## Usage
 
 An example of singular value decomposition.
@@ -94,6 +99,37 @@ puts (x - z).abs.max
 # => 4.440892098500626e-16
 ```
 
+## Development
+
+preparation:
+
+```shell
+$ git clone https://github.com/yoshoku/numo-linalg-alt
+$ cd numo-linalg-alt
+$ bundle install
+```
+
+build and test:
+
+```
+$ bundle exec rake compile
+$ bundle exec rake test
+```
+
+linter:
+
+```shell
+$ bundle exec rubocop
+$ clang-format --dry-run --Werror --style=file ext/**/*.h ext/**/*.c
+```
+
+This project follows [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
+Please run `npm install` to set up husky and commitlint for commit message validation:
+
+```shell
+$ npm install
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/numo-linalg-alt.

data/ext/numo/linalg/blas/dot.c

@@ -67,6 +67,6 @@ DEF_LINALG_FUNC(float, numo_cSFloat, sdot)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_blas_dot(VALUE mBlas) {
-  rb_define_module_function(mBlas, "ddot", RUBY_METHOD_FUNC(_linalg_blas_ddot), 2);
-  rb_define_module_function(mBlas, "sdot", RUBY_METHOD_FUNC(_linalg_blas_sdot), 2);
+  rb_define_module_function(mBlas, "ddot", _linalg_blas_ddot, 2);
+  rb_define_module_function(mBlas, "sdot", _linalg_blas_sdot, 2);
 }

data/ext/numo/linalg/blas/dot_sub.c

@@ -66,6 +66,6 @@ DEF_LINALG_FUNC(float, numo_cSComplex, cdotu_sub)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_blas_dot_sub(VALUE mBlas) {
-  rb_define_module_function(mBlas, "zdotu", RUBY_METHOD_FUNC(_linalg_blas_zdotu_sub), 2);
-  rb_define_module_function(mBlas, "cdotu", RUBY_METHOD_FUNC(_linalg_blas_cdotu_sub), 2);
+  rb_define_module_function(mBlas, "zdotu", _linalg_blas_zdotu_sub, 2);
+  rb_define_module_function(mBlas, "cdotu", _linalg_blas_cdotu_sub, 2);
 }

data/ext/numo/linalg/blas/gemm.c

@@ -186,8 +186,8 @@ DEF_LINALG_FUNC(scomplex, numo_cSComplex, cgemm)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_blas_gemm(VALUE mBlas) {
-  rb_define_module_function(mBlas, "dgemm", RUBY_METHOD_FUNC(_linalg_blas_dgemm), -1);
-  rb_define_module_function(mBlas, "sgemm", RUBY_METHOD_FUNC(_linalg_blas_sgemm), -1);
-  rb_define_module_function(mBlas, "zgemm", RUBY_METHOD_FUNC(_linalg_blas_zgemm), -1);
-  rb_define_module_function(mBlas, "cgemm", RUBY_METHOD_FUNC(_linalg_blas_cgemm), -1);
+  rb_define_module_function(mBlas, "dgemm", _linalg_blas_dgemm, -1);
+  rb_define_module_function(mBlas, "sgemm", _linalg_blas_sgemm, -1);
+  rb_define_module_function(mBlas, "zgemm", _linalg_blas_zgemm, -1);
+  rb_define_module_function(mBlas, "cgemm", _linalg_blas_cgemm, -1);
 }

data/ext/numo/linalg/blas/gemv.c

@@ -158,8 +158,8 @@ DEF_LINALG_FUNC(scomplex, numo_cSComplex, cgemv)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_blas_gemv(VALUE mBlas) {
-  rb_define_module_function(mBlas, "dgemv", RUBY_METHOD_FUNC(_linalg_blas_dgemv), -1);
-  rb_define_module_function(mBlas, "sgemv", RUBY_METHOD_FUNC(_linalg_blas_sgemv), -1);
-  rb_define_module_function(mBlas, "zgemv", RUBY_METHOD_FUNC(_linalg_blas_zgemv), -1);
-  rb_define_module_function(mBlas, "cgemv", RUBY_METHOD_FUNC(_linalg_blas_cgemv), -1);
+  rb_define_module_function(mBlas, "dgemv", _linalg_blas_dgemv, -1);
+  rb_define_module_function(mBlas, "sgemv", _linalg_blas_sgemv, -1);
+  rb_define_module_function(mBlas, "zgemv", _linalg_blas_zgemv, -1);
+  rb_define_module_function(mBlas, "cgemv", _linalg_blas_cgemv, -1);
 }

data/ext/numo/linalg/blas/nrm2.c

@@ -60,8 +60,8 @@ DEF_LINALG_FUNC(scomplex, float, numo_cSComplex, numo_cSFloat, scnrm2)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_blas_nrm2(VALUE mBlas) {
-  rb_define_module_function(mBlas, "dnrm2", RUBY_METHOD_FUNC(_linalg_blas_dnrm2), -1);
-  rb_define_module_function(mBlas, "snrm2", RUBY_METHOD_FUNC(_linalg_blas_snrm2), -1);
-  rb_define_module_function(mBlas, "dznrm2", RUBY_METHOD_FUNC(_linalg_blas_dznrm2), -1);
-  rb_define_module_function(mBlas, "scnrm2", RUBY_METHOD_FUNC(_linalg_blas_scnrm2), -1);
+  rb_define_module_function(mBlas, "dnrm2", _linalg_blas_dnrm2, -1);
+  rb_define_module_function(mBlas, "snrm2", _linalg_blas_snrm2, -1);
+  rb_define_module_function(mBlas, "dznrm2", _linalg_blas_dznrm2, -1);
+  rb_define_module_function(mBlas, "scnrm2", _linalg_blas_scnrm2, -1);
 }

data/ext/numo/linalg/extconf.rb

@@ -96,4 +96,5 @@ $srcs = Dir.glob("#{$srcdir}/**/*.c").map { |path| File.basename(path) }
 $VPATH << '$(srcdir)/blas'
 $VPATH << '$(srcdir)/lapack'
 
+create_header
 create_makefile('numo/linalg/linalg')

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

@@ -0,0 +1,87 @@
+#include "gebal.h"
+
+struct _gebal_option {
+  int matrix_layout;
+  char job;
+};
+
+char _get_job(VALUE val) {
+  const char job = NUM2CHR(val);
+  if (job != 'N' && job != 'P' && job != 'S' && job != 'B') {
+    rb_raise(rb_eArgError, "job must be 'N', 'P', 'S', or 'B'");
+  }
+  return job;
+}
+
+#define DEF_LINALG_FUNC(tDType, tRtDType, tNAryClass, tRtNAryClass, fLapackFunc)               \
+  static void _iter_##fLapackFunc(na_loop_t* const lp) {                                       \
+    tDType* a = (tDType*)NDL_PTR(lp, 0);                                                       \
+    int* ilo = (int*)NDL_PTR(lp, 1);                                                           \
+    int* ihi = (int*)NDL_PTR(lp, 2);                                                           \
+    tRtDType* scale = (tRtDType*)NDL_PTR(lp, 3);                                               \
+    int* info = (int*)NDL_PTR(lp, 4);                                                          \
+    struct _gebal_option* opt = (struct _gebal_option*)(lp->opt_ptr);                          \
+    const lapack_int n =                                                                       \
+      (lapack_int)(opt->matrix_layout == LAPACK_ROW_MAJOR ? NDL_SHAPE(lp, 0)[0]                \
+                                                          : NDL_SHAPE(lp, 0)[1]);              \
+    const lapack_int lda = n;                                                                  \
+    lapack_int i =                                                                             \
+      LAPACKE_##fLapackFunc(opt->matrix_layout, opt->job, n, a, lda, ilo, ihi, scale);         \
+    *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("job") };                                 \
+    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 job = kw_values[1] != Qundef ? _get_job(kw_values[1]) : 'B';                    \
+                                                                                               \
+    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);                                                                \
+    const int n_dims = NA_NDIM(a_nary);                                                        \
+    if (n_dims != 2) {                                                                         \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                           \
+      return Qnil;                                                                             \
+    }                                                                                          \
+                                                                                               \
+    size_t n = matrix_layout == LAPACK_ROW_MAJOR ? NA_SHAPE(a_nary)[0] : NA_SHAPE(a_nary)[1];  \
+    size_t shape_scale[1] = { n };                                                             \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };                                             \
+    ndfunc_arg_out_t aout[4] = { { numo_cInt32, 0 },                                           \
+                                 { numo_cInt32, 0 },                                           \
+                                 { tRtNAryClass, 1, shape_scale },                             \
+                                 { numo_cInt32, 0 } };                                         \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 1, 4, ain, aout };            \
+    struct _gebal_option opt = { matrix_layout, job };                                         \
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);                                            \
+    VALUE ret = rb_ary_concat(rb_ary_new3(1, a_vnary), res);                                   \
+                                                                                               \
+    RB_GC_GUARD(a_vnary);                                                                      \
+    return ret;                                                                                \
+  }
+
+DEF_LINALG_FUNC(double, double, numo_cDFloat, numo_cDFloat, dgebal)
+DEF_LINALG_FUNC(float, float, numo_cSFloat, numo_cSFloat, sgebal)
+DEF_LINALG_FUNC(lapack_complex_double, double, numo_cDComplex, numo_cDFloat, zgebal)
+DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, cgebal)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_gebal(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dgebal", _linalg_lapack_dgebal, -1);
+  rb_define_module_function(mLapack, "sgebal", _linalg_lapack_sgebal, -1);
+  rb_define_module_function(mLapack, "zgebal", _linalg_lapack_zgebal, -1);
+  rb_define_module_function(mLapack, "cgebal", _linalg_lapack_cgebal, -1);
+}

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

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

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

@@ -269,8 +269,8 @@ DEF_LINALG_FUNC_COMPLEX(lapack_complex_float, numo_cSComplex, cgees)
 #undef DEF_LINALG_FUNC_COMPLEX
 
 void define_linalg_lapack_gees(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgees", RUBY_METHOD_FUNC(_linalg_lapack_dgees), -1);
-  rb_define_module_function(mLapack, "sgees", RUBY_METHOD_FUNC(_linalg_lapack_sgees), -1);
-  rb_define_module_function(mLapack, "zgees", RUBY_METHOD_FUNC(_linalg_lapack_zgees), -1);
-  rb_define_module_function(mLapack, "cgees", RUBY_METHOD_FUNC(_linalg_lapack_cgees), -1);
+  rb_define_module_function(mLapack, "dgees", _linalg_lapack_dgees, -1);
+  rb_define_module_function(mLapack, "sgees", _linalg_lapack_sgees, -1);
+  rb_define_module_function(mLapack, "zgees", _linalg_lapack_zgees, -1);
+  rb_define_module_function(mLapack, "cgees", _linalg_lapack_cgees, -1);
 }

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

@@ -162,8 +162,8 @@ DEF_LINALG_FUNC_COMPLEX(lapack_complex_float, numo_cSComplex, cgeev)
 #undef DEF_LINALG_FUNC_COMPLEX
 
 void define_linalg_lapack_geev(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgeev", RUBY_METHOD_FUNC(_linalg_lapack_dgeev), -1);
-  rb_define_module_function(mLapack, "sgeev", RUBY_METHOD_FUNC(_linalg_lapack_sgeev), -1);
-  rb_define_module_function(mLapack, "zgeev", RUBY_METHOD_FUNC(_linalg_lapack_zgeev), -1);
-  rb_define_module_function(mLapack, "cgeev", RUBY_METHOD_FUNC(_linalg_lapack_cgeev), -1);
+  rb_define_module_function(mLapack, "dgeev", _linalg_lapack_dgeev, -1);
+  rb_define_module_function(mLapack, "sgeev", _linalg_lapack_sgeev, -1);
+  rb_define_module_function(mLapack, "zgeev", _linalg_lapack_zgeev, -1);
+  rb_define_module_function(mLapack, "cgeev", _linalg_lapack_cgeev, -1);
 }

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

@@ -0,0 +1,77 @@
+#include "gehrd.h"
+
+struct _gehrd_option {
+  int matrix_layout;
+  int ilo;
+  int ihi;
+};
+
+#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 _gehrd_option* opt = (struct _gehrd_option*)(lp->opt_ptr);                          \
+    const lapack_int ilo = opt->ilo;                                                           \
+    const lapack_int ihi = opt->ihi;                                                           \
+    const lapack_int n =                                                                       \
+      (lapack_int)(opt->matrix_layout == LAPACK_ROW_MAJOR ? NDL_SHAPE(lp, 0)[0]                \
+                                                          : NDL_SHAPE(lp, 0)[1]);              \
+    const lapack_int lda = n;                                                                  \
+    lapack_int i = LAPACKE_##fLapackFunc(opt->matrix_layout, n, ilo, ihi, a, lda, tau);        \
+    *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("ilo"), rb_intern("ihi"), rb_intern("order") };               \
+    VALUE kw_values[3] = { Qundef, Qundef, Qundef };                                           \
+    rb_get_kwargs(kw_args, kw_table, 2, 1, kw_values);                                         \
+    const int ilo = NUM2INT(kw_values[0]);                                                     \
+    const int ihi = NUM2INT(kw_values[1]);                                                     \
+    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);                                                                \
+    const int n_dims = NA_NDIM(a_nary);                                                        \
+    if (n_dims != 2) {                                                                         \
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");                           \
+      return Qnil;                                                                             \
+    }                                                                                          \
+                                                                                               \
+    size_t n = matrix_layout == LAPACK_ROW_MAJOR ? NA_SHAPE(a_nary)[0] : NA_SHAPE(a_nary)[1];  \
+    size_t shape_tau[1] = { n - 1 };                                                           \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };                                             \
+    ndfunc_arg_out_t aout[2] = { { tNAryClass, 1, shape_tau }, { numo_cInt32, 0 } };           \
+    ndfunc_t ndf = { _iter_##fLapackFunc, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };            \
+    struct _gehrd_option opt = { matrix_layout, ilo, ihi };                                    \
+    VALUE res = na_ndloop3(&ndf, &opt, 1, a_vnary);                                            \
+    VALUE ret = rb_ary_concat(rb_ary_new3(1, a_vnary), res);                                   \
+                                                                                               \
+    RB_GC_GUARD(a_vnary);                                                                      \
+    return ret;                                                                                \
+  }
+
+DEF_LINALG_FUNC(double, numo_cDFloat, dgehrd)
+DEF_LINALG_FUNC(float, numo_cSFloat, sgehrd)
+DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, zgehrd)
+DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cgehrd)
+
+#undef DEF_LINALG_FUNC
+
+void define_linalg_lapack_gehrd(VALUE mLapack) {
+  rb_define_module_function(mLapack, "dgehrd", _linalg_lapack_dgehrd, -1);
+  rb_define_module_function(mLapack, "sgehrd", _linalg_lapack_sgehrd, -1);
+  rb_define_module_function(mLapack, "zgehrd", _linalg_lapack_zgehrd, -1);
+  rb_define_module_function(mLapack, "cgehrd", _linalg_lapack_cgehrd, -1);
+}

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

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

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

@@ -96,8 +96,8 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, cgels
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_gelsd(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgelsd", RUBY_METHOD_FUNC(_linalg_lapack_dgelsd), -1);
-  rb_define_module_function(mLapack, "sgelsd", RUBY_METHOD_FUNC(_linalg_lapack_sgelsd), -1);
-  rb_define_module_function(mLapack, "zgelsd", RUBY_METHOD_FUNC(_linalg_lapack_zgelsd), -1);
-  rb_define_module_function(mLapack, "cgelsd", RUBY_METHOD_FUNC(_linalg_lapack_cgelsd), -1);
+  rb_define_module_function(mLapack, "dgelsd", _linalg_lapack_dgelsd, -1);
+  rb_define_module_function(mLapack, "sgelsd", _linalg_lapack_sgelsd, -1);
+  rb_define_module_function(mLapack, "zgelsd", _linalg_lapack_zgelsd, -1);
+  rb_define_module_function(mLapack, "cgelsd", _linalg_lapack_cgelsd, -1);
 }

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

@@ -66,8 +66,8 @@ DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cgeqrf)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_geqrf(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgeqrf", RUBY_METHOD_FUNC(_linalg_lapack_dgeqrf), -1);
-  rb_define_module_function(mLapack, "sgeqrf", RUBY_METHOD_FUNC(_linalg_lapack_sgeqrf), -1);
-  rb_define_module_function(mLapack, "zgeqrf", RUBY_METHOD_FUNC(_linalg_lapack_zgeqrf), -1);
-  rb_define_module_function(mLapack, "cgeqrf", RUBY_METHOD_FUNC(_linalg_lapack_cgeqrf), -1);
+  rb_define_module_function(mLapack, "dgeqrf", _linalg_lapack_dgeqrf, -1);
+  rb_define_module_function(mLapack, "sgeqrf", _linalg_lapack_sgeqrf, -1);
+  rb_define_module_function(mLapack, "zgeqrf", _linalg_lapack_zgeqrf, -1);
+  rb_define_module_function(mLapack, "cgeqrf", _linalg_lapack_cgeqrf, -1);
 }

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

@@ -63,8 +63,8 @@ DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cgerqf)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_gerqf(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgerqf", RUBY_METHOD_FUNC(_linalg_lapack_dgerqf), -1);
-  rb_define_module_function(mLapack, "sgerqf", RUBY_METHOD_FUNC(_linalg_lapack_sgerqf), -1);
-  rb_define_module_function(mLapack, "zgerqf", RUBY_METHOD_FUNC(_linalg_lapack_zgerqf), -1);
-  rb_define_module_function(mLapack, "cgerqf", RUBY_METHOD_FUNC(_linalg_lapack_cgerqf), -1);
+  rb_define_module_function(mLapack, "dgerqf", _linalg_lapack_dgerqf, -1);
+  rb_define_module_function(mLapack, "sgerqf", _linalg_lapack_sgerqf, -1);
+  rb_define_module_function(mLapack, "zgerqf", _linalg_lapack_zgerqf, -1);
+  rb_define_module_function(mLapack, "cgerqf", _linalg_lapack_cgerqf, -1);
 }

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

@@ -111,8 +111,8 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, cgesd
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_gesdd(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgesdd", RUBY_METHOD_FUNC(_linalg_lapack_dgesdd), -1);
-  rb_define_module_function(mLapack, "sgesdd", RUBY_METHOD_FUNC(_linalg_lapack_sgesdd), -1);
-  rb_define_module_function(mLapack, "zgesdd", RUBY_METHOD_FUNC(_linalg_lapack_zgesdd), -1);
-  rb_define_module_function(mLapack, "cgesdd", RUBY_METHOD_FUNC(_linalg_lapack_cgesdd), -1);
+  rb_define_module_function(mLapack, "dgesdd", _linalg_lapack_dgesdd, -1);
+  rb_define_module_function(mLapack, "sgesdd", _linalg_lapack_sgesdd, -1);
+  rb_define_module_function(mLapack, "zgesdd", _linalg_lapack_zgesdd, -1);
+  rb_define_module_function(mLapack, "cgesdd", _linalg_lapack_cgesdd, -1);
 }

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

@@ -94,8 +94,8 @@ DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cgesv)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_gesv(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgesv", RUBY_METHOD_FUNC(_linalg_lapack_dgesv), -1);
-  rb_define_module_function(mLapack, "sgesv", RUBY_METHOD_FUNC(_linalg_lapack_sgesv), -1);
-  rb_define_module_function(mLapack, "zgesv", RUBY_METHOD_FUNC(_linalg_lapack_zgesv), -1);
-  rb_define_module_function(mLapack, "cgesv", RUBY_METHOD_FUNC(_linalg_lapack_cgesv), -1);
+  rb_define_module_function(mLapack, "dgesv", _linalg_lapack_dgesv, -1);
+  rb_define_module_function(mLapack, "sgesv", _linalg_lapack_sgesv, -1);
+  rb_define_module_function(mLapack, "zgesv", _linalg_lapack_zgesv, -1);
+  rb_define_module_function(mLapack, "cgesv", _linalg_lapack_cgesv, -1);
 }

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

@@ -156,8 +156,8 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, cgesv
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_gesvd(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgesvd", RUBY_METHOD_FUNC(_linalg_lapack_dgesvd), -1);
-  rb_define_module_function(mLapack, "sgesvd", RUBY_METHOD_FUNC(_linalg_lapack_sgesvd), -1);
-  rb_define_module_function(mLapack, "zgesvd", RUBY_METHOD_FUNC(_linalg_lapack_zgesvd), -1);
-  rb_define_module_function(mLapack, "cgesvd", RUBY_METHOD_FUNC(_linalg_lapack_cgesvd), -1);
+  rb_define_module_function(mLapack, "dgesvd", _linalg_lapack_dgesvd, -1);
+  rb_define_module_function(mLapack, "sgesvd", _linalg_lapack_sgesvd, -1);
+  rb_define_module_function(mLapack, "zgesvd", _linalg_lapack_zgesvd, -1);
+  rb_define_module_function(mLapack, "cgesvd", _linalg_lapack_cgesvd, -1);
 }

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

@@ -65,8 +65,8 @@ DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cgetrf)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_getrf(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgetrf", RUBY_METHOD_FUNC(_linalg_lapack_dgetrf), -1);
-  rb_define_module_function(mLapack, "sgetrf", RUBY_METHOD_FUNC(_linalg_lapack_sgetrf), -1);
-  rb_define_module_function(mLapack, "zgetrf", RUBY_METHOD_FUNC(_linalg_lapack_zgetrf), -1);
-  rb_define_module_function(mLapack, "cgetrf", RUBY_METHOD_FUNC(_linalg_lapack_cgetrf), -1);
+  rb_define_module_function(mLapack, "dgetrf", _linalg_lapack_dgetrf, -1);
+  rb_define_module_function(mLapack, "sgetrf", _linalg_lapack_sgetrf, -1);
+  rb_define_module_function(mLapack, "zgetrf", _linalg_lapack_zgetrf, -1);
+  rb_define_module_function(mLapack, "cgetrf", _linalg_lapack_cgetrf, -1);
 }

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

@@ -76,8 +76,8 @@ DEF_LINALG_FUNC(lapack_complex_double, numo_cDComplex, zgetri)
 DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cgetri)
 
 void define_linalg_lapack_getri(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgetri", RUBY_METHOD_FUNC(_linalg_lapack_dgetri), -1);
-  rb_define_module_function(mLapack, "sgetri", RUBY_METHOD_FUNC(_linalg_lapack_sgetri), -1);
-  rb_define_module_function(mLapack, "zgetri", RUBY_METHOD_FUNC(_linalg_lapack_zgetri), -1);
-  rb_define_module_function(mLapack, "cgetri", RUBY_METHOD_FUNC(_linalg_lapack_cgetri), -1);
+  rb_define_module_function(mLapack, "dgetri", _linalg_lapack_dgetri, -1);
+  rb_define_module_function(mLapack, "sgetri", _linalg_lapack_sgetri, -1);
+  rb_define_module_function(mLapack, "zgetri", _linalg_lapack_zgetri, -1);
+  rb_define_module_function(mLapack, "cgetri", _linalg_lapack_cgetri, -1);
 }

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

@@ -107,8 +107,8 @@ DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, cgetrs)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_getrs(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgetrs", RUBY_METHOD_FUNC(_linalg_lapack_dgetrs), -1);
-  rb_define_module_function(mLapack, "sgetrs", RUBY_METHOD_FUNC(_linalg_lapack_sgetrs), -1);
-  rb_define_module_function(mLapack, "zgetrs", RUBY_METHOD_FUNC(_linalg_lapack_zgetrs), -1);
-  rb_define_module_function(mLapack, "cgetrs", RUBY_METHOD_FUNC(_linalg_lapack_cgetrs), -1);
+  rb_define_module_function(mLapack, "dgetrs", _linalg_lapack_dgetrs, -1);
+  rb_define_module_function(mLapack, "sgetrs", _linalg_lapack_sgetrs, -1);
+  rb_define_module_function(mLapack, "zgetrs", _linalg_lapack_zgetrs, -1);
+  rb_define_module_function(mLapack, "cgetrs", _linalg_lapack_cgetrs, -1);
 }

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

@@ -207,8 +207,8 @@ DEF_LINALG_FUNC_COMPLEX(lapack_complex_float, numo_cSComplex, cgges)
 #undef DEF_LINALG_FUNC_COMPLEX
 
 void define_linalg_lapack_gges(VALUE mLapack) {
-  rb_define_module_function(mLapack, "dgges", RUBY_METHOD_FUNC(_linalg_lapack_dgges), -1);
-  rb_define_module_function(mLapack, "sgges", RUBY_METHOD_FUNC(_linalg_lapack_sgges), -1);
-  rb_define_module_function(mLapack, "zgges", RUBY_METHOD_FUNC(_linalg_lapack_zgges), -1);
-  rb_define_module_function(mLapack, "cgges", RUBY_METHOD_FUNC(_linalg_lapack_cgges), -1);
+  rb_define_module_function(mLapack, "dgges", _linalg_lapack_dgges, -1);
+  rb_define_module_function(mLapack, "sgges", _linalg_lapack_sgges, -1);
+  rb_define_module_function(mLapack, "zgges", _linalg_lapack_zgges, -1);
+  rb_define_module_function(mLapack, "cgges", _linalg_lapack_cgges, -1);
 }

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

@@ -68,6 +68,6 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, cheev
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_heev(VALUE mLapack) {
-  rb_define_module_function(mLapack, "zheev", RUBY_METHOD_FUNC(_linalg_lapack_zheev), -1);
-  rb_define_module_function(mLapack, "cheev", RUBY_METHOD_FUNC(_linalg_lapack_cheev), -1);
+  rb_define_module_function(mLapack, "zheev", _linalg_lapack_zheev, -1);
+  rb_define_module_function(mLapack, "cheev", _linalg_lapack_cheev, -1);
 }

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

@@ -68,6 +68,6 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, cheev
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_heevd(VALUE mLapack) {
-  rb_define_module_function(mLapack, "zheevd", RUBY_METHOD_FUNC(_linalg_lapack_zheevd), -1);
-  rb_define_module_function(mLapack, "cheevd", RUBY_METHOD_FUNC(_linalg_lapack_cheevd), -1);
+  rb_define_module_function(mLapack, "zheevd", _linalg_lapack_zheevd, -1);
+  rb_define_module_function(mLapack, "cheevd", _linalg_lapack_cheevd, -1);
 }

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

@@ -117,6 +117,6 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, cheev
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_heevr(VALUE mLapack) {
-  rb_define_module_function(mLapack, "zheevr", RUBY_METHOD_FUNC(_linalg_lapack_zheevr), -1);
-  rb_define_module_function(mLapack, "cheevr", RUBY_METHOD_FUNC(_linalg_lapack_cheevr), -1);
+  rb_define_module_function(mLapack, "zheevr", _linalg_lapack_zheevr, -1);
+  rb_define_module_function(mLapack, "cheevr", _linalg_lapack_cheevr, -1);
 }

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

@@ -92,6 +92,6 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, chegv
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_hegv(VALUE mLapack) {
-  rb_define_module_function(mLapack, "zhegv", RUBY_METHOD_FUNC(_linalg_lapack_zhegv), -1);
-  rb_define_module_function(mLapack, "chegv", RUBY_METHOD_FUNC(_linalg_lapack_chegv), -1);
+  rb_define_module_function(mLapack, "zhegv", _linalg_lapack_zhegv, -1);
+  rb_define_module_function(mLapack, "chegv", _linalg_lapack_chegv, -1);
 }

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

@@ -92,6 +92,6 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, chegv
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_hegvd(VALUE mLapack) {
-  rb_define_module_function(mLapack, "zhegvd", RUBY_METHOD_FUNC(_linalg_lapack_zhegvd), -1);
-  rb_define_module_function(mLapack, "chegvd", RUBY_METHOD_FUNC(_linalg_lapack_chegvd), -1);
+  rb_define_module_function(mLapack, "zhegvd", _linalg_lapack_zhegvd, -1);
+  rb_define_module_function(mLapack, "chegvd", _linalg_lapack_chegvd, -1);
 }

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

@@ -140,6 +140,6 @@ DEF_LINALG_FUNC(lapack_complex_float, float, numo_cSComplex, numo_cSFloat, chegv
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_hegvx(VALUE mLapack) {
-  rb_define_module_function(mLapack, "zhegvx", RUBY_METHOD_FUNC(_linalg_lapack_zhegvx), -1);
-  rb_define_module_function(mLapack, "chegvx", RUBY_METHOD_FUNC(_linalg_lapack_chegvx), -1);
+  rb_define_module_function(mLapack, "zhegvx", _linalg_lapack_zhegvx, -1);
+  rb_define_module_function(mLapack, "chegvx", _linalg_lapack_chegvx, -1);
 }

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

@@ -67,6 +67,6 @@ DEF_LINALG_FUNC(lapack_complex_float, numo_cSComplex, chetrf)
 #undef DEF_LINALG_FUNC
 
 void define_linalg_lapack_hetrf(VALUE mLapack) {
-  rb_define_module_function(mLapack, "zhetrf", RUBY_METHOD_FUNC(_linalg_lapack_zhetrf), -1);
-  rb_define_module_function(mLapack, "chetrf", RUBY_METHOD_FUNC(_linalg_lapack_chetrf), -1);
+  rb_define_module_function(mLapack, "zhetrf", _linalg_lapack_zhetrf, -1);
+  rb_define_module_function(mLapack, "chetrf", _linalg_lapack_chetrf, -1);
 }