numo-linalg-alt 0.2.0 → 0.4.0

data/lib/numo/linalg.rb

@@ -444,6 +444,54 @@ module Numo
       u.dot(vh[0...rank, true]).conj.transpose
     end
 
+    # Computes the polar decomposition of a matrix.
+    #
+    # https://en.wikipedia.org/wiki/Polar_decomposition
+    #
+    # @example
+    #   require 'numo/linalg'
+    #
+    #   a = Numo::DFloat[[0.5, 1, 2], [1.5, 3, 4]]
+    #   u, p = Numo::Linalg.polar(a)
+    #   pp u.dot(p)
+    #   # =>
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[0.5, 1, 2],
+    #   #  [1.5, 3, 4]]
+    #   pp u.dot(u.transpose)
+    #   # =>
+    #   # Numo::DFloat#shape=[2,2]
+    #   # [[1, -1.68043e-16],
+    #   #  [-1.68043e-16, 1]]
+    #
+    #   u, p = Numo::Linalg.polar(a, side: 'left')
+    #   pp p.dot(u)
+    #   # =>
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[0.5, 1, 2],
+    #   #  [1.5, 3, 4]]
+    #
+    # @param a [Numo::NArray] The m-by-n matrix to be decomposed.
+    # @param side [String] The side of polar decomposition ('right' or 'left').
+    # @return [Array<Numo::NArray>] The unitary matrix `U` and the positive-semidefinite Hermitian matrix `P`
+    #   such that `A = U * P` if side='right', or `A = P * U` if side='left'.
+    def polar(a, side: 'right')
+      raise Numo::NArray::ShapeError, 'input array a must be 2-dimensional' if a.ndim != 2
+      raise ArugumentError, "invalid side: #{side}" unless %w[left right].include?(side)
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      s, w, vh = svd(a, driver: 'svd', job: 'S')
+      u = w.dot(vh)
+      p_mat = if side == 'right'
+                vh.transpose.conj.dot(s.diag).dot(vh)
+              else
+                w.dot(s.diag).dot(w.transpose.conj)
+              end
+      [u, p_mat]
+    end
+
     # Computes the QR decomposition of a matrix.
     #
     # @example
@@ -512,6 +560,186 @@ 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,
+    # and `T` is an upper triangular matrix (or quasi-upper triangular matrix in real case).
+    #
+    # @example
+    #   require 'numo/linalg'
+    #
+    #   a = Numo::DFloat[[0, 2, 3], [4, 5, 6], [7, 8, 9]]
+    #   t, z, sdim = Numo::Linalg.schur(a)
+    #   pp t
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[16.0104, 4.81155, 0.920982],
+    #   #  [0, -1.91242, 0.0274406],
+    #   #  [0, 0, -0.0979794]]
+    #   pp z
+    #   # =>
+    #   # Numo::DFloat#shape=[3,3]
+    #   # [[-0.219668, -0.94667, 0.235716],
+    #   #  [-0.527141, -0.0881306, -0.845195],
+    #   #  [-0.820895, 0.309918, 0.479669]]
+    #   pp sdim
+    #   # => 0
+    #   pp (a - z.dot(t).dot(z.transpose)).abs.max
+    #   # => 1.0658141036401503e-14
+    #
+    # @param a [Numo::NArray] The n-by-n square matrix.
+    # @param sort [String/Nil] The option for sorting eigenvalues ('lhp', 'rhp', 'iuc', 'ouc', or nil).
+    #   - 'lhp': eigenvalue.real < 0
+    #   - 'rhp': eigenvalue.real >= 0
+    #   - 'iuc': eigenvalue.abs <= 1
+    #   - 'ouc': eigenvalue.abs > 1
+    # @return [Array<Numo::NArray, Numo::NArray, Integer>] The Schur form `T`, the unitary matrix `Z`,
+    #   and the number of eigenvalues for which the sorting condition is true.
+    def schur(a, sort: nil)
+      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]
+      raise ArgumentError, "invalid sort: #{sort}" unless sort.nil? || %w[lhp rhp iuc ouc].include?(sort)
+
+      bchr = blas_char(a)
+      raise ArgumentError, "invalid array type: #{a.class}" if bchr == 'n'
+
+      fnc = :"#{bchr}gees"
+      if %w[d s].include?(bchr)
+        b, _wr, _wi, v, sdim, info = Numo::Linalg::Lapack.send(fnc, a.dup, jobvs: 'V', sort: sort)
+      else
+        b, _w, v, sdim, info = Numo::Linalg::Lapack.send(fnc, a.dup, jobvs: 'V', sort: sort)
+      end
+
+      n = a.shape[0]
+      raise "the #{-info}-th argument of #{fnc} had illegal value" if info.negative?
+      raise 'the QR algorithm failed to compute all the eigenvalues.' if info.positive? && info <= n
+      raise 'the eigenvalues could not be reordered.' if info == n + 1
+      raise 'after reordering, roundoff changed values of some complex eigenvalues.' if info == n + 2
+
+      [b, v, sdim]
+    end
+
     # Solves linear equation `A * x = b` or `A * X = B` for `x` from square matrix `A`.
     #
     # @example
