LU drivers: general, banded and tridiagonal systems. More...

Functions/Subroutines
pure subroutine, public	la_sgtsv (n, nrhs, dl, d, du, b, ldb, info)
	SGTSV: solves the equation AX = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation ATX = B may be solved by interchanging the order of the arguments DU and DL.

pure subroutine, public	la_dgtsv (n, nrhs, dl, d, du, b, ldb, info)
	DGTSV: solves the equation AX = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation ATX = B may be solved by interchanging the order of the arguments DU and DL.

pure subroutine, public	la_qgtsv (n, nrhs, dl, d, du, b, ldb, info)
	QGTSV: solves the equation AX = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation ATX = B may be solved by interchanging the order of the arguments DU and DL.

pure subroutine, public	la_sgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	SGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_dgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	DGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_qgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	QGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

subroutine, public	la_sgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	SGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_dgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	DGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_qgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	QGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_sgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	SGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A*T X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_dgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	DGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A*T X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_qgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	QGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A*T X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_dsgesv (n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, iter, info)
	DSGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. DSGESV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with DOUBLE PRECISION normwise backward error quality (see below). If the approach fails the method switches to a DOUBLE PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over DOUBLE PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)XNRMANRMEPSBWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

subroutine, public	la_qdgesv (n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, iter, info)
	QDGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. QDGESV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with QUAD PRECISION normwise backward error quality (see below). If the approach fails the method switches to a QUAD PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over QUAD PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)XNRMANRMEPSBWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

pure subroutine, public	la_sgesv (n, nrhs, a, lda, ipiv, b, ldb, info)
	SGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_dgesv (n, nrhs, a, lda, ipiv, b, ldb, info)
	DGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_qgesv (n, nrhs, a, lda, ipiv, b, ldb, info)
	QGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

subroutine, public	la_sgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	SGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_dgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	DGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_qgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	QGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cgtsv (n, nrhs, dl, d, du, b, ldb, info)
	CGTSV: solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.

pure subroutine, public	la_zgtsv (n, nrhs, dl, d, du, b, ldb, info)
	ZGTSV: solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.

pure subroutine, public	la_wgtsv (n, nrhs, dl, d, du, b, ldb, info)
	WGTSV: solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.

pure subroutine, public	la_cgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	CGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_zgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	ZGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_wgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
	WGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

subroutine, public	la_cgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_zgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	ZGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_wgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	WGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_cgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_zgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	ZGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

pure subroutine, public	la_wgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	WGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A*T X = B, or A*H X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_zcgesv (n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, rwork, iter, info)
	ZCGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. ZCGESV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)XNRMANRMEPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

subroutine, public	la_wzgesv (n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, rwork, iter, info)
	WZGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. WZGESV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)XNRMANRMEPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

pure subroutine, public	la_cgesv (n, nrhs, a, lda, ipiv, b, ldb, info)
	CGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_zgesv (n, nrhs, a, lda, ipiv, b, ldb, info)
	ZGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

pure subroutine, public	la_wgesv (n, nrhs, a, lda, ipiv, b, ldb, info)
	WGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

subroutine, public	la_cgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_zgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	ZGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

subroutine, public	la_wgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	WGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Detailed Description

LU drivers: general, banded and tridiagonal systems.

Function/Subroutine Documentation

◆ la_cgbsv()

pure subroutine, public la_lapack_solve_lu::la_cgbsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

CGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cgbsvx()

subroutine, public la_lapack_solve_lu::la_cgbsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	r,
		real(sp), dimension(*), intent(inout)	c,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

CGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cgesv()

pure subroutine, public la_lapack_solve_lu::la_cgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

CGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_cgesvx()

subroutine, public la_lapack_solve_lu::la_cgesvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	r,
		real(sp), dimension(*), intent(inout)	c,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

CGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_cgtsv()

