txt: ## dist_cpan-FRITH-Math-Libgsl-LinearAlgebra.md
  ## Chunk 1 of 3
  [![Actions Status](https://github.com/frithnanth/raku-Math-Libgsl-LinearAlgebra/workflows/test/badge.svg)](https://github.com/frithnanth/raku-Math-Libgsl-LinearAlgebra/actions) [![Build Status](https://travis-ci.org/frithnanth/raku-Math-Libgsl-LinearAlgebra.svg?branch=master)](https://travis-ci.org/frithnanth/raku-Math-Libgsl-LinearAlgebra)
  
  # NAME
  
  Math::Libgsl::LinearAlgebra - An interface to libgsl, the Gnu Scientific Library - Linear Algebra.
  
  # SYNOPSIS
  
  ```
  use Math::Libgsl::LinearAlgebra;
  
  ```
  
  # DESCRIPTION
  
  Math::Libgsl::LinearAlgebra is an interface to the linear algebra functions of libgsl, the GNU Scientific Library. This package provides both the low-level interface to the C library (Raw) and a more comfortable interface layer for the Raku programmer.
  
  This module provides functions for Num and Complex data types.
  
  ## Num
  
  ### LU-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> List)
  
  This function factorizes the matrix A into the LU decomposition PA = LU. The factorization is done in place, so on output the diagonal and upper triangular (or trapezoidal) part of the input matrix A contain the matrix U. The lower triangular (or trapezoidal) part of the input matrix (excluding the diagonal) contains L. The diagonal elements of L are unity, and are not stored. The return value is a List: the sign of the permutation and a permutation object, which encodes the permutation matrix P. In case of error a failure object is returned.
  
  ### LU-solve(Math::Libgsl::Matrix $LU where \*.matrix.size1 == $LU.matrix.size2, Math::Libgsl::Permutation $p where \*.size == $LU.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $LU.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the square system Ax = b using the LU decomposition of A into (LU, p) given by the output of LU-decomp. In case of error a failure object is returned.
  
  ### LU-svx(Math::Libgsl::Matrix $LU where \*.matrix.size1 == $LU.matrix.size2, Math::Libgsl::Permutation $p where \*.size == $LU.matrix.size1, Math::Libgsl::Vector $x where \*.size == $LU.matrix.size1 --> Int)
  
  This function solves the square system Ax = b in-place using the precomputed LU decomposition of A into (LU, p). On input $x should contain the right-hand side b, which is replaced by the solution on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### LU-refine(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Matrix $LU where { $LU.matrix.size1 == $LU.matrix.size2 && $A.matrix.size1 == $LU.matrix.size2 }, Math::Libgsl::Permutation $p where \*.size == $LU.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $LU.matrix.size1, Math::Libgsl::Vector $x where \*.vector.size == $LU.matrix.size1 --> Int)
  
  This function applies an iterative improvement to x, the solution of Ax = b, from the precomputed LU decomposition of A into (LU, p). This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### LU-invert(Math::Libgsl::Matrix $LU, Math::Libgsl::Permutation $p where \*.size == $LU.matrix.size1 --> Math::Libgsl::Matrix)
  
  This function computes the inverse of a matrix A from its LU decomposition (LU, p), returning the matrix inverse. In case of error a failure object is returned.
  
  ### LU-det(Math::Libgsl::Matrix $LU, Int $signum where \* ~~ -1|1 --> Num)
  
  This function computes the determinant of a matrix A from its LU decomposition, $LU, and the sign of the permutation, $signum. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### LU-lndet(Math::Libgsl::Matrix $LU --> Num)
  
  This function computes the determinant the logarithm of the absolute value of the determinant of a matrix A, ln |det(A)|, from its LU decomposition, $LU. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### LU-sgndet(Math::Libgsl::Matrix $LU, Int $signum where \* ~~ -1|1 --> Int)
  
  This function computes the sign or phase factor of the determinant of a matrix A, det(A)/|det(A)| from its LU decomposition, $LU. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QR-decomp(Math::Libgsl::Matrix $A --> Math::Libgsl::Vector)
  
  This function factorizes the M-by-N matrix $A into the QR decomposition A = QR. On output the diagonal and upper triangular part of the input matrix contain the matrix R. The returned vector and the columns of the lower triangular part of the matrix A contain the Householder coefficients and Householder vectors which encode the orthogonal matrix Q. In case of error a failure object is returned.
  
  ### QR-solve(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == $QR.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $QR.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the square system Ax = b using the QR decomposition of A held in ($QR, $tau) which must have been computed previously with QR-decomp(). In case of error a failure object is returned.
  
  ### QR-svx(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == $QR.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $QR.matrix.size1 --> Int)
  
  This function solves the square system Ax = b in-place using the QR decomposition of A held in ($QR, $tau) which must have been computed previously by QR-decomp(). On input $x should contain the right-hand side b, which is replaced by the solution on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QR-lssolve(Math::Libgsl::Matrix $QR where \*.matrix.size1 ≥ $QR.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == $QR.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $QR.matrix.size1 --> List)
  
  This function finds the least squares solution to the overdetermined system Ax = b where the matrix A has more rows than columns. The least squares solution minimizes the Euclidean norm of the residual, ||Ax − b||. The routine requires as input the QR decomposition of A into ($QR, $tau) given by QR-decomp(). The function returns a List of two Math::Libgsl::Vector objects: the solution x and the residual. In case of error a failure object is returned.
  
  ### QR-QTvec(Math::Libgsl::Matrix $QR, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2), Math::Libgsl::Vector $v where \*.vector.size == $QR.matrix.size1 --> Int)
  
  These function applies the matrix T(Q) encoded in the decomposition (QR, tau) to the vector $v, storing the result T(Q) v in $v. The matrix multiplication is carried out directly using the encoding of the Householder vectors without needing to form the full matrix T(Q). This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QR-Qvec(Math::Libgsl::Matrix $QR, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2), Math::Libgsl::Vector $v where \*.vector.size == $QR.matrix.size1 --> Int)
  
  This function applies the matrix Q encoded in the decomposition ($QR, $tau) to the vector $v, storing the result Qv in $v. The matrix multiplication is carried out directly using the encoding of the Householder vectors without needing to form the full matrix Q. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QR-QTmat(Math::Libgsl::Matrix $QR, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2), Math::Libgsl::Matrix $B where \*.matrix.size1 == $QR.matrix.size1 --> Int)
  
  This function applies the matrix T(Q) encoded in the decomposition ($QR, $tau) to the M-by-K matrix $B, storing the result T(Q) B in $B. The matrix multiplication is carried out directly using the encoding of the Householder vectors without needing to form the full matrix T(Q). This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QR-Rsolve(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $QR.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the triangular system Rx = b and returns the Math::Libgsl::Vector object $x. In case of error a failure object is returned.
  
  ### QR-Rsvx(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $QR.matrix.size2 --> Int)
  
  This function solves the triangular system Rx = b for x in-place. On input $x should contain the right-hand side b and is replaced by the solution on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QR-unpack(Math::Libgsl::Matrix $QR, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2) --> List)
  
  This function unpacks the encoded QR decomposition ($QR, $tau) into the matrices Q and R. The function returns a List of two Math::Libgsl::Matrix objects: $Q which is M-by-M and $R which is M-by-N. In case of error a failure object is returned.
  
  ### QR-QRsolve(Math::Libgsl::Matrix $Q, Math::Libgsl::Matrix $R where { $R.matrix.size1 == $R.matrix.size2 && $Q.matrix.size1 == $R.matrix.size1 }, Math::Libgsl::Vector $b where \*.vector.size == $R.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the system Rx = T(Q) b for x. It can be used when the QR decomposition of a matrix is available in unpacked form as ($Q, $R). The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### QR-update(Math::Libgsl::Matrix $Q, Math::Libgsl::Matrix $R where { $Q.matrix.size1 == $R.matrix.size1 && $Q.matrix.size2 == $R.matrix.size1 }, Math::Libgsl::Vector $w where \*.vector.size == $R.matrix.size1, Math::Libgsl::Vector $v where \*.vector.size == $R.matrix.size2 --> Int)
  
  This function performs a rank-1 update wT(v) of the QR decomposition ($Q, $R). The update is given by Q'R' = Q(R+wT(v)) where the output matrices $Q and $R are also orthogonal and right triangular. Note that $w is destroyed by the update. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### R-solve(Math::Libgsl::Matrix $R where \*.matrix.size1 == $R.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $R.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the triangular system Rx = b for the N-by-N matrix $R. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### R-svx(Math::Libgsl::Matrix $R where \*.matrix.size1 == $R.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $R.matrix.size2 --> Int)
  
  This function solves the triangular system Rx = b in-place. On input $x should contain the right-hand side b, which is replaced by the solution on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QRPT-decomp(Math::Libgsl::Matrix $A --> List)
  
  This function factorizes the M-by-N matrix $A into the QRT(P) decomposition A = QRT(P). On output the diagonal and upper triangular part of the input matrix contain the matrix R. The function's output is a List of three objects: the Math::Libgsl::Vector $tau, the Math::Libgsl::Permutation $p and the sign of the permutation Int $signum. In case of error a failure object is returned.
  
  ### QRPT-decomp2(Math::Libgsl::Matrix $A --> List)
  
  This function factorizes the matrix $A into the decomposition A = QRT(P) without modifying $A itself. The function returns a List: the Math::Libgsl::Matrix $Q, the Math::Libgsl::Matrix $R, the Math::Libgsl::Permutation $p, and the sign of the permutation Int $signum. In case of error a failure object is returned.
  
  ### QRPT-solve(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2), Math::Libgsl::Permutation $p where \*.p.size == $QR.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $QR.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the square system Ax = b using the QRT(P) decomposition of A held in ($QR, $tau, $p) which must have been computed previously by QRPT-decomp. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### QRPT-svx(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2), Math::Libgsl::Permutation $p where \*.p.size == $QR.matrix.size1, Math::Libgsl::Vector $x where \*.vector.size == $QR.matrix.size2 --> Int)
  
  This function solves the square system Ax = b in-place using the QRT(P) decomposition of A held in ($QR, $tau, $p). On input $x should contain the right-hand side b, which is replaced by the solution on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QRPT-lssolve(Math::Libgsl::Matrix $QR where \*.matrix.size1 ≥ $QR.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2), Math::Libgsl::Permutation $p where \*.p.size == $QR.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $QR.matrix.size1 --> List)
  
  This function finds the least squares solution to the overdetermined system Ax = b where the matrix A has more rows than columns and is assumed to have full rank. The least squares solution minimizes the Euclidean norm of the residual, ||b − Ax||. The routine requires as input the QR decomposition of A into ($QR, $tau, $p) given by QRPT-decomp. The function returns a List of two Math::Libgsl::Vector objects: the solution x and the residual. In case of error a failure object is returned.
  
  ### QRPT-lssolve2(Math::Libgsl::Matrix $QR where \*.matrix.size1 ≥ $QR.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == min($QR.matrix.size1, $QR.matrix.size2), Math::Libgsl::Permutation $p where \*.p.size == $QR.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $QR.matrix.size1, Int $rank where 0 < \* ≤ $QR.matrix.size2 --> List)
  
  This function finds the least squares solution to the overdetermined system Ax = b where the matrix A has more rows than columns and has rank given by the input rank. If the user does not know the rank of A, it may be estimated by calling QRPT-rank. The routine requires as input the QR decomposition of A into ($QR, $tau, $p) given by QRPT-decomp. The function returns a List of two Math::Libgsl::Vector objects: the solution x and the residual. In case of error a failure object is returned.
  
  ### QRPT-QRsolve(Math::Libgsl::Matrix $Q where \*.matrix.size1 == $Q.matrix.size2, Math::Libgsl::Matrix $R where {$R.matrix.size1 == $R.matrix.size2 && $R.matrix.size1 == $Q.matrix.size1}, Math::Libgsl::Permutation $p where \*.p.size == $Q.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $Q.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the square system RT(P) x = T(Q) b for x. It can be used when the QR decomposition of a matrix is available in unpacked form as ($Q, $R). The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### QRPT-update(Math::Libgsl::Matrix $Q, Math::Libgsl::Matrix $R where { $Q.matrix.size1 == $R.matrix.size1 && $Q.matrix.size2 == $R.matrix.size1 }, Math::Libgsl::Permutation $p where \*.p.size == $R.matrix.size1, Math::Libgsl::Vector $w where \*.vector.size == $R.matrix.size1, Math::Libgsl::Vector $v where \*.vector.size == $R.matrix.size2 --> Int)
  
  This function performs a rank-1 update wT(v) of the QRT(P) decomposition ($Q, $R, $p). The update is given by Q' R' = Q(R + wT(v) P) where the output matrices Q' and R' are also orthogonal and right triangular. Note that $w is destroyed by the update. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QRPT-Rsolve(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $QR.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $QR.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the triangular system RT(P) x = b for the N-by-N matrix R contained in $QR. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### QRPT-Rsvx(Math::Libgsl::Matrix $QR where \*.matrix.size1 == $QR.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $QR.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $QR.matrix.size2 --> Int)
  
  This function solves the triangular system RT(P) x = b in-place for the N-by-N matrix R contained in $QR. On input $x should contain the right-hand side b, which is replaced by the solution on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### QRPT-rank(Math::Libgsl::Matrix $QR, Num() $tolerance --> Int)
  
  This function returns the rank of the triangular matrix R contained in $QR.
  
  ### QRPT-rcond(Math::Libgsl::Matrix $QR where \*.matrix.size1 ≥ $QR.matrix.size2 --> Num)
  
  This function returns the reciprocal condition number (using the 1-norm) of the R factor, stored in the upper triangle of $QR. In case of error a failure object is returned.
  
  ### LQ-decomp(Math::Libgsl::Matrix $A --> Math::Libgsl::Vector)
  
  This function factorizes the M-by-N matrix $A into the LQ decomposition A = LQ. On output the diagonal and lower trapezoidal part of the input matrix contain the matrix L. This function returns the Math::Libgsl::Vector $tau. The vector $tau and the elements above the diagonal of the matrix $A contain the Householder coefficients and Householder vectors which encode the orthogonal matrix Q. In case of error a failure object is returned.
  
  ### LQ-solve-T(Math::Libgsl::Matrix $LQ where \*.matrix.size1 == $LQ.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == min($LQ.matrix.size1, $LQ.matrix.size2), Math::Libgsl::Vector $b where \*.vector.size == $LQ.matrix.size2 --> Math::Libgsl::Vector)
  
  This function finds the solution to the system Ax = b. The routine requires as input the LQ decomposition of A into ($LQ, $tau) given by LQ-decomp. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### LQ-svx-T(Math::Libgsl::Matrix $LQ where \*.matrix.size1 == $LQ.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == min($LQ.matrix.size1, $LQ.matrix.size2), --> Math::Libgsl::Vector)
  
  This function finds the solution to the system Ax = b. The routine requires as input the LQ decomposition of A into ($LQ, $tau) given by LQ-decomp. On input $x should contain the right-hand side b, which is replaced by the solution on output. In case of error a failure object is returned.
  
  ### LQ-lssolve-T(Math::Libgsl::Matrix $LQ where \*.matrix.size1 ≥ $LQ.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == min($LQ.matrix.size1, $LQ.matrix.size2), Math::Libgsl::Vector $b where \*.vector.size == $LQ.matrix.size1 --> List)
  
  This function finds the minimum norm least squares solution to the underdetermined system Ax = b, where the M-by-N matrix A has M ≤ N. The routine requires as input the LQ decomposition of A into ($LQ, $tau) given by LQ-decomp. The function returns a List of two Math::Libgsl::Vector objects: the solution x and the residual. In case of error a failure object is returned.
  
  ### LQ-Lsolve-T(Math::Libgsl::Matrix $LQ where \*.matrix.size1 == $LQ.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $LQ.matrix.size1 --> Math::Libgsl::Vector)
  
  The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### LQ-Lsvx-T(Math::Libgsl::Matrix $LQ where \*.matrix.size1 == $LQ.matrix.size2 --> Math::Libgsl::Vector)
  
  On input $x should contain the right-hand side b, which is replaced by the solution on output. In case of error a failure object is returned.
  
  ### L-solve-T(Math::Libgsl::Matrix $L where \*.matrix.size1 == $L.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $L.matrix.size2 --> Math::Libgsl::Vector)
  
  The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### LQ-vecQ(Math::Libgsl::Matrix $LQ, Math::Libgsl::Vector $tau where \*.vector.size == min($LQ.matrix.size1, $LQ.matrix.size2), Math::Libgsl::Vector $v where \*.vector.size == $LQ.matrix.size1 --> Int)
  
  This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### LQ-vecQT(Math::Libgsl::Matrix $LQ, Math::Libgsl::Vector $tau where \*.vector.size == min($LQ.matrix.size1, $LQ.matrix.size2), Math::Libgsl::Vector $v where \*.vector.size == $LQ.matrix.size1 --> Int)
  
  This function applies T(Q) to the vector v, storing the result T(Q) v in $v on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### LQ-unpack(Math::Libgsl::Matrix $LQ, Math::Libgsl::Vector $tau where \*.vector.size == min($LQ.matrix.size1, $LQ.matrix.size2) --> List)
  
  This function unpacks the encoded LQ decomposition ($LQ, $tau). The function outputs a List: the Math::Libgsl::Matrix $Q and the Math::Libgsl::Matrix $L. In case of error a failure object is returned.
  
  ### LQ-update(Math::Libgsl::Matrix $Q, Math::Libgsl::Matrix $L where { $L.matrix.size2 == $Q.matrix.size1 && $L.matrix.size2 == $Q.matrix.size2 }, Math::Libgsl::Vector $v where \*.vector.size == $L.matrix.size1, Math::Libgsl::Vector $w where \*.vector.size == $L.matrix.size2 --> Int)
  
  This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### LQ-LQsolve(Math::Libgsl::Matrix $Q, Math::Libgsl::Matrix $L where { $L.matrix.size1 == $L.matrix.size2 && $Q.matrix.size1 == $L.matrix.size2 }, Math::Libgsl::Vector $b where \*.vector.size == $L.matrix.size2 --> Math::Libgsl::Vector)
  
  In case of error a failure object is returned.
  
  ### COD-decomp(Math::Libgsl::Matrix $A --> List)
  
  ### COD-decomp-e(Math::Libgsl::Matrix $A, Num() $tolerance --> List)
  
  These functions factor the M-by-N matrix $A into the decomposition A = QRZT(P). On output the matrix R₁₁ is stored in the upper rank-by-rank block of $A. The matrices Q and Z are encoded in packed storage in $A on output. This function outputs a List: two Math::Libgsl::Vector objects which contain the Householder scalars corresponding to the matrices Q and Z respectively, a Math::Libgsl::Permutation object which contain the permutation matrix P, and the rank of $A. In case of error a failure object is returned.
  
  ### COD-lssolve(Math::Libgsl::Matrix $QRZT where \*.matrix.size1 ≥ $QRZT.matrix.size2, Math::Libgsl::Vector $tau-Q where \*.vector.size == min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Vector $tau-Z where \*.vector.size == min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Permutation $p where \*.p.size == $QRZT.matrix.size2, Int $rank where \* ≤ min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Vector $b where \*.vector.size == $QRZT.matrix.size1 --> List)
  
  This function finds the unique minimum norm least squares solution to the overdetermined system Ax = b where the matrix $A has more rows than columns. The least squares solution minimizes the Euclidean norm of the residual, ||b − Ax|| as well as the norm of the solution ||x||. The routine requires as input the QRZT decomposition of $A into ($QRZT, $tau\_Q, $tau\_Z, $p, $rank) given by COD-decomp. The function outputs a List: a Math::Libgsl::Vector object which is the solution x, and a Math::Libgsl::Vector object which stores the residual b − Ax. In case of error a failure object is returned.
  
  ### COD-lssolve2(Math::Libgsl::Matrix $QRZT where \*.matrix.size1 ≥ $QRZT.matrix.size2, Math::Libgsl::Vector $tau-Q where \*.vector.size == min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Vector $tau-Z where \*.vector.size == min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Permutation $p where \*.p.size == $QRZT.matrix.size2, Int $rank where \* ≤ min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Vector $b where \*.vector.size == $QRZT.matrix.size1, Num() $lambda --> List)
  
  This function finds the solution to the regularized least squares problem in Tikhonov standard form, minₓ||b − Ax||² + λ²||x||². The routine requires as input the QRZT decomposition of A into ($QRZT, $tau\_Q, $tau\_Z, $p, $rank) given by COD-decomp. The parameter λ is supplied in $lambda. The function outputs a List: a Math::Libgsl::Vector object which is the solution x, and a Math::Libgsl::Vector object which stores the residual b − Ax. In case of error a failure object is returned.
  
  ### COD-unpack(Math::Libgsl::Matrix $QRZT, Math::Libgsl::Vector $tau-Q where \*.vector.size == min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Vector $tau-Z where \*.vector.size == min($QRZT.matrix.size1, $QRZT.matrix.size2), Int $rank where \* ≤ min($QRZT.matrix.size1, $QRZT.matrix.size2) --> List)
  
  This function unpacks the encoded QRZT decomposition ($QRZT, $tau\_Q, $tau\_Z, $rank). The function returns a List of three Math::Libgsl::Matrix objects: $Q, $R, $Z. In case of error a failure object is returned.
  
  ### COD-matZ(Math::Libgsl::Matrix $QRZT, Math::Libgsl::Vector $tau-Z where \*.vector.size == min($QRZT.matrix.size1, $QRZT.matrix.size2), Math::Libgsl::Matrix $A where \*.matrix.size2 == $QRZT.matrix.size2, Int $rank --> Int)
  
  This function multiplies the input matrix $A on the right by Z, A’ = AZ using the encoded QRZT decomposition ($QRZT, $tau\_Z, $rank). This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### SV-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2 --> List)
  
  This function factorizes the M-by-N matrix $A into the singular value decomposition A = UST(V) for M ≥ N. On output the matrix $A is replaced by U. The function returns a List: a Math::Libgsl::Matrix object which contains the elements of V in untransposed form, and a Math::Libgsl::Vector object which contains the diagonal elements of the singular value matrix S. The singular values are non-negative and form a non-increasing sequence from S₁ to Sₙ. In case of error a failure object is returned.
  
  ### SV-decomp-mod(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2 --> List)
  
  This function computes the SVD using the modified Golub-Reinsch algorithm, which is faster for M ≫ N. The function returns a List: a Math::Libgsl::Matrix object which contains the elements of V in untransposed form, and a Math::Libgsl::Vector object which contains the diagonal elements of the singular value matrix S. The singular values are non-negative and form a non-increasing sequence from S₁ to Sₙ. In case of error a failure object is returned.
  
  ### SV-decomp-jacobi(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2 --> List)
  
  This function computes the SVD of the M-by-N matrix A using one-sided Jacobi orthogonalization for M ≥ N. The function returns a List: a Math::Libgsl::Matrix object which contains the elements of V in untransposed form, and a Math::Libgsl::Vector object which contains the diagonal elements of the singular value matrix S. The singular values are non-negative and form a non-increasing sequence from S₁ to Sₙ. In case of error a failure object is returned.
  
  ### SV-solve(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2, Math::Libgsl::Matrix $V where { $V.matrix.size1 == $V.matrix.size2 && $V.matrix.size1 == $A.matrix.size2 }, Math::Libgsl::Vector $S where \*.vector.size == $A.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $A.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the system Ax = b using the singular value decomposition (U, S, V) of A which must have been computed previously with COD-decomp. Only non-zero singular values are used in computing the solution. The parts of the solution corresponding to singular values of zero are ignored. Other singular values can be edited out by setting them to zero before calling this function. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### SV-leverage(Math::Libgsl::Matrix $A --> Math::Libgsl::Vector)
  
  This function computes the statistical leverage values hᵢ of a matrix A using its singular value decomposition (U, S, V) previously computed with COD-decomp. The function returns a Math::Libgsl::Vector object which stores the diagonal values of the matrix A(T(A)A)⁻¹T(A) and depend only on the matrix U which is the input to this function. In case of error a failure object is returned.
  
  ### cholesky-decomp1(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Int)
  
  This function factorizes the symmetric, positive-definite square matrix $A into the Cholesky decomposition A = LT(L). On input, the values from the diagonal and lower-triangular part of the matrix $A are used (the upper triangular part is ignored). On output the diagonal and lower triangular part of the input matrix $A contain the matrix L, while the upper triangular part contains the original matrix. If the matrix is not positive-definite then the decomposition will fail, returning the error code GSL\_EDOM. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::