numo-tiny_linalg 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9165d44ad74a388e32e08564402c255b238ac80dc66655d264ce5074b6d9ae66
-  data.tar.gz: d679aae9036c5da1ebb72854b554438dc201dd7d95376c381647513acb4ce5f7
+  metadata.gz: c508a2c2f31a965c26824084f1eeb1a2caf53ea82a3d23e523980d6cf78e6259
+  data.tar.gz: 4bffa14a1a73bfb60230c65fa35c98eeb957e176b8af2003f9c3e5b8aaf89b19
 SHA512:
-  metadata.gz: dc6c2fdebcd684b07a29dfa3650a33da81f3a0339a90ddc17c872876854cc7c4b8fc42c7feaf932501b212fc4f6a460e871ff23aba776e8e97127e6af2d51f0e
-  data.tar.gz: 56b0db97799b6e5c41f67503bc20d2fb08868b9a53a64a7a5a919b29791a61f08749c03f54190a238e84dd8e3f3aac44a2ac4bdb8d7e53d50e3491f7c9874f7e
+  metadata.gz: 4ad7a9af39fdc0c5ffb9ba7fc51dcf037fe8ffe7d81c33c70a0c669b384127929efee3a9ceb8440b7d1ec10c79ee66b362aed7098befbe02a892d4490961f169
+  data.tar.gz: 91c9935714ef5b929718affc9cfae518f6e08f85063f673f26ffa7c137bb7fe62d41c20386704657dccb89feebf57bdaed5b182750c6f0fe3ad5b20e55cc4221

data/CHANGELOG.md

@@ -1,4 +1,12 @@
 ## [Unreleased]
+## [[0.3.6](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.3.5...v0.3.6)] - 2024-01-28
+
+- Add solve_triangular module function to TinyLinalg.
+  - The solve_triangular is not implemented in Numo::Linalg, but I have implemented it because it uses some machine learning algorithms.
+- Add dtrtrs, strtrs, ztrtrs, and ctrtrs module functions to TinyLinalg::Lapack.
+- Add norm module function to TinyLinalg.
+- Add dlange, slange, zlange, and clange module functions to TinyLinalg::Lapack.
+
 ## [[0.3.5](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.3.4...v0.3.5)] - 2024-01-03
 - Bump OpenBLAS to be downloaded from 0.3.25 to 0.3.26.
 - Minor changes using RuboCop.

data/ext/numo/tiny_linalg/extconf.rb

@@ -83,8 +83,7 @@ if build_openblas
     end
   end
 
-  libopenblas_dir = on_windows ? TINYLINALG_DIR : "#{VENDOR_DIR}/lib"
-  abort('libopenblas is not found.') unless find_library('openblas', nil, libopenblas_dir)
+  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")

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