pure subroutine, public la_lapack_solve_lu::la_cgtsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(inout)	dl,
		complex(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(inout)	du,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

CGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL.

Here is the call graph for this function:

◆ la_cgtsvx()

pure subroutine, public la_lapack_solve_lu::la_cgtsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(in)	dl,
		complex(sp), dimension(*), intent(in)	d,
		complex(sp), dimension(*), intent(in)	du,
		complex(sp), dimension(*), intent(inout)	dlf,
		complex(sp), dimension(*), intent(inout)	df,
		complex(sp), dimension(*), intent(inout)	duf,
		complex(sp), dimension(*), intent(inout)	du2,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

CGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_dgbsv()

pure subroutine, public la_lapack_solve_lu::la_dgbsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

DGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_dgbsvx()

subroutine, public la_lapack_solve_lu::la_dgbsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(dp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	r,
		real(dp), dimension(*), intent(inout)	c,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		real(dp), dimension(*), intent(out)	ferr,
		real(dp), dimension(*), intent(out)	berr,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

DGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_dgesv()

pure subroutine, public la_lapack_solve_lu::la_dgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

DGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_dgesvx()

subroutine, public la_lapack_solve_lu::la_dgesvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	r,
		real(dp), dimension(*), intent(inout)	c,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		real(dp), dimension(*), intent(out)	ferr,
		real(dp), dimension(*), intent(out)	berr,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

DGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_dgtsv()

pure subroutine, public la_lapack_solve_lu::la_dgtsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(*), intent(inout)	dl,
		real(dp), dimension(*), intent(inout)	d,
		real(dp), dimension(*), intent(inout)	du,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

DGTSV: solves the equation A*X = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL.

Here is the call graph for this function:

◆ la_dgtsvx()

pure subroutine, public la_lapack_solve_lu::la_dgtsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(*), intent(in)	dl,
		real(dp), dimension(*), intent(in)	d,
		real(dp), dimension(*), intent(in)	du,
		real(dp), dimension(*), intent(inout)	dlf,
		real(dp), dimension(*), intent(inout)	df,
		real(dp), dimension(*), intent(inout)	duf,
		real(dp), dimension(*), intent(inout)	du2,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		real(dp), dimension(*), intent(out)	ferr,
		real(dp), dimension(*), intent(out)	berr,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

DGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A**T * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_dsgesv()

subroutine, public la_lapack_solve_lu::la_dsgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), dimension(n,*), intent(out)	work,
		real(sp), dimension(*), intent(out)	swork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

DSGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. DSGESV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with DOUBLE PRECISION normwise backward error quality (see below). If the approach fails the method switches to a DOUBLE PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over DOUBLE PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

◆ la_qdgesv()

subroutine, public la_lapack_solve_lu::la_qdgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), dimension(n,*), intent(out)	work,
		real(dp), dimension(*), intent(out)	swork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

QDGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. QDGESV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with QUAD PRECISION normwise backward error quality (see below). If the approach fails the method switches to a QUAD PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over QUAD PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

◆ la_qgbsv()

pure subroutine, public la_lapack_solve_lu::la_qgbsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

QGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_qgbsvx()

