numo-tiny_linalg 0.0.1

data/ext/numo/tiny_linalg/gesvd.hpp

@@ -0,0 +1,182 @@
+namespace TinyLinalg {
+
+struct DGESVD {
+  lapack_int call(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n,
+                  double* a, lapack_int lda, double* s, double* u, lapack_int ldu, double* vt, lapack_int ldvt,
+                  double* superb) {
+    return LAPACKE_dgesvd(matrix_order, jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, superb);
+  };
+};
+
+struct SGESVD {
+  lapack_int call(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n,
+                  float* a, lapack_int lda, float* s, float* u, lapack_int ldu, float* vt, lapack_int ldvt,
+                  float* superb) {
+    return LAPACKE_sgesvd(matrix_order, jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, superb);
+  };
+};
+
+struct ZGESVD {
+  lapack_int call(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n,
+                  lapack_complex_double* a, lapack_int lda, double* s, lapack_complex_double* u, lapack_int ldu, lapack_complex_double* vt, lapack_int ldvt,
+                  double* superb) {
+    return LAPACKE_zgesvd(matrix_order, jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, superb);
+  };
+};
+
+struct CGESVD {
+  lapack_int call(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n,
+                  lapack_complex_float* a, lapack_int lda, float* s, lapack_complex_float* u, lapack_int ldu, lapack_complex_float* vt, lapack_int ldvt,
+                  float* superb) {
+    return LAPACKE_cgesvd(matrix_order, jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, superb);
+  };
+};
+
+template <int nary_dtype_id, int nary_rtype_id, typename DType, typename RType, typename FncType>
+class GESVD {
+public:
+  static void define_module_function(VALUE mLapack, const char* mf_name) {
+    rb_define_module_function(mLapack, mf_name, RUBY_METHOD_FUNC(tiny_linalg_gesvd), -1);
+  };
+
+private:
+  struct gesvd_opt {
+    int matrix_order;
+    char jobu;
+    char jobvt;
+  };
+
+  static void iter_gesvd(na_loop_t* const lp) {
+    DType* a = (DType*)NDL_PTR(lp, 0);
+    RType* s = (RType*)NDL_PTR(lp, 1);
+    DType* u = (DType*)NDL_PTR(lp, 2);
+    DType* vt = (DType*)NDL_PTR(lp, 3);
+    int* info = (int*)NDL_PTR(lp, 4);
+    gesvd_opt* opt = (gesvd_opt*)(lp->opt_ptr);
+
+    const size_t m = opt->matrix_order == LAPACK_ROW_MAJOR ? NDL_SHAPE(lp, 0)[0] : NDL_SHAPE(lp, 0)[1];
+    const size_t n = opt->matrix_order == LAPACK_ROW_MAJOR ? NDL_SHAPE(lp, 0)[1] : NDL_SHAPE(lp, 0)[0];
+    const size_t min_mn = m < n ? m : n;
+    const lapack_int lda = n;
+    const lapack_int ldu = opt->jobu == 'A' ? m : min_mn;
+    const lapack_int ldvt = n;
+
+    RType* superb = (RType*)ruby_xmalloc(min_mn * sizeof(RType));
+
+    lapack_int i = FncType().call(opt->matrix_order, opt->jobu, opt->jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, superb);
+    *info = static_cast<int>(i);
+
+    ruby_xfree(superb);
+  };
+
+  static VALUE tiny_linalg_gesvd(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+    VALUE nary_rtype = NaryTypes[nary_rtype_id];
+    VALUE a_vnary = Qnil;
+    VALUE kw_args = Qnil;
+
+    rb_scan_args(argc, argv, "1:", &a_vnary, &kw_args);
+
+    ID kw_table[3] = { rb_intern("jobu"), rb_intern("jobvt"), rb_intern("order") };
+    VALUE kw_values[3] = { Qundef, Qundef, Qundef };
+
+    rb_get_kwargs(kw_args, kw_table, 0, 3, kw_values);
+
+    const char jobu = kw_values[0] == Qundef ? 'A' : StringValueCStr(kw_values[0])[0];
+    const char jobvt = kw_values[1] == Qundef ? 'A' : StringValueCStr(kw_values[1])[0];
+    const char order = kw_values[2] == Qundef ? 'R' : StringValueCStr(kw_values[2])[0];
+
+    if (jobu == 'O' && jobvt == 'O') {
+      rb_raise(rb_eArgError, "jobu and jobvt cannot be both 'O'");
+      return Qnil;
+    }
+    if (CLASS_OF(a_vnary) != nary_dtype) {
+      rb_raise(rb_eTypeError, "type of input array is invalid for overwriting");
+      return Qnil;
+    }
+
+    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 must be 2-dimensional");
+      return Qnil;
+    }
+
+    const int matrix_order = order == 'C' ? LAPACK_COL_MAJOR : LAPACK_ROW_MAJOR;
+    const size_t m = matrix_order == LAPACK_ROW_MAJOR ? NA_SHAPE(a_nary)[0] : NA_SHAPE(a_nary)[1];
+    const size_t n = matrix_order == LAPACK_ROW_MAJOR ? NA_SHAPE(a_nary)[1] : NA_SHAPE(a_nary)[0];
+
+    const size_t min_mn = m < n ? m : n;
+    size_t shape_s[1] = { min_mn };
+    size_t shape_u[2] = { m, m };
+    size_t shape_vt[2] = { n, n };
+
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+    ndfunc_arg_out_t aout[4] = { { nary_rtype, 1, shape_s }, { nary_dtype, 2, shape_u }, { nary_dtype, 2, shape_vt }, { numo_cInt32, 0 } };
+
+    switch (jobu) {
+    case 'A':
+      break;
+    case 'S':
+      shape_u[matrix_order == LAPACK_ROW_MAJOR ? 1 : 0] = min_mn;
+      break;
+    case 'O':
+    case 'N':
+      aout[1].dim = 0;
+      break;
+    default:
+      rb_raise(rb_eArgError, "jobu must be 'A', 'S', 'O', or 'N'");
+      return Qnil;
+    }
+
+    switch (jobvt) {
+    case 'A':
+      break;
+    case 'S':
+      shape_vt[matrix_order == LAPACK_ROW_MAJOR ? 0 : 1] = min_mn;
+      break;
+    case 'O':
+    case 'N':
+      aout[2].dim = 0;
+      break;
+    default:
+      rb_raise(rb_eArgError, "jobvt must be 'A', 'S', 'O', or 'N'");
+      return Qnil;
+    }
+
+    ndfunc_t ndf = { iter_gesvd, NO_LOOP | NDF_EXTRACT, 1, 4, ain, aout };
+    gesvd_opt opt = { matrix_order, jobu, jobvt };
+    VALUE ret = na_ndloop3(&ndf, &opt, 1, a_vnary);
+
+    switch (jobu) {
+    case 'O':
+      rb_ary_store(ret, 1, a_vnary);
+      break;
+    case 'N':
+      rb_ary_store(ret, 1, Qnil);
+      break;
+    }
+
+    switch (jobvt) {
+    case 'O':
+      rb_ary_store(ret, 2, a_vnary);
+      break;
+    case 'N':
+      rb_ary_store(ret, 2, Qnil);
+      break;
+    }
+
+    RB_GC_GUARD(a_vnary);
+    return ret;
+  };
+};
+
+} // namespace TinyLinalg