@@ -921,6 +1149,46 @@ module Numo
       c
     end
 
+    # Computes the orthogonal Procrustes problem.
+    #
+    # https://en.wikipedia.org/wiki/Orthogonal_Procrustes_problem
+    #
+    # @example
+    #   require 'numo/linalg'
+    #
+    #   a = Numo::DFloat[[2, 0, 1], [-2, 0, 0]]
+    #   b = a.fliplr
+    #   r, scale = Numo::Linalg.orthogonal_procrustes(a, b)
+    #
+    #   pp b
+    #   # =>
+    #   # Numo::DFloat(view)#shape=[2,3]
+    #   # [[1, 0, 2],
+    #   #  [0, 0, -2]]
+    #   pp a.dot(r)
+    #   # =>
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[1, 0, 2],
+    #   #  [1.58669e-16, 0, -2]]
+    #   pp (b - a.dot(r)).abs.max
+    #   # =>
+    #   # 2.220446049250313e-16
+    #
+    # @param a [Numo::NArray] The first input matrix.
+    # @param b [Numo::NArray] The second input matrix.
+    # @return [Array<Numo::NArray, Float>] The orthogonal matrix `R` and the scale factor `scale`.
+    def orthogonal_procrustes(a, b)
+      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, "incompatible dimensions: a.shape = #{a.shape} != b.shape = #{b.shape}" if a.shape != b.shape
+
+      m = b.transpose.dot(a.conj).transpose
+      s, u, vt = svd(m, driver: 'svd', job: 'S')
+      r = u.dot(vt)
+      scale = s.sum
+      [r, scale]
+    end
+
     # Computes the eigenvalues and right and/or left eigenvectors of a general square matrix.
     #
     # @example
@@ -1195,6 +1463,60 @@ module Numo
       a_expm
     end
 
+    # Computes the matrix sine using the matrix exponential.
+    #
+    # @param a [Numo::NArray] The n-by-n square matrix.
+    # @return [Numo::NArray] The matrix sine of `a`.
+    def sinm(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'
+
+      b = a * 1.0i
+      if %w[z c].include?(bchr)
+        -0.5i * (expm(b) - expm(-b))
+      else
+        expm(b).imag
+      end
+    end
+
+    # Computes the matrix cosine using the matrix exponential.
+    #
+    # @param a [Numo::NArray] The n-by-n square matrix.
+    # @return [Numo::NArray] The matrix cosine of `a`.
+    def cosm(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'
+
+      b = a * 1.0i
+      if %w[z c].include?(bchr)
+        0.5 * (expm(b) + expm(-b))
+      else
+        expm(b).real
+      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.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - yoshoku
@@ -13,14 +13,14 @@ dependencies:
   name: numo-narray-alt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.3
 description: |
@@ -50,12 +50,16 @@ files:
 - ext/numo/linalg/converter.c
 - ext/numo/linalg/converter.h
 - ext/numo/linalg/extconf.rb
+- ext/numo/linalg/lapack/gees.c
+- ext/numo/linalg/lapack/gees.h
 - ext/numo/linalg/lapack/geev.c
 - ext/numo/linalg/lapack/geev.h
 - ext/numo/linalg/lapack/gelsd.c
 - 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
@@ -68,6 +72,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
@@ -86,6 +92,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
@@ -110,6 +118,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
@@ -124,7 +134,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.2.0/
+  documentation_uri: https://gemdocs.org/gems/numo-linalg-alt/0.4.0/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: