sspsvx
sspsvx - use the diagonal pivoting factorization A = U*D*U**T or A = L*D*L**T to compute the solution to a real 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
SUBROUTINE SSPSVX( FACT, UPLO, N, NRHS, A, AF, IPIVOT, B, LDB, X,
* LDX, RCOND, FERR, BERR, WORK, WORK2, INFO)
CHARACTER * 1 FACT, UPLO
INTEGER N, NRHS, LDB, LDX, INFO
INTEGER IPIVOT(*), WORK2(*)
REAL RCOND
REAL A(*), AF(*), B(LDB,*), X(LDX,*), FERR(*), BERR(*), WORK(*)
SUBROUTINE SSPSVX_64( FACT, UPLO, N, NRHS, A, AF, IPIVOT, B, LDB, X,
* LDX, RCOND, FERR, BERR, WORK, WORK2, INFO)
CHARACTER * 1 FACT, UPLO
INTEGER*8 N, NRHS, LDB, LDX, INFO
INTEGER*8 IPIVOT(*), WORK2(*)
REAL RCOND
REAL A(*), AF(*), B(LDB,*), X(LDX,*), FERR(*), BERR(*), WORK(*)
SUBROUTINE SPSVX( FACT, UPLO, N, NRHS, A, AF, IPIVOT, B, [LDB], X,
* [LDX], RCOND, FERR, BERR, [WORK], [WORK2], [INFO])
CHARACTER(LEN=1) :: FACT, UPLO
INTEGER :: N, NRHS, LDB, LDX, INFO
INTEGER, DIMENSION(:) :: IPIVOT, WORK2
REAL :: RCOND
REAL, DIMENSION(:) :: A, AF, FERR, BERR, WORK
REAL, DIMENSION(:,:) :: B, X
SUBROUTINE SPSVX_64( FACT, UPLO, N, NRHS, A, AF, IPIVOT, B, [LDB],
* X, [LDX], RCOND, FERR, BERR, [WORK], [WORK2], [INFO])
CHARACTER(LEN=1) :: FACT, UPLO
INTEGER(8) :: N, NRHS, LDB, LDX, INFO
INTEGER(8), DIMENSION(:) :: IPIVOT, WORK2
REAL :: RCOND
REAL, DIMENSION(:) :: A, AF, FERR, BERR, WORK
REAL, DIMENSION(:,:) :: B, X
#include <sunperf.h>
void sspsvx(char fact, char uplo, int n, int nrhs, float *a, float *af, int *ipivot, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
void sspsvx_64(char fact, char uplo, long n, long nrhs, float *a, float *af, long *ipivot, float *b, long ldb, float *x, long ldx, float *rcond, float *ferr, float *berr, long *info);
sspsvx uses the diagonal pivoting factorization A = U*D*U**T or
A = L*D*L**T to compute the solution to a real 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.
-
* FACT (input)
-
Specifies whether or not the factored form of A has been
supplied on entry.
-
* UPLO (input)
-
-
* N (input)
-
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
-
* NRHS (input)
-
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
-
* A (input)
-
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 A as follows:
if UPLO = 'U', A(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', A(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
See below for further details.
-
* AF (input/output)
-
(N*(N+1)/2)
If FACT = 'F', then AF 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 SSPTRF, stored as
a packed triangular matrix in the same storage format as A.
If FACT = 'N', then AF 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 SSPTRF, stored as
a packed triangular matrix in the same storage format as A.
-
* IPIVOT (input)
-
If FACT = 'F', then IPIVOT is an input argument and on entry
contains details of the interchanges and the block structure
of D, as determined by SSPTRF.
If IPIVOT(k) > 0, then rows and columns k and IPIVOT(k) were
interchanged and D(k,k) is a 1-by-1 diagonal block.
If UPLO = 'U' and IPIVOT(k) = IPIVOT(k-1) < 0, then rows and
columns k-1 and -IPIVOT(k) were interchanged and D(k-1:k,k-1:k)
is a 2-by-2 diagonal block. If UPLO = 'L' and IPIVOT(k) =
IPIVOT(k+1) < 0, then rows and columns k+1 and -IPIVOT(k) were
interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
If FACT = 'N', then IPIVOT is an output argument and on exit
contains details of the interchanges and the block structure
of D, as determined by SSPTRF.
-
* B (input)
-
The N-by-NRHS right hand side matrix B.
-
* LDB (input)
-
The leading dimension of the array B. LDB >= max(1,N).
-
* X (output)
-
If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X.
-
* LDX (input)
-
The leading dimension of the array X. LDX >= max(1,N).
-
* RCOND (output)
-
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.
-
* FERR (output)
-
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.
-
* BERR (output)
-
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).
-
* WORK (workspace)
-
dimension(3*N)
-
* WORK2 (workspace)
-
-
* INFO (output)
-