numo-linalg-alt 0.3.0 → 0.4.1

data/ext/numo/linalg/linalg.c

@@ -42,9 +42,11 @@ char blas_char(VALUE nary_arr) {
     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 (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';
       }
@@ -97,8 +99,7 @@ static VALUE linalg_blas_call(int argc, VALUE* argv, VALUE self) {
   }
 
   char fn_str[256];
-  snprintf(fn_str, sizeof(fn_str), "%c%s",
-           type, rb_id2name(rb_to_id(rb_to_symbol(fn_name))));
+  snprintf(fn_str, sizeof(fn_str), "%c%s", type, rb_id2name(rb_to_id(rb_to_symbol(fn_name))));
   ID fn_id = rb_intern(fn_str);
   size_t n = RARRAY_LEN(nary_arr);
   VALUE ret = Qnil;
@@ -146,7 +147,8 @@ static VALUE linalg_dot(VALUE self, VALUE a_, VALUE b_) {
       ret = rb_funcall(rb_mLinalgBlas, 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))) {
+      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 {
@@ -160,7 +162,8 @@ static VALUE linalg_dot(VALUE self, VALUE a_, VALUE b_) {
   } 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))) {
+      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 {
@@ -172,13 +175,15 @@ static VALUE linalg_dot(VALUE self, VALUE a_, VALUE b_) {
       ret = rb_funcallv_kw(rb_mLinalgBlas, 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))) {
+      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))) {
+      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 {
@@ -202,7 +207,8 @@ void Init_linalg(void) {
 
   /**
    * Document-module: Numo::Linalg
-   * Numo::Linalg is a subset library from Numo::Linalg consisting only of methods used in Machine Learning algorithms.
+   * Numo::Linalg is a subset library from Numo::Linalg consisting only of methods used
+   * in Machine Learning algorithms.
    */
   rb_mLinalg = rb_define_module_under(rb_mNumo, "Linalg");
   /**
@@ -228,7 +234,7 @@ void Init_linalg(void) {
    *   @param [Numo::NArray] a
    *   @return [String]
    */
-  rb_define_module_function(rb_mLinalg, "blas_char", RUBY_METHOD_FUNC(linalg_blas_char), -1);
+  rb_define_module_function(rb_mLinalg, "blas_char", linalg_blas_char, -1);
   /**
    * Calculates dot product of two vectors / matrices.
    *
@@ -237,7 +243,7 @@ void Init_linalg(void) {
    *   @param [Numo::NArray] b
    *   @return [Float|Complex|Numo::NArray]
    */
-  rb_define_module_function(rb_mLinalg, "dot", RUBY_METHOD_FUNC(linalg_dot), 2);
+  rb_define_module_function(rb_mLinalg, "dot", linalg_dot, 2);
   /**
    * Calls BLAS function prefixed with BLAS char.
    *
@@ -247,7 +253,7 @@ void Init_linalg(void) {
    * @example
    *   Numo::Linalg::Blas.call(:gemv, a, b)
    */
-  rb_define_singleton_method(rb_mLinalgBlas, "call", RUBY_METHOD_FUNC(linalg_blas_call), -1);
+  rb_define_singleton_method(rb_mLinalgBlas, "call", linalg_blas_call, -1);
 
   define_linalg_blas_dot(rb_mLinalgBlas);
   define_linalg_blas_dot_sub(rb_mLinalgBlas);
@@ -255,9 +261,13 @@ void Init_linalg(void) {
   define_linalg_blas_gemv(rb_mLinalgBlas);
   define_linalg_blas_nrm2(rb_mLinalgBlas);
   define_linalg_lapack_geqrf(rb_mLinalgLapack);
+  define_linalg_lapack_gerqf(rb_mLinalgLapack);
   define_linalg_lapack_orgqr(rb_mLinalgLapack);
+  define_linalg_lapack_orgrq(rb_mLinalgLapack);
   define_linalg_lapack_ungqr(rb_mLinalgLapack);
+  define_linalg_lapack_ungrq(rb_mLinalgLapack);
   define_linalg_lapack_gees(rb_mLinalgLapack);
+  define_linalg_lapack_gges(rb_mLinalgLapack);
   define_linalg_lapack_geev(rb_mLinalgLapack);
   define_linalg_lapack_gesv(rb_mLinalgLapack);
   define_linalg_lapack_gesvd(rb_mLinalgLapack);
@@ -285,6 +295,7 @@ void Init_linalg(void) {
   define_linalg_lapack_gelsd(rb_mLinalgLapack);
   define_linalg_lapack_sytrf(rb_mLinalgLapack);
   define_linalg_lapack_hetrf(rb_mLinalgLapack);
+  define_linalg_lapack_gebal(rb_mLinalgLapack);
 
   rb_define_alias(rb_singleton_class(rb_mLinalgBlas), "znrm2", "dznrm2");
   rb_define_alias(rb_singleton_class(rb_mLinalgBlas), "cnrm2", "scnrm2");

data/ext/numo/linalg/linalg.h

@@ -51,16 +51,19 @@
 #include "blas/gemv.h"
 #include "blas/nrm2.h"
 
+#include "lapack/gebal.h"
 #include "lapack/gees.h"
 #include "lapack/geev.h"
 #include "lapack/gelsd.h"
 #include "lapack/geqrf.h"
+#include "lapack/gerqf.h"
 #include "lapack/gesdd.h"
 #include "lapack/gesv.h"
 #include "lapack/gesvd.h"
 #include "lapack/getrf.h"
 #include "lapack/getri.h"
 #include "lapack/getrs.h"
+#include "lapack/gges.h"
 #include "lapack/heev.h"
 #include "lapack/heevd.h"
 #include "lapack/heevr.h"
@@ -70,6 +73,7 @@
 #include "lapack/hetrf.h"
 #include "lapack/lange.h"
 #include "lapack/orgqr.h"
+#include "lapack/orgrq.h"
 #include "lapack/potrf.h"
 #include "lapack/potri.h"
 #include "lapack/potrs.h"
@@ -82,5 +86,6 @@
 #include "lapack/sytrf.h"
 #include "lapack/trtrs.h"
 #include "lapack/ungqr.h"
+#include "lapack/ungrq.h"
 
 #endif /* NUMO_LINALG_ALT_LINALG_H */

data/ext/numo/linalg/util.c

@@ -20,6 +20,14 @@ char get_jobz(VALUE val) {
   return jobz;
 }
 
+char get_jobvs(VALUE val) {
+  const char jobvs = NUM2CHR(val);
+  if (jobvs != 'N' && jobvs != 'V') {
+    rb_raise(rb_eArgError, "jobvs must be 'N' or 'V'");
+  }
+  return jobvs;
+}
+
 char get_range(VALUE val) {
   const char range = NUM2CHR(val);
 

data/ext/numo/linalg/util.h

@@ -8,6 +8,7 @@
 
 lapack_int get_itype(VALUE val);
 char get_jobz(VALUE val);
+char get_jobvs(VALUE val);
 char get_range(VALUE val);
 char get_uplo(VALUE val);
 int get_matrix_layout(VALUE val);

data/lib/numo/linalg/version.rb

@@ -5,6 +5,6 @@ module Numo
   # Numo::Linalg Alternative (numo-linalg-alt) is an alternative to Numo::Linalg.
   module Linalg
     # The version of numo-linalg-alt you install.
-    VERSION = '0.3.0'
+    VERSION = '0.4.1'
   end
 end

data/lib/numo/linalg.rb

@@ -560,6 +560,127 @@ module Numo
       [q, r]
     end
 
+    # Computes the RQ decomposition of a matrix.
+    #
+    # @example
+    #   require 'numo/linalg'
+    #
+    #   a = Numo::DFloat.new(2, 3).rand
+    #   r, q = Numo::Linalg.rq(a)
+    #   pp r
+    #   # =>
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[0, -0.381748, -0.79309],
+    #   #  [0, 0, -0.41502]]
+    #   pp q
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[0.227957, 0.874475, -0.428169],
+    #   #  [0.844617, -0.396377, -0.359872],
+    #   #  [-0.484416, -0.279603, -0.828953]]
+    #   puts (a - r.dot(q)).abs.max
+    #   # => 5.551115123125783e-17
+    #
+    #   r, q = Numo::Linalg.rq(a, mode: 'economic')
+    #   pp r
+    #   # =>
+    #   # Numo::DFloat#shape=[2,2]
+    #   # [[-0.381748, -0.79309],
+    #   #  [0, -0.41502]]
+    #   pp q
+    #   # =>
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[0.844617, -0.396377, -0.359872],
+    #   #  [-0.484416, -0.279603, -0.828953]]
+    #   puts (a - r.dot(q)).abs.max
+    #   # => 5.551115123125783e-17
+    #
+    # @param a [Numo::NArray] The m-by-n matrix to be decomposed.
+    # @param mode [String] The mode of decomposition.
+    #   - "full"     -- returns both R [m, n] and Q [n, n],
+    #   - "r"        -- returns only R,
+    #   - "economic" -- returns both R [m, k] and Q [k, n], where k = min(m, n).
+    # @return [Array<Numo::NArray>/Numo::NArray]
+    #   if mode='full' or 'economic', returns [R, Q].
+    #   if mode='r', returns R.
+    def rq(a, mode: 'full') # rubocop:disable  Metrics/AbcSize
+      raise Numo::NArray::ShapeError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise ArgumentError, "invalid mode: #{mode}" unless %w[full r economic].include?(mode)
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      fnc = :"#{bchr}gerqf"
+      rq, tau, info = Numo::Linalg::Lapack.send(fnc, a.dup)
+      raise "the #{-info}-th argument of #{fnc} had illegal value" if info.negative?
+
+      m, n = rq.shape
+      r = rq.triu(n - m).dup
+      r = r[true, (n - m)...n].dup if mode == 'economic' && n > m
+
+      return r if mode == 'r'
+
+      fnc = %w[d s].include?(bchr) ? :"#{bchr}orgrq" : :"#{bchr}ungrq"
+      tmp = if n < m
+              rq[(m - n)...m, 0...n].dup
+            elsif mode == 'economic'
+              rq.dup
+            else
+              rq.class.zeros(n, n).tap { |mat| mat[(n - m)...n, true] = rq }
+            end
+
+      q, info = Numo::Linalg::Lapack.send(fnc, tmp, tau)
+      raise "the #{-info}-th argument of #{fnc} had illegal value" if info.negative?
+
+      [r, q]
+    end
+
+    # Computes the QZ decomposition (generalized Schur decomposition) of a pair of square matrices.
+    #
+    # The QZ decomposition is given by `A = Q * AA * Z^H` and `B = Q * BB * Z^H`,
+    # where `A` and `B` are the input matrices, `Q` and `Z` are unitary matrices,
+    # and `AA` and `BB` are upper triangular matrices (or quasi-upper triangular matrices in real case).
+    #
+    # @example
+    #   require 'numo/linalg'
+    #
+    #   a = Numo::DFloat.new(5, 5).rand
+    #   b = Numo::DFloat.new(5, 5).rand
+    #
+    #   aa, bb, q, z = Numo::Linalg.qz(a, b)
+    #
+    #   pp (a - q.dot(aa).dot(z.transpose)).abs.max
+    #   # => 1.7763568394002505e-15
+    #   pp (b - q.dot(bb).dot(z.transpose)).abs.max
+    #   # => 1.1102230246251565e-15
+    #
+    # @param a [Numo::NArray] The n-by-n square matrix.
+    # @param b [Numo::NArray] The n-by-n square matrix.
+    # @return [Array<Numo::NArray, Numo::NArray, Numo::NArray, Numo::NArray>]
+    #   The matrices `AA`, `BB`, `Q`, and `Z` such that `A = Q * AA * Z^H` and `B = Q * BB * Z^H`.
+    def qz(a, b) # rubocop:disable Metrics/AbcSize
+      raise Numo::NArray::ShapeError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise Numo::NArray::ShapeError, 'input array b must be 2-dimensional' if b.ndim != 2
+      raise Numo::NArray::ShapeError, 'input array a must be square' if a.shape[0] != a.shape[1]
+      raise Numo::NArray::ShapeError, 'input array b must be square' if b.shape[0] != b.shape[1]
+      raise Numo::NArray::ShapeError, "incompatible dimensions: a.shape = #{a.shape} != b.shape = #{b.shape}" if a.shape != b.shape
+
+      bchr = blas_char(a, b)
+      raise ArgumentError, "invalid array type: #{a.class}, #{b.class}" if bchr == 'n'
+
+      fnc = :"#{bchr}gges"
+      if %w[d s].include?(bchr)
+        aa, bb, _ar, _ai, _beta, q, z, _sdim, info = Numo::Linalg::Lapack.send(fnc, a.dup, b.dup)
+      else
+        aa, bb, _alpha, _beta, q, z, _sdim, info = Numo::Linalg::Lapack.send(fnc, a.dup, b.dup)
+      end
+
+      raise "the #{-info}-th argument of #{fnc} had illegal value" if info.negative?
+      raise 'the QZ algorithm failed.' if info.positive?
+
+      [aa, bb, q, z]
+    end
+
     # Computes the Schur decomposition of a square matrix.
     # The Schur decomposition is given by `A = Z * T * Z^H`,
     # where `A` is the input matrix, `Z` is a unitary matrix,
@@ -604,11 +725,10 @@ module Numo
       raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
 
       fnc = :"#{bchr}gees"
-      b = a.dup
       if %w[d s].include?(bchr)
-        _wr, _wi, v, sdim, info = Numo::Linalg::Lapack.send(fnc, b, jobvs: 'V', sort: sort)
+        b, _wr, _wi, v, sdim, info = Numo::Linalg::Lapack.send(fnc, a.dup, jobvs: 'V', sort: sort)
       else
-        _w, v, sdim, info = Numo::Linalg::Lapack.send(fnc, b, jobvs: 'V', sort: sort)
+        b, _w, v, sdim, info = Numo::Linalg::Lapack.send(fnc, a.dup, jobvs: 'V', sort: sort)
       end
 
       n = a.shape[0]
@@ -1069,6 +1189,102 @@ module Numo
       [r, scale]
     end
 
+    # Computes a diagonal similarity transformation that balances a square matrix.
+    #
+    # @example
+    #   require 'numo/linalg'
+    #
+    #   a = Numo::DFloat[[1, 0, 0], [1, 2, 0], [1, 2, 3]]
+    #   b, h = Numo::Linalg.matrix_balance(a)
+    #   pp b
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[3, 2, 1],
+    #   #  [0, 2, 1],
+    #   #  [0, 0, 1]]
+    #   pp h
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[0, 0, 1],
+    #   #  [0, 1, 0],
+    #   #  [1, 0, 0]]
+    #   pp (Numo::Linalg.inv(h).dot(a).dot(h) - b).abs.max
+    #   # => 0.0
+    #
+    # @param a [Numo::NArray] The n-by-n square matrix.
+    # @param permute [Boolean] The flag indicating whether to permute the matrix.
+    # @param scale [Boolean] The flag indicating whether to scale the matrix.
+    # @param separate [Boolean] The flag indicating whether to return scaling factors and permutation indices
+    #   separately.
+    # @return [Array<Numo::NArray, Numo::NArray>] if `separate` is `false`, the balanced matrix and the
+    #   similarity transformation matrix `H` ([b, h]). if `separate` is `true`, the balanced matrix, the
+    #   scaling factors, and the permutation indices ([b, scaler, perm]).
+    def matrix_balance(a, permute: true, scale: true, separate: false) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      raise Numo::NArray::ShapeError, 'input array a must be 2-dimensional' if a.ndim != 2
+
+      n = a.shape[0]
+      raise ArgumentError, 'input array a must be square' if a.shape[1] != n
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      job = if permute && scale
+              'B'
+            elsif permute && !scale
+              'P'
+            elsif !permute && scale
+              'S'
+            else
+              'N'
+            end
+      fnc = :"#{bchr}gebal"
+      b, lo, hi, prm_scl, info = Numo::Linalg::Lapack.send(fnc, a.dup, job: job)
+
+      raise "the #{info.abs}-th argument of #{fnc} had illegal value" if info.negative?
+
+      # convert from Fortran style index to Ruby style index.
+      lo -= 1
+      hi -= 1
+      iprm_scl = Numo::Int32.cast(prm_scl) - 1
+
+      # extract scaling factors
+      scaler = prm_scl.class.ones(n)
+      scaler[lo...(hi + 1)] = prm_scl[lo...(hi + 1)]
+
+      # extract permutation indices
+      perm = Numo::Int32.new(n).seq
+      if hi < n - 1
+        iprm_scl[(hi + 1)...n].to_a.reverse.each.with_index(1) do |s, i|
+          j = n - i
+          next if s == j
+
+          tmp_ls, tmp_lj = perm[[s, j]].to_a
+          tmp_rj, tmp_rs = perm[[j, s]].to_a
+          perm[[s, j]] = [tmp_rj, tmp_rs]
+          perm[[j, s]] = [tmp_ls, tmp_lj]
+        end
+      end
+      if lo > 0 # rubocop:disable Style/NumericPredicate
+        iprm_scl[0...lo].to_a.each_with_index do |s, j|
+          next if s == j
+
+          tmp_ls, tmp_lj = perm[[s, j]].to_a
+          tmp_rj, tmp_rs = perm[[j, s]].to_a
+          perm[[s, j]] = [tmp_rj, tmp_rs]
+          perm[[j, s]] = [tmp_ls, tmp_lj]
+        end
+      end
+
+      return [b, scaler, perm] if separate
+
+      # construct inverse permutation matrix
+      inv_perm = Numo::Int32.zeros(n)
+      inv_perm[perm] = Numo::Int32.new(n).seq
+      h = scaler.diag[inv_perm, true].dup
+
+      [b, h]
+    end
+
     # Computes the eigenvalues and right and/or left eigenvectors of a general square matrix.
     #
     # @example
@@ -1381,6 +1597,22 @@ module Numo
       end
     end
 
+    # Computes the matrix tangent.
+    #
+    # @param a [Numo::NArray] The n-by-n square matrix.
+    # @return [Numo::NArray] The matrix tangent of `a`.
+    def tanm(a)
+      raise Numo::NArray::ShapeError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise Numo::NArray::ShapeError, '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'
+
+      a_sin = sinm(a)
+      a_cos = cosm(a)
+      a_sin.dot(Numo::Linalg.inv(a_cos))
+    end
+
     # Computes the inverse of a matrix using its LU decomposition.
     #
     # @param lu [Numo::NArray] The LU decomposition of the n-by-n matrix `A`.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numo-linalg-alt
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - yoshoku
@@ -50,6 +50,8 @@ files:
 - ext/numo/linalg/converter.c
 - ext/numo/linalg/converter.h
 - ext/numo/linalg/extconf.rb
+- ext/numo/linalg/lapack/gebal.c
+- ext/numo/linalg/lapack/gebal.h
 - ext/numo/linalg/lapack/gees.c
 - ext/numo/linalg/lapack/gees.h
 - ext/numo/linalg/lapack/geev.c
@@ -58,6 +60,8 @@ files:
 - ext/numo/linalg/lapack/gelsd.h
 - ext/numo/linalg/lapack/geqrf.c
 - ext/numo/linalg/lapack/geqrf.h
+- ext/numo/linalg/lapack/gerqf.c
+- ext/numo/linalg/lapack/gerqf.h
 - ext/numo/linalg/lapack/gesdd.c
 - ext/numo/linalg/lapack/gesdd.h
 - ext/numo/linalg/lapack/gesv.c
@@ -70,6 +74,8 @@ files:
 - ext/numo/linalg/lapack/getri.h
 - ext/numo/linalg/lapack/getrs.c
 - ext/numo/linalg/lapack/getrs.h
+- ext/numo/linalg/lapack/gges.c
+- ext/numo/linalg/lapack/gges.h
 - ext/numo/linalg/lapack/heev.c
 - ext/numo/linalg/lapack/heev.h
 - ext/numo/linalg/lapack/heevd.c
@@ -88,6 +94,8 @@ files:
 - ext/numo/linalg/lapack/lange.h
 - ext/numo/linalg/lapack/orgqr.c
 - ext/numo/linalg/lapack/orgqr.h
+- ext/numo/linalg/lapack/orgrq.c
+- ext/numo/linalg/lapack/orgrq.h
 - ext/numo/linalg/lapack/potrf.c
 - ext/numo/linalg/lapack/potrf.h
 - ext/numo/linalg/lapack/potri.c
@@ -112,6 +120,8 @@ files:
 - ext/numo/linalg/lapack/trtrs.h
 - ext/numo/linalg/lapack/ungqr.c
 - ext/numo/linalg/lapack/ungqr.h
+- ext/numo/linalg/lapack/ungrq.c
+- ext/numo/linalg/lapack/ungrq.h
 - ext/numo/linalg/linalg.c
 - ext/numo/linalg/linalg.h
 - ext/numo/linalg/util.c
@@ -126,7 +136,7 @@ metadata:
   homepage_uri: https://github.com/yoshoku/numo-linalg-alt
   source_code_uri: https://github.com/yoshoku/numo-linalg-alt
   changelog_uri: https://github.com/yoshoku/numo-linalg-alt/blob/main/CHANGELOG.md
-  documentation_uri: https://gemdocs.org/gems/numo-linalg-alt/0.3.0/
+  documentation_uri: https://gemdocs.org/gems/numo-linalg-alt/0.4.1/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: