#
# = Linear Algebra
#
# Contents:
# 1. {LU Decomposition}[link:rdoc/linalg_rdoc.html#label-LU+Decomposition]
# 1. {QR Decomposition}[link:rdoc/linalg_rdoc.html#label-QR+decomposition]
# 1. {QR Decomposition with Column Pivoting}[link:rdoc/linalg_rdoc.html#label-QR+Decomposition+with+Column+Pivoting]
# 1. {Singular Value Decomposition}[link:rdoc/linalg_rdoc.html#label-Singular+Value+Decomposition]
# 1. {Cholesky Decomposition}[link:rdoc/linalg_rdoc.html#label-Cholesky+Decomposition]
# 1. {Tridiagonal Decomposition of Real Symmetric Matrices}[link:rdoc/linalg_rdoc.html#label-Tridiagonal+Decomposition+of+Real+Symmetric+Matrices]
# 1. {Tridiagonal Decomposition of Hermitian Matrices}[link:rdoc/linalg_rdoc.html#label-Tridiagonal+Decomposition+of+Hermitian+Matrices]
# 1. {Hessenberg Decomposition of Real Matrices}[link:rdoc/linalg_rdoc.html#label-Hessenberg+Decomposition+of+Real+Matrices]
# 1. {Hessenberg-Triangular Decomposition of Real Matrices}[link:rdoc/linalg_rdoc.html#label-Hessenberg-Triangular+Decomposition+of+Real+Matrices]
# 1. {Bidiagonalization}[link:rdoc/linalg_rdoc.html#label-Bidiagonalization]
# 1. {Householder Transformations}[link:rdoc/linalg_rdoc.html#label-Householder+Transformations]
# 1. {Householder solver for linear systems}[link:rdoc/linalg_rdoc.html#label-Householder+solver+for+linear+systems]
# 1. {Tridiagonal Systems}[link:rdoc/linalg_rdoc.html#label-Tridiagonal+Systems]
# 1. {Balancing}[link:rdoc/linalg_rdoc.html#label-Balancing]
# 1. {NArray}[link:rdoc/linalg_rdoc.html#label-NArray]
#
# == LU Decomposition
# ---
# * GSL::Linalg::LU.decomp(A)
# * GSL::Matrix#LU_decomp
#
#   These method calculate the LU decomposition of the matrix. The returned
#   value is an array of <tt>[LU, perm, sign]</tt>.
#
#   Examples:
#
# 1. Singleton method of the <tt>GSL::Linalg::LU</tt> module
#
#         >> m = Matrix[1..9, 3, 3]
#         => GSL::Matrix:
#         [ 1.000e+00 2.000e+00 3.000e+00
#           4.000e+00 5.000e+00 6.000e+00
#           7.000e+00 8.000e+00 9.000e+00 ]
#         >> lu, perm, sign = Linalg::LU.decomp(m)
#
# 1. Instance method of <tt>GSL::Matrix</tt> class
#
#         >> lu, perm, sign = m.LU_decomp
#
# ---
# * GSL::Linalg::LU.solve(A, b)
# * GSL::Linalg::LU.solve(lu, perm, b)
# * GSL::Matrix#LU_solve(b)
# * GSL::Linalg::LUMatrix#solve(perm, b)
#
#   The following is an example to solve a linear system
#
#      A x = b, b = [1, 2, 3, 4]
#
#   using LU decomposition.
#
# 1. Singleton method of the <tt>GSL::Linalg::LU</tt> module
#
#         A = Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
#                    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
#         lu, perm, sign = A.LU_decomp
#         b = Vector[1, 2, 3, 4]
#         x = Linalg::LU.solve(lu, perm, b)
#
# 1. Instance method of <tt>GSL::Linalg::LUMatrix</tt> class
#
#         lu, perm, sign = A.LU_decomp  # lu is an instance of Linalg::LUMatrix class
#         b = Vector[1, 2, 3, 4]
#         x = lu.solve(perm, b)
#
# 1. Solve directly
#
#         x = Linalg::LU.solve(A, b)  # LU decomposition is calculated internally (A is not modified)
#
# ---
# * GSL::Linalg::LU.svx(A, b)
# * GSL::Linalg::LU.svx(lu, perm, b)
# * GSL::Matrix#svx(b)
# * GSL::Linalg::LUMatrix#svx(perm, b)
#
#   These solve the system Ax = b. The input vector <tt>b</tt> is overwitten by
#   the solution <tt>x</tt>.
#
# ---
# * GSL::Linalg::LU.refine(A, lu, perm, b, x)
#
#   This method applys an iterative improvement to <tt>x</tt>,
#   the solution of <tt>A x = b</tt>, using the LU decomposition of <tt>A</tt>.
#
# ---
# * GSL::Linalg::LU.invert(A)
# * GSL::Linalg::LU.invert(lu, perm)
# * GSL::Matrix#invert
# * GSL::Linalg::LUMatrix#invert(perm)
#
#   These computes and returns the inverse of the matrix.
#
# ---
# * GSL::Linalg::LU.det(A)
# * GSL::Linalg::LU.det(lu, signum)
# * GSL::Matrix#det
# * GSL::Linalg::LUMatrix#det(signum)
#
#   These methods return the determinant of the matrix.
#
# === {Complex LU decomposition}[link:rdoc/linalg_complex_rdoc.html]
#
# == QR decomposition
#
# ---
# * GSL::Linalg::QR_decomp(A)
# * GSL::Linalg::QR.decomp(A)
# * GSL::Matrix#QR_decomp
#
#   These compute QR decomposition of the matrix and return an array [QR, tau].
#
# 1. Singleton method of the module <tt>GSL::Linalg</tt>
#         qr, tau = Linalg::QR_decomp(m)
#         p qr.class                 # GSL::Linalg::QRMatrix, subclass of GSL::Matrix
#         p tau.class                # GSL::Linalg::TauVector, subclass of GSL::Vector
# 1. Singleton method of the module <tt>GSL::Linalg:QR</tt>
#         qr, tau = Linalg::QR.decomp(m)
# 1. Instance method of <tt>GSL::Matrix</tt>
#         qr, tau = m.QR_decomp
#
# ---
# * GSL::Linalg::QR.solve(A, b)
# * GSL::Linalg::QR.solve(QR, tau, b)
# * GSL::Matrix#QR_solve(b)
# * GSL::Linalg::QRMatrix#solve(tau, b)
#
#   Solve the system A x = b using the QR decomposition.
#
#   * Ex1:
#       m = Matrix.alloc(...)
#       b = Vector.alloc(...)
#       x = Linalg::QR.solve(m, b)
#   * Ex2:
#       x = m.QR_solve(b)
#   * Ex3:
#       qr, tau = Linalg::QR.decomp(m)   # or m.QR_decomp
#       x = Linalg::QR.solve(qr, tau, b)
#   * Ex4:
#       qr, tau = m.QR_decomp
#       x = qr.solve(tau, b)
#
# ---
# * GSL::Linalg::QR.svx(A, x)
# * GSL::Linalg::QR.svx(QR, tau, x)
# * GSL::Matrix#QR_svx(x)
# * GSL::Linalg::QRMatrix#svx(tau, x)
#
#   Solve the system A x = b. The input vector <tt>x</tt> is first give by
#   the right-hand side vector <tt>b</tt>, and is overwritten by the solution.
#
# ---
# * GSL::Linalg::QR.unpack(QR, tau)
# * GSL::Linalg::QRMatrix#unpack(tau)
#
#   Unpack the encoded QR decomposition <tt>QR,tau</tt> and return an array
#   <tt>[Q, R]</tt>.
#
#   Ex:
#     >> m = Matrix[1..9, 3, 3]
#     => GSL::Matrix:
#     [ 1.000e+00 2.000e+00 3.000e+00
#       4.000e+00 5.000e+00 6.000e+00
#       7.000e+00 8.000e+00 9.000e+00 ]
#     >> qr, tau = m.QR_decomp
#     >> q, r = qr.unpack(tau)
#     >> q*r               # Reconstruct the metrix m
#     => GSL::Matrix:
#     [ 1.000e+00 2.000e+00 3.000e+00
#       4.000e+00 5.000e+00 6.000e+00
#       7.000e+00 8.000e+00 9.000e+00 ]
#
# ---
# * GSL::Linalg::QR.QRsolve(Q, R, tau)
#
#   This method solves the system <tt>R x = Q^T b</tt> for <tt>x</tt>.
#   It can be used when the QR decomposition of a matrix is available
#   in unpacked form as <tt>Q,R</tt>.
#
# == QR Decomposition with Column Pivoting
# ---
# * GSL::Linalg::QRPT.decomp(A)
# * GSL::Matrix#QRPT_decomp
#
#   These methods factorize the M-by-N matrix <tt>A</tt> into the QRP^T decomposition A = Q R P^T, and return an array <tt>[QR, tau, perm, signum]</tt>.
#
#   * Ex1:
#       require("gsl")
#       include GSL::Linalg
#       m = Matrix.alloc(...)
#       qr, tau, perm = QRPT.decomp(m)
#       p qr.class                 # GSL::Linalg::QRPTMatrix, subclass of GSL::Matrix
#
#   * Ex2:
#       qr, tau, perm = m.QROT_decomp
#
# ---
# * GSL::Linalg::QRPT.decomp2(A)
# * GSL::Matrix#QRPT_decomp2
#
#   These return an array <tt>[Q, R, tau, perm, signum]</tt>.
#
#   * Ex
#       q, r, tau, perm = QRPT.decomp2(m)
#       p q.class                  <----- GSL::Linalg::QMatrix
#       p r.class                  <----- GSL::Linalg::RMatrix
#
# ---
# * GSL::Linalg::QRPT.solve(m, b)
# * GSL::Linalg::QRPT.solve(qr, tau, perm, b)
# * GSL::Matrix#QRPT_solve(A, b)
# * GSL::Linalg::QRPQMatrix#solve(qr, tau, perm, b)
#
#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of
#   <tt>A</tt> into <tt>QR, tau, perm</tt>. The solution <tt>x</tt> is returned as a Vector.
#
#   * Ex1:
#       m = Matrix.alloc(...)
#       qr, tau, perm = m.QRPT_decomp
#       b = Vector.alloc([1, 2, 3, 4])
#       x = Linalg::QRPT.solve(qr, tau, perm, b)
#   * Ex2:
#       x = Linalg::QRPT.solve(m, b)
#   * Ex3:
#       x = qr.solve(tau, p, b)
#   * Ex4:
#       x = m.QRPT_solve(b)
#
# ---
# * GSL::Linalg::QRPT.svx(m, b)
# * GSL::Linalg::QRPT.svx(qr, tau, perm, b)
# * GSL::Matrix#QRPT_svx(A, b)
#
#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of
#   <tt>A</tt> into <tt>QR, tau, perm</tt>. The input <tt>b</tt> is overwritten by the solution
#   <tt>x</tt>.
#
# ---
# * GSL::Linalg::QRPT.QRsolve(q, r, tau, perm, b)
#
#   This method solves the system <tt>R P^T x = Q^T b</tt> for x.
#   It can be used when the QR decomposition of a matrix is available in
#   unpacked form as <tt>q, r</tt> obtained by the method <tt>decomp2</tt>.
#
#   * Ex:
#      q, r, tau, perm = QRPT_decomp2
#      x = Linalg::QRPT.QRsolve(q, r, perm, b)
#
# ---
# * GSL::Linalg::QRPT.update(q, r, perm, u, v)
# * GSL::Linalg::QRPT.Rsolve(qr, perm, b)
# * GSL::Linalg::QRPTMatrix#Rsolve(perm, b)
# * GSL::Linalg::QRPT.Rsvx(qr, perm, b)
# * GSL::Linalg::QRPTMatrix#Rsvx(perm, b)
#
#
# == Singular Value Decomposition
# ---
# * GSL::Linalg::SV.decomp(A[, work])
# * \GSL::Matrix#SV_decomp([work])
#
#   These methods factorize the M-by-N matrix <tt>A</tt> into the singular value
#   decomposition <tt>A = U S V^T</tt> using  the Golub-Reinsch SVD algorithm,
#   and return an array <tt>[U, V, S]</tt>.
#
#   Ex:
#      >> m = Matrix[[3, 5, 2], [5, 1, 4], [7, 6, 3]]
#      => GSL::Matrix:
#      [ 3.000e+00 5.000e+00 2.000e+00
#        5.000e+00 1.000e+00 4.000e+00
#        7.000e+00 6.000e+00 3.000e+00 ]
#      >> u, v, s = m.SV_decomp  # u, v: Matrix, s: Vector (singular values)
#      >> u*u.trans              # u is orthnormal
#      => GSL::Matrix:
#      [  1.000e+00  2.452e-17 -4.083e-16
#         2.452e-17  1.000e+00 -3.245e-16
#        -4.083e-16 -3.245e-16  1.000e+00 ]
#      >> v*v.trans              # v is also orthnormal
#      => GSL::Matrix:
#      [  1.000e+00  3.555e-17 -1.867e-16
#         3.555e-17  1.000e+00 -1.403e-16
#        -1.867e-16 -1.403e-16  1.000e+00 ]
#      >> u*Matrix.diagonal(s)*v.trans # Reconstruct the matrix
#      => GSL::Matrix:
#      [ 3.000e+00 5.000e+00 2.000e+00
#        5.000e+00 1.000e+00 4.000e+00
#        7.000e+00 6.000e+00 3.000e+00 ]
#
# ---
# * GSL::Linalg::SV.decomp_mod(A)
# * GSL::Matrix#SV_decomp_mod
#
#   These compute the SVD using the modified Golub-Reinsch algorithm,
#   which is faster for M>>N.
#
# ---
# * GSL::Linalg::SV.decomp_jacobi(A)
# * GSL::Matrix#SV_decomp_jacobi
#
#   These compute the SVD using one-sided Jacobi orthogonalization.
#   The Jacobi method can compute singular values to higher relative accuracy
#   than Golub-Reinsch algorithms.
#
# ---
# * GSL::Linalg::SV.solve(A, b)
# * GSL::Linalg::SV.solve(U, V, S, b)
# * GSL::Matrix#SV_solve(b)
#
#   These methods solve the system <tt>A x = b</tt> using the singular value
#   decomposition <tt>U, S, V</tt> of <tt>A</tt>.
#
#   * Ex1:
#       m = Matrix.alloc(...)
#       b = Vector.alloc(...)
#       u, v, s = GSL::Linalg::SV.decomp(m)
#       x = GSL::Linalg::SV.solve(u, v, s, b)
#   * Ex2:
#       x = GSL::Linalg::SV.solve(m, b)
#   * Ex3:
#       x = m.SV_solve(b)
#
# == Cholesky Decomposition
# A symmetric, positive definite square matrix <tt>A</tt> has a Cholesky decomposition
# into a product of a lower triangular matrix L and its transpose L^T,
# as <tt>A = L L^T</tt>. This is sometimes referred to as taking the square-root of a
# matrix. The Cholesky decomposition can only be carried out when all the eigenvalues
# of the matrix are positive. This decomposition can be used to convert the linear
# system <tt>A x = b</tt> into a pair of triangular systems (<tt>L y = b, L^T x = y</tt>),
# which can be solved by forward and back-substitution.
#
# ---
# * GSL::Linalg::Cholesky.decomp(A)
#
#   This method factorizes the positive-definite square matrix <tt>A</tt>
#   into the Cholesky decomposition <tt>A = L L^T</tt>.
#   The upper triangular part of the matrix returned contains L^T, the diagonal terms
#   being identical for both L and L^T. If the matrix is not positive-definite
#   then the decomposition will fail.
#
#   Ex:
#     >> m = Matrix.pascal(3)
#     => GSL::Matrix
#     [  1.000e+00  1.000e+00  1.000e+00
#        1.000e+00  2.000e+00  3.000e+00
#        1.000e+00  3.000e+00  6.000e+00 ]
#     >> c = Linalg::Cholesky.decomp(m)
#     => GSL::Linalg::Cholesky::CholeskyMatrix
#     [  1.000e+00  1.000e+00  1.000e+00
#        1.000e+00  1.000e+00  2.000e+00
#        1.000e+00  2.000e+00  1.000e+00 ]
#     >> l = c.lower
#     => GSL::Matrix
#     [  1.000e+00  0.000e+00  0.000e+00
#        1.000e+00  1.000e+00  0.000e+00
#        1.000e+00  2.000e+00  1.000e+00 ]
#     >> (l*l.trans) == m
#     => true
#
# ---
# * GSL::Linalg::Cholesky.solve(cholesky, b)
# * GSL::Linalg::Cholesky.svx(cholesky, x)
#
#   These methods solve the system <tt>A x = b</tt> using the Cholesky decomposition
#   of <tt>A</tt> into the matrix <tt>cholesky</tt> given by <tt>GSL::Linalg::Cholesky.decomp</tt>.
#
# === {Complex Cholesky decomposition}[link:rdoc/cholesky_complex_rdoc.html]
#
# == Tridiagonal Decomposition of Real Symmetric Matrices
# ---
# * GSL::Linalg::Symmtd::decomp(A)
#
#   Factorizes the symmetric square matrix <tt>A</tt> into the symmetric
#   tridiagonal decomposition Q T Q^T, and returns the results
#   <tt>(A', tau)</tt>. On output the diagonal and subdiagonal part of the
#   matrix <tt>A'</tt>  contain the tridiagonal matrix <tt>T</tt>.
#   The remaining lower triangular part of the matrix <tt>A'</tt> contains
#   the Householder vectors which, together with the Householder
#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>.
#   This storage scheme is the same as used by LAPACK.
#   The upper triangular part of <tt>A</tt> is not referenced.
# ---
# * GSL::Linalg::Symmtd::unpack(A', tau)
#
#   Unpacks the encoded symmetric tridiagonal decomposition <tt>(A', tau)</tt>
#   obtained from <tt>GSL::Linalg::Symmtd::decomp</tt> into the orthogonal
#   matrix <tt>Q</tt>, the vector of diagonal elements <tt>diag</tt>
#   and the vector of subdiagonal elements <tt>subdiag</tt>.
# ---
# * GSL::Linalg::Symmtd::unpack_T(A', tau)
#
#   Unpacks the diagonal and subdiagonal of the encoded symmetric tridiagonal
#   decomposition <tt>(A', tau)</tt> obtained from
#   <tt>GSL::Linalg::Symmtd::decomp</tt> into the vectors
#   <tt>diag</tt> and <tt>subdiag</tt>.
#
# == Tridiagonal Decomposition of Hermitian Matrices
# ---
# * GSL::Linalg::Hermtd::decomp(A)
#
#   Factorizes the hermitian matrix <tt>A</tt> into the symmetric tridiagonal
#   decomposition U T U^T, and returns the result as <tt>(A', tau)</tt>.
#   On output the real parts of the diagonal and subdiagonal part of the
#   matrix <tt>A'</tt> contain the tridiagonal matrix <tt>T</tt>.
#   The remaining lower triangular part of the matrix <tt>A'</tt> contains
#   the Householder vectors which, together with the Householder
#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>.
#   This storage scheme is the same as used by LAPACK.
#   The upper triangular part of <tt>A</tt> and imaginary parts of the diagonal
#   are not referenced.
#
# ---
# * GSL::Linalg::Hermtd::unpack(A', tau)
#
#   Unpacks the encoded tridiagonal decomposition <tt>(A', tau)</tt>
#   obtained from <tt>GSL::Linalg::Hermtd::decomp</tt> into the unitary matrix
#   <tt>U</tt>, the real vector of diagonal elements <tt>diag</tt> and
#   the real vector of subdiagonal elements <tt>subdiag</tt>.
#
# ---
# * GSL::Linalg::Hermtd::unpack_T(A', tau)
#
#   Unpacks the diagonal and subdiagonal of the encoded tridiagonal
#   decomposition <tt>(A, tau)</tt> obtained from the
#   <tt>GSL::Linalg::Hermtd::decomp</tt>
#   into the real vectors <tt>diag</tt> and <tt>subdiag</tt>.
#
# == Hessenberg Decomposition of Real Matrices
# ---
# * GSL::Linalg::Hessenberg::decomp(A)
# * GSL::Linalg::hessenberg_decomp(A)
#
#   Computes the Hessenberg decomposition of the matrix <tt>A</tt>
#   by applying the similarity transformation <tt>H = U^T A U</tt>, and returns
#   the result as <tt>(A', tau</tt>. On output, <tt>H</tt> is stored in the upper
#   portion of <tt>A'</tt>. The information required to construct the matrix
#   <tt>U</tt> is stored in the lower triangular portion of <tt>A'</tt>.
#   <tt>U</tt> is a product of N - 2 Householder matrices.
#   The Householder vectors are stored in the lower portion of <tt>A'</tt>
#   (below the subdiagonal) and the Householder coefficients are stored
#   in the vector <tt>tau</tt>.
#
# ---
# * GSL::Linalg::Hessenberg::unpack(A', tau)
# * GSL::Linalg::hessenberg_unpack(A', tau)
#
#   Constructs the orthogonal matrix <tt>U</tt> and returns it
#   from the information stored  in the Hessenberg matrix <tt>A'</tt>
#   along with the vector <tt>tau</tt>. <tt>A'</tt> and <tt>tau</tt>
#   are outputs from <tt>GSL::Linalg::Hessenberg::decomp</tt>.
#
# ---
# * GSL::Linalg::Hessenberg::unpack_accum(A', tau, V = I)
# * GSL::Linalg::hessenberg_unpack_accum(A', tau, V = I)
#
#   This method is similar to <tt>GSL::Linalg::Hessenberg::unpack</tt>,
#   except it accumulates the matrix <tt>U</tt> into <tt>V</tt>, so that
#   <tt>V' = VU</tt>, and returns <tt>V</tt>. Setting V to the identity matrix
#   provides the same result <tt>GSL::Linalg::Hessenberg::unpack</tt>.
#
# ---
# * GSL::Linalg::Hessenberg::set_zero(A')
# * GSL::Linalg::hessenberg_set_zero(A')
#
#   Sets the lower triangular portion of <tt>A'</tt>, below the subdiagonal,
#   to zero.
#   It is useful for clearing out the Householder vectors after calling
#   <tt>GSL::Linalg::Hessenberg::decomp</tt>.
#
# == Hessenberg-Triangular Decomposition of Real Matrices
# ---
# * GSL::Linalg::hesstri_decomp(A, B)
# * GSL::Linalg::hesstri_decomp(A, B, work)
# * GSL::Linalg::hesstri_decomp(A, B, U, V)
# * GSL::Linalg::hesstri_decomp(A, B, U, V, work)
#
#   Compute the Hessenberg-Triangular decomposition of the matrix pair
#   <tt>(A, B)</tt>, and return <tt>(H, R</tt>.
#   If U and V are provided (they may be null), the similarity
#   transformations are stored in them. <tt>work</tt> is an additional workspace
#   of length <tt>N</tt>.
#
# ---
# * GSL::Linalg::hesstri_decomp!(A, B)
# * GSL::Linalg::hesstri_decomp!(A, B, work)
# * GSL::Linalg::hesstri_decomp!(A, B, U, V)
# * GSL::Linalg::hesstri_decomp!(A, B, U, V, work)
#
#   Compute the Hessenberg-Triangular decomposition of the matrix pair
#   <tt>(A, B)</tt>. On output, <tt>H</tt> is stored in <tt>A</tt>,
#   and <tt>R</tt> is stored in <tt>B</tt>.
#   If U and V are provided (they may be null), the similarity
#   transformations are stored in them. <tt>work</tt> is an additional workspace
#   of length <tt>N</tt>.
#
# == Bidiagonalization
# ---
# * GSL::Linalg::Bidiag::decomp!(A)
# * GSL::Linalg::bidiag_decomp!(A)
# * GSL::Linalg::Bidiag::decomp(A)
# * GSL::Linalg::bidiag_decomp(A)
#
#
# ---
# * GSL::Linalg::Bidiag::unpack
# * GSL::Linalg::bidiag_unpack
# * GSL::Linalg::Bidiag::unpack2
# * GSL::Linalg::bidiag_unpack2
# * GSL::Linalg::Bidiag::unpack_B
# * GSL::Linalg::bidiag_unpack_B
#
#
# == Householder Transformations
# ---
# * GSL::Linalg::Householder::transform(v)
# * GSL::Linalg::HH::transform(v)
# * GSL::Vector#householder_transform
#
#   These methods prepare a Householder transformation P = I - tau v v^T
#   which can be used to zero all the elements of the input vector except the first.
#   On output the transformation is stored in the vector <tt>v</tt>
#   and the scalar tau is returned.
#
# ---
# * GSL::Linalg::Householder::hm(tau, v, A)
# * GSL::Linalg::HH::hm(tau, v, A)
#
#   These methods apply the Householder matrix P defined by the scalar
#   <tt>tau</tt> and the vector <tt>v</tt> to the left-hand side of the matrix <tt>A</tt>.
#   On output the result P A is stored in <tt>A</tt>.
#
# ---
# * GSL::Linalg::Householder::mh(tau, v, A)
# * GSL::Linalg::HH::mh(tau, v, A)
#
#   These methods apply the Householder matrix P defined by the scalar <tt>tau</tt>
#   and the vector <tt>v</tt> to the right-hand side of the matrix <tt>A</tt>.
#   On output the result A P is stored in <tt>A</tt>.
#
# ---
# * GSL::Linalg::Householder::hv(tau, v, w)
# * GSL::Linalg::HH::hv(tau, v, w)
#
#   These methods apply the Householder transformation P defined by the scalar
#   <tt>tau</tt> and the vector <tt>v</tt> to the vector <tt>w</tt>.
#   On output the result P w is stored in <tt>w</tt>.
#
# == Householder solver for linear systems
# ---
# * GSL::Linalg::HH.solve(A, b)
# * GSL::Matrix#HH_solve(b)
#
#   These methods solve the system <tt>A x = b</tt> directly using Householder
#   transformations. The matrix <tt>A</tt> is not modified.
# ---
# * GSL::Linalg::HH.solve!(A, b)
# * GSL::Matrix#HH_solve!(b)
#
#   These methods solve the system <tt>A x = b</tt> directly using Householder
#   transformations. The matrix <tt>A</tt> is destroyed by the
#   Householder transformations.
#
# ---
# * GSL::Linalg::HH.svx(A, b)
# * GSL::Matrix#HH_svx(b)
#
#   These methods solve the system <tt>A x = b</tt> in-place directly using Householder
#   transformations. The input vector <tt>b</tt> is replaced by the solution.
#
# == Tridiagonal Systems
# ---
# * GSL::Linglg::solve_tridiag(diag, e, f, b)
# * GSL::Linglg::Tridiag::solve(diag, e, f, b)
#
#   These methods solve the general N-by-N system A x = b where <tt>A</tt>
#   is tridiagonal ( N >= 2). The super-diagonal and sub-diagonal vectors <tt>e</tt>
#   and <tt>f</tt> must be one element shorter than the diagonal vector <tt>diag</tt>.
#   The form of <tt>A</tt> for the 4-by-4 case is shown below,
#        A = ( d_0 e_0  0   0  )
#            ( f_0 d_1 e_1  0  )
#            (  0  f_1 d_2 e_2 )
#            (  0   0  f_2 d_3 )
#
# ---
# * GSL::Linglg::solve_symm_tridiag(diag, e, b)
# * GSL::Linglg::Tridiag::solve_symm(diag, e, b)
#
#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is
#   symmetric tridiagonal ( N >= 2). The off-diagonal vector <tt>e</tt> must
#   be one element shorter than the diagonal vector <tt>diag</tt>.
#   The form of <tt>A</tt> for the 4-by-4 case is shown below,
#        A = ( d_0 e_0  0   0  )
#            ( e_0 d_1 e_1  0  )
#            (  0  e_1 d_2 e_2 )
#            (  0   0  e_2 d_3 )
#
# ---
# * GSL::Linglg::solve_cyc_tridiag(diag, e, f, b)
# * GSL::Linglg::Tridiag::solve_cyc(diag, e, f, b)
#
#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is
#   cyclic tridiagonal ( N >= 3). The cyclic super-diagonal and sub-diagonal
#   vectors <tt>e</tt> and <tt>f</tt> must have the same number of elements as the
#   diagonal vector <tt>diag</tt>. The form of <tt>A</tt> for the 4-by-4 case is shown below,
#        A = ( d_0 e_0  0  f_3 )
#            ( f_0 d_1 e_1  0  )
#            (  0  f_1 d_2 e_2 )
#            ( e_3  0  f_2 d_3 )
#
# ---
# * GSL::Linglg::solve_symm_cyc_tridiag(diag, e, b)
# * GSL::Linglg::Tridiag::solve_symm_cyc(diag, e, b)
#
#   These methods solve the general N-by-N system A x = b where <tt>A</tt>
#   is symmetric cyclic tridiagonal ( N >= 3). The cyclic off-diagonal vector <tt>e</tt>
#   must have the same number of elements as the diagonal vector <tt>diag</tt>.
#   The form of <tt>A</tt> for the 4-by-4 case is shown below,
#        A = ( d_0 e_0  0  e_3 )
#            ( e_0 d_1 e_1  0  )
#            (  0  e_1 d_2 e_2 )
#            ( e_3  0  e_2 d_3 )
#
# == Balancing
# The process of balancing a matrix applies similarity transformations to
# make the rows and columns have comparable norms. This is useful,
# for example, to reduce roundoff errors in the solution of eigenvalue problems.
# Balancing a matrix <tt>A</tt> consists of replacing <tt>A</tt> with a similar matrix
# where <tt>D</tt> is a diagonal matrix whose entries are powers of the floating
# point radix.
#
# ---
# * GSL::Linalg::balance(A)
# * GSL::Linalg::balance(A, D)
#
#   Calculates the balanced counterpart of <tt>A</tt> and the diagonal elements
#   of the similarity transformation. The result is returned as <tt>(A', D)</tt>.
#
# ---
# * GSL::Linalg::balance!(A)
# * GSL::Linalg::balance!(A, D)
#
#   Replaces the matrix <tt>A</tt> with its balanced counterpart and
#   stores the diagonal elements of the similarity transformation into
#   the vector <tt>D</tt>.
#
#
# == NArray
# The following Linalg methods can handle NArray objects:
# * GSL::Linalg::
#   * LU::
#     * LU.decomp(m)
#     * LU.solve(lu, b)
#     * LU.svx(lu, bx)
#     * LU.det(lu, sign)
#     * LU.lndet(lu)
#     * LU.invert(lu, perm)
#   * QR::
#     * QR.decomp(m)
#     * QR.solve(qr, tau, b)
#     * QR.svx(qr, tau, bx)
#   * SV::
#     * SV.decomp(m)
#     * SV.solve(u, v, s, b)
#     * SV.svx(u, v, s, bx)
#   * Cholesky::
#     * Cholesky.decomp(m)
#     * Cholesky.solve(u, v, s, b)
#     * Cholesky.svx(u, v, s, bx)
#   * HH::
#     * HH.solve(m, b)
#     * HH.svx(m, bx)
#
# {prev}[link:rdoc/blas_rdoc.html]
# {next}[link:rdoc/eigen_rdoc.html]
#
# {Reference index}[link:rdoc/ref_rdoc.html]
# {top}[link:index.html]
#
#
