numo-tiny_linalg 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d640eb16ee97cc31ec5a5c15d9600b9cd3b01395954e5fab80110251445ff56b
-  data.tar.gz: 5133899439b92170f1cffd13a3ce10f792ce5e4434e733d7767b88a7ce3f30a2
+  metadata.gz: c508a2c2f31a965c26824084f1eeb1a2caf53ea82a3d23e523980d6cf78e6259
+  data.tar.gz: 4bffa14a1a73bfb60230c65fa35c98eeb957e176b8af2003f9c3e5b8aaf89b19
 SHA512:
-  metadata.gz: d53553a0e5aabb16012377acaf2b1b3ff47e039dad2f44ec7c70a8e62a038153366b1b5a6d57a7d2c6e44c5ffb991d29132f3eda3a0cb6ff38987b117f7f6ccb
-  data.tar.gz: e8fa35b07eac5f69d4a1a98118cb34bc2cbcfd506852659b0c4a59990a047326348b5d7a612940fb861b635d03ec4efa4420302f01f616f979b58b63b965defa
+  metadata.gz: 4ad7a9af39fdc0c5ffb9ba7fc51dcf037fe8ffe7d81c33c70a0c669b384127929efee3a9ceb8440b7d1ec10c79ee66b362aed7098befbe02a892d4490961f169
+  data.tar.gz: 91c9935714ef5b929718affc9cfae518f6e08f85063f673f26ffa7c137bb7fe62d41c20386704657dccb89feebf57bdaed5b182750c6f0fe3ad5b20e55cc4221

data/CHANGELOG.md

@@ -1,4 +1,15 @@
 ## [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.
 
 ## [[0.3.4](https://github.com/yoshoku/numo-tiny_linalg/compare/v0.3.3...v0.3.4)] - 2023-11-19
 - Bump OpenBLAS to be downloaded from 0.3.24 to 0.3.25.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Atsushi Tatsuma
+Copyright (c) 2023-2024 Atsushi Tatsuma
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/ext/numo/tiny_linalg/extconf.rb

@@ -46,8 +46,8 @@ if build_openblas
 
   VENDOR_DIR = File.expand_path("#{__dir__}/../../../vendor")
   TINYLINALG_DIR = File.expand_path("#{__dir__}/../../../lib/numo/tiny_linalg")
-  OPENBLAS_VER = '0.3.25'
-  OPENBLAS_KEY = '48384e324cd1cdcfbdb0d2e16ca55327'
+  OPENBLAS_VER = '0.3.26'
+  OPENBLAS_KEY = 'bd496a1c81769ed19a161c1f8f904ccd'
   OPENBLAS_URI = "https://github.com/OpenMathLib/OpenBLAS/archive/v#{OPENBLAS_VER}.tar.gz"
   OPENBLAS_TGZ = "#{VENDOR_DIR}/tmp/openblas.tgz"
 
@@ -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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2023 Atsushi Tatsuma
+ * Copyright (c) 2023-2024 Atsushi Tatsuma
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -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/ext/numo/tiny_linalg/tiny_linalg.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2023 Atsushi Tatsuma
+ * Copyright (c) 2023-2024 Atsushi Tatsuma
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

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.4'
+    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
@@ -138,7 +304,7 @@ module Numo
       bchr = blas_char(a)
       raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
 
-      fnc = "#{bchr}potrf".to_sym
+      fnc = :"#{bchr}potrf"
       c, _info = Numo::TinyLinalg::Lapack.send(fnc, a.dup, uplo: uplo)
 
       case uplo
@@ -180,7 +346,7 @@ module Numo
       bchr = blas_char(a, b)
       raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
 
-      fnc = "#{bchr}potrs".to_sym
+      fnc = :"#{bchr}potrs"
       x, _info = Numo::TinyLinalg::Lapack.send(fnc, a, b.dup, uplo: uplo)
       x
     end
@@ -205,7 +371,7 @@ module Numo
       bchr = blas_char(a)
       raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
 
-      getrf = "#{bchr}getrf".to_sym
+      getrf = :"#{bchr}getrf"
       lu, piv, info = Numo::TinyLinalg::Lapack.send(getrf, a.dup)
 
       if info.zero?
@@ -248,8 +414,8 @@ module Numo
       bchr = blas_char(a)
       raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
 
-      getrf = "#{bchr}getrf".to_sym
-      getri = "#{bchr}getri".to_sym
+      getrf = :"#{bchr}getrf"
+      getri = :"#{bchr}getri"
 
       lu, piv, info = Numo::TinyLinalg::Lapack.send(getrf, a.dup)
       if info.zero?
@@ -336,7 +502,7 @@ module Numo
       bchr = blas_char(a)
       raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
 
-      geqrf = "#{bchr}geqrf".to_sym
+      geqrf = :"#{bchr}geqrf"
       qr, tau, = Numo::TinyLinalg::Lapack.send(geqrf, a.dup)
 
       return [qr, tau] if mode == 'raw'
@@ -346,7 +512,7 @@ module Numo
 
       return r if mode == 'r'
 
-      org_ung_qr = %w[d s].include?(bchr) ? "#{bchr}orgqr".to_sym : "#{bchr}ungqr".to_sym
+      org_ung_qr = %w[d s].include?(bchr) ? :"#{bchr}orgqr" : :"#{bchr}ungqr"
 
       q = if m < n
             Numo::TinyLinalg::Lapack.send(org_ung_qr, qr[true, 0...m], tau)[0]
@@ -395,10 +561,51 @@ module Numo
       bchr = blas_char(a, b)
       raise ArgumentError, "invalid array type: #{a.class}, #{b.class}" if bchr == 'n'
 
-      gesv = "#{bchr}gesv".to_sym
+      gesv = :"#{bchr}gesv"
       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
@@ -443,10 +650,10 @@ module Numo
 
       case driver.to_s
       when 'sdd'
-        gesdd = "#{bchr}gesdd".to_sym
+        gesdd = :"#{bchr}gesdd"
         s, u, vt, info = Numo::TinyLinalg::Lapack.send(gesdd, a.dup, jobz: job)
       when 'svd'
-        gesvd = "#{bchr}gesvd".to_sym
+        gesvd = :"#{bchr}gesvd"
         s, u, vt, info = Numo::TinyLinalg::Lapack.send(gesvd, a.dup, jobu: job, jobvt: job)
       else
         raise ArgumentError, "invalid driver: #{driver}"
@@ -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.4
+  version: 0.3.6
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-19 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.20
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Numo::TinyLinalg is a subset library from Numo::Linalg consisting only of