subroutine, public la_lapack_solve_lu::la_qgbsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(qp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	r,
		real(qp), dimension(*), intent(inout)	c,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

QGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_qgesv()

pure subroutine, public la_lapack_solve_lu::la_qgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

QGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_qgesvx()

subroutine, public la_lapack_solve_lu::la_qgesvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	r,
		real(qp), dimension(*), intent(inout)	c,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

QGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_qgtsv()

pure subroutine, public la_lapack_solve_lu::la_qgtsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(*), intent(inout)	dl,
		real(qp), dimension(*), intent(inout)	d,
		real(qp), dimension(*), intent(inout)	du,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

QGTSV: solves the equation A*X = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL.

Here is the call graph for this function:

◆ la_qgtsvx()

pure subroutine, public la_lapack_solve_lu::la_qgtsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(*), intent(in)	dl,
		real(qp), dimension(*), intent(in)	d,
		real(qp), dimension(*), intent(in)	du,
		real(qp), dimension(*), intent(inout)	dlf,
		real(qp), dimension(*), intent(inout)	df,
		real(qp), dimension(*), intent(inout)	duf,
		real(qp), dimension(*), intent(inout)	du2,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		real(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

QGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A**T * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_sgbsv()

pure subroutine, public la_lapack_solve_lu::la_sgbsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

SGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_sgbsvx()

subroutine, public la_lapack_solve_lu::la_sgbsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	r,
		real(sp), dimension(*), intent(inout)	c,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

SGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_sgesv()

pure subroutine, public la_lapack_solve_lu::la_sgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

SGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_sgesvx()

subroutine, public la_lapack_solve_lu::la_sgesvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	r,
		real(sp), dimension(*), intent(inout)	c,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

SGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_sgtsv()

pure subroutine, public la_lapack_solve_lu::la_sgtsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(inout)	dl,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	du,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

SGTSV: solves the equation A*X = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL.

Here is the call graph for this function:

◆ la_sgtsvx()

pure subroutine, public la_lapack_solve_lu::la_sgtsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(in)	dl,
		real(sp), dimension(*), intent(in)	d,
		real(sp), dimension(*), intent(in)	du,
		real(sp), dimension(*), intent(inout)	dlf,
		real(sp), dimension(*), intent(inout)	df,
		real(sp), dimension(*), intent(inout)	duf,
		real(sp), dimension(*), intent(inout)	du2,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		real(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

SGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A**T * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_wgbsv()

pure subroutine, public la_lapack_solve_lu::la_wgbsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

WGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_wgbsvx()

subroutine, public la_lapack_solve_lu::la_wgbsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(qp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	r,
		real(qp), dimension(*), intent(inout)	c,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		complex(qp), dimension(*), intent(out)	work,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

WGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_wgesv()

pure subroutine, public la_lapack_solve_lu::la_wgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

WGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_wgesvx()

subroutine, public la_lapack_solve_lu::la_wgesvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	r,
		real(qp), dimension(*), intent(inout)	c,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		complex(qp), dimension(*), intent(out)	work,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

WGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_wgtsv()

pure subroutine, public la_lapack_solve_lu::la_wgtsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(*), intent(inout)	dl,
		complex(qp), dimension(*), intent(inout)	d,
		complex(qp), dimension(*), intent(inout)	du,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

WGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL.

Here is the call graph for this function:

◆ la_wgtsvx()

pure subroutine, public la_lapack_solve_lu::la_wgtsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(*), intent(in)	dl,
		complex(qp), dimension(*), intent(in)	d,
		complex(qp), dimension(*), intent(in)	du,
		complex(qp), dimension(*), intent(inout)	dlf,
		complex(qp), dimension(*), intent(inout)	df,
		complex(qp), dimension(*), intent(inout)	duf,
		complex(qp), dimension(*), intent(inout)	du2,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		complex(qp), dimension(*), intent(out)	work,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

WGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_wzgesv()

subroutine, public la_lapack_solve_lu::la_wzgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		complex(qp), dimension(n,*), intent(out)	work,
		complex(dp), dimension(*), intent(out)	swork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

WZGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. WZGESV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

◆ la_zcgesv()

subroutine, public la_lapack_solve_lu::la_zcgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		complex(dp), dimension(n,*), intent(out)	work,
		complex(sp), dimension(*), intent(out)	swork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

ZCGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. ZCGESV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

◆ la_zgbsv()

pure subroutine, public la_lapack_solve_lu::la_zgbsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

ZGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_zgbsvx()

subroutine, public la_lapack_solve_lu::la_zgbsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kl,
		integer(ilp), intent(in)	ku,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(dp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	r,
		real(dp), dimension(*), intent(inout)	c,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		real(dp), dimension(*), intent(out)	ferr,
		real(dp), dimension(*), intent(out)	berr,
		complex(dp), dimension(*), intent(out)	work,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

ZGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_zgesv()

pure subroutine, public la_lapack_solve_lu::la_zgesv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

ZGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

◆ la_zgesvx()

subroutine, public la_lapack_solve_lu::la_zgesvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	r,
		real(dp), dimension(*), intent(inout)	c,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		real(dp), dimension(*), intent(out)	ferr,
		real(dp), dimension(*), intent(out)	berr,
		complex(dp), dimension(*), intent(out)	work,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

ZGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

◆ la_zgtsv()

pure subroutine, public la_lapack_solve_lu::la_zgtsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(*), intent(inout)	dl,
		complex(dp), dimension(*), intent(inout)	d,
		complex(dp), dimension(*), intent(inout)	du,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

ZGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL.

Here is the call graph for this function:

◆ la_zgtsvx()

pure subroutine, public la_lapack_solve_lu::la_zgtsvx	(	character, intent(in)	fact,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(*), intent(in)	dl,
		complex(dp), dimension(*), intent(in)	d,
		complex(dp), dimension(*), intent(in)	du,
		complex(dp), dimension(*), intent(inout)	dlf,
		complex(dp), dimension(*), intent(inout)	df,
		complex(dp), dimension(*), intent(inout)	duf,
		complex(dp), dimension(*), intent(inout)	du2,
		integer(ilp), dimension(*), intent(inout)	ipiv,
		complex(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		real(dp), dimension(*), intent(out)	ferr,
		real(dp), dimension(*), intent(out)	berr,
		complex(dp), dimension(*), intent(out)	work,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

ZGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

Functions/Subroutines

Detailed Description

Function/Subroutine Documentation

◆ la_cgbsv()

◆ la_cgbsvx()

◆ la_cgesv()

◆ la_cgesvx()

◆ la_cgtsv()

◆ la_cgtsvx()

◆ la_dgbsv()

◆ la_dgbsvx()

◆ la_dgesv()

◆ la_dgesvx()

◆ la_dgtsv()

◆ la_dgtsvx()

◆ la_dsgesv()

◆ la_qdgesv()

◆ la_qgbsv()

◆ la_qgbsvx()

◆ la_qgesv()

◆ la_qgesvx()

◆ la_qgtsv()

◆ la_qgtsvx()

◆ la_sgbsv()

◆ la_sgbsvx()

◆ la_sgesv()

◆ la_sgesvx()

◆ la_sgtsv()

◆ la_sgtsvx()

◆ la_wgbsv()

◆ la_wgbsvx()

◆ la_wgesv()

◆ la_wgesvx()

◆ la_wgtsv()

◆ la_wgtsvx()

◆ la_wzgesv()

◆ la_zcgesv()

◆ la_zgbsv()

◆ la_zgbsvx()

◆ la_zgesv()

◆ la_zgesvx()

◆ la_zgtsv()

◆ la_zgtsvx()