- Generated by
1.15.0
Functions | |
| subroutine | cgglse (m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) |
| CGGLSE solves overdetermined or underdetermined systems for OTHER matrices | |
| subroutine | chpsv (uplo, n, nrhs, ap, ipiv, b, ldb, info) |
| CHPSV computes the solution to system of linear equations A * X = B for OTHER matrices | |
| subroutine | chpsvx (fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| CHPSVX computes the solution to system of linear equations A * X = B for OTHER matrices | |
| subroutine | cpbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info) |
| CPBSV computes the solution to system of linear equations A * X = B for OTHER matrices | |
| subroutine | cpbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| CPBSVX computes the solution to system of linear equations A * X = B for OTHER matrices | |
| subroutine | cppsv (uplo, n, nrhs, ap, b, ldb, info) |
| CPPSV computes the solution to system of linear equations A * X = B for OTHER matrices | |
| subroutine | cppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| CPPSVX computes the solution to system of linear equations A * X = B for OTHER matrices | |
| subroutine | cspsv (uplo, n, nrhs, ap, ipiv, b, ldb, info) |
| CSPSV computes the solution to system of linear equations A * X = B for OTHER matrices | |
| subroutine | cspsvx (fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| CSPSVX computes the solution to system of linear equations A * X = B for OTHER matrices | |
This is the group of complex Other Solve routines
| subroutine cgglse | ( | integer | m, |
| integer | n, | ||
| integer | p, | ||
| complex, dimension( lda, * ) | a, | ||
| integer | lda, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| complex, dimension( * ) | c, | ||
| complex, dimension( * ) | d, | ||
| complex, dimension( * ) | x, | ||
| complex, dimension( * ) | work, | ||
| integer | lwork, | ||
| integer | info ) |
CGGLSE solves overdetermined or underdetermined systems for OTHER matrices
Download CGGLSE + dependencies [TGZ] [ZIP] [TXT]
!> !> CGGLSE solves the linear equality-constrained least squares (LSE) !> problem: !> !> minimize || c - A*x ||_2 subject to B*x = d !> !> where A is an M-by-N matrix, B is a P-by-N matrix, c is a given !> M-vector, and d is a given P-vector. It is assumed that !> P <= N <= M+P, and !> !> rank(B) = P and rank( (A) ) = N. !> ( (B) ) !> !> These conditions ensure that the LSE problem has a unique solution, !> which is obtained using a generalized RQ factorization of the !> matrices (B, A) given by !> !> B = (0 R)*Q, A = Z*T*Q. !>
| [in] | M | !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> |
| [in] | N | !> N is INTEGER !> The number of columns of the matrices A and B. N >= 0. !> |
| [in] | P | !> P is INTEGER !> The number of rows of the matrix B. 0 <= P <= N <= M+P. !> |
| [in,out] | A | !> A is COMPLEX array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, the elements on and above the diagonal of the array !> contain the min(M,N)-by-N upper trapezoidal matrix T. !> |
| [in] | LDA | !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> |
| [in,out] | B | !> B is COMPLEX array, dimension (LDB,N) !> On entry, the P-by-N matrix B. !> On exit, the upper triangle of the subarray B(1:P,N-P+1:N) !> contains the P-by-P upper triangular matrix R. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,P). !> |
| [in,out] | C | !> C is COMPLEX array, dimension (M) !> On entry, C contains the right hand side vector for the !> least squares part of the LSE problem. !> On exit, the residual sum of squares for the solution !> is given by the sum of squares of elements N-P+1 to M of !> vector C. !> |
| [in,out] | D | !> D is COMPLEX array, dimension (P) !> On entry, D contains the right hand side vector for the !> constrained equation. !> On exit, D is destroyed. !> |
| [out] | X | !> X is COMPLEX array, dimension (N) !> On exit, X is the solution of the LSE problem. !> |
| [out] | WORK | !> WORK is COMPLEX array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> |
| [in] | LWORK | !> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= max(1,M+N+P). !> For optimum performance LWORK >= P+min(M,N)+max(M,N)*NB, !> where NB is an upper bound for the optimal blocksizes for !> CGEQRF, CGERQF, CUNMQR and CUNMRQ. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> = 1: the upper triangular factor R associated with B in the !> generalized RQ factorization of the pair (B, A) is !> singular, so that rank(B) < P; the least squares !> solution could not be computed. !> = 2: the (N-P) by (N-P) part of the upper trapezoidal factor !> T associated with A in the generalized RQ factorization !> of the pair (B, A) is singular, so that !> rank( (A) ) < N; the least squares solution could not !> ( (B) ) !> be computed. !> |
Definition at line 178 of file cgglse.f.
| subroutine chpsv | ( | character | uplo, |
| integer | n, | ||
| integer | nrhs, | ||
| complex, dimension( * ) | ap, | ||
| integer, dimension( * ) | ipiv, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| integer | info ) |
CHPSV computes the solution to system of linear equations A * X = B for OTHER matrices
Download CHPSV + dependencies [TGZ] [ZIP] [TXT]
!> !> CHPSV computes the solution to a complex system of linear equations !> A * X = B, !> where A is an N-by-N Hermitian matrix stored in packed format and X !> and B are N-by-NRHS matrices. !> !> The diagonal pivoting method is used to factor A as !> A = U * D * U**H, if UPLO = 'U', or !> A = L * D * L**H, if UPLO = 'L', !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, D is Hermitian and block diagonal with 1-by-1 !> and 2-by-2 diagonal blocks. The factored form of A is then used to !> solve the system of equations A * X = B. !>
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 0. !> |
| [in,out] | AP | !> AP is COMPLEX array, dimension (N*(N+1)/2) !> On entry, the upper or lower triangle of the Hermitian matrix !> A, packed columnwise in a linear array. The j-th column of A !> is stored in the array AP as follows: !> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; !> if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. !> See below for further details. !> !> On exit, the block diagonal matrix D and the multipliers used !> to obtain the factor U or L from the factorization !> A = U*D*U**H or A = L*D*L**H as computed by CHPTRF, stored as !> a packed triangular matrix in the same storage format as A. !> |
| [out] | IPIV | !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D, as !> determined by CHPTRF. If IPIV(k) > 0, then rows and columns !> k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1 !> diagonal block. If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, !> then rows and columns k-1 and -IPIV(k) were interchanged and !> D(k-1:k,k-1:k) is a 2-by-2 diagonal block. If UPLO = 'L' and !> IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and !> -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2 !> diagonal block. !> |
| [in,out] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be !> computed. !> |
!> !> The packed storage scheme is illustrated by the following example !> when N = 4, UPLO = 'U': !> !> Two-dimensional storage of the Hermitian matrix A: !> !> a11 a12 a13 a14 !> a22 a23 a24 !> a33 a34 (aij = conjg(aji)) !> a44 !> !> Packed storage of the upper triangle of A: !> !> AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ] !>
Definition at line 161 of file chpsv.f.
| subroutine chpsvx | ( | character | fact, |
| character | uplo, | ||
| integer | n, | ||
| integer | nrhs, | ||
| complex, dimension( * ) | ap, | ||
| complex, dimension( * ) | afp, | ||
| integer, dimension( * ) | ipiv, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| complex, dimension( ldx, * ) | x, | ||
| integer | ldx, | ||
| real | rcond, | ||
| real, dimension( * ) | ferr, | ||
| real, dimension( * ) | berr, | ||
| complex, dimension( * ) | work, | ||
| real, dimension( * ) | rwork, | ||
| integer | info ) |
CHPSVX computes the solution to system of linear equations A * X = B for OTHER matrices
Download CHPSVX + dependencies [TGZ] [ZIP] [TXT]
!> !> CHPSVX uses the diagonal pivoting factorization A = U*D*U**H or !> A = L*D*L**H to compute the solution to a complex system of linear !> equations A * X = B, where A is an N-by-N Hermitian matrix stored !> in packed format and X and B are N-by-NRHS matrices. !> !> Error bounds on the solution and a condition estimate are also !> provided. !>
!> !> The following steps are performed: !> !> 1. If FACT = 'N', the diagonal pivoting method is used to factor A as !> A = U * D * U**H, if UPLO = 'U', or !> A = L * D * L**H, if UPLO = 'L', !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices and D is Hermitian and block diagonal with !> 1-by-1 and 2-by-2 diagonal blocks. !> !> 2. If some D(i,i)=0, so that D is exactly singular, then the routine !> returns with INFO = i. Otherwise, the factored form of A is used !> to estimate the condition number of the matrix A. If the !> reciprocal of the condition number is less than machine precision, !> INFO = N+1 is returned as a warning, but the routine still goes on !> to solve for X and compute error bounds as described below. !> !> 3. The system of equations is solved for X using the factored form !> of A. !> !> 4. Iterative refinement is applied to improve the computed solution !> matrix and calculate error bounds and backward error estimates !> for it. !>
| [in] | FACT | !> FACT is CHARACTER*1 !> Specifies whether or not the factored form of A has been !> supplied on entry. !> = 'F': On entry, AFP and IPIV contain the factored form of !> A. AFP and IPIV will not be modified. !> = 'N': The matrix A will be copied to AFP and factored. !> |
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrices B and X. NRHS >= 0. !> |
| [in] | AP | !> AP is COMPLEX array, dimension (N*(N+1)/2) !> The upper or lower triangle of the Hermitian matrix A, packed !> columnwise in a linear array. The j-th column of A is stored !> in the array AP as follows: !> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; !> if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n. !> See below for further details. !> |
| [in,out] | AFP | !> AFP is COMPLEX array, dimension (N*(N+1)/2) !> If FACT = 'F', then AFP is an input argument and on entry !> contains the block diagonal matrix D and the multipliers used !> to obtain the factor U or L from the factorization !> A = U*D*U**H or A = L*D*L**H as computed by CHPTRF, stored as !> a packed triangular matrix in the same storage format as A. !> !> If FACT = 'N', then AFP is an output argument and on exit !> contains the block diagonal matrix D and the multipliers used !> to obtain the factor U or L from the factorization !> A = U*D*U**H or A = L*D*L**H as computed by CHPTRF, stored as !> a packed triangular matrix in the same storage format as A. !> |
| [in,out] | IPIV | !> IPIV is INTEGER array, dimension (N) !> If FACT = 'F', then IPIV is an input argument and on entry !> contains details of the interchanges and the block structure !> of D, as determined by CHPTRF. !> If IPIV(k) > 0, then rows and columns k and IPIV(k) were !> interchanged and D(k,k) is a 1-by-1 diagonal block. !> If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and !> columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k) !> is a 2-by-2 diagonal block. If UPLO = 'L' and IPIV(k) = !> IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were !> interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block. !> !> If FACT = 'N', then IPIV is an output argument and on exit !> contains details of the interchanges and the block structure !> of D, as determined by CHPTRF. !> |
| [in] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> The N-by-NRHS right hand side matrix B. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | X | !> X is COMPLEX array, dimension (LDX,NRHS) !> If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X. !> |
| [in] | LDX | !> LDX is INTEGER !> The leading dimension of the array X. LDX >= max(1,N). !> |
| [out] | RCOND | !> RCOND is REAL !> The estimate of the reciprocal condition number of the matrix !> A. If RCOND is less than the machine precision (in !> particular, if RCOND = 0), the matrix is singular to working !> precision. This condition is indicated by a return code of !> INFO > 0. !> |
| [out] | FERR | !> FERR is REAL array, dimension (NRHS) !> The estimated forward error bound for each solution vector !> X(j) (the j-th column of the solution matrix X). !> If XTRUE is the true solution corresponding to X(j), FERR(j) !> is an estimated upper bound for the magnitude of the largest !> element in (X(j) - XTRUE) divided by the magnitude of the !> largest element in X(j). The estimate is as reliable as !> the estimate for RCOND, and is almost always a slight !> overestimate of the true error. !> |
| [out] | BERR | !> BERR is REAL array, dimension (NRHS) !> The componentwise relative backward error of each solution !> vector X(j) (i.e., the smallest relative change in !> any element of A or B that makes X(j) an exact solution). !> |
| [out] | WORK | !> WORK is COMPLEX array, dimension (2*N) !> |
| [out] | RWORK | !> RWORK is REAL array, dimension (N) !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, and i is !> <= N: D(i,i) is exactly zero. The factorization !> has been completed but the factor D is exactly !> singular, so the solution and error bounds could !> not be computed. RCOND = 0 is returned. !> = N+1: D is nonsingular, but RCOND is less than machine !> precision, meaning that the matrix is singular !> to working precision. Nevertheless, the !> solution and error bounds are computed because !> there are a number of situations where the !> computed solution can be more accurate than the !> value of RCOND would suggest. !> |
!> !> The packed storage scheme is illustrated by the following example !> when N = 4, UPLO = 'U': !> !> Two-dimensional storage of the Hermitian matrix A: !> !> a11 a12 a13 a14 !> a22 a23 a24 !> a33 a34 (aij = conjg(aji)) !> a44 !> !> Packed storage of the upper triangle of A: !> !> AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ] !>
Definition at line 275 of file chpsvx.f.
| subroutine cpbsv | ( | character | uplo, |
| integer | n, | ||
| integer | kd, | ||
| integer | nrhs, | ||
| complex, dimension( ldab, * ) | ab, | ||
| integer | ldab, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| integer | info ) |
CPBSV computes the solution to system of linear equations A * X = B for OTHER matrices
Download CPBSV + dependencies [TGZ] [ZIP] [TXT]
!> !> CPBSV computes the solution to a complex system of linear equations !> A * X = B, !> where A is an N-by-N Hermitian positive definite band matrix and X !> and B are N-by-NRHS matrices. !> !> The Cholesky decomposition is used to factor A as !> A = U**H * U, if UPLO = 'U', or !> A = L * L**H, if UPLO = 'L', !> where U is an upper triangular band matrix, and L is a lower !> triangular band matrix, with the same number of superdiagonals or !> subdiagonals as A. The factored form of A is then used to solve the !> system of equations A * X = B. !>
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | KD | !> KD is INTEGER !> The number of superdiagonals of the matrix A if UPLO = 'U', !> or the number of subdiagonals if UPLO = 'L'. KD >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 0. !> |
| [in,out] | AB | !> AB is COMPLEX array, dimension (LDAB,N) !> On entry, the upper or lower triangle of the Hermitian band !> matrix A, stored in the first KD+1 rows of the array. The !> j-th column of A is stored in the j-th column of the array AB !> as follows: !> if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j; !> if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(N,j+KD). !> See below for further details. !> !> On exit, if INFO = 0, the triangular factor U or L from the !> Cholesky factorization A = U**H*U or A = L*L**H of the band !> matrix A, in the same storage format as A. !> |
| [in] | LDAB | !> LDAB is INTEGER !> The leading dimension of the array AB. LDAB >= KD+1. !> |
| [in,out] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, the leading minor of order i of A is not !> positive definite, so the factorization could not be !> completed, and the solution has not been computed. !> |
!> !> The band storage scheme is illustrated by the following example, when !> N = 6, KD = 2, and UPLO = 'U': !> !> On entry: On exit: !> !> * * a13 a24 a35 a46 * * u13 u24 u35 u46 !> * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 !> a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 !> !> Similarly, if UPLO = 'L' the format of A is as follows: !> !> On entry: On exit: !> !> a11 a22 a33 a44 a55 a66 l11 l22 l33 l44 l55 l66 !> a21 a32 a43 a54 a65 * l21 l32 l43 l54 l65 * !> a31 a42 a53 a64 * * l31 l42 l53 l64 * * !> !> Array elements marked * are not used by the routine. !>
Definition at line 163 of file cpbsv.f.
| subroutine cpbsvx | ( | character | fact, |
| character | uplo, | ||
| integer | n, | ||
| integer | kd, | ||
| integer | nrhs, | ||
| complex, dimension( ldab, * ) | ab, | ||
| integer | ldab, | ||
| complex, dimension( ldafb, * ) | afb, | ||
| integer | ldafb, | ||
| character | equed, | ||
| real, dimension( * ) | s, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| complex, dimension( ldx, * ) | x, | ||
| integer | ldx, | ||
| real | rcond, | ||
| real, dimension( * ) | ferr, | ||
| real, dimension( * ) | berr, | ||
| complex, dimension( * ) | work, | ||
| real, dimension( * ) | rwork, | ||
| integer | info ) |
CPBSVX computes the solution to system of linear equations A * X = B for OTHER matrices
Download CPBSVX + dependencies [TGZ] [ZIP] [TXT]
!> !> CPBSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to !> compute the solution to a complex system of linear equations !> A * X = B, !> where A is an N-by-N Hermitian positive definite band matrix and X !> and B are N-by-NRHS matrices. !> !> Error bounds on the solution and a condition estimate are also !> provided. !>
!> !> The following steps are performed: !> !> 1. If FACT = 'E', real scaling factors are computed to equilibrate !> the system: !> diag(S) * A * diag(S) * inv(diag(S)) * X = diag(S) * B !> Whether or not the system will be equilibrated depends on the !> scaling of the matrix A, but if equilibration is used, A is !> overwritten by diag(S)*A*diag(S) and B by diag(S)*B. !> !> 2. If FACT = 'N' or 'E', the Cholesky decomposition is used to !> factor the matrix A (after equilibration if FACT = 'E') as !> A = U**H * U, if UPLO = 'U', or !> A = L * L**H, if UPLO = 'L', !> where U is an upper triangular band matrix, and L is a lower !> triangular band matrix. !> !> 3. If the leading i-by-i principal minor is not positive definite, !> then the routine returns with INFO = i. Otherwise, the factored !> form of A is used to estimate the condition number of the matrix !> A. If the reciprocal of the condition number is less than machine !> precision, INFO = N+1 is returned as a warning, but the routine !> still goes on to solve for X and compute error bounds as !> described below. !> !> 4. The system of equations is solved for X using the factored form !> of A. !> !> 5. Iterative refinement is applied to improve the computed solution !> matrix and calculate error bounds and backward error estimates !> for it. !> !> 6. If equilibration was used, the matrix X is premultiplied by !> diag(S) so that it solves the original system before !> equilibration. !>
| [in] | FACT | !> FACT is CHARACTER*1 !> Specifies whether or not the factored form of the matrix A is !> supplied on entry, and if not, whether the matrix A should be !> equilibrated before it is factored. !> = 'F': On entry, AFB contains the factored form of A. !> If EQUED = 'Y', the matrix A has been equilibrated !> with scaling factors given by S. AB and AFB will not !> be modified. !> = 'N': The matrix A will be copied to AFB and factored. !> = 'E': The matrix A will be equilibrated if necessary, then !> copied to AFB and factored. !> |
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | KD | !> KD is INTEGER !> The number of superdiagonals of the matrix A if UPLO = 'U', !> or the number of subdiagonals if UPLO = 'L'. KD >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right-hand sides, i.e., the number of columns !> of the matrices B and X. NRHS >= 0. !> |
| [in,out] | AB | !> AB is COMPLEX array, dimension (LDAB,N) !> On entry, the upper or lower triangle of the Hermitian band !> matrix A, stored in the first KD+1 rows of the array, except !> if FACT = 'F' and EQUED = 'Y', then A must contain the !> equilibrated matrix diag(S)*A*diag(S). The j-th column of A !> is stored in the j-th column of the array AB as follows: !> if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j; !> if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(N,j+KD). !> See below for further details. !> !> On exit, if FACT = 'E' and EQUED = 'Y', A is overwritten by !> diag(S)*A*diag(S). !> |
| [in] | LDAB | !> LDAB is INTEGER !> The leading dimension of the array A. LDAB >= KD+1. !> |
| [in,out] | AFB | !> AFB is COMPLEX array, dimension (LDAFB,N) !> If FACT = 'F', then AFB is an input argument and on entry !> contains the triangular factor U or L from the Cholesky !> factorization A = U**H*U or A = L*L**H of the band matrix !> A, in the same storage format as A (see AB). If EQUED = 'Y', !> then AFB is the factored form of the equilibrated matrix A. !> !> If FACT = 'N', then AFB is an output argument and on exit !> returns the triangular factor U or L from the Cholesky !> factorization A = U**H*U or A = L*L**H. !> !> If FACT = 'E', then AFB is an output argument and on exit !> returns the triangular factor U or L from the Cholesky !> factorization A = U**H*U or A = L*L**H of the equilibrated !> matrix A (see the description of A for the form of the !> equilibrated matrix). !> |
| [in] | LDAFB | !> LDAFB is INTEGER !> The leading dimension of the array AFB. LDAFB >= KD+1. !> |
| [in,out] | EQUED | !> EQUED is CHARACTER*1 !> Specifies the form of equilibration that was done. !> = 'N': No equilibration (always true if FACT = 'N'). !> = 'Y': Equilibration was done, i.e., A has been replaced by !> diag(S) * A * diag(S). !> EQUED is an input argument if FACT = 'F'; otherwise, it is an !> output argument. !> |
| [in,out] | S | !> S is REAL array, dimension (N) !> The scale factors for A; not accessed if EQUED = 'N'. S is !> an input argument if FACT = 'F'; otherwise, S is an output !> argument. If FACT = 'F' and EQUED = 'Y', each element of S !> must be positive. !> |
| [in,out] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if EQUED = 'N', B is not modified; if EQUED = 'Y', !> B is overwritten by diag(S) * B. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | X | !> X is COMPLEX array, dimension (LDX,NRHS) !> If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X to !> the original system of equations. Note that if EQUED = 'Y', !> A and B are modified on exit, and the solution to the !> equilibrated system is inv(diag(S))*X. !> |
| [in] | LDX | !> LDX is INTEGER !> The leading dimension of the array X. LDX >= max(1,N). !> |
| [out] | RCOND | !> RCOND is REAL !> The estimate of the reciprocal condition number of the matrix !> A after equilibration (if done). If RCOND is less than the !> machine precision (in particular, if RCOND = 0), the matrix !> is singular to working precision. This condition is !> indicated by a return code of INFO > 0. !> |
| [out] | FERR | !> FERR is REAL array, dimension (NRHS) !> The estimated forward error bound for each solution vector !> X(j) (the j-th column of the solution matrix X). !> If XTRUE is the true solution corresponding to X(j), FERR(j) !> is an estimated upper bound for the magnitude of the largest !> element in (X(j) - XTRUE) divided by the magnitude of the !> largest element in X(j). The estimate is as reliable as !> the estimate for RCOND, and is almost always a slight !> overestimate of the true error. !> |
| [out] | BERR | !> BERR is REAL array, dimension (NRHS) !> The componentwise relative backward error of each solution !> vector X(j) (i.e., the smallest relative change in !> any element of A or B that makes X(j) an exact solution). !> |
| [out] | WORK | !> WORK is COMPLEX array, dimension (2*N) !> |
| [out] | RWORK | !> RWORK is REAL array, dimension (N) !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, and i is !> <= N: the leading minor of order i of A is !> not positive definite, so the factorization !> could not be completed, and the solution has not !> been computed. RCOND = 0 is returned. !> = N+1: U is nonsingular, but RCOND is less than machine !> precision, meaning that the matrix is singular !> to working precision. Nevertheless, the !> solution and error bounds are computed because !> there are a number of situations where the !> computed solution can be more accurate than the !> value of RCOND would suggest. !> |
!> !> The band storage scheme is illustrated by the following example, when !> N = 6, KD = 2, and UPLO = 'U': !> !> Two-dimensional storage of the Hermitian matrix A: !> !> a11 a12 a13 !> a22 a23 a24 !> a33 a34 a35 !> a44 a45 a46 !> a55 a56 !> (aij=conjg(aji)) a66 !> !> Band storage of the upper triangle of A: !> !> * * a13 a24 a35 a46 !> * a12 a23 a34 a45 a56 !> a11 a22 a33 a44 a55 a66 !> !> Similarly, if UPLO = 'L' the format of A is as follows: !> !> a11 a22 a33 a44 a55 a66 !> a21 a32 a43 a54 a65 * !> a31 a42 a53 a64 * * !> !> Array elements marked * are not used by the routine. !>
Definition at line 339 of file cpbsvx.f.
| subroutine cppsv | ( | character | uplo, |
| integer | n, | ||
| integer | nrhs, | ||
| complex, dimension( * ) | ap, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| integer | info ) |
CPPSV computes the solution to system of linear equations A * X = B for OTHER matrices
Download CPPSV + dependencies [TGZ] [ZIP] [TXT]
!> !> CPPSV computes the solution to a complex system of linear equations !> A * X = B, !> where A is an N-by-N Hermitian positive definite matrix stored in !> packed format and X and B are N-by-NRHS matrices. !> !> The Cholesky decomposition is used to factor A as !> A = U**H * U, if UPLO = 'U', or !> A = L * L**H, if UPLO = 'L', !> where U is an upper triangular matrix and L is a lower triangular !> matrix. The factored form of A is then used to solve the system of !> equations A * X = B. !>
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 0. !> |
| [in,out] | AP | !> AP is COMPLEX array, dimension (N*(N+1)/2) !> On entry, the upper or lower triangle of the Hermitian matrix !> A, packed columnwise in a linear array. The j-th column of A !> is stored in the array AP as follows: !> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; !> if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. !> See below for further details. !> !> On exit, if INFO = 0, the factor U or L from the Cholesky !> factorization A = U**H*U or A = L*L**H, in the same storage !> format as A. !> |
| [in,out] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, the leading minor of order i of A is not !> positive definite, so the factorization could not be !> completed, and the solution has not been computed. !> |
!> !> The packed storage scheme is illustrated by the following example !> when N = 4, UPLO = 'U': !> !> Two-dimensional storage of the Hermitian matrix A: !> !> a11 a12 a13 a14 !> a22 a23 a24 !> a33 a34 (aij = conjg(aji)) !> a44 !> !> Packed storage of the upper triangle of A: !> !> AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ] !>
Definition at line 143 of file cppsv.f.
| subroutine cppsvx | ( | character | fact, |
| character | uplo, | ||
| integer | n, | ||
| integer | nrhs, | ||
| complex, dimension( * ) | ap, | ||
| complex, dimension( * ) | afp, | ||
| character | equed, | ||
| real, dimension( * ) | s, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| complex, dimension( ldx, * ) | x, | ||
| integer | ldx, | ||
| real | rcond, | ||
| real, dimension( * ) | ferr, | ||
| real, dimension( * ) | berr, | ||
| complex, dimension( * ) | work, | ||
| real, dimension( * ) | rwork, | ||
| integer | info ) |
CPPSVX computes the solution to system of linear equations A * X = B for OTHER matrices
Download CPPSVX + dependencies [TGZ] [ZIP] [TXT]
!> !> CPPSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to !> compute the solution to a complex system of linear equations !> A * X = B, !> where A is an N-by-N Hermitian positive definite matrix stored in !> packed format and X and B are N-by-NRHS matrices. !> !> Error bounds on the solution and a condition estimate are also !> provided. !>
!> !> The following steps are performed: !> !> 1. If FACT = 'E', real scaling factors are computed to equilibrate !> the system: !> diag(S) * A * diag(S) * inv(diag(S)) * X = diag(S) * B !> Whether or not the system will be equilibrated depends on the !> scaling of the matrix A, but if equilibration is used, A is !> overwritten by diag(S)*A*diag(S) and B by diag(S)*B. !> !> 2. If FACT = 'N' or 'E', the Cholesky decomposition is used to !> factor the matrix A (after equilibration if FACT = 'E') as !> A = U**H * U , if UPLO = 'U', or !> A = L * L**H, if UPLO = 'L', !> where U is an upper triangular matrix, L is a lower triangular !> matrix, and **H indicates conjugate transpose. !> !> 3. If the leading i-by-i principal minor is not positive definite, !> then the routine returns with INFO = i. Otherwise, the factored !> form of A is used to estimate the condition number of the matrix !> A. If the reciprocal of the condition number is less than machine !> precision, INFO = N+1 is returned as a warning, but the routine !> still goes on to solve for X and compute error bounds as !> described below. !> !> 4. The system of equations is solved for X using the factored form !> of A. !> !> 5. Iterative refinement is applied to improve the computed solution !> matrix and calculate error bounds and backward error estimates !> for it. !> !> 6. If equilibration was used, the matrix X is premultiplied by !> diag(S) so that it solves the original system before !> equilibration. !>
| [in] | FACT | !> FACT is CHARACTER*1 !> Specifies whether or not the factored form of the matrix A is !> supplied on entry, and if not, whether the matrix A should be !> equilibrated before it is factored. !> = 'F': On entry, AFP contains the factored form of A. !> If EQUED = 'Y', the matrix A has been equilibrated !> with scaling factors given by S. AP and AFP will not !> be modified. !> = 'N': The matrix A will be copied to AFP and factored. !> = 'E': The matrix A will be equilibrated if necessary, then !> copied to AFP and factored. !> |
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrices B and X. NRHS >= 0. !> |
| [in,out] | AP | !> AP is COMPLEX array, dimension (N*(N+1)/2) !> On entry, the upper or lower triangle of the Hermitian matrix !> A, packed columnwise in a linear array, except if FACT = 'F' !> and EQUED = 'Y', then A must contain the equilibrated matrix !> diag(S)*A*diag(S). The j-th column of A is stored in the !> array AP as follows: !> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; !> if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. !> See below for further details. A is not modified if !> FACT = 'F' or 'N', or if FACT = 'E' and EQUED = 'N' on exit. !> !> On exit, if FACT = 'E' and EQUED = 'Y', A is overwritten by !> diag(S)*A*diag(S). !> |
| [in,out] | AFP | !> AFP is COMPLEX array, dimension (N*(N+1)/2) !> If FACT = 'F', then AFP is an input argument and on entry !> contains the triangular factor U or L from the Cholesky !> factorization A = U**H*U or A = L*L**H, in the same storage !> format as A. If EQUED .ne. 'N', then AFP is the factored !> form of the equilibrated matrix A. !> !> If FACT = 'N', then AFP is an output argument and on exit !> returns the triangular factor U or L from the Cholesky !> factorization A = U**H * U or A = L * L**H of the original !> matrix A. !> !> If FACT = 'E', then AFP is an output argument and on exit !> returns the triangular factor U or L from the Cholesky !> factorization A = U**H*U or A = L*L**H of the equilibrated !> matrix A (see the description of AP for the form of the !> equilibrated matrix). !> |
| [in,out] | EQUED | !> EQUED is CHARACTER*1 !> Specifies the form of equilibration that was done. !> = 'N': No equilibration (always true if FACT = 'N'). !> = 'Y': Equilibration was done, i.e., A has been replaced by !> diag(S) * A * diag(S). !> EQUED is an input argument if FACT = 'F'; otherwise, it is an !> output argument. !> |
| [in,out] | S | !> S is REAL array, dimension (N) !> The scale factors for A; not accessed if EQUED = 'N'. S is !> an input argument if FACT = 'F'; otherwise, S is an output !> argument. If FACT = 'F' and EQUED = 'Y', each element of S !> must be positive. !> |
| [in,out] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if EQUED = 'N', B is not modified; if EQUED = 'Y', !> B is overwritten by diag(S) * B. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | X | !> X is COMPLEX array, dimension (LDX,NRHS) !> If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X to !> the original system of equations. Note that if EQUED = 'Y', !> A and B are modified on exit, and the solution to the !> equilibrated system is inv(diag(S))*X. !> |
| [in] | LDX | !> LDX is INTEGER !> The leading dimension of the array X. LDX >= max(1,N). !> |
| [out] | RCOND | !> RCOND is REAL !> The estimate of the reciprocal condition number of the matrix !> A after equilibration (if done). If RCOND is less than the !> machine precision (in particular, if RCOND = 0), the matrix !> is singular to working precision. This condition is !> indicated by a return code of INFO > 0. !> |
| [out] | FERR | !> FERR is REAL array, dimension (NRHS) !> The estimated forward error bound for each solution vector !> X(j) (the j-th column of the solution matrix X). !> If XTRUE is the true solution corresponding to X(j), FERR(j) !> is an estimated upper bound for the magnitude of the largest !> element in (X(j) - XTRUE) divided by the magnitude of the !> largest element in X(j). The estimate is as reliable as !> the estimate for RCOND, and is almost always a slight !> overestimate of the true error. !> |
| [out] | BERR | !> BERR is REAL array, dimension (NRHS) !> The componentwise relative backward error of each solution !> vector X(j) (i.e., the smallest relative change in !> any element of A or B that makes X(j) an exact solution). !> |
| [out] | WORK | !> WORK is COMPLEX array, dimension (2*N) !> |
| [out] | RWORK | !> RWORK is REAL array, dimension (N) !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, and i is !> <= N: the leading minor of order i of A is !> not positive definite, so the factorization !> could not be completed, and the solution has not !> been computed. RCOND = 0 is returned. !> = N+1: U is nonsingular, but RCOND is less than machine !> precision, meaning that the matrix is singular !> to working precision. Nevertheless, the !> solution and error bounds are computed because !> there are a number of situations where the !> computed solution can be more accurate than the !> value of RCOND would suggest. !> |
!> !> The packed storage scheme is illustrated by the following example !> when N = 4, UPLO = 'U': !> !> Two-dimensional storage of the Hermitian matrix A: !> !> a11 a12 a13 a14 !> a22 a23 a24 !> a33 a34 (aij = conjg(aji)) !> a44 !> !> Packed storage of the upper triangle of A: !> !> AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ] !>
Definition at line 309 of file cppsvx.f.
| subroutine cspsv | ( | character | uplo, |
| integer | n, | ||
| integer | nrhs, | ||
| complex, dimension( * ) | ap, | ||
| integer, dimension( * ) | ipiv, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| integer | info ) |
CSPSV computes the solution to system of linear equations A * X = B for OTHER matrices
Download CSPSV + dependencies [TGZ] [ZIP] [TXT]
!> !> CSPSV computes the solution to a complex system of linear equations !> A * X = B, !> where A is an N-by-N symmetric matrix stored in packed format and X !> and B are N-by-NRHS matrices. !> !> The diagonal pivoting method is used to factor A as !> A = U * D * U**T, if UPLO = 'U', or !> A = L * D * L**T, if UPLO = 'L', !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices, D is symmetric and block diagonal with 1-by-1 !> and 2-by-2 diagonal blocks. The factored form of A is then used to !> solve the system of equations A * X = B. !>
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 0. !> |
| [in,out] | AP | !> AP is COMPLEX array, dimension (N*(N+1)/2) !> On entry, the upper or lower triangle of the symmetric matrix !> A, packed columnwise in a linear array. The j-th column of A !> is stored in the array AP as follows: !> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; !> if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. !> See below for further details. !> !> On exit, the block diagonal matrix D and the multipliers used !> to obtain the factor U or L from the factorization !> A = U*D*U**T or A = L*D*L**T as computed by CSPTRF, stored as !> a packed triangular matrix in the same storage format as A. !> |
| [out] | IPIV | !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D, as !> determined by CSPTRF. If IPIV(k) > 0, then rows and columns !> k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1 !> diagonal block. If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, !> then rows and columns k-1 and -IPIV(k) were interchanged and !> D(k-1:k,k-1:k) is a 2-by-2 diagonal block. If UPLO = 'L' and !> IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and !> -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2 !> diagonal block. !> |
| [in,out] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, D(i,i) is exactly zero. The factorization !> has been completed, but the block diagonal matrix D is !> exactly singular, so the solution could not be !> computed. !> |
!> !> The packed storage scheme is illustrated by the following example !> when N = 4, UPLO = 'U': !> !> Two-dimensional storage of the symmetric matrix A: !> !> a11 a12 a13 a14 !> a22 a23 a24 !> a33 a34 (aij = aji) !> a44 !> !> Packed storage of the upper triangle of A: !> !> AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ] !>
Definition at line 161 of file cspsv.f.
| subroutine cspsvx | ( | character | fact, |
| character | uplo, | ||
| integer | n, | ||
| integer | nrhs, | ||
| complex, dimension( * ) | ap, | ||
| complex, dimension( * ) | afp, | ||
| integer, dimension( * ) | ipiv, | ||
| complex, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| complex, dimension( ldx, * ) | x, | ||
| integer | ldx, | ||
| real | rcond, | ||
| real, dimension( * ) | ferr, | ||
| real, dimension( * ) | berr, | ||
| complex, dimension( * ) | work, | ||
| real, dimension( * ) | rwork, | ||
| integer | info ) |
CSPSVX computes the solution to system of linear equations A * X = B for OTHER matrices
Download CSPSVX + dependencies [TGZ] [ZIP] [TXT]
!> !> CSPSVX uses the diagonal pivoting factorization A = U*D*U**T or !> A = L*D*L**T to compute the solution to a complex system of linear !> equations A * X = B, where A is an N-by-N symmetric matrix stored !> in packed format and X and B are N-by-NRHS matrices. !> !> Error bounds on the solution and a condition estimate are also !> provided. !>
!> !> The following steps are performed: !> !> 1. If FACT = 'N', the diagonal pivoting method is used to factor A as !> A = U * D * U**T, if UPLO = 'U', or !> A = L * D * L**T, if UPLO = 'L', !> where U (or L) is a product of permutation and unit upper (lower) !> triangular matrices and D is symmetric and block diagonal with !> 1-by-1 and 2-by-2 diagonal blocks. !> !> 2. If some D(i,i)=0, so that D is exactly singular, then the routine !> returns with INFO = i. Otherwise, the factored form of A is used !> to estimate the condition number of the matrix A. If the !> reciprocal of the condition number is less than machine precision, !> INFO = N+1 is returned as a warning, but the routine still goes on !> to solve for X and compute error bounds as described below. !> !> 3. The system of equations is solved for X using the factored form !> of A. !> !> 4. Iterative refinement is applied to improve the computed solution !> matrix and calculate error bounds and backward error estimates !> for it. !>
| [in] | FACT | !> FACT is CHARACTER*1 !> Specifies whether or not the factored form of A has been !> supplied on entry. !> = 'F': On entry, AFP and IPIV contain the factored form !> of A. AP, AFP and IPIV will not be modified. !> = 'N': The matrix A will be copied to AFP and factored. !> |
| [in] | UPLO | !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> |
| [in] | N | !> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0. !> |
| [in] | NRHS | !> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrices B and X. NRHS >= 0. !> |
| [in] | AP | !> AP is COMPLEX array, dimension (N*(N+1)/2) !> The upper or lower triangle of the symmetric matrix A, packed !> columnwise in a linear array. The j-th column of A is stored !> in the array AP as follows: !> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; !> if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n. !> See below for further details. !> |
| [in,out] | AFP | !> AFP is COMPLEX array, dimension (N*(N+1)/2) !> If FACT = 'F', then AFP is an input argument and on entry !> contains the block diagonal matrix D and the multipliers used !> to obtain the factor U or L from the factorization !> A = U*D*U**T or A = L*D*L**T as computed by CSPTRF, stored as !> a packed triangular matrix in the same storage format as A. !> !> If FACT = 'N', then AFP is an output argument and on exit !> contains the block diagonal matrix D and the multipliers used !> to obtain the factor U or L from the factorization !> A = U*D*U**T or A = L*D*L**T as computed by CSPTRF, stored as !> a packed triangular matrix in the same storage format as A. !> |
| [in,out] | IPIV | !> IPIV is INTEGER array, dimension (N) !> If FACT = 'F', then IPIV is an input argument and on entry !> contains details of the interchanges and the block structure !> of D, as determined by CSPTRF. !> If IPIV(k) > 0, then rows and columns k and IPIV(k) were !> interchanged and D(k,k) is a 1-by-1 diagonal block. !> If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and !> columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k) !> is a 2-by-2 diagonal block. If UPLO = 'L' and IPIV(k) = !> IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were !> interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block. !> !> If FACT = 'N', then IPIV is an output argument and on exit !> contains details of the interchanges and the block structure !> of D, as determined by CSPTRF. !> |
| [in] | B | !> B is COMPLEX array, dimension (LDB,NRHS) !> The N-by-NRHS right hand side matrix B. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> |
| [out] | X | !> X is COMPLEX array, dimension (LDX,NRHS) !> If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X. !> |
| [in] | LDX | !> LDX is INTEGER !> The leading dimension of the array X. LDX >= max(1,N). !> |
| [out] | RCOND | !> RCOND is REAL !> The estimate of the reciprocal condition number of the matrix !> A. If RCOND is less than the machine precision (in !> particular, if RCOND = 0), the matrix is singular to working !> precision. This condition is indicated by a return code of !> INFO > 0. !> |
| [out] | FERR | !> FERR is REAL array, dimension (NRHS) !> The estimated forward error bound for each solution vector !> X(j) (the j-th column of the solution matrix X). !> If XTRUE is the true solution corresponding to X(j), FERR(j) !> is an estimated upper bound for the magnitude of the largest !> element in (X(j) - XTRUE) divided by the magnitude of the !> largest element in X(j). The estimate is as reliable as !> the estimate for RCOND, and is almost always a slight !> overestimate of the true error. !> |
| [out] | BERR | !> BERR is REAL array, dimension (NRHS) !> The componentwise relative backward error of each solution !> vector X(j) (i.e., the smallest relative change in !> any element of A or B that makes X(j) an exact solution). !> |
| [out] | WORK | !> WORK is COMPLEX array, dimension (2*N) !> |
| [out] | RWORK | !> RWORK is REAL array, dimension (N) !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, and i is !> <= N: D(i,i) is exactly zero. The factorization !> has been completed but the factor D is exactly !> singular, so the solution and error bounds could !> not be computed. RCOND = 0 is returned. !> = N+1: D is nonsingular, but RCOND is less than machine !> precision, meaning that the matrix is singular !> to working precision. Nevertheless, the !> solution and error bounds are computed because !> there are a number of situations where the !> computed solution can be more accurate than the !> value of RCOND would suggest. !> |
!> !> The packed storage scheme is illustrated by the following example !> when N = 4, UPLO = 'U': !> !> Two-dimensional storage of the symmetric matrix A: !> !> a11 a12 a13 a14 !> a22 a23 a24 !> a33 a34 (aij = aji) !> a44 !> !> Packed storage of the upper triangle of A: !> !> AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ] !>
Definition at line 275 of file cspsvx.f.
1.15.0