posvx#

sposvx

Functions

void sposvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          f32*  restrict A,
    const INT            lda,
          f32*  restrict AF,
    const INT            ldaf,
          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 sposvx(const char *fact, const char *uplo, const INT n, const INT nrhs, f32 *restrict A, const INT lda, f32 *restrict AF, const INT ldaf, 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)#

SPOSVX 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 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 the matrix A is supplied on entry, and if not, whether to equilibrate. = ‘F’: AF contains the factored form of A; S, equed specify equilibration done previously. = ‘N’: The matrix A will be factored without equilibration. = ‘E’: The matrix A will be equilibrated then 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

A

The symmetric matrix A, or equilibrated form. Array of dimension (lda, n).

in

lda

The leading dimension of A. lda >= max(1, n).

inout

AF

The triangular factor U or L. Array of dimension (ldaf, n).

in

ldaf

The leading dimension of AF. ldaf >= max(1, n).

inout

equed

On entry if fact = ‘F’, specifies whether A has been equilibrated (‘N’ or ‘Y’). On exit, set to ‘Y’ if equilibration was done.

inout

S

Scale factors. Array of dimension (n).

inout

B

Right hand side matrix B (scaled if equed = ‘Y’). Array of dimension (ldb, nrhs).

in

ldb

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

out

X

Solution matrix X. Array of dimension (ldx, nrhs).

in

ldx

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

out

rcond

Reciprocal condition number estimate.

out

ferr

Forward error bound. Array of dimension (nrhs).

out

berr

Backward error. Array of dimension (nrhs).

out

work

Workspace, dimension (3*n).

out

iwork

Integer workspace, dimension (n).

out

info

= 0: successful exit
< 0: if info = -k, the k-th argument had an illegal value
> 0, <= n: the leading principal minor of order info is not positive; rcond = 0 is returned.
= n+1: the matrix is singular to working precision.

dposvx

Functions

void dposvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          f64*  restrict A,
    const INT            lda,
          f64*  restrict AF,
    const INT            ldaf,
          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 dposvx(const char *fact, const char *uplo, const INT n, const INT nrhs, f64 *restrict A, const INT lda, f64 *restrict AF, const INT ldaf, 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)#

DPOSVX 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 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 the matrix A is supplied on entry, and if not, whether to equilibrate. = ‘F’: AF contains the factored form of A; S, equed specify equilibration done previously. = ‘N’: The matrix A will be factored without equilibration. = ‘E’: The matrix A will be equilibrated then 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

A

The symmetric matrix A, or equilibrated form. Array of dimension (lda, n).

in

lda

The leading dimension of A. lda >= max(1, n).

inout

AF

The triangular factor U or L. Array of dimension (ldaf, n).

in

ldaf

The leading dimension of AF. ldaf >= max(1, n).

inout

equed

On entry if fact = ‘F’, specifies whether A has been equilibrated (‘N’ or ‘Y’). On exit, set to ‘Y’ if equilibration was done.

inout

S

Scale factors. Array of dimension (n).

inout

B

Right hand side matrix B (scaled if equed = ‘Y’). Array of dimension (ldb, nrhs).

in

ldb

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

out

X

Solution matrix X. Array of dimension (ldx, nrhs).

in

ldx

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

out

rcond

Reciprocal condition number estimate.

out

ferr

Forward error bound. Array of dimension (nrhs).

out

berr

Backward error. Array of dimension (nrhs).

out

work

Workspace, dimension (3*n).

out

iwork

Integer workspace, dimension (n).

out

info

= 0: successful exit
< 0: if info = -k, the k-th argument had an illegal value
> 0, <= n: the leading principal minor of order info is not positive; rcond = 0 is returned.
= n+1: the matrix is singular to working precision.

cposvx

Functions

void cposvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          c64*  restrict A,
    const INT            lda,
          c64*  restrict AF,
    const INT            ldaf,
          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 cposvx(const char *fact, const char *uplo, const INT n, const INT nrhs, c64 *restrict A, const INT lda, c64 *restrict AF, const INT ldaf, 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)#

CPOSVX 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 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 the matrix A is supplied on entry, and if not, whether to equilibrate. = ‘F’: AF contains the factored form of A; S, equed specify equilibration done previously. = ‘N’: The matrix A will be factored without equilibration. = ‘E’: The matrix A will be equilibrated then 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

A

The Hermitian matrix A, or equilibrated form. Array of dimension (lda, n).

in

lda

The leading dimension of A. lda >= max(1, n).

inout

AF

The triangular factor U or L. Array of dimension (ldaf, n).

in

ldaf

The leading dimension of AF. ldaf >= max(1, n).

inout

equed

On entry if fact = ‘F’, specifies whether A has been equilibrated (‘N’ or ‘Y’). On exit, set to ‘Y’ if equilibration was done.

inout

S

Scale factors. Array of dimension (n).

inout

B

Right hand side matrix B (scaled if equed = ‘Y’). Array of dimension (ldb, nrhs).

in

ldb

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

out

X

Solution matrix X. Array of dimension (ldx, nrhs).

in

ldx

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

out

rcond

Reciprocal condition number estimate.

out

ferr

Forward error bound. Array of dimension (nrhs).

out

berr

Backward error. Array of dimension (nrhs).

out

work

Workspace, dimension (2*n).

out

rwork

Real workspace, dimension (n).

out

info

= 0: successful exit
< 0: if info = -k, the k-th argument had an illegal value
> 0, <= n: the leading principal minor of order info is not positive; rcond = 0 is returned.
= n+1: the matrix is singular to working precision.

zposvx

Functions

void zposvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            nrhs,
          c128* restrict A,
    const INT            lda,
          c128* restrict AF,
    const INT            ldaf,
          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 zposvx(const char *fact, const char *uplo, const INT n, const INT nrhs, c128 *restrict A, const INT lda, c128 *restrict AF, const INT ldaf, 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)#

ZPOSVX 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 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 the matrix A is supplied on entry, and if not, whether to equilibrate. = ‘F’: AF contains the factored form of A; S, equed specify equilibration done previously. = ‘N’: The matrix A will be factored without equilibration. = ‘E’: The matrix A will be equilibrated then 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

A

The Hermitian matrix A, or equilibrated form. Array of dimension (lda, n).

in

lda

The leading dimension of A. lda >= max(1, n).

inout

AF

The triangular factor U or L. Array of dimension (ldaf, n).

in

ldaf

The leading dimension of AF. ldaf >= max(1, n).

inout

equed

On entry if fact = ‘F’, specifies whether A has been equilibrated (‘N’ or ‘Y’). On exit, set to ‘Y’ if equilibration was done.

inout

S

Scale factors. Array of dimension (n).

inout

B

Right hand side matrix B (scaled if equed = ‘Y’). Array of dimension (ldb, nrhs).

in

ldb

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

out

X

Solution matrix X. Array of dimension (ldx, nrhs).

in

ldx

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

out

rcond

Reciprocal condition number estimate.

out

ferr

Forward error bound. Array of dimension (nrhs).

out

berr

Backward error. Array of dimension (nrhs).

out

work

Workspace, dimension (2*n).

out

rwork

Real workspace, dimension (n).

out

info

= 0: successful exit
< 0: if info = -k, the k-th argument had an illegal value
> 0, <= n: the leading principal minor of order info is not positive; rcond = 0 is returned.
= n+1: the matrix is singular to working precision.

posvx#

This Page