numo-tiny_linalg 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15ddc75f758bbff2ef6887db5d71c13dd517f7eeb0c4d3ab181c5c2db8b8f995
-  data.tar.gz: 20350f1d084a31e51e05c317dddc23f6285dd27430176a753edd3eea935331be
+  metadata.gz: bbebba3b506ab283688f9d0935739e14c09106918a98571b9addb64b6689cc75
+  data.tar.gz: 85eaa28da383e21a4503407667baacb95fb5382f20f54804f02e4c2d49c15cd1
 SHA512:
-  metadata.gz: 457d487b20bfffb3eade0fc80120f5de7acfa3f0678550f3b844abac139e7b6db469fdcf6b686337755ea2b49b8bad54ea66381368d2e4e554fdb32df6e2d87d
-  data.tar.gz: 217765d951cf0d790e8620e1a4e4d28a884a5955bdca32cc4386fd4951c8ae2a133be029c24b20e987ce6fb2c7adfa101fe327c55cce327c2e89f4ff4d54a874
+  metadata.gz: 262e38a4bbbbf6141cca723830f93c80cc9d33ac8a34753e3af1b9b5b239f4576140f18ad43999e8d0568438380f8bb2f6cf3f78c1f5d35402d57fcf55e4e253
+  data.tar.gz: ba6e767f8728022dff634e1a3824a166c5b3f4d17057b65f2e279a2ccda293c2432aea07783708fdd9f1d810e7a9bc9428ae2b9fe559b0bb519d8b1cb828b01e

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [[0.0.3](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.0.2...v0.0.3)] - 2023-08-02
+- Add dgeqrf, sgeqrf, zgeqrf, and cgeqrf module functions to TinyLinalg::Lapack.
+- Add dorgqr, sorgqr, zungqr, and cungqr module functions to TinyLinalg::Lapack.
+- Add det module function to TinyLinalg.
+- Add pinv module function to TinyLinalg.
+- Add qr module function to TinyLinalg.
+
+## [[0.0.2](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.0.1...v0.0.2)] - 2023-07-26
+- Add automatic build of OpenBLAS if it is not found.
+- Add dgesv, sgesv, zgesv, and cgesv module functions to TinyLinalg::Lapack.
+- Add dgetrf, sgetrf, zgetrf, and cgetrf module functions to TinyLinalg::Lapack.
+- Add dgetri, sgetri, zgetri, and cgetri module functions to TinyLinalg::Lapack.
+- Add solve module function to TinyLinalg.
+- Add inv module function to TinyLinalg.
+
 ## [0.0.1] - 2023-07-14
 
 - Initial release

data/README.md

@@ -1,7 +1,9 @@
 # Numo::TinyLinalg
 
