pbsvx#

Functions

void spbsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            kd,
    const INT            nrhs,
          f32*  restrict AB,
    const INT            ldab,
          f32*  restrict AFB,
    const INT            ldafb,
          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 spbsvx(const char *fact, const char *uplo, const INT n, const INT kd, const INT nrhs, f32 *restrict AB, const INT ldab, f32 *restrict AFB, const INT ldafb, 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)#

SPBSVX 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 band 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

= ‘F’: AFB contains the factored form of A = ‘N’: The matrix A will be copied to AFB and factored = ‘E’: The matrix A will be equilibrated, copied, 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
kd

The number of super-diagonals (if uplo=’U’) or sub-diagonals (if uplo=’L’). kd >= 0.

in
nrhs

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

inout
AB

The banded matrix A. Array of dimension (ldab, n).

in
ldab

The leading dimension of AB. ldab >= kd+1.

inout
AFB

The factored form of A. Array of dimension (ldafb, n).

in
ldafb

The leading dimension of AFB. ldafb >= kd+1.

inout
equed

= ‘N’: No equilibration = ‘Y’: Equilibration was done

inout
S

The scale factors for A. Array of dimension (n).

inout
B

On entry, the 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.

out
ferr

The forward error bound. Array of dimension (nrhs).

out
berr

The backward error. 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, the leading minor of order i is not positive definite; if info = n+1, rcond is too small.

Functions

void dpbsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            kd,
    const INT            nrhs,
          f64*  restrict AB,
    const INT            ldab,
          f64*  restrict AFB,
    const INT            ldafb,
          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 dpbsvx(const char *fact, const char *uplo, const INT n, const INT kd, const INT nrhs, f64 *restrict AB, const INT ldab, f64 *restrict AFB, const INT ldafb, 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)#

DPBSVX 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 band 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

= ‘F’: AFB contains the factored form of A = ‘N’: The matrix A will be copied to AFB and factored = ‘E’: The matrix A will be equilibrated, copied, 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
kd

The number of super-diagonals (if uplo=’U’) or sub-diagonals (if uplo=’L’). kd >= 0.

in
nrhs

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

inout
AB

The banded matrix A. Array of dimension (ldab, n).

in
ldab

The leading dimension of AB. ldab >= kd+1.

inout
AFB

The factored form of A. Array of dimension (ldafb, n).

in
ldafb

The leading dimension of AFB. ldafb >= kd+1.

inout
equed

= ‘N’: No equilibration = ‘Y’: Equilibration was done

inout
S

The scale factors for A. Array of dimension (n).

inout
B

On entry, the 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.

out
ferr

The forward error bound. Array of dimension (nrhs).

out
berr

The backward error. 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, the leading minor of order i is not positive definite; if info = n+1, rcond is too small.

Functions

void cpbsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            kd,
    const INT            nrhs,
          c64*  restrict AB,
    const INT            ldab,
          c64*  restrict AFB,
    const INT            ldafb,
          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 cpbsvx(const char *fact, const char *uplo, const INT n, const INT kd, const INT nrhs, c64 *restrict AB, const INT ldab, c64 *restrict AFB, const INT ldafb, 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)#

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.

Parameters

in
fact

= ‘F’: AFB contains the factored form of A = ‘N’: The matrix A will be copied to AFB and factored = ‘E’: The matrix A will be equilibrated, copied, 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
kd

The number of super-diagonals (if uplo=’U’) or sub-diagonals (if uplo=’L’). kd >= 0.

in
nrhs

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

inout
AB

The banded matrix A. Array of dimension (ldab, n).

in
ldab

The leading dimension of AB. ldab >= kd+1.

inout
AFB

The factored form of A. Array of dimension (ldafb, n).

in
ldafb

The leading dimension of AFB. ldafb >= kd+1.

inout
equed

= ‘N’: No equilibration = ‘Y’: Equilibration was done

inout
S

The scale factors for A. Array of dimension (n).

inout
B

On entry, the 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.

out
ferr

The forward error bound. Array of dimension (nrhs).

out
berr

The backward error. Array of dimension (nrhs).

out
work

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, the leading minor of order i is not positive definite; if info = n+1, rcond is too small.

Functions

void zpbsvx(
    const char*          fact,
    const char*          uplo,
    const INT            n,
    const INT            kd,
    const INT            nrhs,
          c128* restrict AB,
    const INT            ldab,
          c128* restrict AFB,
    const INT            ldafb,
          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 zpbsvx(const char *fact, const char *uplo, const INT n, const INT kd, const INT nrhs, c128 *restrict AB, const INT ldab, c128 *restrict AFB, const INT ldafb, 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)#

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

Parameters

in
fact

= ‘F’: AFB contains the factored form of A = ‘N’: The matrix A will be copied to AFB and factored = ‘E’: The matrix A will be equilibrated, copied, 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
kd

The number of super-diagonals (if uplo=’U’) or sub-diagonals (if uplo=’L’). kd >= 0.

in
nrhs

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

inout
AB

The banded matrix A. Array of dimension (ldab, n).

in
ldab

The leading dimension of AB. ldab >= kd+1.

inout
AFB

The factored form of A. Array of dimension (ldafb, n).

in
ldafb

The leading dimension of AFB. ldafb >= kd+1.

inout
equed

= ‘N’: No equilibration = ‘Y’: Equilibration was done

inout
S

The scale factors for A. Array of dimension (n).

inout
B

On entry, the 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.

out
ferr

The forward error bound. Array of dimension (nrhs).

out
berr

The backward error. Array of dimension (nrhs).

out
work

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, the leading minor of order i is not positive definite; if info = n+1, rcond is too small.

On this page

This Page