txt: ## dist_cpan-FRITH-Math-Libgsl-LinearAlgebra.md
  ## Chunk 2 of 3
  gsl-error.
  
  ### cholesky-solve(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $A.matrix.size1 --> Math::Libgsl::Vector)
  
  These functions solve the system Ax = b using the Cholesky decomposition of $A which must have been previously computed by cholesky-decomp1. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### cholesky-svx(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $A.matrix.size1 --> Int)
  
  This function solves the system Ax = b in-place using the Cholesky decomposition of $A which must have been previously computed by cholesky-decomp1. 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.
  
  ### cholesky-solve-mat(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Matrix $B where \*.matrix.size1 == $A.matrix.size1 --> Math::Libgsl::Matrix)
  
  In case of error a failure object is returned.
  
  ### cholesky-svx-mat(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Matrix $X where \*.matrix.size1 == $A.matrix.size1 --> Int)
  
  This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### cholesky-invert(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Int)
  
  These functions compute the inverse of a matrix from its Cholesky decomposition $A, which must have been previously computed by cholesky-decomp1. On output, the inverse is stored in-place in $A. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### cholesky-decomp2(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Math::Libgsl::Vector)
  
  This function calculates a diagonal scaling transformation S for the symmetric, positive-definite square matrix $A, and then computes the Cholesky decomposition SAS = 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 of the input matrix is overwritten with T(L) (the diagonal terms being identical for both L and L T). If the matrix is not positive-definite then the decomposition will fail, returning the error code GSL\_EDOM. The function returns a Math::Libgsl::Vector object which stores the diagonal scale factors. In case of error a failure object is returned.
  
  ### cholesky-solve2(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Vector $s where \*.vector.size == $A.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $A.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the system (SAS)(S⁻¹ x) = Sb using the Cholesky decomposition of SAS held in the matrix $A which must have been previously computed by cholesky-decomp2. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### cholesky-svx2(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Vector $s where \*.size == $A.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $A.matrix.size2 --> Int)
  
  This function solves the system (SAS)(S⁻¹ x) = Sb using the Cholesky decomposition of SAS held in the matrix $A which must have been previously computed by cholesky-decomp2. 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.
  
  ### cholesky-decomp-unit(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Math::Libgsl::Vector)
  
  The function returns the Math::Libgsl::Vector $d. In case of error a failure object is returned.
  
  ### cholesky-scale(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Math::Libgsl::Vector)
  
  This function calculates a diagonal scaling transformation of the symmetric, positive definite matrix $A, such that SAS has a condition number within a factor of N of the matrix of smallest possible condition number over all possible diagonal scalings. The function outputs a Math::Libgsl::Vector object which contains the scale factors. In case of error a failure object is returned.
  
  ### cholesky-scale-apply(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Vector $s where \*.vector.size == $A.matrix.size2 --> Int)
  
  This function applies the scaling transformation S to the matrix $A. On output, $A is replaced by SAS. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### cholesky-rcond(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Num)
  
  This function estimates the reciprocal condition number (using the 1-norm) of the symmetric positive definite matrix A, using its Cholesky decomposition provided in $A. The function returns a Math::Libgsl::Vector object which stores the reciprocal condition number estimate, defined as 1/(||A||₁ · ||A⁻¹||₁). In case of error a failure object is returned.
  
  ### pcholesky-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Math::Libgsl::Permutation)
  
  This function factors the symmetric, positive-definite square matrix $A into the Pivoted Cholesky decomposition PAT(P) = LDT(L). On input, the values from the diagonal and lower-triangular part of the matrix $A are used to construct the factorization. On output the diagonal of the input matrix $A stores the diagonal elements of D, and the lower triangular portion of $A contains the matrix L. Since L has ones on its diagonal these do not need to be explicitely stored. The upper triangular portion of $A is unmodified. The function returns the Math::Libgsl::Permutation object which stores the permutation matrix P. In case of error a failure object is returned.
  
  ### pcholesky-solve(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $LDLT.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the system Ax = b using the Pivoted Cholesky decomposition of A held in the matrix $LDLT and permutation $p which must have been previously computed by pcholesky-decomp. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### pcholesky-svx(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1, Math::Libgsl::Vector $x where \*.vector.size == $LDLT.matrix.size1 --> Int)
  
  This function solves the system Ax = b using the Pivoted Cholesky decomposition of A held in the matrix $LDLT and permutation $p which must have been previously computed by pcholesky-decomp. On input, $x contains the right hand side vector b which is replaced by the solution vector on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### pcholesky-decomp2(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> List)
  
  This function computes the pivoted Cholesky factorization of the matrix SAS, where the input matrix $A is symmetric and positive definite, and the diagonal scaling matrix S is computed to reduce the condition number of $A as much as possible. On input, the values from the diagonal and lower-triangular part of the matrix $A are used to construct the factorization. On output the diagonal of the input matrix $A stores the diagonal elements of D, and the lower triangular portion of $A contains the matrix L. Since L has ones on its diagonal these do not need to be explicitely stored. The upper triangular portion of $A is unmodified. The function returns a List: the permutation matrix P is stored in a Math::Libgsl::Permutation object, the diagonal scaling transformation is stored in a Math::Libgsl::Vector object. In case of error a failure object is returned.
  
  ### pcholesky-solve2(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1, Math::Libgsl::Vector $s where \*.vector.size == $LDLT.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $LDLT.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the system (SAS)(S⁻¹x) = Sb using the Pivoted Cholesky decomposition of SAS held in the matrix $LDLT, permutation $p, and vector $S, which must have been previously computed by pcholesky-decomp2. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### pcholesky-svx2(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1, Math::Libgsl::Vector $s where \*.vector.size == $LDLT.matrix.size1, Math::Libgsl::Vector $x where \*.vector.size == $LDLT.matrix.size1 --> Int)
  
  This function solves the system (SAS)(S⁻¹x) = Sb using the Pivoted Cholesky decomposition of SAS held in the matrix $LDLT, permutation $p, and vector $S, which must have been previously computed by pcholesky-decomp2. On input, $x contains the right hand side vector b which is replaced by the solution vector on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### pcholesky-invert(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1 --> Math::Libgsl::Matrix)
  
  This function computes the inverse of the matrix A, using the Pivoted Cholesky decomposition stored in $LDLT and $p. The function returns the Math::Libgsl::Matrix A⁻¹. In case of error a failure object is returned.
  
  ### pcholesky-rcond(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1 --> Num)
  
  This function estimates the reciprocal condition number (using the 1-norm) of the symmetric positive definite matrix A, using its pivoted Cholesky decomposition provided in $LDLT. The function returns the reciprocal condition number estimate, defined as 1/(||A||₁ · ||A⁻¹||₁). This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### mcholesky-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Bool :$perturbation = True --> List)
  
  This function factors the symmetric, indefinite square matrix $A into the Modified Cholesky decomposition P(A + E)T(P) = LDT(L). On input, the values from the diagonal and lower-triangular part of the matrix $A are used to construct the factorization. On output the diagonal of the input matrix $A stores the diagonal elements of D, and the lower triangular portion of $A contains the matrix L. Since L has ones on its diagonal these do not need to be explicitely stored. The upper triangular portion of $A is unmodified. The function returns a List: the permutation matrix P, stored in a Math::Libgsl::Permutation object and the diagonal perturbation matrix, stored in a Math::Libgsl::Vector object. In case of error a failure object is returned.
  
  ### mcholesky-solve(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1, Math::Libgsl::Vector $b where \*.vector.size == $LDLT.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the perturbed system (A + E)x = b using the Cholesky decomposition of A + E held in the matrix $LDLT and permutation $p which must have been previously computed by mcholesky-decomp. The function returns the Math::Libgsl::Vector $x. In case of error a failure object is returned.
  
  ### mcholesky-svx(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1, Math::Libgsl::Vector $x where \*.vector.size == $LDLT.matrix.size1 --> Int)
  
  This function solves the perturbed system (A + E)x = b using the Cholesky decomposition of A + E held in the matrix $LDLT and permutation $p which must have been previously computed by mcholesky-decomp. On input, $x contains the right hand side vector b which is replaced by the solution vector on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### mcholesky-rcond(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1 --> Num)
  
  This function estimates the reciprocal condition number (using the 1-norm) of the perturbed matrix A+E, using its pivoted Cholesky decomposition provided in $LDLT. The function returns the reciprocal condition number estimate, defined as 1/(||A + E||₁ · ||(A + E)⁻¹||₁). In case of error a failure object is returned.
  
  ### mcholesky-invert(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Permutation $p where \*.p.size == $LDLT.matrix.size1 --> Math::Libgsl::Matrix)
  
  The function returns the inverted matrix. In case of error a failure object is returned.
  
  ### ldlt-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Int)
  
  This function factorizes the symmetric, non-singular square matrix $A into the decomposition A = LDT(L). On input, the values from the diagonal and lower-triangular part of the matrix $A are used. The upper triangle of $A is used as temporary workspace. On output the diagonal of $A contains the matrix D and the lower triangle of $A contains the unit lower triangular matrix L. The matrix 1-norm, ||A||₁ is stored in the upper right corner on output This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error. This function is available only in the C library starting from v2.6.
  
  ### ldlt-solve(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $LDLT.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the system Ax = b using the LDT(L) decomposition of A held in the matrix $LDLT which must have been previously computed by ldlt-decomp. In case of error a failure object is returned. This function is available only in the C library starting from v2.6.
  
  ### ldlt-svx(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $LDLT.matrix.size1 --> Int)
  
  This function solves the system Ax = b using the LDT(L) decomposition of A held in the matrix $LDLT which must have been previously computed by ldlt-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. This function is available only in the C library starting from v2.6.
  
  ### ldlt-rcond(Math::Libgsl::Matrix $LDLT where \*.matrix.size1 == $LDLT.matrix.size2 --> Num)
  
  This function estimates the reciprocal condition number (using the 1-norm) of the symmetric nonsingular matrix A, using its LDT(L) decomposition provided in $LDLT. The function returns the reciprocal condition number estimate, defined as 1/(||A + E||₁ · ||(A + E)⁻¹||₁). In case of error a failure object is returned. This function is available only in the C library starting from v2.6.
  
  ### symmtd-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Math::Libgsl::Vector)
  
  This function factorizes the symmetric square matrix $A into the symmetric tridiagonal decomposition QTT(Q). On output the diagonal and subdiagonal part of the input matrix $A contain the tridiagonal matrix T. The remaining lower triangular part of the input matrix contains the Householder vectors which, together with the Householder coefficients tau returned as a Math::Libgsl::Vector object, encode the orthogonal matrix Q. The upper triangular part of $A is not referenced. In case of error a failure object is returned.
  
  ### symmtd-unpack(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == $A.matrix.size1 - 1 --> List)
  
  This function unpacks the encoded symmetric tridiagonal decomposition ($A, $tau) obtained from symmtd-decomp. The function returns a List: the orthogonal matrix $Q as a Math::Libgsl::Matrix, the vector of diagonal elements $diag as a Math::Libgsl::Vector, and the vector of subdiagonal elements $subdiag as a Math::Libgsl::Vector. In case of error a failure object is returned.
  
  ### symmtd-unpack-T(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> List)
  
  This function unpacks the diagonal and subdiagonal of the encoded symmetric tridiagonal decomposition ($A, $tau) obtained from symmtd-decomp. The function returns a List of two Math::Libgsl::Vector: $diag and $subdiag. In case of error a failure object is returned.
  
  ### hessenberg-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Math::Libgsl::Vector)
  
  This function computes the Hessenberg decomposition of the matrix $A by applying the similarity transformation H = T(U)AU. On output, H is stored in the upper portion of $A. The information required to construct the matrix U is stored in the lower triangular portion of $A. U is a product of N−2 Householder matrices. The Householder vectors are stored in the lower portion of $A (below the subdiagonal) and the Householder coefficients are returned as a Math::Libgsl::Vector. In case of error a failure object is returned.
  
  ### hessenberg-unpack(Math::Libgsl::Matrix $H where \*.matrix.size1 == $H.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == $H.matrix.size1 --> Math::Libgsl::Matrix)
  
  This function constructs the orthogonal matrix U from the information stored in the Hessenberg matrix $H along with the vector $tau. $H and $tau are outputs from hessenberg-decomp. The function returns the Math::Libgsl::Matrix which stores $U. In case of error a failure object is returned.
  
  ### hessenberg-unpack-accum(Math::Libgsl::Matrix $H where \*.matrix.size1 == $H.matrix.size2, Math::Libgsl::Vector $tau where \*.vector.size == $H.matrix.size1 --> Math::Libgsl::Matrix)
  
  This function is similar to hessenberg-unpack, except it accumulates the matrix U into V, so that V′ = VU. The function returns the Math::Libgsl::Matrix which stores $V. In case of error a failure object is returned.
  
  ### hessenberg-set-zero(Math::Libgsl::Matrix $H where \*.matrix.size1 == $H.matrix.size2 --> Int)
  
  This function sets the lower triangular portion of $H, below the subdiagonal, to zero. It is useful for clearing out the Householder vectors after calling hessenberg-decomp. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### hesstri-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2, Math::Libgsl::Matrix $B where { $B.matrix.size1 == $A.matrix.size1 && $B.matrix.size2 == $A.matrix.size2}, Bool :$similarity = True --> List)
  
  This function computes the Hessenberg-Triangular decomposition of the matrix pair ($A, $B). On output, H is stored in $A, and R is stored in $B. If the $similarity Bool parameter is True (default), then the similarity transformations are returned as a List of Math::Libgsl::Matrix objects. In case of error a failure object is returned.
  
  ### bidiag-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2 --> List)
  
  This function factorizes the M-by-N matrix $A into bidiagonal form UBT(V). The diagonal and superdiagonal of the matrix B are stored in the diagonal and superdiagonal of $A. The orthogonal matrices U and V are stored as compressed Householder vectors in the remaining elements of $A. This function returns a List of Math::Libgsl::Vector objects: the two Householder coefficients $tau\_U and $tau\_V. In case of error a failure object is returned.
  
  ### bidiag-unpack(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2, Math::Libgsl::Vector $tau\_U where \*.vector.size == $A.matrix.size2, Math::Libgsl::Vector $tau\_V where \*.vector.size == $A.matrix.size2 - 1 --> List)
  
  This function unpacks the bidiagonal decomposition of $A produced by bidiag-decomp, ($A, $tau\_U, $tau\_V) into the separate orthogonal matrices U, V and the diagonal vector diag and superdiagonal superdiag. Note that U is stored as a compact M-by-N orthogonal matrix satisfying T(U)U = I for efficiency. The function returns a List of four objects: the Math::Libgsl::Matrix $U and $V, and the Math::Libgsl::Vector $diag and $sdiag. In case of error a failure object is returned.
  
  ### bidiag-unpack2(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2, Math::Libgsl::Vector $tau\_U where \*.vector.size == $A.matrix.size2, Math::Libgsl::Vector $tau\_V where \*.vector.size == $A.matrix.size2 - 1 --> Math::Libgsl::Matrix)
  
  This function unpacks the bidiagonal decomposition of $A produced by bidiag-decomp, ($A, $tau\_U, $tau\_V) into the separate orthogonal matrices U, V and the diagonal vector diag and superdiagonal superdiag. The matrix U is stored in-place in $A. The function returns the Math::Libgsl::Matrix object $V. In case of error a failure object is returned.
  
  ### bidiag-unpack-B(Math::Libgsl::Matrix $A where \*.matrix.size1 ≥ $A.matrix.size2 --> List)
  
  This function unpacks the diagonal and superdiagonal of the bidiagonal decomposition of $A from bidiag-decomp. The function returns a List of two objects: the Math::Libgsl::Vector $diag and $sdiag. In case of error a failure object is returned.
  
  ### givens(Num() $a, Num() $b --> List)
  
  This function computes c = cos θ and s = sin θ so that the Givens matrix G(θ) acting on the vector (a, b) produces (r, 0), with r = √ a² + b². The function returns a List of Num: the c and s elements of the Givens matrix.
  
  ### givens-gv(Math::Libgsl::Vector $v, Int, $i, Int $j, Num() $c, Num() $s)
  
  This function applies the Givens rotation defined by c = cos θ and s = sin θ to the i and j elements of v. On output, (v(i), v(j)) ← G(θ)(v(i), v(j)). This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### householder-transform(Math::Libgsl::Vector $w --> Num)
  
  This function prepares a Householder transformation H = I − τvT(v) which can be used to zero all the elements of the input vector $w except the first. On output the Householder vector v is stored in $w and the scalar τ is returned. The householder vector v is normalized so that v[0] = 1, however this 1 is not stored in the output vector. Instead, $w[0] is set to the first element of the transformed vector, so that if u = Hw, w[0] = u[0] on output and the remainder of u is zero. This function returns a Num: $τ.
  
  ### householder-hm(Num() $tau, Math::Libgsl::Vector $v, Math::Libgsl::Matrix $A --> Int)
  
  This function applies the Householder matrix H defined by the scalar $tau and the vector $v to the left-hand side of the matrix $A. On output the result HA is stored in $A. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### householder-mh(Num() $tau, Math::Libgsl::Vector $v, Math::Libgsl::Matrix $A --> Int)
  
  This function applies the Householder matrix H defined by the scalar $tau and the vector $v to the right-hand side of the matrix $A. On output the result AH is stored in $A. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### householder-hv(Num() $tau, Math::Libgsl::Vector $v, Math::Libgsl::Vector $w --> Int)
  
  This function applies the Householder transformation H defined by the scalar $tau and the vector $v to the vector $w. On output the result Hw is stored in w. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### HH-solve(Math::Libgsl::Matrix $A where \*.matrix.size1 ≤ $A.matrix.size2, Math::Libgsl::Vector $b where \*.vector.size == $A.matrix.size1 --> Math::Libgsl::Vector)
  
  This function solves the system Ax = b directly using Householder transformations. $b is not modified. The matrix $A is destroyed by the Householder transformations. The function returns a Math::Libgsl::Vector object: the solution $x. In case of error a failure object is returned.
  
  ### HH-svx(Math::Libgsl::Matrix $A where \*.matrix.size1 ≤ $A.matrix.size2, Math::Libgsl::Vector $x where \*.vector.size == $A.matrix.size2 --> Int)
  
  This function solves the system Ax = b in-place using Householder transformations. On input $x should contain the right-hand side b, which is replaced by the solution on output. The matrix $A is destroyed by the Householder transformations. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tridiag-solve(Math::Libgsl::Vector $diag, Math::Libgsl::Vector $abovediag where \*.vector.size == $diag.vector.size - 1, Math::Libgsl::Vector $belowdiag where \*.vector.size == $diag.vector.size - 1, Math::Libgsl::Vector $rhs where \*.vector.size == $diag.vector.size --> Math::Libgsl::Vector)
  
  This function solves the general N-by-N system Ax = b where A is tridiagonal (N ≥ 2). The super-diagonal and sub-diagonal vectors must be one element shorter than the diagonal vector diag. The function returns the Math::Libgsl::Vector solution $x. In case of error a failure object is returned.
  
  ### tridiag-symm-solve(Math::Libgsl::Vector $diag, Math::Libgsl::Vector $offdiag where \*.vector.size == $diag.vector.size - 1, Math::Libgsl::Vector $rhs where \*.vector.size == $diag.vector.size --> Math::Libgsl::Vector)
  
  This function solves the general N-by-N system Ax = b where A is symmetric tridiagonal (N ≥ 2). The off-diagonal vector $offdiag must be one element shorter than the diagonal vector $diag. The function returns the Math::Libgsl::Vector solution $x. In case of error a failure object is returned.
  
  ### tridiag-cyc-solve(Math::Libgsl::Vector $diag where \*.vector.size ≥ 3, Math::Libgsl::Vector $abovediag where \*.vector.size == $diag.vector.size, Math::Libgsl::Vector $belowdiag where \*.vector.size == $diag.vector.size, Math::Libgsl::Vector $rhs where \*.vector.size == $diag.vector.size --> Math::Libgsl::Vector)
  
  This function solves the general N-by-N system Ax = b where A is cyclic tridiagonal (N ≥ 3). The cyclic super-diagonal and sub-diagonal vectors $abovediag and $belowdiag must have the same number of elements as the diagonal vector $diag. The function returns the Math::Libgsl::Vector solution $x. In case of error a failure object is returned.
  
  ### tridiag-symm-cyc-solve(Math::Libgsl::Vector $diag where \*.vector.size ≥ 3, Math::Libgsl::Vector $offdiag where \*.vector.size == $diag.vector.size, Math::Libgsl::Vector $rhs where \*.vector.size == $diag.vector.size --> Math::Libgsl::Vector)
  
  This function solves the general N-by-N system Ax = b where A is symmetric cyclic tridiagonal (N ≥ 3). The cyclic off-diagonal vector $offdiag must have the same number of elements as the diagonal vector $diag. The function returns the Math::Libgsl::Vector solution $x. In case of error a failure object is returned.
  
  ### tri-upper-rcond(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Num)
  
  This function estimates the reciprocal condition number. In case of error a failure object is returned.
  
  ### tri-lower-rcond(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Num)
  
  This function estimates the reciprocal condition number. In case of error a failure object is returned.
  
  ### tri-upper-invert(Math::Libgsl::Matrix $T where \*.matrix.size1 == $T.matrix.size2 --> Int)
  
  This function computes the in-place inverse of the triangular matrix $T, stored in the upper triangle. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tri-lower-invert(Math::Libgsl::Matrix $T where \*.matrix.size1 == $T.matrix.size2 --> Int)
  
  This function computes the in-place inverse of the triangular matrix $T, stored in the lower triangle. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tri-upper-unit-invert(Math::Libgsl::Matrix $T where \*.matrix.size1 == $T.matrix.size2 --> Int)
  
  This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tri-lower-unit-invert(Math::Libgsl::Matrix $T where \*.matrix.size1 == $T.matrix.size2 --> Int)
  
  This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tri-invert(Int $Uplo, Int $Diag, Math::Libgsl::Matrix $T where \*.matrix.size1 == $T.matrix.size2 --> Int)
  
  This function is available only from the C library v2.6. This function computes the in-place inverse of the triangular matrix $T, stored in the lower triangle when $Uplo = CblasLower and upper triangle when $Uplo = CblasUpper. The parameter $Diag = CblasUnit, CblasNonUnit specifies whether the matrix is unit triangular. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tri-LTL(Math::Libgsl::Matrix $L where \*.matrix.size1 == $L.matrix.size2 --> Int)
  
  This function is available only from the C library v2.6. This function computes the product LT(L) in-place and stores it in the lower triangle of $L on output. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tri-UL(Math::Libgsl::Matrix $LU where \*.matrix.size1 == $LU.matrix.size2 --> Int)
  
  This function is available only from the C library v2.6. This function compute the product $UL where U is upper triangular and L is unit lower triangular, stored in $LU, as computed by LU-decomp. This function returns GSL\_SUCCESS if successful, or one of the error codes listed in Math::Libgsl::Constants::gsl-error.
  
  ### tri-rcond(Int $Uplo, Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Num)
  
  This function is available only from the C library v2.6. This function estimates the 1-norm reciprocal condition number of the triangular matrix $A, using the lower triangle when $Uplo is CblasLower and upper triangle when $Uplo is CblasUpper. The function returns the reciprocal condition number 1/(||A||₁||A⁻¹||₁). In case of error a failure object is returned.
  
  ### cholesky-band-decomp(Math::Libgsl::Matrix $A where \*.matrix.size1 == $A.matrix.size2 --> Int)
  
  This function is available only from the C library v2.6. This function factorizes the symmetric, positive-definite square matrix $A into the Cholesky decomposition A = LT(L). The input matrix $