+[![Gem Version](https://badge.fury.io/rb/numo-tiny_linalg.svg)](https://badge.fury.io/rb/numo-tiny_linalg)
 [![Build Status](https://github.com/yoshoku/numo-tiny_linalg/actions/workflows/main.yml/badge.svg)](https://github.com/yoshoku/numo-tiny_linalg/actions/workflows/main.yml)
 [![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/numo-tiny_linalg/blob/main/LICENSE.txt)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/numo-tiny_linalg/doc/)
 
 Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
 

data/ext/numo/tiny_linalg/extconf.rb

@@ -2,6 +2,12 @@
 
 require 'mkmf'
 require 'numo/narray'
+require 'open-uri'
+require 'etc'
+require 'fileutils'
+require 'open3'
+require 'digest/md5'
+require 'rubygems/package'
 
 $LOAD_PATH.each do |lp|
   if File.exist?(File.join(lp, 'numo/numo/narray.h'))
@@ -22,33 +28,75 @@ if RUBY_PLATFORM.match?(/mswin|cygwin|mingw/)
   abort 'libnarray.a is not found' unless have_library('narray', 'nary_new')
 end
 
-if RUBY_PLATFORM.include?('darwin') && Gem::Version.new('3.1.0') <= Gem::Version.new(RUBY_VERSION) &&
-   try_link('int main(void){return 0;}', '-Wl,-undefined,dynamic_lookup')
-  $LDFLAGS << ' -Wl,-undefined,dynamic_lookup'
-end
+abort 'libstdc++ is not found.' unless have_library('stdc++')
+$CXXFLAGS << ' -std=c++11'
 
-use_accelerate = false
 # NOTE: Accelerate framework does not support LAPACKE.
+# use_accelerate = false
 # if RUBY_PLATFORM.include?('darwin') && have_framework('Accelerate')
 #   $CFLAGS << ' -DTINYLINALG_USE_ACCELERATE'
 #   use_accelerate = true
 # end
 
-unless use_accelerate
-  if have_library('openblas')
-    $CFLAGS << ' -DTINYLINALG_USE_OPENBLAS'
-  else
-    abort 'libblas is not found' unless have_library('blas')
-    $CFLAGS << ' -DTINYLINALG_USE_BLAS'
+build_openblas = false
+unless find_library('openblas', 'LAPACKE_dsyevr')
+  build_openblas = true unless have_library('openblas')
+  build_openblas = true unless have_library('lapacke')
+end
+build_openblas = true unless have_header('cblas.h')
+build_openblas = true unless have_header('lapacke.h')
+build_openblas = true unless have_header('openblas_config.h')
+
+if build_openblas
+  warn 'BLAS and LAPACKE APIs are not found. Downloading and Building OpenBLAS...'
+
+  VENDOR_DIR = File.expand_path("#{__dir__}/../../../vendor")
+  OPENBLAS_VER = '0.3.23'
+  OPENBLAS_KEY = '115634b39007de71eb7e75cf7591dfb2'
+  OPENBLAS_URI = "https://github.com/xianyi/OpenBLAS/archive/v#{OPENBLAS_VER}.tar.gz"
+  OPENBLAS_TGZ = "#{VENDOR_DIR}/tmp/openblas.tgz"
+
+  unless File.exist?("#{VENDOR_DIR}/installed_#{OPENBLAS_VER}")
+    URI.parse(OPENBLAS_URI).open { |f| File.binwrite(OPENBLAS_TGZ, f.read) }
+    abort('MD5 digest of downloaded OpenBLAS does not match.') if Digest::MD5.file(OPENBLAS_TGZ).to_s != OPENBLAS_KEY
+
+    Gem::Package::TarReader.new(Zlib::GzipReader.open(OPENBLAS_TGZ)) do |tar|
+      tar.each do |entry|
+        next unless entry.file?
+
+        filename = "#{VENDOR_DIR}/tmp/#{entry.full_name}"
+        next if filename == File.dirname(filename)
+
+        FileUtils.mkdir_p("#{VENDOR_DIR}/tmp/#{File.dirname(entry.full_name)}")
+        File.binwrite(filename, entry.read)
+        File.chmod(entry.header.mode, filename)
+      end
+    end
+
+    Dir.chdir("#{VENDOR_DIR}/tmp/OpenBLAS-#{OPENBLAS_VER}") do
+      mkstdout, _mkstderr, mkstatus = Open3.capture3("make -j#{Etc.nprocessors}")
+      File.open("#{VENDOR_DIR}/tmp/openblas.log", 'w') { |f| f.puts(mkstdout) }
+      abort("Failed to build OpenBLAS. Check the openblas.log file for more details: #{VENDOR_DIR}/tmp/openblas.log") unless mkstatus.success?
+
+      insstdout, _insstderr, insstatus = Open3.capture3("make install PREFIX=#{VENDOR_DIR}")
+      File.open("#{VENDOR_DIR}/tmp/openblas.log", 'a') { |f| f.puts(insstdout) }
+      abort("Failed to install OpenBLAS. Check the openblas.log file for more details: #{VENDOR_DIR}/tmp/openblas.log") unless insstatus.success?
+
+      FileUtils.touch("#{VENDOR_DIR}/installed_#{OPENBLAS_VER}")
+    end
   end
 
-  abort 'liblapacke is not found' if !have_func('LAPACKE_dsyevr') && !have_library('lapacke')
-  abort 'cblas.h is not found' unless have_header('cblas.h')
-  abort 'lapacke.h is not found' unless have_header('lapacke.h')
+  abort('libopenblas is not found.') unless find_library('openblas', nil, "#{VENDOR_DIR}/lib")
+  abort('openblas_config.h is not found.') unless find_header('openblas_config.h', nil, "#{VENDOR_DIR}/include")
+  abort('cblas.h is not found.') unless find_header('cblas.h', nil, "#{VENDOR_DIR}/include")
+  abort('lapacke.h is not found.') unless find_header('lapacke.h', nil, "#{VENDOR_DIR}/include")
 end
 
-abort 'libstdc++ is not found.' unless have_library('stdc++')
+$CFLAGS << ' -DNUMO_TINY_LINALG_USE_OPENBLAS'
 
-$CXXFLAGS << ' -std=c++11'
+if RUBY_PLATFORM.include?('darwin') && Gem::Version.new('3.1.0') <= Gem::Version.new(RUBY_VERSION) &&
+   try_link('int main(void){return 0;}', '-Wl,-undefined,dynamic_lookup')
+  $LDFLAGS << ' -Wl,-undefined,dynamic_lookup'
+end
 
 create_makefile('numo/tiny_linalg/tiny_linalg')

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

@@ -0,0 +1,118 @@
+namespace TinyLinalg {
+
+struct DGeQrf {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  double* a, lapack_int lda, double* tau) {
+    return LAPACKE_dgeqrf(matrix_layout, m, n, a, lda, tau);
+  }
+};
+
+struct SGeQrf {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  float* a, lapack_int lda, float* tau) {
+    return LAPACKE_sgeqrf(matrix_layout, m, n, a, lda, tau);
+  }
+};
+
+struct ZGeQrf {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  lapack_complex_double* a, lapack_int lda, lapack_complex_double* tau) {
+    return LAPACKE_zgeqrf(matrix_layout, m, n, a, lda, tau);
+  }
+};
+
+struct CGeQrf {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  lapack_complex_float* a, lapack_int lda, lapack_complex_float* tau) {
+    return LAPACKE_cgeqrf(matrix_layout, m, n, a, lda, tau);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class GeQrf {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_geqrf), -1);
+  }
+
+private:
+  struct geqrf_opt {
+    int matrix_layout;
+  };
+
+  static void iter_geqrf(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* tau = (DType*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    geqrf_opt* opt = (geqrf_opt*)(lp->opt_ptr);
+    const lapack_int m = NDL_SHAPE(lp, 0)[0];
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = n;
+    const lapack_int i = FncType().call(opt->matrix_layout, m, n, a, lda, tau);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_geqrf(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "1:", &a_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) != nary_dtype) {
+      a_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, a_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(a_vnary))) {
+      a_vnary = nary_dup(a_vnary);
+    }
+
+    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 m = NA_SHAPE(a_nary)[0];
+    size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { m < n ? m : n };
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[2] = { { nary_dtype, 1, shape }, { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_geqrf, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };
+    geqrf_opt opt = { matrix_layout };
+    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;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char* option_str = StringValueCStr(val);
+
+    if (std::strlen(option_str) > 0) {
+      switch (option_str[0]) {
+      case 'r':
+      case 'R':
+        break;
+      case 'c':
+      case 'C':
+        rb_warn("Numo::TinyLinalg::Lapack.getrf does not support column major.");
+        break;
+      }
+    }
+
+    RB_GC_GUARD(val);
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,148 @@
+namespace TinyLinalg {
+
+struct DGESV {
+  lapack_int call(int matrix_layout, lapack_int n, lapack_int nrhs,
+                  double* a, lapack_int lda, lapack_int* ipiv,
+                  double* b, lapack_int ldb) {
+    return LAPACKE_dgesv(matrix_layout, n, nrhs, a, lda, ipiv, b, ldb);
+  }
+};
+
+struct SGESV {
+  lapack_int call(int matrix_layout, lapack_int n, lapack_int nrhs,
+                  float* a, lapack_int lda, lapack_int* ipiv,
+                  float* b, lapack_int ldb) {
+    return LAPACKE_sgesv(matrix_layout, n, nrhs, a, lda, ipiv, b, ldb);
+  }
+};
+
+struct ZGESV {
+  lapack_int call(int matrix_layout, lapack_int n, lapack_int nrhs,
+                  lapack_complex_double* a, lapack_int lda, lapack_int* ipiv,
+                  lapack_complex_double* b, lapack_int ldb) {
+    return LAPACKE_zgesv(matrix_layout, n, nrhs, a, lda, ipiv, b, ldb);
+  }
+};
+
+struct CGESV {
+  lapack_int call(int matrix_layout, lapack_int n, lapack_int nrhs,
+                  lapack_complex_float* a, lapack_int lda, lapack_int* ipiv,
+                  lapack_complex_float* b, lapack_int ldb) {
+    return LAPACKE_cgesv(matrix_layout, n, nrhs, a, lda, ipiv, b, ldb);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class GESV {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_gesv), -1);
+  }
+
+private:
+  struct gesv_opt {
+    int matrix_layout;
+  };
+
+  static void iter_gesv(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    DType* b = (DType*)NDL_PTR(lp, 1);
+    int* ipiv = (int*)NDL_PTR(lp, 2);
+    int* info = (int*)NDL_PTR(lp, 3);
+    gesv_opt* opt = (gesv_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[0];
+    const lapack_int nhrs = lp->args[1].ndim == 1 ? 1 : NDL_SHAPE(lp, 1)[1];
+    const lapack_int lda = n;
+    const lapack_int ldb = nhrs;
+    const lapack_int i = FncType().call(opt->matrix_layout, n, nhrs, a, lda, ipiv, b, ldb);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_gesv(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+    VALUE a_vnary = Qnil;
+    VALUE b_vnary = Qnil;
+    VALUE kw_args = Qnil;
+
+    rb_scan_args(argc, argv, "2:", &a_vnary, &b_vnary, &kw_args);
+
+    ID kw_table[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) != nary_dtype) {
+      a_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, a_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(a_vnary))) {
+      a_vnary = nary_dup(a_vnary);
+    }
+    if (CLASS_OF(b_vnary) != nary_dtype) {
+      b_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, b_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(b_vnary))) {
+      b_vnary = nary_dup(b_vnary);
+    }
+
+    narray_t* a_nary = NULL;
+    narray_t* b_nary = NULL;
+    GetNArray(a_vnary, a_nary);
+    GetNArray(b_vnary, b_nary);
+    const int a_n_dims = NA_NDIM(a_nary);
+    const int b_n_dims = NA_NDIM(b_nary);
+    if (a_n_dims != 2) {
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");
+      return Qnil;
+    }
+    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 = NA_SHAPE(a_nary)[0];
+    lapack_int nb = b_n_dims == 1 ? NA_SHAPE(b_nary)[0] : NA_SHAPE(b_nary)[0];
+    if (n != nb) {
+      rb_raise(nary_eShapeError, "shape1[1](=%d) != shape2[0](=%d)", n, nb);
+    }
+
+    lapack_int nhrs = b_n_dims == 1 ? 1 : NA_SHAPE(b_nary)[1];
+    size_t shape[2] = { static_cast<size_t>(n), static_cast<size_t>(nhrs) };
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { OVERWRITE, b_n_dims } };
+    ndfunc_arg_out_t aout[2] = { { numo_cInt32, 1, shape }, { numo_cInt32, 0 } };
+
+    ndfunc_t ndf = { iter_gesv, NO_LOOP | NDF_EXTRACT, 2, 2, ain, aout };
+    gesv_opt opt = { matrix_layout };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+
+    VALUE ret = rb_ary_concat(rb_assoc_new(a_vnary, b_vnary), res);
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char* option_str = StringValueCStr(val);
+
+    if (std::strlen(option_str) > 0) {
+      switch (option_str[0]) {
+      case 'r':
+      case 'R':
+        break;
+      case 'c':
+      case 'C':
+        rb_warn("Numo::TinyLinalg::Lapack.gesv does not support column major.");
+        break;
+      }
+    }
+
+    RB_GC_GUARD(val);
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,118 @@
+namespace TinyLinalg {
+
+struct DGETRF {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  double* a, lapack_int lda, lapack_int* ipiv) {
+    return LAPACKE_dgetrf(matrix_layout, m, n, a, lda, ipiv);
+  }
+};
+
+struct SGETRF {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  float* a, lapack_int lda, lapack_int* ipiv) {
+    return LAPACKE_sgetrf(matrix_layout, m, n, a, lda, ipiv);
+  }
+};
+
+struct ZGETRF {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  lapack_complex_double* a, lapack_int lda, lapack_int* ipiv) {
+    return LAPACKE_zgetrf(matrix_layout, m, n, a, lda, ipiv);
+  }
+};
+
+struct CGETRF {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n,
+                  lapack_complex_float* a, lapack_int lda, lapack_int* ipiv) {
+    return LAPACKE_cgetrf(matrix_layout, m, n, a, lda, ipiv);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class GETRF {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_getrf), -1);
+  }
+
+private:
+  struct getrf_opt {
+    int matrix_layout;
+  };
+
+  static void iter_getrf(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    int* ipiv = (int*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    getrf_opt* opt = (getrf_opt*)(lp->opt_ptr);
+    const lapack_int m = NDL_SHAPE(lp, 0)[0];
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int lda = n;
+    const lapack_int i = FncType().call(opt->matrix_layout, m, n, a, lda, ipiv);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_getrf(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "1:", &a_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) != nary_dtype) {
+      a_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, a_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(a_vnary))) {
+      a_vnary = nary_dup(a_vnary);
+    }
+
+    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 m = NA_SHAPE(a_nary)[0];
+    size_t n = NA_SHAPE(a_nary)[1];
+    size_t shape[1] = { m < n ? m : 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_getrf, NO_LOOP | NDF_EXTRACT, 1, 2, ain, aout };
+    getrf_opt opt = { matrix_layout };
+    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;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char* option_str = StringValueCStr(val);
+
+    if (std::strlen(option_str) > 0) {
+      switch (option_str[0]) {
+      case 'r':
+      case 'R':
+        break;
+      case 'c':
+      case 'C':
+        rb_warn("Numo::TinyLinalg::Lapack.getrf does not support column major.");
+        break;
+      }
+    }
+
+    RB_GC_GUARD(val);
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,127 @@
+namespace TinyLinalg {
+
+struct DGETRI {
+  lapack_int call(int matrix_layout, lapack_int n, double* a, lapack_int lda, const lapack_int* ipiv) {
+    return LAPACKE_dgetri(matrix_layout, n, a, lda, ipiv);
+  }
+};
+
+struct SGETRI {
+  lapack_int call(int matrix_layout, lapack_int n, float* a, lapack_int lda, const lapack_int* ipiv) {
+    return LAPACKE_sgetri(matrix_layout, n, a, lda, ipiv);
+  }
+};
+
+struct ZGETRI {
+  lapack_int call(int matrix_layout, lapack_int n, lapack_complex_double* a, lapack_int lda, const lapack_int* ipiv) {
+    return LAPACKE_zgetri(matrix_layout, n, a, lda, ipiv);
+  }
+};
+
+struct CGETRI {
+  lapack_int call(int matrix_layout, lapack_int n, lapack_complex_float* a, lapack_int lda, const lapack_int* ipiv) {
+    return LAPACKE_cgetri(matrix_layout, n, a, lda, ipiv);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class GETRI {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_getri), -1);
+  }
+
+private:
+  struct getri_opt {
+    int matrix_layout;
+  };
+
+  static void iter_getri(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    lapack_int* ipiv = (lapack_int*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    getri_opt* opt = (getri_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[0];
+    const lapack_int lda = n;
+    const lapack_int i = FncType().call(opt->matrix_layout, n, a, lda, ipiv);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_getri(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    VALUE a_vnary = Qnil;
+    VALUE ipiv_vnary = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "2:", &a_vnary, &ipiv_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) != nary_dtype) {
+      a_vnary = rb_funcall(nary_dtype, rb_intern("cast"), 1, a_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(a_vnary))) {
+      a_vnary = nary_dup(a_vnary);
+    }
+    if (CLASS_OF(ipiv_vnary) != numo_cInt32) {
+      ipiv_vnary = rb_funcall(numo_cInt32, rb_intern("cast"), 1, ipiv_vnary);
+    }
+    if (!RTEST(nary_check_contiguous(ipiv_vnary))) {
+      ipiv_vnary = nary_dup(ipiv_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* ipiv_nary = NULL;
+    GetNArray(ipiv_vnary, ipiv_nary);
+    if (NA_NDIM(ipiv_nary) != 1) {
+      rb_raise(rb_eArgError, "input array ipiv must be 1-dimensional");
+      return Qnil;
+    }
+
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 2 }, { numo_cInt32, 1 } };
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_getri, NO_LOOP | NDF_EXTRACT, 2, 1, ain, aout };
+    getri_opt opt = { matrix_layout };
+    VALUE res = na_ndloop3(&ndf, &opt, 2, a_vnary, ipiv_vnary);
+
+    VALUE ret = rb_ary_new3(2, a_vnary, res);
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(ipiv_vnary);
+
+    return ret;
+  }
+
+  static int get_matrix_layout(VALUE val) {
+    const char* option_str = StringValueCStr(val);
+
+    if (std::strlen(option_str) > 0) {
+      switch (option_str[0]) {
+      case 'r':
+      case 'R':
+        break;
+      case 'c':
+      case 'C':
+        rb_warn("Numo::TinyLinalg::Lapack.getri does not support column major.");
+        break;
+      }
+    }
+
+    RB_GC_GUARD(val);
+
+    return LAPACK_ROW_MAJOR;
+  }
+};
+
+} // namespace TinyLinalg