spsvx#

Functions

void sspsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
    const f32*  restrict AP,
          f32*  restrict AFP,
          INT*  restrict ipiv,
    const f32*  restrict B,
    const INT            ldb,
          f32*  restrict X,
    const INT            ldx,
          f32*           rcond,
          f32*  restrict ferr,
          f32*  restrict berr,
          f32*  restrict work,
          INT*  restrict iwork,
          INT*           info
);
void sspsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, const f32 *restrict AP, f32 *restrict AFP, INT *restrict ipiv, const f32 *restrict B, const INT ldb, f32 *restrict X, const INT ldx, f32 *rcond, f32 *restrict ferr, f32 *restrict berr, f32 *restrict work, INT *restrict iwork, INT *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.

Parameters

in
fact

= ‘F’: AFP and IPIV contain the factored form of A = ‘N’: The matrix A will be copied to AFP and factored

in
uplo

= ‘U’: Upper triangle of A is stored = ‘L’: Lower triangle of A is stored

in
n

The order of the matrix A. n >= 0.

in
nrhs

The number of right hand sides. nrhs >= 0.

in
AP

The original packed symmetric matrix A. Array of dimension (n*(n+1)/2).

inout
AFP

If fact = ‘F’, contains the factored form from SSPTRF. If fact = ‘N’, on exit contains the factored form. Array of dimension (n*(n+1)/2).

inout
ipiv

If fact = ‘F’, contains the pivot indices from SSPTRF. If fact = ‘N’, on exit contains the pivot indices. Array of dimension (n).

in
B

The right hand side matrix B. Array of dimension (ldb, nrhs).

in
ldb

The leading dimension of B. ldb >= max(1,n).

out
X

The solution matrix X. Array of dimension (ldx, nrhs).

in
ldx

The leading dimension of X. ldx >= max(1,n).

out
rcond

The reciprocal condition number of A.

out
ferr

The forward error bound for each solution vector. Array of dimension (nrhs).

out
berr

The backward error for each solution vector. Array of dimension (nrhs).

out
work

Workspace array of dimension (3*n).

out
iwork

Integer workspace array of dimension (n).

out
info

  • = 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, or if info = n+1, the matrix is singular to working precision

Functions

void dspsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
    const f64*  restrict AP,
          f64*  restrict AFP,
          INT*  restrict ipiv,
    const f64*  restrict B,
    const INT            ldb,
          f64*  restrict X,
    const INT            ldx,
          f64*           rcond,
          f64*  restrict ferr,
          f64*  restrict berr,
          f64*  restrict work,
          INT*  restrict iwork,
          INT*           info
);
void dspsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, const f64 *restrict AP, f64 *restrict AFP, INT *restrict ipiv, const f64 *restrict B, const INT ldb, f64 *restrict X, const INT ldx, f64 *rcond, f64 *restrict ferr, f64 *restrict berr, f64 *restrict work, INT *restrict iwork, INT *info)#

DSPSVX 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.

Parameters

in
fact

= ‘F’: AFP and IPIV contain the factored form of A = ‘N’: The matrix A will be copied to AFP and factored

in
uplo

= ‘U’: Upper triangle of A is stored = ‘L’: Lower triangle of A is stored

in
n

The order of the matrix A. n >= 0.

in
nrhs

The number of right hand sides. nrhs >= 0.

in
AP

The original packed symmetric matrix A. Array of dimension (n*(n+1)/2).

inout
AFP

If fact = ‘F’, contains the factored form from DSPTRF. If fact = ‘N’, on exit contains the factored form. Array of dimension (n*(n+1)/2).

inout
ipiv

If fact = ‘F’, contains the pivot indices from DSPTRF. If fact = ‘N’, on exit contains the pivot indices. Array of dimension (n).

in
B

The right hand side matrix B. Array of dimension (ldb, nrhs).

in
ldb

The leading dimension of B. ldb >= max(1,n).

out
X

The solution matrix X. Array of dimension (ldx, nrhs).

in
ldx

The leading dimension of X. ldx >= max(1,n).

out
rcond

The reciprocal condition number of A.

out
ferr

The forward error bound for each solution vector. Array of dimension (nrhs).

out
berr

The backward error for each solution vector. Array of dimension (nrhs).

out
work

Workspace array of dimension (3*n).

out
iwork

Integer workspace array of dimension (n).

out
info

  • = 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, or if info = n+1, the matrix is singular to working precision

Functions

void cspsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
    const c64*  restrict AP,
          c64*  restrict AFP,
          INT*  restrict ipiv,
    const c64*  restrict B,
    const INT            ldb,
          c64*  restrict X,
    const INT            ldx,
          f32*           rcond,
          f32*  restrict ferr,
          f32*  restrict berr,
          c64*  restrict work,
          f32*  restrict rwork,
          INT*           info
);
void cspsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, const c64 *restrict AP, c64 *restrict AFP, INT *restrict ipiv, const c64 *restrict B, const INT ldb, c64 *restrict X, const INT ldx, f32 *rcond, f32 *restrict ferr, f32 *restrict berr, c64 *restrict work, f32 *restrict rwork, INT *info)#

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.

Parameters

in
fact

= ‘F’: AFP and IPIV contain the factored form of A = ‘N’: The matrix A will be copied to AFP and factored

in
uplo

= ‘U’: Upper triangle of A is stored = ‘L’: Lower triangle of A is stored

in
n

The order of the matrix A. n >= 0.

in
nrhs

The number of right hand sides. nrhs >= 0.

in
AP

The original packed symmetric matrix A. Array of dimension (n*(n+1)/2).

inout
AFP

If fact = ‘F’, contains the factored form from CSPTRF. If fact = ‘N’, on exit contains the factored form. Array of dimension (n*(n+1)/2).

inout
ipiv

If fact = ‘F’, contains the pivot indices from CSPTRF. If fact = ‘N’, on exit contains the pivot indices. Array of dimension (n).

in
B

The right hand side matrix B. Array of dimension (ldb, nrhs).

in
ldb

The leading dimension of B. ldb >= max(1,n).

out
X

The solution matrix X. Array of dimension (ldx, nrhs).

in
ldx

The leading dimension of X. ldx >= max(1,n).

out
rcond

The reciprocal condition number of A.

out
ferr

The forward error bound for each solution vector. Array of dimension (nrhs).

out
berr

The backward error for each solution vector. Array of dimension (nrhs).

out
work

Complex workspace array of dimension (2*n).

out
rwork

Single precision workspace array of dimension (n).

out
info

  • = 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, or if info = n+1, the matrix is singular to working precision

Functions

void zspsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
    const c128* restrict AP,
          c128* restrict AFP,
          INT*  restrict ipiv,
    const c128* restrict B,
    const INT            ldb,
          c128* restrict X,
    const INT            ldx,
          f64*           rcond,
          f64*  restrict ferr,
          f64*  restrict berr,
          c128* restrict work,
          f64*  restrict rwork,
          INT*           info
);
void zspsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, const c128 *restrict AP, c128 *restrict AFP, INT *restrict ipiv, const c128 *restrict B, const INT ldb, c128 *restrict X, const INT ldx, f64 *rcond, f64 *restrict ferr, f64 *restrict berr, c128 *restrict work, f64 *restrict rwork, INT *info)#

ZSPSVX 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.

Parameters

in
fact

= ‘F’: AFP and IPIV contain the factored form of A = ‘N’: The matrix A will be copied to AFP and factored

in
uplo

= ‘U’: Upper triangle of A is stored = ‘L’: Lower triangle of A is stored

in
n

The order of the matrix A. n >= 0.

in
nrhs

The number of right hand sides. nrhs >= 0.

in
AP

The original packed symmetric matrix A. Array of dimension (n*(n+1)/2).

inout
AFP

If fact = ‘F’, contains the factored form from ZSPTRF. If fact = ‘N’, on exit contains the factored form. Array of dimension (n*(n+1)/2).

inout
ipiv

If fact = ‘F’, contains the pivot indices from ZSPTRF. If fact = ‘N’, on exit contains the pivot indices. Array of dimension (n).

in
B

The right hand side matrix B. Array of dimension (ldb, nrhs).

in
ldb

The leading dimension of B. ldb >= max(1,n).

out
X

The solution matrix X. Array of dimension (ldx, nrhs).

in
ldx

The leading dimension of X. ldx >= max(1,n).

out
rcond

The reciprocal condition number of A.

out
ferr

The forward error bound for each solution vector. Array of dimension (nrhs).

out
berr

The backward error for each solution vector. Array of dimension (nrhs).

out
work

Complex workspace array of dimension (2*n).

out
rwork

Double precision workspace array of dimension (n).

out
info

  • = 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, or if info = n+1, the matrix is singular to working precision

On this page

This Page