LAPACK++
LAPACK C++ API
|
Functions | |
int64_t | lapack::gbsv (int64_t n, int64_t kl, int64_t ku, int64_t nrhs, double *AB, int64_t ldab, int64_t *ipiv, double *B, int64_t ldb) |
int64_t | lapack::gbsv (int64_t n, int64_t kl, int64_t ku, int64_t nrhs, float *AB, int64_t ldab, int64_t *ipiv, float *B, int64_t ldb) |
int64_t | lapack::gbsv (int64_t n, int64_t kl, int64_t ku, int64_t nrhs, std::complex< double > *AB, int64_t ldab, int64_t *ipiv, std::complex< double > *B, int64_t ldb) |
Computes the solution to a system of linear equations \(A 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. More... | |
int64_t | lapack::gbsv (int64_t n, int64_t kl, int64_t ku, int64_t nrhs, std::complex< float > *AB, int64_t ldab, int64_t *ipiv, std::complex< float > *B, int64_t ldb) |
int64_t | lapack::gbsvx (lapack::Factored fact, lapack::Op trans, int64_t n, int64_t kl, int64_t ku, int64_t nrhs, double *AB, int64_t ldab, double *AFB, int64_t ldafb, int64_t *ipiv, lapack::Equed *equed, double *R, double *C, double *B, int64_t ldb, double *X, int64_t ldx, double *rcond, double *ferr, double *berr) |
int64_t | lapack::gbsvx (lapack::Factored fact, lapack::Op trans, int64_t n, int64_t kl, int64_t ku, int64_t nrhs, float *AB, int64_t ldab, float *AFB, int64_t ldafb, int64_t *ipiv, lapack::Equed *equed, float *R, float *C, float *B, int64_t ldb, float *X, int64_t ldx, float *rcond, float *ferr, float *berr) |
int64_t | lapack::gbsvx (lapack::Factored fact, lapack::Op trans, int64_t n, int64_t kl, int64_t ku, int64_t nrhs, std::complex< double > *AB, int64_t ldab, std::complex< double > *AFB, int64_t ldafb, int64_t *ipiv, lapack::Equed *equed, double *R, double *C, std::complex< double > *B, int64_t ldb, std::complex< double > *X, int64_t ldx, double *rcond, double *ferr, double *berr) |
Uses the LU factorization to compute the solution to a system of linear equations. More... | |
int64_t | lapack::gbsvx (lapack::Factored fact, lapack::Op trans, int64_t n, int64_t kl, int64_t ku, int64_t nrhs, std::complex< float > *AB, int64_t ldab, std::complex< float > *AFB, int64_t ldafb, int64_t *ipiv, lapack::Equed *equed, float *R, float *C, std::complex< float > *B, int64_t ldb, std::complex< float > *X, int64_t ldx, float *rcond, float *ferr, float *berr) |
int64_t lapack::gbsv | ( | int64_t | n, |
int64_t | kl, | ||
int64_t | ku, | ||
int64_t | nrhs, | ||
std::complex< double > * | AB, | ||
int64_t | ldab, | ||
int64_t * | ipiv, | ||
std::complex< double > * | B, | ||
int64_t | ldb | ||
) |
Computes the solution to a system of linear equations \(A 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.
The LU decomposition with partial pivoting and row interchanges is used to factor A as \(A = L U\), where L is a product of permutation and unit lower triangular matrices with kl subdiagonals, and U is upper triangular with kl+ku superdiagonals. The factored form of A is then used to solve the system of equations \(A X = B\).
Overloaded versions are available for float
, double
, std::complex<float>
, and std::complex<double>
.
[in] | n | The number of linear equations, i.e., the order of the matrix 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, i.e., the number of columns of the matrix B. nrhs >= 0. |
[in,out] | AB | The n-by-n band matrix AB, stored in an ldab-by-n array. On entry, the matrix A in band storage, in rows kl+1 to 2*kl+ku+1; rows 1 to kl of the array need not be set. The j-th column of A is stored in the j-th column of the array AB as follows: AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku) <= i <= min(n,j+kl) On exit, details of the factorization: U is stored as an upper triangular band matrix with kl+ku superdiagonals in rows 1 to kl+ku+1, and the multipliers used during the factorization are stored in rows kl+ku+2 to 2*kl+ku+1. See below for further details. |
[in] | ldab | The leading dimension of the array AB. ldab >= 2*kl+ku+1. |
[out] | ipiv | The vector ipiv of length n. The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row ipiv(i). |
[in,out] | B | The n-by-nrhs matrix B, stored in an ldb-by-nrhs array. On entry, the n-by-nrhs right hand side matrix B. On successful exit, the n-by-nrhs solution matrix X. |
[in] | ldb | The leading dimension of the array B. ldb >= max(1,n). |
The band storage scheme is illustrated by the following example, when n = 6, kl = 2, ku = 1:
On entry: On exit: * * * + + + * * * u14 u25 u36 * * + + + + * * u13 u24 u35 u46 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * *
Array elements marked * are not used by the routine; elements marked
int64_t lapack::gbsvx | ( | lapack::Factored | fact, |
lapack::Op | trans, | ||
int64_t | n, | ||
int64_t | kl, | ||
int64_t | ku, | ||
int64_t | nrhs, | ||
std::complex< double > * | AB, | ||
int64_t | ldab, | ||
std::complex< double > * | AFB, | ||
int64_t | ldafb, | ||
int64_t * | ipiv, | ||
lapack::Equed * | equed, | ||
double * | R, | ||
double * | C, | ||
std::complex< double > * | B, | ||
int64_t | ldb, | ||
std::complex< double > * | X, | ||
int64_t | ldx, | ||
double * | rcond, | ||
double * | ferr, | ||
double * | berr | ||
) |
Uses the LU factorization to compute the solution to a 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.
Overloaded versions are available for float
, double
, std::complex<float>
, and std::complex<double>
.
[in] | fact | Whether or not the factored form of the matrix A is supplied on entry, and if not, whether the matrix A should be equilibrated before it is factored.
|
[in] | trans | The form of the system of equations:
|
[in] | n | The number of linear equations, i.e., the order of the matrix 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, i.e., the number of columns of the matrices B and X. nrhs >= 0. |
[in,out] | AB | The kl+ku+1-by-n matrix AB, stored in an ldab-by-n array. On entry, the matrix A in band storage, in rows 1 to kl+ku+1. The j-th column of A is stored in the j-th column of the array AB as follows: AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku) <= i <= min(n,j+kl)
|
[in] | ldab | The leading dimension of the array AB. ldab >= kl+ku+1. |
[in,out] | AFB | The 2*kl+ku+1-by-n matrix AFB, stored in an ldafb-by-n array.
|
[in] | ldafb | The leading dimension of the array AFB. ldafb >= 2*kl+ku+1. |
[in,out] | ipiv | The vector ipiv of length n.
|
[in,out] | equed | The form of equilibration that was done:
|
[in,out] | R | The vector R of length n. The row scale factors for A.
|
[in,out] | C | The vector C of length n. The column scale factors for A.
|
[in,out] | B | The n-by-nrhs matrix B, stored in an ldb-by-nrhs array. On entry, the right hand side matrix B. On exit,
|
[in] | ldb | The leading dimension of the array B. ldb >= max(1,n). |
[out] | X | The n-by-nrhs matrix X, stored in an ldx-by-nrhs array. If successful or return value = n+1, the n-by-nrhs solution matrix X to the original system of equations. Note that A and B are modified on exit if equed != None, and the solution to the equilibrated system is \(\text{diag}(C)^{-1} X\) if trans = NoTrans and equed = Col or Both, or \(\text{diag}(R)^{-1} X\) if trans = Trans or ConjTrans and equed = Row or Both. |
[in] | ldx | The leading dimension of the array X. ldx >= max(1,n). |
[out] | rcond | The estimate of the reciprocal condition number of the matrix A after equilibration (if done). If rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision. This condition is indicated by a return code of return value > 0. |
[out] | ferr | The vector ferr of length nrhs. The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), ferr(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error. |
[out] | berr | The vector berr of length nrhs. The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution). |