(index ("sgesv" 0) ("dgesv" 123) ("cgesv" 246) ("zgesv" 369) ("sposv" 1446) ("dposv" 1564) ("cposv" 1682) ("zposv" 1800) ("sgetrf" 2778) ("dgetrf" 2876) ("cgetrf" 2974) ("zgetrf" 3072) ("sgetrs" 3659) ("dgetrs" 3772) ("cgetrs" 3885) ("zgetrs" 3998) ("sgetri" 4595) ("dgetri" 4685) ("cgetri" 4775) ("zgetri" 4865) ("spotrf" 5404) ("dpotrf" 5493) ("cpotrf" 5582) ("zpotrf" 5671) ("spotrs" 6316) ("dpotrs" 6424) ("cpotrs" 6532) ("zpotrs" 6640) ("spotri" 7432) ("dpotri" 7521) ("cpotri" 7610) ("zpotri" 7699) ("strtri" 8342) ("dtrtri" 8438) ("ctrtri" 8534) ("ztrtri" 8630) ("slauum" 9294) ("dlauum" 9390) ("clauum" 9486) ("zlauum" 9582))
(def (sig (procedure "sgesv:: ORDER * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR * F32VECTOR * S32VECTOR" (id sgesv))))
(def (sig (procedure "dgesv:: ORDER * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR * F64VECTOR * S32VECTOR" (id dgesv))))
(def (sig (procedure "cgesv:: ORDER * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR * F32VECTOR * S32VECTOR" (id cgesv))))
(def (sig (procedure "zgesv:: ORDER * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR * F64VECTOR * S32VECTOR" (id zgesv))) (p "The routines compute the solution to a system of linear equations ''A") (ul (li "X = B" (i ", where ") "A" (i " is an N-by-N matrix and ") "X" (i " and ") "B" (i " are N-by-NRHS matrices. Optional arguments ") "LDA" (i " and ") "LDB" (i " are the leading dimensions of arrays ") "A" (i " and ") "B" (i ", respectively. LU decomposition with partial pivoting and row interchanges is used to factor ") "A" (i " as ") "A = P * L * U" (i ", where ") "P" (i " is a permutation matrix, ") "L" (i " is unit lower triangular, and ") "U" (i " is upper triangular. The factored form of ") "A'' is then used to solve the system. The return values are:") (li "a matrix containing the factors " (i "L") " and " (i "U") " from the factorization " (i "A = P*L*U") "; ") (li "the N-by-NRHS solution matrix " (i "X")) (li "a vector with pivot indices:  for 1 <= i <= min(M,N), row " (i "i") " of the matrix " (i "A") " was interchanged with row pivot(" (i "i") ")")))
(def (sig (procedure "sposv:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR * F32VECTOR" (id sposv))))
(def (sig (procedure "dposv:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR * F64VECTOR" (id dposv))))
(def (sig (procedure "cposv:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR * F32VECTOR" (id cposv))))
(def (sig (procedure "zposv:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR * F64VECTOR" (id zposv))) (p "The routines compute the solution to a system of linear equations ''A") (ul (li "X = B" (i ", where ") "A" (i " is an N-by-N symmetric positive definite matrix and ") "X" (i " and ") "B" (i " are N-by-NRHS matrices. Optional arguments ") "LDA" (i " and ") "LDB" (i " are the leading dimensions of arrays ") "A" (i " and ") "B" (i ", respectively. Cholesky decomposition is used to factor ") "A'' as") (li (i "A = U**T * U") "     if UPLO = " (b "Upper")) (li (i "A = L  * L**T") "     if UPLO = " (b "Lower") " where " (i "U") " is an upper triangular, and " (i "L") " is a lower triangular matrix. The factored form of " (i "A") " is then used to solve the system. The return values are:") (li "the factor " (i "U") " or " (i "L") "from the Cholesky factorization, depending on the value of argument UPLO.") (li "the N-by-NRHS solution matrix " (i "X"))))
(def (sig (procedure "sgetrf:: ORDER * M * N * A * [LDA] -> F32VECTOR * S32VECTOR" (id sgetrf))))
(def (sig (procedure "dgetrf:: ORDER * M * N * A * [LDA] -> F64VECTOR * S32VECTOR" (id dgetrf))))
(def (sig (procedure "cgetrf:: ORDER * M * N * A * [LDA] -> F32VECTOR * S32VECTOR" (id cgetrf))))
(def (sig (procedure "zgetrf:: ORDER * M * N * A * [LDA] -> F64VECTOR * S32VECTOR" (id zgetrf))) (p "These routines compute an LU factorization of a general M-by-N matrix " (i "A") " using partial pivoting with row interchanges. Optional argument " (i "LDA") " is the leading dimension of array " (i "A") ". The return values are:") (ol (li "a matrix containing the factors " (i "L") " and " (i "U") " from the factorization " (i "A = P*L*U") "; ") (li "a vector with pivot indices:  for 1 <= i <= min(M,N), row " (i "i") " of the matrix was interchanged with row pivot(" (i "i") ")")))
(def (sig (procedure "sgetrs:: ORDER * TRANSPOSE * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR" (id sgetrs))))
(def (sig (procedure "dgetrs:: ORDER * TRANSPOSE * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR" (id dgetrs))))
(def (sig (procedure "cgetrs:: ORDER * TRANSPOSE * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR" (id cgetrs))))
(def (sig (procedure "zgetrs:: ORDER * TRANSPOSE * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR" (id zgetrs))) (p "These routines solve a system of linear equations " (i "A * X = B") " or " (i "A' * X = B") " with a general N-by-N matrix " (i "A") " using the LU factorization computed by the xGETRF routines. Argument " (i "NRHS") " is the number of right-hand sides (i.e. number of columns in " (i "B") "). Optional arguments " (i "LDA") " and " (i "LDB") " are the leading dimensions of arrays " (i "A") " and " (i "B") ", respectively. The return value is the solution matrix " (i "X") "."))
(def (sig (procedure "sgetri:: ORDER * N * A * PIVOT * [LDA] -> F32VECTOR" (id sgetri))))
(def (sig (procedure "dgetri:: ORDER * N * A * PIVOT * [LDA] -> F64VECTOR" (id dgetri))))
(def (sig (procedure "cgetri:: ORDER * N * A * PIVOT * [LDA] -> F32VECTOR" (id cgetri))))
(def (sig (procedure "zgetri:: ORDER * N * A * PIVOT * [LDA] -> F64VECTOR" (id zgetri))) (p "These routines compute the inverse of a matrix using the LU factorization computed by the xGETRF routines. Argument " (i "A") " must contain the factors L and U from the LU factorization computed by xGETRF. Argument " (i "PIVOT") " must be the pivot vector returned by the factorization routine. Optional argument " (i "LDA") " is the leading dimension of array " (i "A") ". The return value is the inverse of the original matrix " (i "A") "."))
(def (sig (procedure "spotrf:: ORDER * UPLO * N * A * [LDA] -> F32VECTOR" (id spotrf))))
(def (sig (procedure "dpotrf:: ORDER * UPLO * N * A * [LDA] -> F64VECTOR" (id dpotrf))))
(def (sig (procedure "cpotrf:: ORDER * UPLO * N * A * [LDA] -> F32VECTOR" (id cpotrf))))
(def (sig (procedure "zpotrf:: ORDER * UPLO * N * A * [LDA] -> F64VECTOR" (id zpotrf))) (p "These routines compute the Cholesky factorization of a symmetric positive definite matrix " (i "A") ". The factorization has the form:") (ul (li (i "A = U**T * U") "     if UPLO = " (b "Upper")) (li (i "A = L  * L**T") "     if UPLO = " (b "Lower") " where " (i "U") " is an upper triangular, and " (i "L") " is a lower triangular matrix. Optional argument " (i "LDA") " is the leading dimension of array " (i "A") ". The return value is the factor " (i "U") " or " (i "L") "from the Cholesky factorization, depending on the value of argument UPLO.")))
(def (sig (procedure "spotrs:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR" (id spotrs))))
(def (sig (procedure "dpotrs:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR" (id dpotrs))))
(def (sig (procedure "cpotrs:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F32VECTOR" (id cpotrs))))
(def (sig (procedure "zpotrs:: ORDER * UPLO * N * NRHS * A * B * [LDA] * [LDB] -> F64VECTOR" (id zpotrs))) (p "These routines solve a system of linear equations " (i "A * X = B") " with a symmetric positive definite matrix " (i "A") " using the Cholesky factorization computed by the xPOTRF routines. Argument " (i "A") " is the triangular factor " (i "U") " or " (i "L") " as computed by xPOTRF. Argument " (i "NRHS") " is the number of right-hand sides (i.e. number of columns in " (i "B") "). Argument UPLO indicates whether upper or lower triangle of A is stored (" (b "Upper") " or " (b "Lower") "). Optional arguments " (i "LDA") " and " (i "LDB") " are the leading dimensions of arrays " (i "A") " and " (i "B") ", respectively. The return value is the solution matrix " (i "X") "."))
(def (sig (procedure "spotri:: ORDER * UPLO * N * A * [LDA] -> F32VECTOR" (id spotri))))
(def (sig (procedure "dpotri:: ORDER * UPLO * N * A * [LDA] -> F64VECTOR" (id dpotri))))
(def (sig (procedure "cpotri:: ORDER * UPLO * N * A * [LDA] -> F32VECTOR" (id cpotri))))
(def (sig (procedure "zpotri:: ORDER * UPLO * N * A * [LDA] -> F64VECTOR" (id zpotri))) (p "These routines compute the inverse of a symmetric positive definite matrix " (i "A") " using the Cholesky factorization " (i "A = U**T*U") " or " (i "A = L*L**T") " computed by xPOTRF. Argument " (i "A") " is the triangular factor " (i "U") " or " (i "L") " as computed by xPOTRF. Argument UPLO indicates whether upper or lower triangle of A is stored (" (b "Upper") " or " (b "Lower") "). Optional argument " (i "LDA") " is the leading dimension of array " (i "A") ". The return value is the upper or lower triangle of the inverse of " (i "A") "."))
(def (sig (procedure "strtri:: ORDER * UPLO * DIAG * N * A * [LDA] -> F32VECTOR" (id strtri))))
(def (sig (procedure "dtrtri:: ORDER * UPLO * DIAG * N * A * [LDA] -> F64VECTOR" (id dtrtri))))
(def (sig (procedure "ctrtri:: ORDER * UPLO * DIAG * N * A * [LDA] -> F32VECTOR" (id ctrtri))))
(def (sig (procedure "ztrtri:: ORDER * UPLO * DIAG * N * A * [LDA] -> F64VECTOR" (id ztrtri))) (p "These routines compute the inverse of a triangular matrix " (i "A") ". Argument " (i "A") " is the triangular factor " (i "U") " or " (i "L") " as computed by xPOTRF. Argument UPLO indicates whether upper or lower triangle of A is stored (" (b "Upper") " or " (b "Lower") "). Argument DIAG indicates whether A is non-unit triangular or unit triangular (" (b "NonUnit") " or " (b "Unit") "). Optional argument " (i "LDA") " is the leading dimension of array " (i "A") ". The return value is the triangular inverse of the input matrix, in the same storage format."))
(def (sig (procedure "slauum:: ORDER * UPLO * DIAG * N * A * [LDA] -> F32VECTOR" (id slauum))))
(def (sig (procedure "dlauum:: ORDER * UPLO * DIAG * N * A * [LDA] -> F64VECTOR" (id dlauum))))
(def (sig (procedure "clauum:: ORDER * UPLO * DIAG * N * A * [LDA] -> F32VECTOR" (id clauum))))
(def (sig (procedure "zlauum:: ORDER * UPLO * DIAG * N * A * [LDA] -> F64VECTOR" (id zlauum))) (p "These routines compute the product " (i "U * U") "' or " (i "L' * L") ", where the triangular factor " (i "U") " or " (i "L") " is stored in the upper or lower triangular part of the array " (i "A") ". Argument UPLO indicates whether upper or lower triangle of A is stored (" (b "Upper") " or " (i "Lower") "'). Optional argument " (i "LDA") " is the leading dimension of array " (i "A") ". The return value is the lower triangle of the lower triangular product, or the upper triangle of upper triangular product, in the respective storage format."))
