numo-tiny_linalg 0.0.1 → 0.0.3

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

@@ -0,0 +1,115 @@
+namespace TinyLinalg {
+
+struct DOrgQr {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n, lapack_int k,
+                  double* a, lapack_int lda, const double* tau) {
+    return LAPACKE_dorgqr(matrix_layout, m, n, k, a, lda, tau);
+  }
+};
+
+struct SOrgQr {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n, lapack_int k,
+                  float* a, lapack_int lda, const float* tau) {
+    return LAPACKE_sorgqr(matrix_layout, m, n, k, a, lda, tau);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class OrgQr {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_orgqr), -1);
+  }
+
+private:
+  struct orgqr_opt {
+    int matrix_layout;
+  };
+
+  static void iter_orgqr(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);
+    orgqr_opt* opt = (orgqr_opt*)(lp->opt_ptr);
+    const lapack_int m = NDL_SHAPE(lp, 0)[0];
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int k = NDL_SHAPE(lp, 1)[0];
+    const lapack_int lda = n;
+    const lapack_int i = FncType().call(opt->matrix_layout, m, n, k, a, lda, tau);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_orgqr(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    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) != 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(tau_vnary) != nary_dtype) {
+      tau_vnary = rb_funcall(nary_dtype, 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 }, { nary_dtype, 1 } };
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_orgqr, NO_LOOP | NDF_EXTRACT, 2, 1, ain, aout };
+    orgqr_opt 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;
+  }
+
+  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/ungqr.hpp

@@ -0,0 +1,115 @@
+namespace TinyLinalg {
+
+struct ZUngQr {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n, lapack_int k,
+                  lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau) {
+    return LAPACKE_zungqr(matrix_layout, m, n, k, a, lda, tau);
+  }
+};
+
+struct CUngQr {
+  lapack_int call(int matrix_layout, lapack_int m, lapack_int n, lapack_int k,
+                  lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau) {
+    return LAPACKE_cungqr(matrix_layout, m, n, k, a, lda, tau);
+  }
+};
+
+template <int nary_dtype_id, typename DType, typename FncType>
+class UngQr {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_ungqr), -1);
+  }
+
+private:
+  struct ungqr_opt {
+    int matrix_layout;
+  };
+
+  static void iter_ungqr(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);
+    ungqr_opt* opt = (ungqr_opt*)(lp->opt_ptr);
+    const lapack_int m = NDL_SHAPE(lp, 0)[0];
+    const lapack_int n = NDL_SHAPE(lp, 0)[1];
+    const lapack_int k = NDL_SHAPE(lp, 1)[0];
+    const lapack_int lda = n;
+    const lapack_int i = FncType().call(opt->matrix_layout, m, n, k, a, lda, tau);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_ungqr(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    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) != 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(tau_vnary) != nary_dtype) {
+      tau_vnary = rb_funcall(nary_dtype, 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 }, { nary_dtype, 1 } };
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_ungqr, NO_LOOP | NDF_EXTRACT, 2, 1, ain, aout };
+    ungqr_opt 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;
+  }
+
+  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/tiny_linalg.cpp

@@ -1,12 +1,18 @@
 #include "tiny_linalg.hpp"
+#include "blas/dot.hpp"
+#include "blas/dot_sub.hpp"
+#include "blas/gemm.hpp"
+#include "blas/gemv.hpp"
+#include "blas/nrm2.hpp"
 #include "converter.hpp"
-#include "dot.hpp"
-#include "dot_sub.hpp"
-#include "gemm.hpp"
-#include "gemv.hpp"
-#include "gesdd.hpp"
-#include "gesvd.hpp"
-#include "nrm2.hpp"
+#include "lapack/geqrf.hpp"
+#include "lapack/gesdd.hpp"
+#include "lapack/gesv.hpp"
+#include "lapack/gesvd.hpp"
+#include "lapack/getrf.hpp"
+#include "lapack/getri.hpp"
+#include "lapack/orgqr.hpp"
+#include "lapack/ungqr.hpp"
 
 VALUE rb_mTinyLinalg;
 VALUE rb_mTinyLinalgBlas;
