ppsvx

sppsvx

Functions

void sppsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          f32*  restrict AP,
          f32*  restrict AFP,
          char*          equed,
          f32*  restrict S,
          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 sppsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, f32 *restrict AP, f32 *restrict AFP, char *equed, f32 *restrict S, 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)

SPPSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric 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.

Parameters

in

fact

Specifies whether the factored form of A is supplied. = ‘F’: AFP contains the factored form of A. = ‘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

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

in

n

The number of linear equations. n >= 0.

in

nrhs

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

inout

AP

On entry, the symmetric matrix A in packed format. On exit, if fact = ‘E’ and equed = ‘Y’, A is overwritten by diag(S)*A*diag(S). Array of dimension (n*(n+1)/2).

inout

AFP

If fact = ‘F’, AFP is an input with the factored form. Otherwise, AFP is an output with the Cholesky factor. Array of dimension (n*(n+1)/2).

inout

equed

Specifies the form of equilibration. = ‘N’: No equilibration = ‘Y’: Equilibration was done equed is an input if fact = ‘F’; otherwise, it is an output.

inout

S

Scale factors for A. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equed = ‘Y’, B is overwritten by diag(S)*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 estimate.

out

ferr

Forward error bounds. Array of dimension (nrhs).

out

berr

Backward error bounds. 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 and i <= n, the leading principal minor of order i is not positive; if info = n+1, the matrix is singular to working precision.

dppsvx

Functions

void dppsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          f64*  restrict AP,
          f64*  restrict AFP,
          char*          equed,
          f64*  restrict S,
          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 dppsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, f64 *restrict AP, f64 *restrict AFP, char *equed, f64 *restrict S, 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)

DPPSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric 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.

Parameters

in

fact

Specifies whether the factored form of A is supplied. = ‘F’: AFP contains the factored form of A. = ‘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

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

in

n

The number of linear equations. n >= 0.

in

nrhs

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

inout

AP

On entry, the symmetric matrix A in packed format. On exit, if fact = ‘E’ and equed = ‘Y’, A is overwritten by diag(S)*A*diag(S). Array of dimension (n*(n+1)/2).

inout

AFP

If fact = ‘F’, AFP is an input with the factored form. Otherwise, AFP is an output with the Cholesky factor. Array of dimension (n*(n+1)/2).

inout

equed

Specifies the form of equilibration. = ‘N’: No equilibration = ‘Y’: Equilibration was done equed is an input if fact = ‘F’; otherwise, it is an output.

inout

S

Scale factors for A. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equed = ‘Y’, B is overwritten by diag(S)*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 estimate.

out

ferr

Forward error bounds. Array of dimension (nrhs).

out

berr

Backward error bounds. 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 and i <= n, the leading principal minor of order i is not positive; if info = n+1, the matrix is singular to working precision.

cppsvx

Functions

void cppsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          c64*  restrict AP,
          c64*  restrict AFP,
          char*          equed,
          f32*  restrict S,
          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 cppsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, c64 *restrict AP, c64 *restrict AFP, char *equed, f32 *restrict S, 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)

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.

Parameters

in

fact

Specifies whether the factored form of A is supplied. = ‘F’: AFP contains the factored form of A. = ‘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

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

in

n

The number of linear equations. n >= 0.

in

nrhs

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

inout

AP

On entry, the Hermitian matrix A in packed format. On exit, if fact = ‘E’ and equed = ‘Y’, A is overwritten by diag(S)*A*diag(S). Array of dimension (n*(n+1)/2).

inout

AFP

If fact = ‘F’, AFP is an input with the factored form. Otherwise, AFP is an output with the Cholesky factor. Array of dimension (n*(n+1)/2).

inout

equed

Specifies the form of equilibration. = ‘N’: No equilibration = ‘Y’: Equilibration was done equed is an input if fact = ‘F’; otherwise, it is an output.

inout

S

Scale factors for A. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equed = ‘Y’, B is overwritten by diag(S)*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 estimate.

out

ferr

Forward error bounds. Array of dimension (nrhs).

out

berr

Backward error bounds. Array of dimension (nrhs).

out

work

Complex workspace array of dimension (2*n).

out

rwork

Real 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 and i <= n, the leading principal minor of order i is not positive; if info = n+1, the matrix is singular to working precision.

zppsvx

Functions

void zppsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          c128* restrict AP,
          c128* restrict AFP,
          char*          equed,
          f64*  restrict S,
          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 zppsvx(const char *fact, const char *uplo, const INT n, const INT nrhs, c128 *restrict AP, c128 *restrict AFP, char *equed, f64 *restrict S, 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)

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

Parameters

in

fact

Specifies whether the factored form of A is supplied. = ‘F’: AFP contains the factored form of A. = ‘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

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

in

n

The number of linear equations. n >= 0.

in

nrhs

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

inout

AP

On entry, the Hermitian matrix A in packed format. On exit, if fact = ‘E’ and equed = ‘Y’, A is overwritten by diag(S)*A*diag(S). Array of dimension (n*(n+1)/2).

inout

AFP

If fact = ‘F’, AFP is an input with the factored form. Otherwise, AFP is an output with the Cholesky factor. Array of dimension (n*(n+1)/2).

inout

equed

Specifies the form of equilibration. = ‘N’: No equilibration = ‘Y’: Equilibration was done equed is an input if fact = ‘F’; otherwise, it is an output.

inout

S

Scale factors for A. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equed = ‘Y’, B is overwritten by diag(S)*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 estimate.

out

ferr

Forward error bounds. Array of dimension (nrhs).

out

berr

Backward error bounds. Array of dimension (nrhs).

out

work

Complex workspace array of dimension (2*n).

out

rwork

Real 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 and i <= n, the leading principal minor of order i is not positive; if info = n+1, the matrix is singular to working precision.