gbsvx#

sgbsvx

Functions

void sgbsvx(
    const char*          fact,
    const char*          trans,
    const INT            n,
    const INT            kl,
    const INT            ku,
    const INT            nrhs,
          f32*  restrict AB,
    const INT            ldab,
          f32*  restrict AFB,
    const INT            ldafb,
          INT*  restrict ipiv,
          char*          equed,
          f32*  restrict R,
          f32*  restrict C,
          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 sgbsvx(const char *fact, const char *trans, const INT n, const INT kl, const INT ku, const INT nrhs, f32 *restrict AB, const INT ldab, f32 *restrict AFB, const INT ldafb, INT *restrict ipiv, char *equed, f32 *restrict R, f32 *restrict C, 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)#

SGBSVX uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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 and IPIV contain the factored form of A. ‘N’: The matrix A will be copied to AFB and factored. ‘E’: The matrix A will be equilibrated if necessary, then copied to AFB and factored.

in

trans

‘N’: A * X = B (No transpose) ‘T’: A**T * X = B (Transpose) ‘C’: A**H * X = B (Conjugate transpose = Transpose)

in

n

The number of linear equations (order of A). n >= 0.

in

kl

The number of subdiagonals within the band of A. kl >= 0.

in

ku

The number of superdiagonals within the band of A. ku >= 0.

in

nrhs

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

inout

AB

On entry, the matrix A in band storage, in rows 0 to kl+ku. On exit, if equilibration was done, A is scaled. Array of dimension (ldab, n).

in

ldab

The leading dimension of AB. ldab >= kl+ku+1.

inout

AFB

On entry (if fact=’F’), contains the LU factors. On exit, contains the factors L and U. Array of dimension (ldafb, n).

in

ldafb

The leading dimension of AFB. ldafb >= 2*kl+ku+1.

inout

ipiv

Pivot indices from factorization. Array of dimension (n).

inout

equed

On entry (if fact=’F’), specifies equilibration done. On exit, specifies the form of equilibration: ‘N’: No equilibration ‘R’: Row equilibration (A := diag(R) * A) ‘C’: Column equilibration (A := A * diag(C)) ‘B’: Both (A := diag(R) * A * diag(C))

inout

R

Row scale factors. Array of dimension (n).

inout

C

Column scale factors. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equilibration was done, B is scaled. Array of dimension (ldb, nrhs).

in

ldb

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

out

X

The N-by-NRHS 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 for each solution vector. Array of dimension (nrhs).

out

berr

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

out

work

Workspace array of dimension (3*n). On exit, work[0] contains the reciprocal pivot growth factor.

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, U(i,i) is exactly zero (1-based). if info = n+1, U is nonsingular but RCOND < machine precision.

dgbsvx

Functions

void dgbsvx(
    const char*          fact,
    const char*          trans,
    const INT            n,
    const INT            kl,
    const INT            ku,
    const INT            nrhs,
          f64*  restrict AB,
    const INT            ldab,
          f64*  restrict AFB,
    const INT            ldafb,
          INT*  restrict ipiv,
          char*          equed,
          f64*  restrict R,
          f64*  restrict C,
          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 dgbsvx(const char *fact, const char *trans, const INT n, const INT kl, const INT ku, const INT nrhs, f64 *restrict AB, const INT ldab, f64 *restrict AFB, const INT ldafb, INT *restrict ipiv, char *equed, f64 *restrict R, f64 *restrict C, 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)#

DGBSVX uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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 and IPIV contain the factored form of A. ‘N’: The matrix A will be copied to AFB and factored. ‘E’: The matrix A will be equilibrated if necessary, then copied to AFB and factored.

in

trans

‘N’: A * X = B (No transpose) ‘T’: A**T * X = B (Transpose) ‘C’: A**H * X = B (Conjugate transpose = Transpose)

in

n

The number of linear equations (order of A). n >= 0.

in

kl

The number of subdiagonals within the band of A. kl >= 0.

in

ku

The number of superdiagonals within the band of A. ku >= 0.

in

nrhs

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

inout

AB

On entry, the matrix A in band storage, in rows 0 to kl+ku. On exit, if equilibration was done, A is scaled. Array of dimension (ldab, n).

in

ldab

The leading dimension of AB. ldab >= kl+ku+1.

inout

AFB

On entry (if fact=’F’), contains the LU factors. On exit, contains the factors L and U. Array of dimension (ldafb, n).

in

ldafb

The leading dimension of AFB. ldafb >= 2*kl+ku+1.

inout

ipiv

Pivot indices from factorization. Array of dimension (n).

inout

equed

On entry (if fact=’F’), specifies equilibration done. On exit, specifies the form of equilibration: ‘N’: No equilibration ‘R’: Row equilibration (A := diag(R) * A) ‘C’: Column equilibration (A := A * diag(C)) ‘B’: Both (A := diag(R) * A * diag(C))

inout

R

Row scale factors. Array of dimension (n).

inout

C

Column scale factors. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equilibration was done, B is scaled. Array of dimension (ldb, nrhs).

in

ldb

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

out

X

The N-by-NRHS 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 for each solution vector. Array of dimension (nrhs).

out

berr

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

out

work

Workspace array of dimension (3*n). On exit, work[0] contains the reciprocal pivot growth factor.

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, U(i,i) is exactly zero (1-based). if info = n+1, U is nonsingular but RCOND < machine precision.

cgbsvx

Functions

void cgbsvx(
    const char*          fact,
    const char*          trans,
    const INT            n,
    const INT            kl,
    const INT            ku,
    const INT            nrhs,
          c64*  restrict AB,
    const INT            ldab,
          c64*  restrict AFB,
    const INT            ldafb,
          INT*  restrict ipiv,
          char*          equed,
          f32*  restrict R,
          f32*  restrict C,
          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 cgbsvx(const char *fact, const char *trans, const INT n, const INT kl, const INT ku, const INT nrhs, c64 *restrict AB, const INT ldab, c64 *restrict AFB, const INT ldafb, INT *restrict ipiv, char *equed, f32 *restrict R, f32 *restrict C, 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)#

CGBSVX uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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 and IPIV contain the factored form of A. ‘N’: The matrix A will be copied to AFB and factored. ‘E’: The matrix A will be equilibrated if necessary, then copied to AFB and factored.

in

trans

‘N’: A * X = B (No transpose) ‘T’: A**T * X = B (Transpose) ‘C’: A**H * X = B (Conjugate transpose)

in

n

The number of linear equations (order of A). n >= 0.

in

kl

The number of subdiagonals within the band of A. kl >= 0.

in

ku

The number of superdiagonals within the band of A. ku >= 0.

in

nrhs

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

inout

AB

On entry, the matrix A in band storage, in rows 0 to kl+ku. On exit, if equilibration was done, A is scaled. Array of dimension (ldab, n).

in

ldab

The leading dimension of AB. ldab >= kl+ku+1.

inout

AFB

On entry (if fact=’F’), contains the LU factors. On exit, contains the factors L and U. Array of dimension (ldafb, n).

in

ldafb

The leading dimension of AFB. ldafb >= 2*kl+ku+1.

inout

ipiv

Pivot indices from factorization. Array of dimension (n).

inout

equed

On entry (if fact=’F’), specifies equilibration done. On exit, specifies the form of equilibration: ‘N’: No equilibration ‘R’: Row equilibration (A := diag(R) * A) ‘C’: Column equilibration (A := A * diag(C)) ‘B’: Both (A := diag(R) * A * diag(C))

inout

R

Row scale factors. Array of dimension (n).

inout

C

Column scale factors. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equilibration was done, B is scaled. Array of dimension (ldb, nrhs).

in

ldb

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

out

X

The N-by-NRHS 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 for each solution vector. Array of dimension (nrhs).

out

berr

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

out

work

Complex workspace array of dimension (2*n).

out

rwork

Real workspace array of dimension (max(1, n)). On exit, rwork[0] contains the reciprocal pivot growth factor.

out

info

= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
> 0: if info = i, U(i,i) is exactly zero (1-based). if info = n+1, U is nonsingular but RCOND < machine precision.

zgbsvx

Functions

void zgbsvx(
    const char*          fact,
    const char*          trans,
    const INT            n,
    const INT            kl,
    const INT            ku,
    const INT            nrhs,
          c128* restrict AB,
    const INT            ldab,
          c128* restrict AFB,
    const INT            ldafb,
          INT*  restrict ipiv,
          char*          equed,
          f64*  restrict R,
          f64*  restrict C,
          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 zgbsvx(const char *fact, const char *trans, const INT n, const INT kl, const INT ku, const INT nrhs, c128 *restrict AB, const INT ldab, c128 *restrict AFB, const INT ldafb, INT *restrict ipiv, char *equed, f64 *restrict R, f64 *restrict C, 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)#

ZGBSVX uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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 and IPIV contain the factored form of A. ‘N’: The matrix A will be copied to AFB and factored. ‘E’: The matrix A will be equilibrated if necessary, then copied to AFB and factored.

in

trans

‘N’: A * X = B (No transpose) ‘T’: A**T * X = B (Transpose) ‘C’: A**H * X = B (Conjugate transpose)

in

n

The number of linear equations (order of A). n >= 0.

in

kl

The number of subdiagonals within the band of A. kl >= 0.

in

ku

The number of superdiagonals within the band of A. ku >= 0.

in

nrhs

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

inout

AB

On entry, the matrix A in band storage, in rows 0 to kl+ku. On exit, if equilibration was done, A is scaled. Array of dimension (ldab, n).

in

ldab

The leading dimension of AB. ldab >= kl+ku+1.

inout

AFB

On entry (if fact=’F’), contains the LU factors. On exit, contains the factors L and U. Array of dimension (ldafb, n).

in

ldafb

The leading dimension of AFB. ldafb >= 2*kl+ku+1.

inout

ipiv

Pivot indices from factorization. Array of dimension (n).

inout

equed

On entry (if fact=’F’), specifies equilibration done. On exit, specifies the form of equilibration: ‘N’: No equilibration ‘R’: Row equilibration (A := diag(R) * A) ‘C’: Column equilibration (A := A * diag(C)) ‘B’: Both (A := diag(R) * A * diag(C))

inout

R

Row scale factors. Array of dimension (n).

inout

C

Column scale factors. Array of dimension (n).

inout

B

On entry, the N-by-NRHS right hand side matrix B. On exit, if equilibration was done, B is scaled. Array of dimension (ldb, nrhs).

in

ldb

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

out

X

The N-by-NRHS 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 for each solution vector. Array of dimension (nrhs).

out

berr

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

out

work

Complex workspace array of dimension (2*n).

out

rwork

Real workspace array of dimension (max(1, n)). On exit, rwork[0] contains the reciprocal pivot growth factor.

out

info

= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
> 0: if info = i, U(i,i) is exactly zero (1-based). if info = n+1, U is nonsingular but RCOND < machine precision.

gbsvx#

This Page