@@ -237,6 +243,10 @@ extern "C" void Init_tiny_linalg(void) {
   TinyLinalg::Nrm2<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SNrm2>::define_module_function(rb_mTinyLinalgBlas, "snrm2");
   TinyLinalg::Nrm2<TinyLinalg::numo_cDComplexId, double, TinyLinalg::DZNrm2>::define_module_function(rb_mTinyLinalgBlas, "dznrm2");
   TinyLinalg::Nrm2<TinyLinalg::numo_cSComplexId, float, TinyLinalg::SCNrm2>::define_module_function(rb_mTinyLinalgBlas, "scnrm2");
+  TinyLinalg::GESV<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DGESV>::define_module_function(rb_mTinyLinalgLapack, "dgesv");
+  TinyLinalg::GESV<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGESV>::define_module_function(rb_mTinyLinalgLapack, "sgesv");
+  TinyLinalg::GESV<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZGESV>::define_module_function(rb_mTinyLinalgLapack, "zgesv");
+  TinyLinalg::GESV<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CGESV>::define_module_function(rb_mTinyLinalgLapack, "cgesv");
   TinyLinalg::GESVD<TinyLinalg::numo_cDFloatId, TinyLinalg::numo_cDFloatId, double, double, TinyLinalg::DGESVD>::define_module_function(rb_mTinyLinalgLapack, "dgesvd");
   TinyLinalg::GESVD<TinyLinalg::numo_cSFloatId, TinyLinalg::numo_cSFloatId, float, float, TinyLinalg::SGESVD>::define_module_function(rb_mTinyLinalgLapack, "sgesvd");
   TinyLinalg::GESVD<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZGESVD>::define_module_function(rb_mTinyLinalgLapack, "zgesvd");
@@ -245,6 +255,22 @@ extern "C" void Init_tiny_linalg(void) {
   TinyLinalg::GESDD<TinyLinalg::numo_cSFloatId, TinyLinalg::numo_cSFloatId, float, float, TinyLinalg::SGESDD>::define_module_function(rb_mTinyLinalgLapack, "sgesdd");
   TinyLinalg::GESDD<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZGESDD>::define_module_function(rb_mTinyLinalgLapack, "zgesdd");
   TinyLinalg::GESDD<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CGESDD>::define_module_function(rb_mTinyLinalgLapack, "cgesdd");
+  TinyLinalg::GETRF<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DGETRF>::define_module_function(rb_mTinyLinalgLapack, "dgetrf");
+  TinyLinalg::GETRF<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGETRF>::define_module_function(rb_mTinyLinalgLapack, "sgetrf");
+  TinyLinalg::GETRF<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZGETRF>::define_module_function(rb_mTinyLinalgLapack, "zgetrf");
+  TinyLinalg::GETRF<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CGETRF>::define_module_function(rb_mTinyLinalgLapack, "cgetrf");
+  TinyLinalg::GETRI<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DGETRI>::define_module_function(rb_mTinyLinalgLapack, "dgetri");
+  TinyLinalg::GETRI<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGETRI>::define_module_function(rb_mTinyLinalgLapack, "sgetri");
+  TinyLinalg::GETRI<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZGETRI>::define_module_function(rb_mTinyLinalgLapack, "zgetri");
+  TinyLinalg::GETRI<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CGETRI>::define_module_function(rb_mTinyLinalgLapack, "cgetri");
+  TinyLinalg::GeQrf<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DGeQrf>::define_module_function(rb_mTinyLinalgLapack, "dgeqrf");
+  TinyLinalg::GeQrf<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGeQrf>::define_module_function(rb_mTinyLinalgLapack, "sgeqrf");
+  TinyLinalg::GeQrf<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZGeQrf>::define_module_function(rb_mTinyLinalgLapack, "zgeqrf");
+  TinyLinalg::GeQrf<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CGeQrf>::define_module_function(rb_mTinyLinalgLapack, "cgeqrf");
+  TinyLinalg::OrgQr<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DOrgQr>::define_module_function(rb_mTinyLinalgLapack, "dorgqr");
+  TinyLinalg::OrgQr<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SOrgQr>::define_module_function(rb_mTinyLinalgLapack, "sorgqr");
+  TinyLinalg::UngQr<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZUngQr>::define_module_function(rb_mTinyLinalgLapack, "zungqr");
+  TinyLinalg::UngQr<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CUngQr>::define_module_function(rb_mTinyLinalgLapack, "cungqr");
 
   rb_define_alias(rb_singleton_class(rb_mTinyLinalgBlas), "znrm2", "dznrm2");
   rb_define_alias(rb_singleton_class(rb_mTinyLinalgBlas), "cnrm2", "scnrm2");

data/lib/numo/tiny_linalg/version.rb

@@ -5,6 +5,6 @@ module Numo
   # Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
   module TinyLinalg
     # The version of Numo::TinyLinalg you install.
-    VERSION = '0.0.1'
+    VERSION = '0.0.3'
   end
 end

data/lib/numo/tiny_linalg.rb

@@ -7,9 +7,139 @@ require_relative 'tiny_linalg/tiny_linalg'
 # Ruby/Numo (NUmerical MOdules)
 module Numo
   # Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
-  module TinyLinalg
+  module TinyLinalg # rubocop:disable Metrics/ModuleLength
     module_function
 
+    # Computes the determinant of matrix.
+    #
+    # @param a [Numo::NArray] n-by-n square matrix.
+    # @return [Float/Complex] The determinant of `a`.
+    def det(a)
+      raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise ArgumentError, 'input array a must be square' if a.shape[0] != a.shape[1]
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      getrf = "#{bchr}getrf".to_sym
+      lu, piv, info = Numo::TinyLinalg::Lapack.send(getrf, a.dup)
+
+      if info.zero?
+        det_l = 1
+        det_u = lu.diagonal.prod
+        det_p = piv.map_with_index { |v, i| v == i + 1 ? 1 : -1 }.prod
+        det_l * det_u * det_p
+      elsif info.positive?
+        raise 'the factor U is singular, and the inverse matrix could not be computed.'
+      else
+        raise "the #{-info}-th argument of getrf had illegal value"
+      end
+    end
+
+    # Computes the inverse matrix of a square matrix.
+    #
+    # @param a [Numo::NArray] n-by-n square matrix.
+    # @param driver [String] This argument is for compatibility with Numo::Linalg.solver, and is not used.
+    # @param uplo [String] This argument is for compatibility with Numo::Linalg.solver, and is not used.
+    # @return [Numo::NArray] The inverse matrix of `a`.
+    def inv(a, driver: 'getrf', uplo: 'U') # rubocop:disable Lint/UnusedMethodArgument
+      raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise ArgumentError, 'input array a must be square' if a.shape[0] != a.shape[1]
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      getrf = "#{bchr}getrf".to_sym
+      getri = "#{bchr}getri".to_sym
+
+      lu, piv, info = Numo::TinyLinalg::Lapack.send(getrf, a.dup)
+      if info.zero?
+        Numo::TinyLinalg::Lapack.send(getri, lu, piv)[0]
+      elsif info.positive?
+        raise 'the factor U is singular, and the inverse matrix could not be computed.'
+      else
+        raise "the #{-info}-th argument of getrf had illegal value"
+      end
+    end
+
+    # Compute the (Moore-Penrose) pseudo-inverse of a matrix using singular value decomposition.
+    #
+    # @param a [Numo::NArray] The m-by-n matrix to be pseudo-inverted.
+    # @param driver [String] LAPACK driver to be used ('svd' or 'sdd').
+    # @param rcond [Float] The threshold value for small singular values of `a`, default value is `a.shape.max * EPS`.
+    # @return [Numo::NArray] The pseudo-inverse of `a`.
+    def pinv(a, driver: 'svd', rcond: nil)
+      s, u, vh = svd(a, driver: driver, job: 'S')
+      rcond = a.shape.max * s.class::EPSILON if rcond.nil?
+      rank = s.gt(rcond * s[0]).count
+
+      u = u[true, 0...rank] / s[0...rank]
+      u.dot(vh[0...rank, true]).conj.transpose
+    end
+
+    # Compute QR decomposition of a matrix.
+    #
+    # @param a [Numo::NArray] The m-by-n matrix to be decomposed.
+    # @param mode [String] The mode of decomposition.
+    #   - "reduce"   -- returns both Q [m, m] and R [m, n],
+    #   - "r"        -- returns only R,
+    #   - "economic" -- returns both Q [m, n] and R [n, n],
+    #   - "raw"      -- returns QR and TAU (LAPACK geqrf results).
+    # @return [Numo::NArray] if mode='r'
+    # @return [Array<Numo::NArray,Numo::NArray>] if mode='reduce' or mode='economic'
+    # @return [Array<Numo::NArray,Numo::NArray>] if mode='raw' (LAPACK geqrf result)
+    def qr(a, mode: 'reduce')
+      raise ArgumentError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise ArgumentError, "invalid mode: #{mode}" unless %w[reduce r economic raw].include?(mode)
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      geqrf = "#{bchr}geqrf".to_sym
+      qr, tau, = Numo::TinyLinalg::Lapack.send(geqrf, a.dup)
+
+      return [qr, tau] if mode == 'raw'
+
+      m, n = qr.shape
+      r = m > n && %w[economic raw].include?(mode) ? qr[0...n, true].triu : qr.triu
+
+      return r if mode == 'r'
+
+      org_ung_qr = %w[d s].include?(bchr) ? "#{bchr}orgqr".to_sym : "#{bchr}ungqr".to_sym
+
+      q = if m < n
+            Numo::TinyLinalg::Lapack.send(org_ung_qr, qr[true, 0...m], tau)[0]
+          elsif mode == 'economic'
+            Numo::TinyLinalg::Lapack.send(org_ung_qr, qr, tau)[0]
+          else
+            qqr = a.class.zeros(m, m)
+            qqr[0...m, 0...n] = qr
+            Numo::TinyLinalg::Lapack.send(org_ung_qr, qqr, tau)[0]
+          end
+
+      [q, r]
+    end
+
+    # Solves linear equation `A * x = b` or `A * X = B` for `x` from square matrix `a`.
+    #
+    # @param a [Numo::NArray] The n-by-n square matrix  (>= 2-dimensinal NArray).
+    # @param b [Numo::NArray] The n right-hand side vector, or n-by-nrhs right-hand side matrix (>= 1-dimensinal NArray).
+    # @param driver [String] This argument is for compatibility with Numo::Linalg.solver, and is not used.
+    # @param uplo [String] This argument is for compatibility with Numo::Linalg.solver, and is not used.
+    # @return [Numo::NArray] The solusion vector / matrix `x`.
+    def solve(a, b, driver: 'gen', uplo: 'U') # rubocop:disable Lint/UnusedMethodArgument
+      case blas_char(a, b)
+      when 'd'
+        Lapack.dgesv(a.dup, b.dup)[1]
+      when 's'
+        Lapack.sgesv(a.dup, b.dup)[1]
+      when 'z'
+        Lapack.zgesv(a.dup, b.dup)[1]
+      when 'c'
+        Lapack.cgesv(a.dup, b.dup)[1]
+      end
+    end
+
     # Calculates the Singular Value Decomposition (SVD) of a matrix: `A = U * S * V^T`
     #
     # @param a [Numo::NArray] Matrix to be decomposed.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-tiny_linalg
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-14 00:00:00.000000000 Z
+date: 2023-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -35,31 +35,30 @@ extensions:
 - ext/numo/tiny_linalg/extconf.rb
 extra_rdoc_files: []
 files:
-- ".clang-format"
-- ".husky/commit-msg"
-- ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- commitlint.config.js
+- ext/numo/tiny_linalg/blas/dot.hpp
+- ext/numo/tiny_linalg/blas/dot_sub.hpp
+- ext/numo/tiny_linalg/blas/gemm.hpp
+- ext/numo/tiny_linalg/blas/gemv.hpp
+- ext/numo/tiny_linalg/blas/nrm2.hpp
 - ext/numo/tiny_linalg/converter.hpp
-- ext/numo/tiny_linalg/dot.hpp
-- ext/numo/tiny_linalg/dot_sub.hpp
 - ext/numo/tiny_linalg/extconf.rb
-- ext/numo/tiny_linalg/gemm.hpp
-- ext/numo/tiny_linalg/gemv.hpp
-- ext/numo/tiny_linalg/gesdd.hpp
-- ext/numo/tiny_linalg/gesvd.hpp
-- ext/numo/tiny_linalg/nrm2.hpp
+- ext/numo/tiny_linalg/lapack/geqrf.hpp
+- ext/numo/tiny_linalg/lapack/gesdd.hpp
+- ext/numo/tiny_linalg/lapack/gesv.hpp
+- ext/numo/tiny_linalg/lapack/gesvd.hpp
+- ext/numo/tiny_linalg/lapack/getrf.hpp
+- ext/numo/tiny_linalg/lapack/getri.hpp
+- ext/numo/tiny_linalg/lapack/orgqr.hpp
+- ext/numo/tiny_linalg/lapack/ungqr.hpp
 - ext/numo/tiny_linalg/tiny_linalg.cpp
 - ext/numo/tiny_linalg/tiny_linalg.hpp
 - lib/numo/tiny_linalg.rb
 - lib/numo/tiny_linalg/version.rb
-- numo-tiny_linalg.gemspec
-- package.json
+- vendor/tmp/.gitkeep
 homepage: https://github.com/yoshoku/numo-tiny_linalg
 licenses:
 - BSD-3-Clause
@@ -67,6 +66,7 @@ metadata:
   homepage_uri: https://github.com/yoshoku/numo-tiny_linalg
   source_code_uri: https://github.com/yoshoku/numo-tiny_linalg
   changelog_uri: https://github.com/yoshoku/numo-tiny_linalg/blob/main/CHANGELOG.md
+  documentation_uri: https://yoshoku.github.io/numo-tiny_linalg/doc/
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []

data/.clang-format

@@ -1,149 +0,0 @@
----
-Language:        Cpp
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -2
-AlignAfterOpenBracket: Align
-AlignConsecutiveMacros: false
-AlignConsecutiveAssignments: false
-AlignConsecutiveBitFields: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Right
-AlignOperands:   Align
-AlignTrailingComments: true
-AllowAllArgumentsOnNextLine: true
-AllowAllConstructorInitializersOnNextLine: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortEnumsOnASingleLine: true
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: All
-AllowShortLambdasOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: true
-AllowShortLoopsOnASingleLine: true
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: MultiLine
-BinPackArguments: true
-BinPackParameters: true
-BraceWrapping:
-  AfterCaseLabel:  false
-  AfterClass:      false
-  AfterControlStatement: Never
-  AfterEnum:       false
-  AfterFunction:   false
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     false
-  AfterUnion:      false
-  AfterExternBlock: false
-  BeforeCatch:     false
-  BeforeElse:      false
-  BeforeLambdaBody: false
-  BeforeWhile:     false
-  IndentBraces:    false
-  SplitEmptyFunction: true
-  SplitEmptyRecord: true
-  SplitEmptyNamespace: true
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Attach
-BreakBeforeInheritanceComma: false
-BreakInheritanceList: BeforeColon
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakConstructorInitializers: BeforeColon
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     0
-CommentPragmas:  '^ IWYU pragma:'
-CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 2
-Cpp11BracedListStyle: false
-DeriveLineEnding: true
-DerivePointerAlignment: false
-DisableFormat:   false
-ExperimentalAutoDetectBinPacking: false
-FixNamespaceComments: true
-ForEachMacros:
-  - foreach
-  - Q_FOREACH
-  - BOOST_FOREACH
-IncludeBlocks:   Preserve
-IncludeCategories:
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-    Priority:        2
-    SortPriority:    0
-  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
-    Priority:        3
-    SortPriority:    0
-  - Regex:           '.*'
-    Priority:        1
-    SortPriority:    0
-IncludeIsMainRegex: '(Test)?$'
-IncludeIsMainSourceRegex: ''
-IndentCaseLabels: false
-IndentCaseBlocks: false
-IndentGotoLabels: true
-IndentPPDirectives: None
-IndentExternBlock: AfterExternBlock
-IndentWidth:     2
-IndentWrappedFunctionNames: false
-InsertTrailingCommas: None
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBinPackProtocolList: Auto
-ObjCBlockIndentWidth: 2
-ObjCBreakBeforeNestedBlockParam: true
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyBreakTemplateDeclaration: 10
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Left
-ReflowComments:  true
-SortIncludes:    true
-SortUsingDeclarations: true
-SpaceAfterCStyleCast: false
-SpaceAfterLogicalNot: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCpp11BracedList: false
-SpaceBeforeCtorInitializerColon: true
-SpaceBeforeInheritanceColon: true
-SpaceBeforeParens: ControlStatements
-SpaceBeforeRangeBasedForLoopColon: true
-SpaceInEmptyBlock: false
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInConditionalStatement: false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-SpaceBeforeSquareBrackets: false
-Standard:        Latest
-StatementMacros:
-  - Q_UNUSED
-  - QT_REQUIRE_VERSION
-TabWidth:        8
-UseCRLF:         false
-UseTab:          Never
-WhitespaceSensitiveMacros:
-  - STRINGIZE
-  - PP_STRINGIZE
-  - BOOST_PP_STRINGIZE
-...
-

data/.husky/commit-msg

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-yarn commitlint --edit "$1"