data/ext/numo/tiny_linalg/nrm2.hpp

@@ -0,0 +1,89 @@
+namespace TinyLinalg {
+
+struct DNrm2 {
+  double call(const int n, const double* x, const int incx) {
+    return cblas_dnrm2(n, x, incx);
+  }
+};
+
+struct SNrm2 {
+  float call(const int n, const float* x, const int incx) {
+    return cblas_snrm2(n, x, incx);
+  }
+};
+
+struct DZNrm2 {
+  double call(const int n, const void* x, const int incx) {
+    return cblas_dznrm2(n, x, incx);
+  }
+};
+
+struct SCNrm2 {
+  double call(const int n, const void* x, const int incx) {
+    return cblas_scnrm2(n, x, incx);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class BlasFn>
+class Nrm2 {
+public:
+  static void define_module_function(VALUE mBlas, const char* modfn_name) {
+    rb_define_module_function(mBlas, modfn_name, RUBY_METHOD_FUNC(tiny_linalg_dot), -1);
+  }
+
+private:
+  static void iter_nrm2(na_loop_t* const lp) {
+    dtype* x = (dtype*)NDL_PTR(lp, 0);
+    dtype* d = (dtype*)NDL_PTR(lp, 1);
+    const size_t n = NDL_SHAPE(lp, 0)[0];
+    dtype ret = BlasFn().call(n, x, 1);
+    *d = ret;
+  }
+
+  static VALUE tiny_linalg_dot(int argc, VALUE* argv, VALUE self) {
+    VALUE nary_dtype = NaryTypes[nary_dtype_id];
+
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    rb_scan_args(argc, argv, "1:", &x, &kw_args);
+
+    ID kw_table[1] = { rb_intern("keepdims") };
+    VALUE kw_values[1] = { Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 1, kw_values);
+    const bool keepdims = kw_values[0] != Qundef ? RTEST(kw_values[0]) : false;
+
+    if (CLASS_OF(x) != nary_dtype) {
+      x = rb_funcall(nary_dtype, rb_intern("cast"), 1, x);
+    }
+    if (!RTEST(nary_check_contiguous(x))) {
+      x = nary_dup(x);
+    }
+
+    narray_t* x_nary = NULL;
+    GetNArray(x, x_nary);
+
+    if (NA_NDIM(x_nary) != 1) {
+      rb_raise(rb_eArgError, "x must be 1-dimensional");
+      return Qnil;
+    }
+    if (NA_SIZE(x_nary) == 0) {
+      rb_raise(rb_eArgError, "x must not be empty");
+      return Qnil;
+    }
+
+    ndfunc_arg_in_t ain[1] = { { nary_dtype, 1 } };
+    size_t shape_out[1] = { 1 };
+    ndfunc_arg_out_t aout[1] = { { nary_dtype, 0, shape_out } };
+    ndfunc_t ndf = { iter_nrm2, NO_LOOP | NDF_EXTRACT, 1, 1, ain, aout };
+    if (keepdims) {
+      ndf.flag |= NDF_KEEP_DIM;
+    }
+
+    VALUE ret = na_ndloop(&ndf, 1, x);
+
+    RB_GC_GUARD(x);
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

data/ext/numo/tiny_linalg/tiny_linalg.cpp

@@ -0,0 +1,251 @@
+#include "tiny_linalg.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"
+
+VALUE rb_mTinyLinalg;
+VALUE rb_mTinyLinalgBlas;
+VALUE rb_mTinyLinalgLapack;
+
+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 tiny_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 tiny_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;
+  }
+
+  std::string type_str{ type };
+  std::string fn_str = type_str + std::string(rb_id2name(rb_to_id(rb_to_symbol(fn_name))));
+  ID fn_id = rb_intern(fn_str.c_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, 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, n + 1, args, RB_PASS_KEYWORDS);
+  }
+
+  return ret;
+}
+
+static VALUE tiny_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_mTinyLinalgBlas, 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_mTinyLinalgBlas, 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_mTinyLinalgBlas, 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_mTinyLinalgBlas, rb_intern(fn_name), 3, argv, RB_PASS_KEYWORDS);
+    }
+  }
+
+  RB_GC_GUARD(a);
+  RB_GC_GUARD(b);
+
+  return ret;
+}
+
+extern "C" void Init_tiny_linalg(void) {
+  rb_require("numo/narray");
+
+  /**
+   * Document-module: Numo::TinyLinalg
+   * Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
+   */
+  rb_mTinyLinalg = rb_define_module_under(rb_mNumo, "TinyLinalg");
+  /**
+   * Document-module: Numo::TinyLinalg::Blas
+   * Numo::TinyLinalg::Blas is wrapper module of BLAS functions.
+   */
+  rb_mTinyLinalgBlas = rb_define_module_under(rb_mTinyLinalg, "Blas");
+  /**
+   * Document-module: Numo::TinyLinalg::Lapack
+   * Numo::TinyLinalg::Lapack is wrapper module of LAPACK functions.
+   */
+  rb_mTinyLinalgLapack = rb_define_module_under(rb_mTinyLinalg, "Lapack");
+
+  /**
+   * 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_mTinyLinalg, "blas_char", RUBY_METHOD_FUNC(tiny_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_mTinyLinalg, "dot", RUBY_METHOD_FUNC(tiny_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::TinyLinalg::Blas.call(:gemv, a, b)
+   */
+  rb_define_singleton_method(rb_mTinyLinalgBlas, "call", RUBY_METHOD_FUNC(tiny_linalg_blas_call), -1);
+
+  TinyLinalg::Dot<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DDot>::define_module_function(rb_mTinyLinalgBlas, "ddot");
+  TinyLinalg::Dot<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SDot>::define_module_function(rb_mTinyLinalgBlas, "sdot");
+  TinyLinalg::DotSub<TinyLinalg::numo_cDComplexId, double, TinyLinalg::ZDotuSub>::define_module_function(rb_mTinyLinalgBlas, "zdotu");
+  TinyLinalg::DotSub<TinyLinalg::numo_cSComplexId, float, TinyLinalg::CDotuSub>::define_module_function(rb_mTinyLinalgBlas, "cdotu");
+  TinyLinalg::Gemm<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DGemm, TinyLinalg::DConverter>::define_module_function(rb_mTinyLinalgBlas, "dgemm");
+  TinyLinalg::Gemm<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGemm, TinyLinalg::SConverter>::define_module_function(rb_mTinyLinalgBlas, "sgemm");
+  TinyLinalg::Gemm<TinyLinalg::numo_cDComplexId, dcomplex, TinyLinalg::ZGemm, TinyLinalg::ZConverter>::define_module_function(rb_mTinyLinalgBlas, "zgemm");
+  TinyLinalg::Gemm<TinyLinalg::numo_cSComplexId, scomplex, TinyLinalg::CGemm, TinyLinalg::CConverter>::define_module_function(rb_mTinyLinalgBlas, "cgemm");
+  TinyLinalg::Gemv<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DGemv, TinyLinalg::DConverter>::define_module_function(rb_mTinyLinalgBlas, "dgemv");
+  TinyLinalg::Gemv<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SGemv, TinyLinalg::SConverter>::define_module_function(rb_mTinyLinalgBlas, "sgemv");
+  TinyLinalg::Gemv<TinyLinalg::numo_cDComplexId, dcomplex, TinyLinalg::ZGemv, TinyLinalg::ZConverter>::define_module_function(rb_mTinyLinalgBlas, "zgemv");
+  TinyLinalg::Gemv<TinyLinalg::numo_cSComplexId, scomplex, TinyLinalg::CGemv, TinyLinalg::CConverter>::define_module_function(rb_mTinyLinalgBlas, "cgemv");
+  TinyLinalg::Nrm2<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DNrm2>::define_module_function(rb_mTinyLinalgBlas, "dnrm2");
+  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::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");
+  TinyLinalg::GESVD<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CGESVD>::define_module_function(rb_mTinyLinalgLapack, "cgesvd");
+  TinyLinalg::GESDD<TinyLinalg::numo_cDFloatId, TinyLinalg::numo_cDFloatId, double, double, TinyLinalg::DGESDD>::define_module_function(rb_mTinyLinalgLapack, "dgesdd");
+  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");
+
+  rb_define_alias(rb_singleton_class(rb_mTinyLinalgBlas), "znrm2", "dznrm2");
+  rb_define_alias(rb_singleton_class(rb_mTinyLinalgBlas), "cnrm2", "scnrm2");
+}