@@ -0,0 +1,89 @@
+namespace TinyLinalg {
+
+struct DLanGe {
+  double call(int matrix_layout, char norm, lapack_int m, lapack_int n, const double* a, lapack_int lda) {
+    return LAPACKE_dlange(matrix_layout, norm, m, n, a, lda);
+  }
+};
+
+struct SLanGe {
+  float call(int matrix_layout, char norm, lapack_int m, lapack_int n, const float* a, lapack_int lda) {
+    return LAPACKE_slange(matrix_layout, norm, m, n, a, lda);
+  }
+};
+
+struct ZLanGe {
+  double call(int matrix_layout, char norm, lapack_int m, lapack_int n, const lapack_complex_double* a, lapack_int lda) {
+    return LAPACKE_zlange(matrix_layout, norm, m, n, a, lda);
+  }
+};
+
+struct CLanGe {
+  float call(int matrix_layout, char norm, lapack_int m, lapack_int n, const lapack_complex_float* a, lapack_int lda) {
+    return LAPACKE_clange(matrix_layout, norm, m, n, a, lda);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class LapackFn>
+class LanGe {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_lange), -1);
+  }
+
+private:
+  struct lange_opt {
+    int matrix_layout;
+    char norm;
+  };
+
+  static void iter_lange(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    dtype* d = (dtype*)NDL_PTR(lp, 1);
+    lange_opt* opt = (lange_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;
+    *d = LapackFn().call(opt->matrix_layout, opt->norm, m, n, a, lda);
+  }
+
+  static VALUE tiny_linalg_lange(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[2] = { rb_intern("order"), rb_intern("norm") };
+    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 ? Util().get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR;
+    const char norm = kw_values[1] != Qundef ? NUM2CHR(kw_values[1]) : 'F';
+
+    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);
+    if (NA_NDIM(a_nary) != 2) {
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");
+      return Qnil;
+    }
+
+    ndfunc_arg_in_t ain[1] = { { nary_dtype, 2 } };
+    size_t shape_out[1] = { 1 };
+    ndfunc_arg_out_t aout[1] = { { nary_dtype, 0, shape_out } };
+    ndfunc_t ndf = { iter_lange, NO_LOOP | NDF_EXTRACT, 1, 1, ain, aout };
+    lange_opt opt = { matrix_layout, norm };
+    VALUE ret = na_ndloop3(&ndf, &opt, 1, a_vnary);
+
+    RB_GC_GUARD(a_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

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

@@ -0,0 +1,126 @@
+namespace TinyLinalg {
+
+struct DTrTrs {
+  lapack_int call(int matrix_layout, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
+                  const double* a, lapack_int lda, double* b, lapack_int ldb) {
+    return LAPACKE_dtrtrs(matrix_layout, uplo, trans, diag, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+struct STrTrs {
+  lapack_int call(int matrix_layout, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
+                  const float* a, lapack_int lda, float* b, lapack_int ldb) {
+    return LAPACKE_strtrs(matrix_layout, uplo, trans, diag, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+struct ZTrTrs {
+  lapack_int call(int matrix_layout, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
+                  const lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb) {
+    return LAPACKE_ztrtrs(matrix_layout, uplo, trans, diag, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+struct CTrTrs {
+  lapack_int call(int matrix_layout, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
+                  const lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb) {
+    return LAPACKE_ctrtrs(matrix_layout, uplo, trans, diag, n, nrhs, a, lda, b, ldb);
+  }
+};
+
+template <int nary_dtype_id, typename dtype, class LapackFn>
+class TrTrs {
+public:
+  static void define_module_function(VALUE mLapack, const char* fnc_name) {
+    rb_define_module_function(mLapack, fnc_name, RUBY_METHOD_FUNC(tiny_linalg_trtrs), -1);
+  }
+
+private:
+  struct trtrs_opt {
+    int matrix_layout;
+    char uplo;
+    char trans;
+    char diag;
+  };
+
+  static void iter_trtrs(na_loop_t* const lp) {
+    dtype* a = (dtype*)NDL_PTR(lp, 0);
+    dtype* b = (dtype*)NDL_PTR(lp, 1);
+    int* info = (int*)NDL_PTR(lp, 2);
+    trtrs_opt* opt = (trtrs_opt*)(lp->opt_ptr);
+    const lapack_int n = NDL_SHAPE(lp, 0)[0];
+    const lapack_int nrhs = lp->args[1].ndim == 1 ? 1 : NDL_SHAPE(lp, 1)[1];
+    const lapack_int lda = n;
+    const lapack_int ldb = nrhs;
+    const lapack_int i = LapackFn().call(opt->matrix_layout, opt->uplo, opt->trans, opt->diag, n, nrhs, a, lda, b, ldb);
+    *info = static_cast<int>(i);
+  }
+
+  static VALUE tiny_linalg_trtrs(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[4] = { rb_intern("order"), rb_intern("uplo"), rb_intern("trans"), rb_intern("diag") };
+    VALUE kw_values[4] = { Qundef, Qundef, Qundef, Qundef };
+    rb_get_kwargs(kw_args, kw_table, 0, 4, kw_values);
+    const int matrix_layout = kw_values[0] != Qundef ? Util().get_matrix_layout(kw_values[0]) : LAPACK_ROW_MAJOR;
+    const char uplo = kw_values[1] != Qundef ? Util().get_uplo(kw_values[1]) : 'U';
+    const char trans = kw_values[2] != Qundef ? NUM2CHR(kw_values[2]) : 'N';
+    const char diag = kw_values[3] != Qundef ? NUM2CHR(kw_values[3]) : 'N';
+
+    if (CLASS_OF(a_vnary) != 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;
+    GetNArray(a_vnary, a_nary);
+    if (NA_NDIM(a_nary) != 2) {
+      rb_raise(rb_eArgError, "input array a must be 2-dimensional");
+      return Qnil;
+    }
+    if (NA_SHAPE(a_nary)[0] != NA_SHAPE(a_nary)[1]) {
+      rb_raise(rb_eArgError, "input array a must be square");
+      return Qnil;
+    }
+
+    narray_t* b_nary = NULL;
+    GetNArray(b_vnary, b_nary);
+    const int b_n_dims = NA_NDIM(b_nary);
+    if (b_n_dims != 1 && b_n_dims != 2) {
+      rb_raise(rb_eArgError, "input array b must be 1- or 2-dimensional");
+      return Qnil;
+    }
+
+    lapack_int n = NA_SHAPE(a_nary)[0];
+    lapack_int nb = NA_SHAPE(b_nary)[0];
+    if (n != nb) {
+      rb_raise(nary_eShapeError, "shape1[0](=%d) != shape2[0](=%d)", n, nb);
+    }
+
+    ndfunc_arg_in_t ain[2] = { { nary_dtype, 2 }, { OVERWRITE, b_n_dims } };
+    ndfunc_arg_out_t aout[1] = { { numo_cInt32, 0 } };
+    ndfunc_t ndf = { iter_trtrs, NO_LOOP | NDF_EXTRACT, 2, 1, ain, aout };
+    trtrs_opt opt = { matrix_layout, uplo, trans, diag };
+    VALUE info = na_ndloop3(&ndf, &opt, 2, a_vnary, b_vnary);
+    VALUE ret = rb_ary_new3(2, b_vnary, info);
+
+    RB_GC_GUARD(a_vnary);
+    RB_GC_GUARD(b_vnary);
+
+    return ret;
+  }
+};
+
+} // namespace TinyLinalg

data/ext/numo/tiny_linalg/tiny_linalg.cpp

@@ -50,6 +50,7 @@
 #include "lapack/hegv.hpp"
 #include "lapack/hegvd.hpp"
 #include "lapack/hegvx.hpp"
+#include "lapack/lange.hpp"
 #include "lapack/orgqr.hpp"
 #include "lapack/potrf.hpp"
 #include "lapack/potrs.hpp"
@@ -59,6 +60,7 @@
 #include "lapack/sygv.hpp"
 #include "lapack/sygvd.hpp"
 #include "lapack/sygvx.hpp"
+#include "lapack/trtrs.hpp"
 #include "lapack/ungqr.hpp"
 
 VALUE rb_mTinyLinalg;
@@ -314,6 +316,10 @@ extern "C" void Init_tiny_linalg(void) {
   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::TrTrs<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DTrTrs>::define_module_function(rb_mTinyLinalgLapack, "dtrtrs");
+  TinyLinalg::TrTrs<TinyLinalg::numo_cSFloatId, float, TinyLinalg::STrTrs>::define_module_function(rb_mTinyLinalgLapack, "strtrs");
+  TinyLinalg::TrTrs<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZTrTrs>::define_module_function(rb_mTinyLinalgLapack, "ztrtrs");
+  TinyLinalg::TrTrs<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CTrTrs>::define_module_function(rb_mTinyLinalgLapack, "ctrtrs");
   TinyLinalg::PoTrf<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DPoTrf>::define_module_function(rb_mTinyLinalgLapack, "dpotrf");
   TinyLinalg::PoTrf<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SPoTrf>::define_module_function(rb_mTinyLinalgLapack, "spotrf");
   TinyLinalg::PoTrf<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZPoTrf>::define_module_function(rb_mTinyLinalgLapack, "zpotrf");
@@ -354,6 +360,10 @@ extern "C" void Init_tiny_linalg(void) {
   TinyLinalg::SyGvx<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SSyGvx>::define_module_function(rb_mTinyLinalgLapack, "ssygvx");
   TinyLinalg::HeGvx<TinyLinalg::numo_cDComplexId, TinyLinalg::numo_cDFloatId, lapack_complex_double, double, TinyLinalg::ZHeGvx>::define_module_function(rb_mTinyLinalgLapack, "zhegvx");
   TinyLinalg::HeGvx<TinyLinalg::numo_cSComplexId, TinyLinalg::numo_cSFloatId, lapack_complex_float, float, TinyLinalg::CHeGvx>::define_module_function(rb_mTinyLinalgLapack, "chegvx");
+  TinyLinalg::LanGe<TinyLinalg::numo_cDFloatId, double, TinyLinalg::DLanGe>::define_module_function(rb_mTinyLinalgLapack, "dlange");
+  TinyLinalg::LanGe<TinyLinalg::numo_cSFloatId, float, TinyLinalg::SLanGe>::define_module_function(rb_mTinyLinalgLapack, "slange");
+  TinyLinalg::LanGe<TinyLinalg::numo_cDComplexId, lapack_complex_double, TinyLinalg::ZLanGe>::define_module_function(rb_mTinyLinalgLapack, "zlange");
+  TinyLinalg::LanGe<TinyLinalg::numo_cSComplexId, lapack_complex_float, TinyLinalg::CLanGe>::define_module_function(rb_mTinyLinalgLapack, "clange");
 
   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.3.5'
+    VERSION = '0.3.6'
   end
 end

data/lib/numo/tiny_linalg.rb

@@ -95,6 +95,172 @@ module Numo
       [vals, vecs]
     end
 
+    # Computes the matrix or vector norm.
+    #
+    #   |  ord  |  matrix norm           | vector norm                 |
+    #   | ----- | ---------------------- | --------------------------- |
+    #   |  nil  | Frobenius norm         | 2-norm                      |
+    #   | 'fro' | Frobenius norm         |  -                          |
+    #   | 'nuc' | nuclear norm           |  -                          |
+    #   | 'inf' | x.abs.sum(axis:-1).max | x.abs.max                   |
+    #   |    0  |  -                     | (x.ne 0).sum                |
+    #   |    1  | x.abs.sum(axis:-2).max | same as below               |
+    #   |    2  | 2-norm (max sing_vals) | same as below               |
+    #   | other |  -                     | (x.abs**ord).sum**(1.0/ord) |
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #   Numo::Linalg = Numo::TinyLinalg unless defined?(Numo::Linalg)
+    #
+    #   # matrix norm
+    #   x = Numo::DFloat[[1, 2, -3, 1], [-4, 1, 8, 2]]
+    #   pp Numo::Linalg.norm(x)
+    #   # => 10
+    #
+    #   # vector norm
+    #   x = Numo::DFloat[3, -4]
+    #   pp Numo::Linalg.norm(x)
+    #   # => 5
+    #
+    # @param a [Numo::NArray] The matrix or vector (>= 1-dimensinal NArray)
+    # @param ord [String/Numeric] The order of the norm.
+    # @param axis [Integer/Array] The applied axes.
+    # @param keepdims [Bool] The flag indicating whether to leave the normed axes in the result as dimensions with size one.
+    # @return [Numo::NArray/Numeric] The norm of the matrix or vectors.
+    def norm(a, ord = nil, axis: nil, keepdims: false) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      a = Numo::NArray.asarray(a) unless a.is_a?(Numo::NArray)
+
+      return 0.0 if a.empty?
+
+      # for compatibility with Numo::Linalg.norm
+      if ord.is_a?(String)
+        if ord == 'inf'
+          ord = Float::INFINITY
+        elsif ord == '-inf'
+          ord = -Float::INFINITY
+        end
+      end
+
+      if axis.nil?
+        norm = case a.ndim
+               when 1
+                 Numo::TinyLinalg::Blas.send(:"#{blas_char(a)}nrm2", a) if ord.nil? || ord == 2
+               when 2
+                 if ord.nil? || ord == 'fro'
+                   Numo::TinyLinalg::Lapack.send(:"#{blas_char(a)}lange", a, norm: 'F')
+                 elsif ord.is_a?(Numeric)
+                   if ord == 1
+                     Numo::TinyLinalg::Lapack.send(:"#{blas_char(a)}lange", a, norm: '1')
+                   elsif !ord.infinite?.nil? && ord.infinite?.positive?
+                     Numo::TinyLinalg::Lapack.send(:"#{blas_char(a)}lange", a, norm: 'I')
+                   end
+                 end
+               else
+                 if ord.nil?
+                   b = a.flatten.dup
+                   Numo::TinyLinalg::Blas.send(:"#{blas_char(b)}nrm2", b)
+                 end
+               end
+        unless norm.nil?
+          norm = Numo::NArray.asarray(norm).reshape(*([1] * a.ndim)) if keepdims
+          return norm
+        end
+      end
+
+      if axis.nil?
+        axis = Array.new(a.ndim) { |d| d }
+      else
+        case axis
+        when Integer
+          axis = [axis]
+        when Array, Numo::NArray
+          axis = axis.flatten.to_a
+        else
+          raise ArgumentError, "invalid axis: #{axis}"
+        end
+      end
+
+      raise ArgumentError, "the number of dimensions of axis is inappropriate for the norm: #{axis.size}" unless axis.size == 1 || axis.size == 2
+      raise ArgumentError, "axis is out of range: #{axis}" unless axis.all? { |ax| (-a.ndim...a.ndim).cover?(ax) }
+
+      if axis.size == 1
+        ord ||= 2
+        raise ArgumentError, "invalid ord: #{ord}" unless ord.is_a?(Numeric)
+
+        ord_inf = ord.infinite?
+        if ord_inf.nil?
+          case ord
+          when 0
+            a.class.cast(a.ne(0)).sum(axis: axis, keepdims: keepdims)
+          when 1
+            a.abs.sum(axis: axis, keepdims: keepdims)
+          else
+            (a.abs**ord).sum(axis: axis, keepdims: keepdims)**1.fdiv(ord)
+          end
+        elsif ord_inf.positive?
+          a.abs.max(axis: axis, keepdims: keepdims)
+        else
+          a.abs.min(axis: axis, keepdims: keepdims)
+        end
+      else
+        ord ||= 'fro'
+        raise ArgumentError, "invalid ord: #{ord}" unless ord.is_a?(String) || ord.is_a?(Numeric)
+        raise ArgumentError, "invalid axis: #{axis}" if axis.uniq.size == 1
+
+        r_axis, c_axis = axis.map { |ax| ax.negative? ? ax + a.ndim : ax }
+
+        norm = if ord.is_a?(String)
+                 raise ArgumentError, "invalid ord: #{ord}" unless %w[fro nuc].include?(ord)
+
+                 if ord == 'fro'
+                   Numo::NMath.sqrt((a.abs**2).sum(axis: axis))
+                 else
+                   b = a.transpose(c_axis, r_axis).dup
+                   gesvd = :"#{blas_char(b)}gesvd"
+                   s, = Numo::TinyLinalg::Lapack.send(gesvd, b, jobu: 'N', jobvt: 'N')
+                   s.sum(axis: -1)
+                 end
+               else
+                 ord_inf = ord.infinite?
+                 if ord_inf.nil?
+                   case ord
+                   when -2
+                     b = a.transpose(c_axis, r_axis).dup
+                     gesvd = :"#{blas_char(b)}gesvd"
+                     s, = Numo::TinyLinalg::Lapack.send(gesvd, b, jobu: 'N', jobvt: 'N')
+                     s.min(axis: -1)
+                   when -1
+                     c_axis -= 1 if c_axis > r_axis
+                     a.abs.sum(axis: r_axis).min(axis: c_axis)
+                   when 1
+                     c_axis -= 1 if c_axis > r_axis
+                     a.abs.sum(axis: r_axis).max(axis: c_axis)
+                   when 2
+                     b = a.transpose(c_axis, r_axis).dup
+                     gesvd = :"#{blas_char(b)}gesvd"
+                     s, = Numo::TinyLinalg::Lapack.send(gesvd, b, jobu: 'N', jobvt: 'N')
+                     s.max(axis: -1)
+                   else
+                     raise ArgumentError, "invalid ord: #{ord}"
+                   end
+                 else
+                   r_axis -= 1 if r_axis > c_axis
+                   if ord_inf.positive?
+                     a.abs.sum(axis: c_axis).max(axis: r_axis)
+                   else
+                     a.abs.sum(axis: c_axis).min(axis: r_axis)
+                   end
+                 end
+               end
+        if keepdims
+          norm = Numo::NArray.asarray(norm) unless norm.is_a?(Numo::NArray)
+          norm = norm.reshape(*([1] * a.ndim))
+        end
+
+        norm
+      end
+    end
+
     # Computes the Cholesky decomposition of a symmetric / Hermitian positive-definite matrix.
     #
     # @example
@@ -399,6 +565,47 @@ module Numo
       Numo::TinyLinalg::Lapack.send(gesv, a.dup, b.dup)[1]
     end
 
+    # Solves linear equation `A * x = b` or `A * X = B` for `x` assuming `A` is a triangular matrix.
+    #
+    # @example
+    #   require 'numo/tiny_linalg'
+    #
+    #   Numo::Linalg = Numo::TinyLinalg unless defined?(Numo::Linalg)
+    #
+    #   a = Numo::DFloat.new(3, 3).rand.triu
+    #   b = Numo::DFloat.eye(3)
+    #
+    #   x = Numo::Linalg.solve(a, b)
+    #
+    #   pp x
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[16.1932, -52.0604, 30.5283],
+    #   #  [0, 8.61765, -17.9585],
+    #   #  [0, 0, 6.05735]]
+    #
+    #   pp (b - a.dot(x)).abs.max
+    #   # => 4.071100642430302e-16
+    #
+    # @param a [Numo::NArray] The n-by-n triangular matrix.
+    # @param b [Numo::NArray] The n right-hand side vector, or n-by-nrhs right-hand side matrix.
+    # @param lower [Boolean] The flag indicating whether to use the lower-triangular part of `a`.
+    # @return [Numo::NArray] The solusion vector / matrix `X`.
+    def solve_triangular(a, b, lower: false)
+      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, b)
+      raise ArgumentError, "invalid array type: #{a.class}, #{b.class}" if bchr == 'n'
+
+      trtrs = :"#{bchr}trtrs"
+      uplo = lower ? 'L' : 'U'
+      x, info = Numo::TinyLinalg::Lapack.send(trtrs, a, b.dup, uplo: uplo)
+      raise "wrong value is given to the #{info}-th argument of #{trtrs} used internally" if info.negative?
+
+      x
+    end
+
     # Computes the Singular Value Decomposition (SVD) of a matrix: `A = U * S * V^T`
     #
     # @example
@@ -534,11 +741,6 @@ module Numo
       raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
     end
 
-    # @!visibility private
-    def norm(*args)
-      raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"
-    end
-
     # @!visibility private
     def cond(*args)
       raise NotImplementedError, "#{__method__} is not yet implemented in Numo::TinyLinalg"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-tiny_linalg
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-03 00:00:00.000000000 Z
+date: 2024-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -57,6 +57,7 @@ files:
 - ext/numo/tiny_linalg/lapack/hegv.hpp
 - ext/numo/tiny_linalg/lapack/hegvd.hpp
 - ext/numo/tiny_linalg/lapack/hegvx.hpp
+- ext/numo/tiny_linalg/lapack/lange.hpp
 - ext/numo/tiny_linalg/lapack/orgqr.hpp
 - ext/numo/tiny_linalg/lapack/potrf.hpp
 - ext/numo/tiny_linalg/lapack/potrs.hpp
@@ -66,6 +67,7 @@ files:
 - ext/numo/tiny_linalg/lapack/sygv.hpp
 - ext/numo/tiny_linalg/lapack/sygvd.hpp
 - ext/numo/tiny_linalg/lapack/sygvx.hpp
+- ext/numo/tiny_linalg/lapack/trtrs.hpp
 - ext/numo/tiny_linalg/lapack/ungqr.hpp
 - ext/numo/tiny_linalg/tiny_linalg.cpp
 - ext/numo/tiny_linalg/tiny_linalg.hpp
@@ -97,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of