COMPLEX routines for general band matrix
cgbbrd
USAGE:
d, e, q, pt, info, ab, c = NumRu::Lapack.cgbbrd( vect, kl, ku, ab, c, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBBRD( VECT, M, N, NCC, KL, KU, AB, LDAB, D, E, Q, LDQ, PT, LDPT, C, LDC, WORK, RWORK, INFO )
* Purpose
* =======
*
* CGBBRD reduces a complex general m-by-n band matrix A to real upper
* bidiagonal form B by a unitary transformation: Q' * A * P = B.
*
* The routine computes B, and optionally forms Q or P', or computes
* Q'*C for a given matrix C.
*
* Arguments
* =========
*
* VECT (input) CHARACTER*1
* Specifies whether or not the matrices Q and P' are to be
* formed.
* = 'N': do not form Q or P';
* = 'Q': form Q only;
* = 'P': form P' only;
* = 'B': form both.
*
* M (input) INTEGER
* The number of rows of the matrix A. M >= 0.
*
* N (input) INTEGER
* The number of columns of the matrix A. N >= 0.
*
* NCC (input) INTEGER
* The number of columns of the matrix C. NCC >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals of the matrix A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals of the matrix A. KU >= 0.
*
* AB (input/output) COMPLEX array, dimension (LDAB,N)
* On entry, the m-by-n band matrix A, stored 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(m,j+kl).
* On exit, A is overwritten by values generated during the
* reduction.
*
* LDAB (input) INTEGER
* The leading dimension of the array A. LDAB >= KL+KU+1.
*
* D (output) REAL array, dimension (min(M,N))
* The diagonal elements of the bidiagonal matrix B.
*
* E (output) REAL array, dimension (min(M,N)-1)
* The superdiagonal elements of the bidiagonal matrix B.
*
* Q (output) COMPLEX array, dimension (LDQ,M)
* If VECT = 'Q' or 'B', the m-by-m unitary matrix Q.
* If VECT = 'N' or 'P', the array Q is not referenced.
*
* LDQ (input) INTEGER
* The leading dimension of the array Q.
* LDQ >= max(1,M) if VECT = 'Q' or 'B'; LDQ >= 1 otherwise.
*
* PT (output) COMPLEX array, dimension (LDPT,N)
* If VECT = 'P' or 'B', the n-by-n unitary matrix P'.
* If VECT = 'N' or 'Q', the array PT is not referenced.
*
* LDPT (input) INTEGER
* The leading dimension of the array PT.
* LDPT >= max(1,N) if VECT = 'P' or 'B'; LDPT >= 1 otherwise.
*
* C (input/output) COMPLEX array, dimension (LDC,NCC)
* On entry, an m-by-ncc matrix C.
* On exit, C is overwritten by Q'*C.
* C is not referenced if NCC = 0.
*
* LDC (input) INTEGER
* The leading dimension of the array C.
* LDC >= max(1,M) if NCC > 0; LDC >= 1 if NCC = 0.
*
* WORK (workspace) COMPLEX array, dimension (max(M,N))
*
* RWORK (workspace) REAL array, dimension (max(M,N))
*
* INFO (output) INTEGER
* = 0: successful exit.
* < 0: if INFO = -i, the i-th argument had an illegal value.
*
* =====================================================================
*
go to the page top
cgbcon
USAGE:
rcond, info = NumRu::Lapack.cgbcon( norm, kl, ku, ab, ipiv, anorm, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBCON( NORM, N, KL, KU, AB, LDAB, IPIV, ANORM, RCOND, WORK, RWORK, INFO )
* Purpose
* =======
*
* CGBCON estimates the reciprocal of the condition number of a complex
* general band matrix A, in either the 1-norm or the infinity-norm,
* using the LU factorization computed by CGBTRF.
*
* An estimate is obtained for norm(inv(A)), and the reciprocal of the
* condition number is computed as
* RCOND = 1 / ( norm(A) * norm(inv(A)) ).
*
* Arguments
* =========
*
* NORM (input) CHARACTER*1
* Specifies whether the 1-norm condition number or the
* infinity-norm condition number is required:
* = '1' or 'O': 1-norm;
* = 'I': Infinity-norm.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* AB (input) COMPLEX array, dimension (LDAB,N)
* Details of the LU factorization of the band matrix A, as
* computed by CGBTRF. 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.
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= 2*KL+KU+1.
*
* IPIV (input) INTEGER array, dimension (N)
* The pivot indices; for 1 <= i <= N, row i of the matrix was
* interchanged with row IPIV(i).
*
* ANORM (input) REAL
* If NORM = '1' or 'O', the 1-norm of the original matrix A.
* If NORM = 'I', the infinity-norm of the original matrix A.
*
* RCOND (output) REAL
* The reciprocal of the condition number of the matrix A,
* computed as RCOND = 1/(norm(A) * norm(inv(A))).
*
* WORK (workspace) COMPLEX array, dimension (2*N)
*
* RWORK (workspace) REAL array, dimension (N)
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
*
* =====================================================================
*
go to the page top
cgbequ
USAGE:
r, c, rowcnd, colcnd, amax, info = NumRu::Lapack.cgbequ( m, kl, ku, ab, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBEQU( M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, AMAX, INFO )
* Purpose
* =======
*
* CGBEQU computes row and column scalings intended to equilibrate an
* M-by-N band matrix A and reduce its condition number. R returns the
* row scale factors and C the column scale factors, chosen to try to
* make the largest element in each row and column of the matrix B with
* elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.
*
* R(i) and C(j) are restricted to be between SMLNUM = smallest safe
* number and BIGNUM = largest safe number. Use of these scaling
* factors is not guaranteed to reduce the condition number of A but
* works well in practice.
*
* Arguments
* =========
*
* M (input) INTEGER
* The number of rows of the matrix A. M >= 0.
*
* N (input) INTEGER
* The number of columns of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* AB (input) COMPLEX array, dimension (LDAB,N)
* The band matrix A, stored 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(m,j+kl).
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= KL+KU+1.
*
* R (output) REAL array, dimension (M)
* If INFO = 0, or INFO > M, R contains the row scale factors
* for A.
*
* C (output) REAL array, dimension (N)
* If INFO = 0, C contains the column scale factors for A.
*
* ROWCND (output) REAL
* If INFO = 0 or INFO > M, ROWCND contains the ratio of the
* smallest R(i) to the largest R(i). If ROWCND >= 0.1 and
* AMAX is neither too large nor too small, it is not worth
* scaling by R.
*
* COLCND (output) REAL
* If INFO = 0, COLCND contains the ratio of the smallest
* C(i) to the largest C(i). If COLCND >= 0.1, it is not
* worth scaling by C.
*
* AMAX (output) REAL
* Absolute value of largest matrix element. If AMAX is very
* close to overflow or very close to underflow, the matrix
* should be scaled.
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, and i is
* <= M: the i-th row of A is exactly zero
* > M: the (i-M)-th column of A is exactly zero
*
* =====================================================================
*
go to the page top
cgbequb
USAGE:
r, c, rowcnd, colcnd, amax, info = NumRu::Lapack.cgbequb( kl, ku, ab, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBEQUB( M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, AMAX, INFO )
* Purpose
* =======
*
* CGBEQUB computes row and column scalings intended to equilibrate an
* M-by-N matrix A and reduce its condition number. R returns the row
* scale factors and C the column scale factors, chosen to try to make
* the largest element in each row and column of the matrix B with
* elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most
* the radix.
*
* R(i) and C(j) are restricted to be a power of the radix between
* SMLNUM = smallest safe number and BIGNUM = largest safe number. Use
* of these scaling factors is not guaranteed to reduce the condition
* number of A but works well in practice.
*
* This routine differs from CGEEQU by restricting the scaling factors
* to a power of the radix. Baring over- and underflow, scaling by
* these factors introduces no additional rounding errors. However, the
* scaled entries' magnitured are no longer approximately 1 but lie
* between sqrt(radix) and 1/sqrt(radix).
*
* Arguments
* =========
*
* M (input) INTEGER
* The number of rows of the matrix A. M >= 0.
*
* N (input) INTEGER
* The number of columns of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* AB (input) DOUBLE PRECISION array, dimension (LDAB,N)
* 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)
*
* LDAB (input) INTEGER
* The leading dimension of the array A. LDAB >= max(1,M).
*
* R (output) REAL array, dimension (M)
* If INFO = 0 or INFO > M, R contains the row scale factors
* for A.
*
* C (output) REAL array, dimension (N)
* If INFO = 0, C contains the column scale factors for A.
*
* ROWCND (output) REAL
* If INFO = 0 or INFO > M, ROWCND contains the ratio of the
* smallest R(i) to the largest R(i). If ROWCND >= 0.1 and
* AMAX is neither too large nor too small, it is not worth
* scaling by R.
*
* COLCND (output) REAL
* If INFO = 0, COLCND contains the ratio of the smallest
* C(i) to the largest C(i). If COLCND >= 0.1, it is not
* worth scaling by C.
*
* AMAX (output) REAL
* Absolute value of largest matrix element. If AMAX is very
* close to overflow or very close to underflow, the matrix
* should be scaled.
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
* > 0: if INFO = i, and i is
* <= M: the i-th row of A is exactly zero
* > M: the (i-M)-th column of A is exactly zero
*
* =====================================================================
*
go to the page top
cgbrfs
USAGE:
ferr, berr, info, x = NumRu::Lapack.cgbrfs( trans, kl, ku, ab, afb, ipiv, b, x, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBRFS( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO )
* Purpose
* =======
*
* CGBRFS improves the computed solution to a system of linear
* equations when the coefficient matrix is banded, and provides
* error bounds and backward error estimates for the solution.
*
* Arguments
* =========
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations:
* = 'N': A * X = B (No transpose)
* = 'T': A**T * X = B (Transpose)
* = 'C': A**H * X = B (Conjugate transpose)
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* NRHS (input) INTEGER
* The number of right hand sides, i.e., the number of columns
* of the matrices B and X. NRHS >= 0.
*
* AB (input) COMPLEX array, dimension (LDAB,N)
* The original band matrix A, stored 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).
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= KL+KU+1.
*
* AFB (input) COMPLEX array, dimension (LDAFB,N)
* Details of the LU factorization of the band matrix A, as
* computed by CGBTRF. 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.
*
* LDAFB (input) INTEGER
* The leading dimension of the array AFB. LDAFB >= 2*KL*KU+1.
*
* IPIV (input) INTEGER array, dimension (N)
* The pivot indices from CGBTRF; for 1<=i<=N, row i of the
* matrix was interchanged with row IPIV(i).
*
* B (input) COMPLEX array, dimension (LDB,NRHS)
* The right hand side matrix B.
*
* LDB (input) INTEGER
* The leading dimension of the array B. LDB >= max(1,N).
*
* X (input/output) COMPLEX array, dimension (LDX,NRHS)
* On entry, the solution matrix X, as computed by CGBTRS.
* On exit, the improved solution matrix X.
*
* LDX (input) INTEGER
* The leading dimension of the array X. LDX >= max(1,N).
*
* FERR (output) REAL array, dimension (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.
*
* BERR (output) REAL array, dimension (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).
*
* WORK (workspace) COMPLEX array, dimension (2*N)
*
* RWORK (workspace) REAL array, dimension (N)
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
*
* Internal Parameters
* ===================
*
* ITMAX is the maximum number of steps of iterative refinement.
*
* =====================================================================
*
go to the page top
cgbrfsx
USAGE:
rcond, berr, err_bnds_norm, err_bnds_comp, info, r, c, x, params = NumRu::Lapack.cgbrfsx( trans, equed, kl, ku, ab, afb, ipiv, r, c, b, x, params, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBRFSX( TRANS, EQUED, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, IPIV, R, C, B, LDB, X, LDX, RCOND, BERR, N_ERR_BNDS, ERR_BNDS_NORM, ERR_BNDS_COMP, NPARAMS, PARAMS, WORK, RWORK, INFO )
* Purpose
* =======
*
* CGBRFSX improves the computed solution to a system of linear
* equations and provides error bounds and backward error estimates
* for the solution. In addition to normwise error bound, the code
* provides maximum componentwise error bound if possible. See
* comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the
* error bounds.
*
* The original system of linear equations may have been equilibrated
* before calling this routine, as described by arguments EQUED, R
* and C below. In this case, the solution and error bounds returned
* are for the original unequilibrated system.
*
* Arguments
* =========
*
* Some optional parameters are bundled in the PARAMS array. These
* settings determine how refinement is performed, but often the
* defaults are acceptable. If the defaults are acceptable, users
* can pass NPARAMS = 0 which prevents the source code from accessing
* the PARAMS argument.
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations:
* = 'N': A * X = B (No transpose)
* = 'T': A**T * X = B (Transpose)
* = 'C': A**H * X = B (Conjugate transpose = Transpose)
*
* EQUED (input) CHARACTER*1
* Specifies the form of equilibration that was done to A
* before calling this routine. This is needed to compute
* the solution and error bounds correctly.
* = 'N': No equilibration
* = 'R': Row equilibration, i.e., A has been premultiplied by
* diag(R).
* = 'C': Column equilibration, i.e., A has been postmultiplied
* by diag(C).
* = 'B': Both row and column equilibration, i.e., A has been
* replaced by diag(R) * A * diag(C).
* The right hand side B has been changed accordingly.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* NRHS (input) INTEGER
* The number of right hand sides, i.e., the number of columns
* of the matrices B and X. NRHS >= 0.
*
* AB (input) DOUBLE PRECISION array, dimension (LDAB,N)
* The original band matrix A, stored 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).
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= KL+KU+1.
*
* AFB (input) DOUBLE PRECISION array, dimension (LDAFB,N)
* Details of the LU factorization of the band matrix A, as
* computed by DGBTRF. 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.
*
* LDAFB (input) INTEGER
* The leading dimension of the array AFB. LDAFB >= 2*KL*KU+1.
*
* IPIV (input) INTEGER array, dimension (N)
* The pivot indices from SGETRF; for 1<=i<=N, row i of the
* matrix was interchanged with row IPIV(i).
*
* R (input or output) REAL array, dimension (N)
* The row scale factors for A. If EQUED = 'R' or 'B', A is
* multiplied on the left by diag(R); if EQUED = 'N' or 'C', R
* is not accessed. R is an input argument if FACT = 'F';
* otherwise, R is an output argument. If FACT = 'F' and
* EQUED = 'R' or 'B', each element of R must be positive.
* If R is output, each element of R is a power of the radix.
* If R is input, each element of R should be a power of the radix
* to ensure a reliable solution and error estimates. Scaling by
* powers of the radix does not cause rounding errors unless the
* result underflows or overflows. Rounding errors during scaling
* lead to refining with a matrix that is not equivalent to the
* input matrix, producing error estimates that may not be
* reliable.
*
* C (input or output) REAL array, dimension (N)
* The column scale factors for A. If EQUED = 'C' or 'B', A is
* multiplied on the right by diag(C); if EQUED = 'N' or 'R', C
* is not accessed. C is an input argument if FACT = 'F';
* otherwise, C is an output argument. If FACT = 'F' and
* EQUED = 'C' or 'B', each element of C must be positive.
* If C is output, each element of C is a power of the radix.
* If C is input, each element of C should be a power of the radix
* to ensure a reliable solution and error estimates. Scaling by
* powers of the radix does not cause rounding errors unless the
* result underflows or overflows. Rounding errors during scaling
* lead to refining with a matrix that is not equivalent to the
* input matrix, producing error estimates that may not be
* reliable.
*
* B (input) REAL array, dimension (LDB,NRHS)
* The right hand side matrix B.
*
* LDB (input) INTEGER
* The leading dimension of the array B. LDB >= max(1,N).
*
* X (input/output) REAL array, dimension (LDX,NRHS)
* On entry, the solution matrix X, as computed by SGETRS.
* On exit, the improved solution matrix X.
*
* LDX (input) INTEGER
* The leading dimension of the array X. LDX >= max(1,N).
*
* RCOND (output) REAL
* Reciprocal scaled condition number. This is an estimate of the
* reciprocal Skeel condition number of the matrix A after
* equilibration (if done). If this is less than the machine
* precision (in particular, if it is zero), the matrix is singular
* to working precision. Note that the error may still be small even
* if this number is very small and the matrix appears ill-
* conditioned.
*
* BERR (output) REAL array, dimension (NRHS)
* Componentwise relative backward error. This is 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).
*
* N_ERR_BNDS (input) INTEGER
* Number of error bounds to return for each right hand side
* and each type (normwise or componentwise). See ERR_BNDS_NORM and
* ERR_BNDS_COMP below.
*
* ERR_BNDS_NORM (output) REAL array, dimension (NRHS, N_ERR_BNDS)
* For each right-hand side, this array contains information about
* various error bounds and condition numbers corresponding to the
* normwise relative error, which is defined as follows:
*
* Normwise relative error in the ith solution vector:
* max_j (abs(XTRUE(j,i) - X(j,i)))
* ------------------------------
* max_j abs(X(j,i))
*
* The array is indexed by the type of error information as described
* below. There currently are up to three pieces of information
* returned.
*
* The first index in ERR_BNDS_NORM(i,:) corresponds to the ith
* right-hand side.
*
* The second index in ERR_BNDS_NORM(:,err) contains the following
* three fields:
* err = 1 "Trust/don't trust" boolean. Trust the answer if the
* reciprocal condition number is less than the threshold
* sqrt(n) * slamch('Epsilon').
*
* err = 2 "Guaranteed" error bound: The estimated forward error,
* almost certainly within a factor of 10 of the true error
* so long as the next entry is greater than the threshold
* sqrt(n) * slamch('Epsilon'). This error bound should only
* be trusted if the previous boolean is true.
*
* err = 3 Reciprocal condition number: Estimated normwise
* reciprocal condition number. Compared with the threshold
* sqrt(n) * slamch('Epsilon') to determine if the error
* estimate is "guaranteed". These reciprocal condition
* numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
* appropriately scaled matrix Z.
* Let Z = S*A, where S scales each row by a power of the
* radix so all absolute row sums of Z are approximately 1.
*
* See Lapack Working Note 165 for further details and extra
* cautions.
*
* ERR_BNDS_COMP (output) REAL array, dimension (NRHS, N_ERR_BNDS)
* For each right-hand side, this array contains information about
* various error bounds and condition numbers corresponding to the
* componentwise relative error, which is defined as follows:
*
* Componentwise relative error in the ith solution vector:
* abs(XTRUE(j,i) - X(j,i))
* max_j ----------------------
* abs(X(j,i))
*
* The array is indexed by the right-hand side i (on which the
* componentwise relative error depends), and the type of error
* information as described below. There currently are up to three
* pieces of information returned for each right-hand side. If
* componentwise accuracy is not requested (PARAMS(3) = 0.0), then
* ERR_BNDS_COMP is not accessed. If N_ERR_BNDS .LT. 3, then at most
* the first (:,N_ERR_BNDS) entries are returned.
*
* The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
* right-hand side.
*
* The second index in ERR_BNDS_COMP(:,err) contains the following
* three fields:
* err = 1 "Trust/don't trust" boolean. Trust the answer if the
* reciprocal condition number is less than the threshold
* sqrt(n) * slamch('Epsilon').
*
* err = 2 "Guaranteed" error bound: The estimated forward error,
* almost certainly within a factor of 10 of the true error
* so long as the next entry is greater than the threshold
* sqrt(n) * slamch('Epsilon'). This error bound should only
* be trusted if the previous boolean is true.
*
* err = 3 Reciprocal condition number: Estimated componentwise
* reciprocal condition number. Compared with the threshold
* sqrt(n) * slamch('Epsilon') to determine if the error
* estimate is "guaranteed". These reciprocal condition
* numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
* appropriately scaled matrix Z.
* Let Z = S*(A*diag(x)), where x is the solution for the
* current right-hand side and S scales each row of
* A*diag(x) by a power of the radix so all absolute row
* sums of Z are approximately 1.
*
* See Lapack Working Note 165 for further details and extra
* cautions.
*
* NPARAMS (input) INTEGER
* Specifies the number of parameters set in PARAMS. If .LE. 0, the
* PARAMS array is never referenced and default values are used.
*
* PARAMS (input / output) REAL array, dimension NPARAMS
* Specifies algorithm parameters. If an entry is .LT. 0.0, then
* that entry will be filled with default value used for that
* parameter. Only positions up to NPARAMS are accessed; defaults
* are used for higher-numbered parameters.
*
* PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative
* refinement or not.
* Default: 1.0
* = 0.0 : No refinement is performed, and no error bounds are
* computed.
* = 1.0 : Use the double-precision refinement algorithm,
* possibly with doubled-single computations if the
* compilation environment does not support DOUBLE
* PRECISION.
* (other values are reserved for future use)
*
* PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual
* computations allowed for refinement.
* Default: 10
* Aggressive: Set to 100 to permit convergence using approximate
* factorizations or factorizations other than LU. If
* the factorization uses a technique other than
* Gaussian elimination, the guarantees in
* err_bnds_norm and err_bnds_comp may no longer be
* trustworthy.
*
* PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code
* will attempt to find a solution with small componentwise
* relative error in the double-precision algorithm. Positive
* is true, 0.0 is false.
* Default: 1.0 (attempt componentwise convergence)
*
* WORK (workspace) COMPLEX array, dimension (2*N)
*
* RWORK (workspace) REAL array, dimension (2*N)
*
* INFO (output) INTEGER
* = 0: Successful exit. The solution to every right-hand side is
* guaranteed.
* < 0: If INFO = -i, the i-th argument had an illegal value
* > 0 and <= N: U(INFO,INFO) is exactly zero. The factorization
* has been completed, but the factor U is exactly singular, so
* the solution and error bounds could not be computed. RCOND = 0
* is returned.
* = N+J: The solution corresponding to the Jth right-hand side is
* not guaranteed. The solutions corresponding to other right-
* hand sides K with K > J may not be guaranteed as well, but
* only the first such right-hand side is reported. If a small
* componentwise error is not requested (PARAMS(3) = 0.0) then
* the Jth right-hand side is the first with a normwise error
* bound that is not guaranteed (the smallest J such
* that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)
* the Jth right-hand side is the first with either a normwise or
* componentwise error bound that is not guaranteed (the smallest
* J such that either ERR_BNDS_NORM(J,1) = 0.0 or
* ERR_BNDS_COMP(J,1) = 0.0). See the definition of
* ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information
* about all of the right-hand sides check ERR_BNDS_NORM or
* ERR_BNDS_COMP.
*
* ==================================================================
*
go to the page top
cgbsv
USAGE:
ipiv, info, ab, b = NumRu::Lapack.cgbsv( kl, ku, ab, b, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBSV( N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB, INFO )
* Purpose
* =======
*
* CGBSV computes the solution to a complex 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.
*
* Arguments
* =========
*
* N (input) INTEGER
* The number of linear equations, i.e., the order of the
* matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* NRHS (input) INTEGER
* The number of right hand sides, i.e., the number of columns
* of the matrix B. NRHS >= 0.
*
* AB (input/output) COMPLEX array, dimension (LDAB,N)
* 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.
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= 2*KL+KU+1.
*
* IPIV (output) INTEGER array, dimension (N)
* The pivot indices that define the permutation matrix P;
* row i of the matrix was interchanged with row IPIV(i).
*
* B (input/output) COMPLEX array, dimension (LDB,NRHS)
* On entry, the N-by-NRHS right hand side matrix B.
* On exit, if INFO = 0, the N-by-NRHS solution matrix X.
*
* LDB (input) INTEGER
* The leading dimension of the array B. LDB >= max(1,N).
*
* INFO (output) INTEGER
* = 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. The factorization
* has been completed, but the factor U is exactly
* singular, and the solution has not been computed.
*
* Further Details
* ===============
*
* The band storage scheme is illustrated by the following example, when
* M = 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
* + need not be set on entry, but are required by the routine to store
* elements of U because of fill-in resulting from the row interchanges.
*
* =====================================================================
*
* .. External Subroutines ..
EXTERNAL CGBTRF, CGBTRS, XERBLA
* ..
* .. Intrinsic Functions ..
INTRINSIC MAX
* ..
go to the page top
cgbsvx
USAGE:
x, rcond, ferr, berr, rwork, info, ab, afb, ipiv, equed, r, c, b = NumRu::Lapack.cgbsvx( fact, trans, kl, ku, ab, b, [:afb => afb, :ipiv => ipiv, :equed => equed, :r => r, :c => c, :usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBSVX( FACT, TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, IPIV, EQUED, R, C, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, RWORK, INFO )
* Purpose
* =======
*
* 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.
*
* Description
* ===========
*
* The following steps are performed by this subroutine:
*
* 1. If FACT = 'E', real scaling factors are computed to equilibrate
* the system:
* TRANS = 'N': diag(R)*A*diag(C) *inv(diag(C))*X = diag(R)*B
* TRANS = 'T': (diag(R)*A*diag(C))**T *inv(diag(R))*X = diag(C)*B
* TRANS = 'C': (diag(R)*A*diag(C))**H *inv(diag(R))*X = diag(C)*B
* Whether or not the system will be equilibrated depends on the
* scaling of the matrix A, but if equilibration is used, A is
* overwritten by diag(R)*A*diag(C) and B by diag(R)*B (if TRANS='N')
* or diag(C)*B (if TRANS = 'T' or 'C').
*
* 2. If FACT = 'N' or 'E', the LU decomposition is used to factor the
* matrix A (after equilibration if FACT = 'E') 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.
*
* 3. If some U(i,i)=0, so that U is exactly singular, then the routine
* returns with INFO = i. Otherwise, the factored form of A is used
* to estimate the condition number of the matrix A. If the
* reciprocal of the condition number is less than machine precision,
* INFO = N+1 is returned as a warning, but the routine still goes on
* to solve for X and compute error bounds as described below.
*
* 4. The system of equations is solved for X using the factored form
* of A.
*
* 5. Iterative refinement is applied to improve the computed solution
* matrix and calculate error bounds and backward error estimates
* for it.
*
* 6. If equilibration was used, the matrix X is premultiplied by
* diag(C) (if TRANS = 'N') or diag(R) (if TRANS = 'T' or 'C') so
* that it solves the original system before equilibration.
*
* Arguments
* =========
*
* FACT (input) CHARACTER*1
* Specifies 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.
* = 'F': On entry, AFB and IPIV contain the factored form of
* A. If EQUED is not 'N', the matrix A has been
* equilibrated with scaling factors given by R and C.
* AB, AFB, and IPIV are not modified.
* = '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.
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations.
* = 'N': A * X = B (No transpose)
* = 'T': A**T * X = B (Transpose)
* = 'C': A**H * X = B (Conjugate transpose)
*
* N (input) INTEGER
* The number of linear equations, i.e., the order of the
* matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* NRHS (input) INTEGER
* The number of right hand sides, i.e., the number of columns
* of the matrices B and X. NRHS >= 0.
*
* AB (input/output) COMPLEX array, dimension (LDAB,N)
* 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)
*
* If FACT = 'F' and EQUED is not 'N', then A must have been
* equilibrated by the scaling factors in R and/or C. AB is not
* modified if FACT = 'F' or 'N', or if FACT = 'E' and
* EQUED = 'N' on exit.
*
* On exit, if EQUED .ne. 'N', A is scaled as follows:
* EQUED = 'R': A := diag(R) * A
* EQUED = 'C': A := A * diag(C)
* EQUED = 'B': A := diag(R) * A * diag(C).
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= KL+KU+1.
*
* AFB (input or output) COMPLEX array, dimension (LDAFB,N)
* If FACT = 'F', then AFB is an input argument and on entry
* contains details of the LU factorization of the band matrix
* A, as computed by CGBTRF. 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. If EQUED .ne. 'N', then AFB is
* the factored form of the equilibrated matrix A.
*
* If FACT = 'N', then AFB is an output argument and on exit
* returns details of the LU factorization of A.
*
* If FACT = 'E', then AFB is an output argument and on exit
* returns details of the LU factorization of the equilibrated
* matrix A (see the description of AB for the form of the
* equilibrated matrix).
*
* LDAFB (input) INTEGER
* The leading dimension of the array AFB. LDAFB >= 2*KL+KU+1.
*
* IPIV (input or output) INTEGER array, dimension (N)
* If FACT = 'F', then IPIV is an input argument and on entry
* contains the pivot indices from the factorization A = L*U
* as computed by CGBTRF; row i of the matrix was interchanged
* with row IPIV(i).
*
* If FACT = 'N', then IPIV is an output argument and on exit
* contains the pivot indices from the factorization A = L*U
* of the original matrix A.
*
* If FACT = 'E', then IPIV is an output argument and on exit
* contains the pivot indices from the factorization A = L*U
* of the equilibrated matrix A.
*
* EQUED (input or output) CHARACTER*1
* Specifies the form of equilibration that was done.
* = 'N': No equilibration (always true if FACT = 'N').
* = 'R': Row equilibration, i.e., A has been premultiplied by
* diag(R).
* = 'C': Column equilibration, i.e., A has been postmultiplied
* by diag(C).
* = 'B': Both row and column equilibration, i.e., A has been
* replaced by diag(R) * A * diag(C).
* EQUED is an input argument if FACT = 'F'; otherwise, it is an
* output argument.
*
* R (input or output) REAL array, dimension (N)
* The row scale factors for A. If EQUED = 'R' or 'B', A is
* multiplied on the left by diag(R); if EQUED = 'N' or 'C', R
* is not accessed. R is an input argument if FACT = 'F';
* otherwise, R is an output argument. If FACT = 'F' and
* EQUED = 'R' or 'B', each element of R must be positive.
*
* C (input or output) REAL array, dimension (N)
* The column scale factors for A. If EQUED = 'C' or 'B', A is
* multiplied on the right by diag(C); if EQUED = 'N' or 'R', C
* is not accessed. C is an input argument if FACT = 'F';
* otherwise, C is an output argument. If FACT = 'F' and
* EQUED = 'C' or 'B', each element of C must be positive.
*
* B (input/output) COMPLEX array, dimension (LDB,NRHS)
* On entry, the right hand side matrix B.
* On exit,
* if EQUED = 'N', B is not modified;
* if TRANS = 'N' and EQUED = 'R' or 'B', B is overwritten by
* diag(R)*B;
* if TRANS = 'T' or 'C' and EQUED = 'C' or 'B', B is
* overwritten by diag(C)*B.
*
* LDB (input) INTEGER
* The leading dimension of the array B. LDB >= max(1,N).
*
* X (output) COMPLEX array, dimension (LDX,NRHS)
* If INFO = 0 or INFO = 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 .ne. 'N', and the solution to the
* equilibrated system is inv(diag(C))*X if TRANS = 'N' and
* EQUED = 'C' or 'B', or inv(diag(R))*X if TRANS = 'T' or 'C'
* and EQUED = 'R' or 'B'.
*
* LDX (input) INTEGER
* The leading dimension of the array X. LDX >= max(1,N).
*
* RCOND (output) REAL
* 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 INFO > 0.
*
* FERR (output) REAL array, dimension (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.
*
* BERR (output) REAL array, dimension (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).
*
* WORK (workspace) COMPLEX array, dimension (2*N)
*
* RWORK (workspace/output) REAL array, dimension (N)
* On exit, RWORK(1) contains the reciprocal pivot growth
* factor norm(A)/norm(U). The "max absolute element" norm is
* used. If RWORK(1) is much less than 1, then the stability
* of the LU factorization of the (equilibrated) matrix A
* could be poor. This also means that the solution X, condition
* estimator RCOND, and forward error bound FERR could be
* unreliable. If factorization fails with 0 0: if INFO = i, and i is
* <= N: U(i,i) is exactly zero. The factorization
* has been completed, but the factor U is exactly
* singular, so the solution and error bounds
* could not be computed. RCOND = 0 is returned.
* = N+1: U is nonsingular, but RCOND is less than machine
* precision, meaning that the matrix is singular
* to working precision. Nevertheless, the
* solution and error bounds are computed because
* there are a number of situations where the
* computed solution can be more accurate than the
* value of RCOND would suggest.
*
* =====================================================================
* Moved setting of INFO = N+1 so INFO does not subsequently get
* overwritten. Sven, 17 Mar 05.
* =====================================================================
*
go to the page top
cgbsvxx
USAGE:
x, rcond, rpvgrw, berr, err_bnds_norm, err_bnds_comp, info, ab, afb, ipiv, equed, r, c, b, params = NumRu::Lapack.cgbsvxx( fact, trans, kl, ku, ab, afb, ipiv, equed, r, c, b, params, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBSVXX( FACT, TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, IPIV, EQUED, R, C, B, LDB, X, LDX, RCOND, RPVGRW, BERR, N_ERR_BNDS, ERR_BNDS_NORM, ERR_BNDS_COMP, NPARAMS, PARAMS, WORK, RWORK, INFO )
* Purpose
* =======
*
* CGBSVXX uses the LU factorization to compute the solution to a
* complex system of linear equations A * X = B, where A is an
* N-by-N matrix and X and B are N-by-NRHS matrices.
*
* If requested, both normwise and maximum componentwise error bounds
* are returned. CGBSVXX will return a solution with a tiny
* guaranteed error (O(eps) where eps is the working machine
* precision) unless the matrix is very ill-conditioned, in which
* case a warning is returned. Relevant condition numbers also are
* calculated and returned.
*
* CGBSVXX accepts user-provided factorizations and equilibration
* factors; see the definitions of the FACT and EQUED options.
* Solving with refinement and using a factorization from a previous
* CGBSVXX call will also produce a solution with either O(eps)
* errors or warnings, but we cannot make that claim for general
* user-provided factorizations and equilibration factors if they
* differ from what CGBSVXX would itself produce.
*
* Description
* ===========
*
* The following steps are performed:
*
* 1. If FACT = 'E', real scaling factors are computed to equilibrate
* the system:
*
* TRANS = 'N': diag(R)*A*diag(C) *inv(diag(C))*X = diag(R)*B
* TRANS = 'T': (diag(R)*A*diag(C))**T *inv(diag(R))*X = diag(C)*B
* TRANS = 'C': (diag(R)*A*diag(C))**H *inv(diag(R))*X = diag(C)*B
*
* Whether or not the system will be equilibrated depends on the
* scaling of the matrix A, but if equilibration is used, A is
* overwritten by diag(R)*A*diag(C) and B by diag(R)*B (if TRANS='N')
* or diag(C)*B (if TRANS = 'T' or 'C').
*
* 2. If FACT = 'N' or 'E', the LU decomposition is used to factor
* the matrix A (after equilibration if FACT = 'E') as
*
* A = P * L * U,
*
* where P is a permutation matrix, L is a unit lower triangular
* matrix, and U is upper triangular.
*
* 3. If some U(i,i)=0, so that U is exactly singular, then the
* routine returns with INFO = i. Otherwise, the factored form of A
* is used to estimate the condition number of the matrix A (see
* argument RCOND). If the reciprocal of the condition number is less
* than machine precision, the routine still goes on to solve for X
* and compute error bounds as described below.
*
* 4. The system of equations is solved for X using the factored form
* of A.
*
* 5. By default (unless PARAMS(LA_LINRX_ITREF_I) is set to zero),
* the routine will use iterative refinement to try to get a small
* error and error bounds. Refinement calculates the residual to at
* least twice the working precision.
*
* 6. If equilibration was used, the matrix X is premultiplied by
* diag(C) (if TRANS = 'N') or diag(R) (if TRANS = 'T' or 'C') so
* that it solves the original system before equilibration.
*
* Arguments
* =========
*
* Some optional parameters are bundled in the PARAMS array. These
* settings determine how refinement is performed, but often the
* defaults are acceptable. If the defaults are acceptable, users
* can pass NPARAMS = 0 which prevents the source code from accessing
* the PARAMS argument.
*
* FACT (input) CHARACTER*1
* Specifies 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.
* = 'F': On entry, AF and IPIV contain the factored form of A.
* If EQUED is not 'N', the matrix A has been
* equilibrated with scaling factors given by R and C.
* A, AF, and IPIV are not modified.
* = 'N': The matrix A will be copied to AF and factored.
* = 'E': The matrix A will be equilibrated if necessary, then
* copied to AF and factored.
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations:
* = 'N': A * X = B (No transpose)
* = 'T': A**T * X = B (Transpose)
* = 'C': A**H * X = B (Conjugate Transpose = Transpose)
*
* N (input) INTEGER
* The number of linear equations, i.e., the order of the
* matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* NRHS (input) INTEGER
* The number of right hand sides, i.e., the number of columns
* of the matrices B and X. NRHS >= 0.
*
* AB (input/output) REAL array, dimension (LDAB,N)
* 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)
*
* If FACT = 'F' and EQUED is not 'N', then AB must have been
* equilibrated by the scaling factors in R and/or C. AB is not
* modified if FACT = 'F' or 'N', or if FACT = 'E' and
* EQUED = 'N' on exit.
*
* On exit, if EQUED .ne. 'N', A is scaled as follows:
* EQUED = 'R': A := diag(R) * A
* EQUED = 'C': A := A * diag(C)
* EQUED = 'B': A := diag(R) * A * diag(C).
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= KL+KU+1.
*
* AFB (input or output) REAL array, dimension (LDAFB,N)
* If FACT = 'F', then AFB is an input argument and on entry
* contains details of the LU factorization of the band matrix
* A, as computed by CGBTRF. 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. If EQUED .ne. 'N', then AFB is
* the factored form of the equilibrated matrix A.
*
* If FACT = 'N', then AF is an output argument and on exit
* returns the factors L and U from the factorization A = P*L*U
* of the original matrix A.
*
* If FACT = 'E', then AF is an output argument and on exit
* returns the factors L and U from the factorization A = P*L*U
* of the equilibrated matrix A (see the description of A for
* the form of the equilibrated matrix).
*
* LDAFB (input) INTEGER
* The leading dimension of the array AFB. LDAFB >= 2*KL+KU+1.
*
* IPIV (input or output) INTEGER array, dimension (N)
* If FACT = 'F', then IPIV is an input argument and on entry
* contains the pivot indices from the factorization A = P*L*U
* as computed by SGETRF; row i of the matrix was interchanged
* with row IPIV(i).
*
* If FACT = 'N', then IPIV is an output argument and on exit
* contains the pivot indices from the factorization A = P*L*U
* of the original matrix A.
*
* If FACT = 'E', then IPIV is an output argument and on exit
* contains the pivot indices from the factorization A = P*L*U
* of the equilibrated matrix A.
*
* EQUED (input or output) CHARACTER*1
* Specifies the form of equilibration that was done.
* = 'N': No equilibration (always true if FACT = 'N').
* = 'R': Row equilibration, i.e., A has been premultiplied by
* diag(R).
* = 'C': Column equilibration, i.e., A has been postmultiplied
* by diag(C).
* = 'B': Both row and column equilibration, i.e., A has been
* replaced by diag(R) * A * diag(C).
* EQUED is an input argument if FACT = 'F'; otherwise, it is an
* output argument.
*
* R (input or output) REAL array, dimension (N)
* The row scale factors for A. If EQUED = 'R' or 'B', A is
* multiplied on the left by diag(R); if EQUED = 'N' or 'C', R
* is not accessed. R is an input argument if FACT = 'F';
* otherwise, R is an output argument. If FACT = 'F' and
* EQUED = 'R' or 'B', each element of R must be positive.
* If R is output, each element of R is a power of the radix.
* If R is input, each element of R should be a power of the radix
* to ensure a reliable solution and error estimates. Scaling by
* powers of the radix does not cause rounding errors unless the
* result underflows or overflows. Rounding errors during scaling
* lead to refining with a matrix that is not equivalent to the
* input matrix, producing error estimates that may not be
* reliable.
*
* C (input or output) REAL array, dimension (N)
* The column scale factors for A. If EQUED = 'C' or 'B', A is
* multiplied on the right by diag(C); if EQUED = 'N' or 'R', C
* is not accessed. C is an input argument if FACT = 'F';
* otherwise, C is an output argument. If FACT = 'F' and
* EQUED = 'C' or 'B', each element of C must be positive.
* If C is output, each element of C is a power of the radix.
* If C is input, each element of C should be a power of the radix
* to ensure a reliable solution and error estimates. Scaling by
* powers of the radix does not cause rounding errors unless the
* result underflows or overflows. Rounding errors during scaling
* lead to refining with a matrix that is not equivalent to the
* input matrix, producing error estimates that may not be
* reliable.
*
* B (input/output) REAL array, dimension (LDB,NRHS)
* On entry, the N-by-NRHS right hand side matrix B.
* On exit,
* if EQUED = 'N', B is not modified;
* if TRANS = 'N' and EQUED = 'R' or 'B', B is overwritten by
* diag(R)*B;
* if TRANS = 'T' or 'C' and EQUED = 'C' or 'B', B is
* overwritten by diag(C)*B.
*
* LDB (input) INTEGER
* The leading dimension of the array B. LDB >= max(1,N).
*
* X (output) REAL array, dimension (LDX,NRHS)
* If INFO = 0, the N-by-NRHS solution matrix X to the original
* system of equations. Note that A and B are modified on exit
* if EQUED .ne. 'N', and the solution to the equilibrated system is
* inv(diag(C))*X if TRANS = 'N' and EQUED = 'C' or 'B', or
* inv(diag(R))*X if TRANS = 'T' or 'C' and EQUED = 'R' or 'B'.
*
* LDX (input) INTEGER
* The leading dimension of the array X. LDX >= max(1,N).
*
* RCOND (output) REAL
* Reciprocal scaled condition number. This is an estimate of the
* reciprocal Skeel condition number of the matrix A after
* equilibration (if done). If this is less than the machine
* precision (in particular, if it is zero), the matrix is singular
* to working precision. Note that the error may still be small even
* if this number is very small and the matrix appears ill-
* conditioned.
*
* RPVGRW (output) REAL
* Reciprocal pivot growth. On exit, this contains the reciprocal
* pivot growth factor norm(A)/norm(U). The "max absolute element"
* norm is used. If this is much less than 1, then the stability of
* the LU factorization of the (equilibrated) matrix A could be poor.
* This also means that the solution X, estimated condition numbers,
* and error bounds could be unreliable. If factorization fails with
* 0 0 and <= N: U(INFO,INFO) is exactly zero. The factorization
* has been completed, but the factor U is exactly singular, so
* the solution and error bounds could not be computed. RCOND = 0
* is returned.
* = N+J: The solution corresponding to the Jth right-hand side is
* not guaranteed. The solutions corresponding to other right-
* hand sides K with K > J may not be guaranteed as well, but
* only the first such right-hand side is reported. If a small
* componentwise error is not requested (PARAMS(3) = 0.0) then
* the Jth right-hand side is the first with a normwise error
* bound that is not guaranteed (the smallest J such
* that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)
* the Jth right-hand side is the first with either a normwise or
* componentwise error bound that is not guaranteed (the smallest
* J such that either ERR_BNDS_NORM(J,1) = 0.0 or
* ERR_BNDS_COMP(J,1) = 0.0). See the definition of
* ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information
* about all of the right-hand sides check ERR_BNDS_NORM or
* ERR_BNDS_COMP.
*
* ==================================================================
*
go to the page top
cgbtf2
USAGE:
ipiv, info, ab = NumRu::Lapack.cgbtf2( m, kl, ku, ab, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBTF2( M, N, KL, KU, AB, LDAB, IPIV, INFO )
* Purpose
* =======
*
* CGBTF2 computes an LU factorization of a complex m-by-n band matrix
* A using partial pivoting with row interchanges.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
*
* Arguments
* =========
*
* M (input) INTEGER
* The number of rows of the matrix A. M >= 0.
*
* N (input) INTEGER
* The number of columns of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* AB (input/output) COMPLEX array, dimension (LDAB,N)
* 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(m,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.
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= 2*KL+KU+1.
*
* IPIV (output) INTEGER array, dimension (min(M,N))
* The pivot indices; for 1 <= i <= min(M,N), row i of the
* matrix was interchanged with row IPIV(i).
*
* INFO (output) INTEGER
* = 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. The factorization
* has been completed, but the factor U is exactly
* singular, and division by zero will occur if it is used
* to solve a system of equations.
*
* Further Details
* ===============
*
* The band storage scheme is illustrated by the following example, when
* M = 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
* + need not be set on entry, but are required by the routine to store
* elements of U, because of fill-in resulting from the row
* interchanges.
*
* =====================================================================
*
go to the page top
cgbtrf
USAGE:
ipiv, info, ab = NumRu::Lapack.cgbtrf( m, kl, ku, ab, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBTRF( M, N, KL, KU, AB, LDAB, IPIV, INFO )
* Purpose
* =======
*
* CGBTRF computes an LU factorization of a complex m-by-n band matrix A
* using partial pivoting with row interchanges.
*
* This is the blocked version of the algorithm, calling Level 3 BLAS.
*
* Arguments
* =========
*
* M (input) INTEGER
* The number of rows of the matrix A. M >= 0.
*
* N (input) INTEGER
* The number of columns of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* AB (input/output) COMPLEX array, dimension (LDAB,N)
* 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(m,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.
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= 2*KL+KU+1.
*
* IPIV (output) INTEGER array, dimension (min(M,N))
* The pivot indices; for 1 <= i <= min(M,N), row i of the
* matrix was interchanged with row IPIV(i).
*
* INFO (output) INTEGER
* = 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. The factorization
* has been completed, but the factor U is exactly
* singular, and division by zero will occur if it is used
* to solve a system of equations.
*
* Further Details
* ===============
*
* The band storage scheme is illustrated by the following example, when
* M = 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
* + need not be set on entry, but are required by the routine to store
* elements of U because of fill-in resulting from the row interchanges.
*
* =====================================================================
*
go to the page top
cgbtrs
USAGE:
info, b = NumRu::Lapack.cgbtrs( trans, kl, ku, ab, ipiv, b, [:usage => usage, :help => help])
FORTRAN MANUAL
SUBROUTINE CGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB, INFO )
* Purpose
* =======
*
* CGBTRS solves a system of linear equations
* A * X = B, A**T * X = B, or A**H * X = B
* with a general band matrix A using the LU factorization computed
* by CGBTRF.
*
* Arguments
* =========
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations.
* = 'N': A * X = B (No transpose)
* = 'T': A**T * X = B (Transpose)
* = 'C': A**H * X = B (Conjugate transpose)
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
* NRHS (input) INTEGER
* The number of right hand sides, i.e., the number of columns
* of the matrix B. NRHS >= 0.
*
* AB (input) COMPLEX array, dimension (LDAB,N)
* Details of the LU factorization of the band matrix A, as
* computed by CGBTRF. 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.
*
* LDAB (input) INTEGER
* The leading dimension of the array AB. LDAB >= 2*KL+KU+1.
*
* IPIV (input) INTEGER array, dimension (N)
* The pivot indices; for 1 <= i <= N, row i of the matrix was
* interchanged with row IPIV(i).
*
* B (input/output) COMPLEX array, dimension (LDB,NRHS)
* On entry, the right hand side matrix B.
* On exit, the solution matrix X.
*
* LDB (input) INTEGER
* The leading dimension of the array B. LDB >= max(1,N).
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = -i, the i-th argument had an illegal value
*
* =====================================================================
*
go to the page top
back to matrix types
back to data types