data/ext/numo/tiny_linalg/tiny_linalg.hpp

@@ -0,0 +1,38 @@
+#ifndef NUMO_TINY_LINALG_H
+#define NUMO_TINY_LINALG_H 1
+
+#if defined(TINYLINALG_USE_ACCELERATE)
+#include <Accelerate/Accelerate.h>
+#else
+#include <cblas.h>
+#include <lapacke.h>
+#endif
+
+#include <string>
+
+#include <cstring>
+
+#include <ruby.h>
+
+#include <numo/narray.h>
+#include <numo/template.h>
+
+namespace TinyLinalg {
+
+const VALUE NaryTypes[4] = {
+  numo_cDFloat,
+  numo_cSFloat,
+  numo_cDComplex,
+  numo_cSComplex
+};
+
+enum NaryType {
+  numo_cDFloatId,
+  numo_cSFloatId,
+  numo_cDComplexId,
+  numo_cSComplexId
+};
+
+} // namespace TinyLinalg
+
+#endif /* NUMO_TINY_LINALG_H */

data/lib/numo/tiny_linalg/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# 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
+    # The version of Numo::TinyLinalg you install.
+    VERSION = '0.0.1'
+  end
+end

data/lib/numo/tiny_linalg.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+require_relative 'tiny_linalg/version'
+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_function
+
+    # Calculates the Singular Value Decomposition (SVD) of a matrix: `A = U * S * V^T`
+    #
+    # @param a [Numo::NArray] Matrix to be decomposed.
+    # @param driver [String] LAPACK driver to be used ('svd' or 'sdd').
+    # @param job [String] Job option ('A', 'S', or 'N').
+    # @return [Array<Numo::NArray>] Singular values and singular vectors ([s, u, vt]).
+    def svd(a, driver: 'svd', job: 'A')
+      raise ArgumentError, "invalid job: #{job}" unless /^[ASN]/i.match?(job.to_s)
+
+      case driver.to_s
+      when 'sdd'
+        s, u, vt, info = case a
+                         when Numo::DFloat
+                           Numo::TinyLinalg::Lapack.dgesdd(a.dup, jobz: job)
+                         when Numo::SFloat
+                           Numo::TinyLinalg::Lapack.sgesdd(a.dup, jobz: job)
+                         when Numo::DComplex
+                           Numo::TinyLinalg::Lapack.zgesdd(a.dup, jobz: job)
+                         when Numo::SComplex
+                           Numo::TinyLinalg::Lapack.cgesdd(a.dup, jobz: job)
+                         else
+                           raise ArgumentError, "invalid array type: #{a.class}"
+                         end
+      when 'svd'
+        s, u, vt, info = case a
+                         when Numo::DFloat
+                           Numo::TinyLinalg::Lapack.dgesvd(a.dup, jobu: job, jobvt: job)
+                         when Numo::SFloat
+                           Numo::TinyLinalg::Lapack.sgesvd(a.dup, jobu: job, jobvt: job)
+                         when Numo::DComplex
+                           Numo::TinyLinalg::Lapack.zgesvd(a.dup, jobu: job, jobvt: job)
+                         when Numo::SComplex
+                           Numo::TinyLinalg::Lapack.cgesvd(a.dup, jobu: job, jobvt: job)
+                         else
+                           raise ArgumentError, "invalid array type: #{a.class}"
+                         end
+      else
+        raise ArgumentError, "invalid driver: #{driver}"
+      end
+
+      raise "the #{info.abs}-th argument had illegal value" if info.negative?
+      raise 'input array has a NAN entry' if info == -4
+      raise 'svd did not converge' if info.positive?
+
+      [s, u, vt]
+    end
+  end
+end

data/numo-tiny_linalg.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/numo/tiny_linalg/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'numo-tiny_linalg'
+  spec.version = Numo::TinyLinalg::VERSION
+  spec.authors = ['yoshoku']
+  spec.email = ['yoshoku@outlook.com']
+
+  spec.summary = <<~MSG
+    Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
+  MSG
+  spec.description = <<~MSG
+    Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
+  MSG
+  spec.homepage = 'https://github.com/yoshoku/numo-tiny_linalg'
+  spec.license = 'BSD-3-Clause'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.extensions = ['ext/numo/tiny_linalg/extconf.rb']
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'numo-narray', '>= 0.9.1'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "numo-tiny_linalg",
+  "repository": "git@github.com:yoshoku/numo-tiny_linalg.git",
+  "author": "Atsushi Tatsuma <yoshoku@outlook.com>",
+  "license": "BSD-3-Clause",
+  "private": true,
+  "scripts": {
+    "prepare": "husky install"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.6.1",
+    "@commitlint/config-conventional": "^17.6.1",
+    "husky": "^8.0.3"
+  }
+}