SGBBRD reduces a real general m-by-n band matrix A to upper


 bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.


 The routine computes B, and optionally forms Q or P**T, or computes


 Q**T*C for a given matrix C.

VECT

          VECT is CHARACTER*1


          Specifies whether or not the matrices Q and P**T are to be


          formed.


          = 'N': do not form Q or P**T;


          = 'Q': form Q only;


          = 'P': form P**T only;


          = 'B': form both.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

NCC

          NCC is INTEGER


          The number of columns of the matrix C.  NCC >= 0.

KL

          KL is INTEGER


          The number of subdiagonals of the matrix A. KL >= 0.

KU

          KU is INTEGER


          The number of superdiagonals of the matrix A. KU >= 0.

AB

          AB is REAL 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

          LDAB is INTEGER


          The leading dimension of the array A. LDAB >= KL+KU+1.

D

          D is REAL array, dimension (min(M,N))


          The diagonal elements of the bidiagonal matrix B.

E

          E is REAL array, dimension (min(M,N)-1)


          The superdiagonal elements of the bidiagonal matrix B.

Q

          Q is REAL array, dimension (LDQ,M)


          If VECT = 'Q' or 'B', the m-by-m orthogonal matrix Q.


          If VECT = 'N' or 'P', the array Q is not referenced.

LDQ

          LDQ is INTEGER


          The leading dimension of the array Q.


          LDQ >= max(1,M) if VECT = 'Q' or 'B'; LDQ >= 1 otherwise.

PT

          PT is REAL array, dimension (LDPT,N)


          If VECT = 'P' or 'B', the n-by-n orthogonal matrix P'.


          If VECT = 'N' or 'Q', the array PT is not referenced.

LDPT

          LDPT is INTEGER


          The leading dimension of the array PT.


          LDPT >= max(1,N) if VECT = 'P' or 'B'; LDPT >= 1 otherwise.

C

          C is REAL array, dimension (LDC,NCC)


          On entry, an m-by-ncc matrix C.


          On exit, C is overwritten by Q**T*C.


          C is not referenced if NCC = 0.

LDC

          LDC is INTEGER


          The leading dimension of the array C.


          LDC >= max(1,M) if NCC > 0; LDC >= 1 if NCC = 0.

WORK

          WORK is REAL array, dimension (2*max(M,N))

INFO

          INFO is INTEGER


          = 0:  successful exit.


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SGBCON estimates the reciprocal of the condition number of a real


 general band matrix A, in either the 1-norm or the infinity-norm,


 using the LU factorization computed by SGBTRF.


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

NORM

          NORM is 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

          N is INTEGER


          The order of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

AB

          AB is REAL array, dimension (LDAB,N)


          Details of the LU factorization of the band matrix A, as


          computed by SGBTRF.  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

          LDAB is INTEGER


          The leading dimension of the array AB.  LDAB >= 2*KL+KU+1.

IPIV

          IPIV is INTEGER array, dimension (N)


          The pivot indices; for 1 <= i <= N, row i of the matrix was


          interchanged with row IPIV(i).

ANORM

          ANORM is 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

          RCOND is REAL


          The reciprocal of the condition number of the matrix A,


          computed as RCOND = 1/(norm(A) * norm(inv(A))).

WORK

          WORK is REAL array, dimension (3*N)

IWORK

          IWORK is INTEGER array, dimension (N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

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

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

AB

          AB is REAL 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

          LDAB is INTEGER


          The leading dimension of the array AB.  LDAB >= KL+KU+1.

R

          R is REAL array, dimension (M)


          If INFO = 0, or INFO > M, R contains the row scale factors


          for A.

C

          C is REAL array, dimension (N)


          If INFO = 0, C contains the column scale factors for A.

ROWCND

          ROWCND is 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

          COLCND is 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

          AMAX is 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

          INFO is 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

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SGBEQUB 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 SGEEQU by restricting the scaling factors


 to a power of the radix.  Barring over- and underflow, scaling by


 these factors introduces no additional rounding errors.  However, the


 scaled entries' magnitudes are no longer approximately 1 but lie


 between sqrt(radix) and 1/sqrt(radix).

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

AB

          AB is 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)

LDAB

          LDAB is INTEGER


          The leading dimension of the array A.  LDAB >= max(1,M).

R

          R is REAL array, dimension (M)


          If INFO = 0 or INFO > M, R contains the row scale factors


          for A.

C

          C is REAL array, dimension (N)


          If INFO = 0,  C contains the column scale factors for A.

ROWCND

          ROWCND is 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

          COLCND is 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

          AMAX is 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

          INFO is 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

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

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

TRANS

          TRANS is 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

          N is INTEGER


          The order of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

NRHS

          NRHS is INTEGER


          The number of right hand sides, i.e., the number of columns


          of the matrices B and X.  NRHS >= 0.

AB

          AB is REAL 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

          LDAB is INTEGER


          The leading dimension of the array AB.  LDAB >= KL+KU+1.

AFB

          AFB is REAL array, dimension (LDAFB,N)


          Details of the LU factorization of the band matrix A, as


          computed by SGBTRF.  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

          LDAFB is INTEGER


          The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1.

IPIV

          IPIV is INTEGER array, dimension (N)


          The pivot indices from SGBTRF; for 1<=i<=N, row i of the


          matrix was interchanged with row IPIV(i).

B

          B is REAL array, dimension (LDB,NRHS)


          The right hand side matrix B.

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max(1,N).

X

          X is REAL array, dimension (LDX,NRHS)


          On entry, the solution matrix X, as computed by SGBTRS.


          On exit, the improved solution matrix X.

LDX

          LDX is INTEGER


          The leading dimension of the array X.  LDX >= max(1,N).

FERR

          FERR is 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

          BERR is 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

          WORK is REAL array, dimension (3*N)

IWORK

          IWORK is INTEGER array, dimension (N)

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

  ITMAX is the maximum number of steps of iterative refinement.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

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

     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

          TRANS is 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

          EQUED is 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

          N is INTEGER


     The order of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

NRHS

          NRHS is INTEGER


     The number of right hand sides, i.e., the number of columns


     of the matrices B and X.  NRHS >= 0.

AB

          AB is REAL 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

          LDAB is INTEGER


     The leading dimension of the array AB.  LDAB >= KL+KU+1.

AFB

          AFB is REAL array, dimension (LDAFB,N)


     Details of the LU factorization of the band matrix A, as


     computed by SGBTRF.  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

          LDAFB is INTEGER


     The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1.

IPIV

          IPIV is 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

          R is 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

          C is 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

          B is REAL array, dimension (LDB,NRHS)


     The right hand side matrix B.

LDB

          LDB is INTEGER


     The leading dimension of the array B.  LDB >= max(1,N).

X

          X is REAL array, dimension (LDX,NRHS)


     On entry, the solution matrix X, as computed by SGETRS.


     On exit, the improved solution matrix X.

LDX

          LDX is INTEGER


     The leading dimension of the array X.  LDX >= max(1,N).

RCOND

          RCOND is 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

          BERR is 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

          N_ERR_BNDS is 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

          ERR_BNDS_NORM is 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

          ERR_BNDS_COMP is 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 < 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

          NPARAMS is INTEGER


     Specifies the number of parameters set in PARAMS.  If <= 0, the


     PARAMS array is never referenced and default values are used.

PARAMS

          PARAMS is REAL array, dimension NPARAMS


     Specifies algorithm parameters.  If an entry is < 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

          WORK is REAL array, dimension (4*N)

IWORK

          IWORK is INTEGER array, dimension (N)

INFO

          INFO is 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.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SGBTF2 computes an LU factorization of a real m-by-n band matrix A


 using partial pivoting with row interchanges.


 This is the unblocked version of the algorithm, calling Level 2 BLAS.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

AB

          AB is REAL 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

          LDAB is INTEGER


          The leading dimension of the array AB.  LDAB >= 2*KL+KU+1.

IPIV

          IPIV is 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

          INFO is 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.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  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.

 SGBTRF computes an LU factorization of a real m-by-n band matrix A


 using partial pivoting with row interchanges.


 This is the blocked version of the algorithm, calling Level 3 BLAS.

M

          M is INTEGER


          The number of rows of the matrix A.  M >= 0.

N

          N is INTEGER


          The number of columns of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

AB

          AB is REAL 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

          LDAB is INTEGER


          The leading dimension of the array AB.  LDAB >= 2*KL+KU+1.

IPIV

          IPIV is 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

          INFO is 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.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  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.

 SGBTRS solves a system of linear equations


    A * X = B  or  A**T * X = B


 with a general band matrix A using the LU factorization computed


 by SGBTRF.

TRANS

          TRANS is CHARACTER*1


          Specifies the form of the system of equations.


          = 'N':  A * X = B  (No transpose)


          = 'T':  A**T* X = B  (Transpose)


          = 'C':  A**T* X = B  (Conjugate transpose = Transpose)

N

          N is INTEGER


          The order of the matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

NRHS

          NRHS is INTEGER


          The number of right hand sides, i.e., the number of columns


          of the matrix B.  NRHS >= 0.

AB

          AB is REAL array, dimension (LDAB,N)


          Details of the LU factorization of the band matrix A, as


          computed by SGBTRF.  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

          LDAB is INTEGER


          The leading dimension of the array AB.  LDAB >= 2*KL+KU+1.

IPIV

          IPIV is INTEGER array, dimension (N)


          The pivot indices; for 1 <= i <= N, row i of the matrix was


          interchanged with row IPIV(i).

B

          B is REAL array, dimension (LDB,NRHS)


          On entry, the right hand side matrix B.


          On exit, the solution matrix X.

LDB

          LDB is INTEGER


          The leading dimension of the array B.  LDB >= max(1,N).

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0: if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SGGBAK forms the right or left eigenvectors of a real generalized


 eigenvalue problem A*x = lambda*B*x, by backward transformation on


 the computed eigenvectors of the balanced pair of matrices output by


 SGGBAL.

JOB

          JOB is CHARACTER*1


          Specifies the type of backward transformation required:


          = 'N':  do nothing, return immediately;


          = 'P':  do backward transformation for permutation only;


          = 'S':  do backward transformation for scaling only;


          = 'B':  do backward transformations for both permutation and


                  scaling.


          JOB must be the same as the argument JOB supplied to SGGBAL.

SIDE

          SIDE is CHARACTER*1


          = 'R':  V contains right eigenvectors;


          = 'L':  V contains left eigenvectors.

N

          N is INTEGER


          The number of rows of the matrix V.  N >= 0.

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          The integers ILO and IHI determined by SGGBAL.


          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

LSCALE

          LSCALE is REAL array, dimension (N)


          Details of the permutations and/or scaling factors applied


          to the left side of A and B, as returned by SGGBAL.

RSCALE

          RSCALE is REAL array, dimension (N)


          Details of the permutations and/or scaling factors applied


          to the right side of A and B, as returned by SGGBAL.

M

          M is INTEGER


          The number of columns of the matrix V.  M >= 0.

V

          V is REAL array, dimension (LDV,M)


          On entry, the matrix of right or left eigenvectors to be


          transformed, as returned by STGEVC.


          On exit, V is overwritten by the transformed eigenvectors.

LDV

          LDV is INTEGER


          The leading dimension of the matrix V. LDV >= max(1,N).

INFO

          INFO is INTEGER


          = 0:  successful exit.


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  See R.C. Ward, Balancing the generalized eigenvalue problem,


                 SIAM J. Sci. Stat. Comp. 2 (1981), 141-152.

 SGGBAL balances a pair of general real matrices (A,B).  This


 involves, first, permuting A and B by similarity transformations to


 isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N


 elements on the diagonal; and second, applying a diagonal similarity


 transformation to rows and columns ILO to IHI to make the rows


 and columns as close in norm as possible. Both steps are optional.


 Balancing may reduce the 1-norm of the matrices, and improve the


 accuracy of the computed eigenvalues and/or eigenvectors in the


 generalized eigenvalue problem A*x = lambda*B*x.

JOB

          JOB is CHARACTER*1


          Specifies the operations to be performed on A and B:


          = 'N':  none:  simply set ILO = 1, IHI = N, LSCALE(I) = 1.0


                  and RSCALE(I) = 1.0 for i = 1,...,N.


          = 'P':  permute only;


          = 'S':  scale only;


          = 'B':  both permute and scale.

N

          N is INTEGER


          The order of the matrices A and B.  N >= 0.

A

          A is REAL array, dimension (LDA,N)


          On entry, the input matrix A.


          On exit,  A is overwritten by the balanced matrix.


          If JOB = 'N', A is not referenced.

LDA

          LDA is INTEGER


          The leading dimension of the array A. LDA >= max(1,N).

B

          B is REAL array, dimension (LDB,N)


          On entry, the input matrix B.


          On exit,  B is overwritten by the balanced matrix.


          If JOB = 'N', B is not referenced.

LDB

          LDB is INTEGER


          The leading dimension of the array B. LDB >= max(1,N).

ILO

          ILO is INTEGER

IHI

          IHI is INTEGER


          ILO and IHI are set to integers such that on exit


          A(i,j) = 0 and B(i,j) = 0 if i > j and


          j = 1,...,ILO-1 or i = IHI+1,...,N.


          If JOB = 'N' or 'S', ILO = 1 and IHI = N.

LSCALE

          LSCALE is REAL array, dimension (N)


          Details of the permutations and scaling factors applied


          to the left side of A and B.  If P(j) is the index of the


          row interchanged with row j, and D(j)


          is the scaling factor applied to row j, then


            LSCALE(j) = P(j)    for J = 1,...,ILO-1


                      = D(j)    for J = ILO,...,IHI


                      = P(j)    for J = IHI+1,...,N.


          The order in which the interchanges are made is N to IHI+1,


          then 1 to ILO-1.

RSCALE

          RSCALE is REAL array, dimension (N)


          Details of the permutations and scaling factors applied


          to the right side of A and B.  If P(j) is the index of the


          column interchanged with column j, and D(j)


          is the scaling factor applied to column j, then


            LSCALE(j) = P(j)    for J = 1,...,ILO-1


                      = D(j)    for J = ILO,...,IHI


                      = P(j)    for J = IHI+1,...,N.


          The order in which the interchanges are made is N to IHI+1,


          then 1 to ILO-1.

WORK

          WORK is REAL array, dimension (lwork)


          lwork must be at least max(1,6*N) when JOB = 'S' or 'B', and


          at least 1 when JOB = 'N' or 'P'.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

  See R.C. WARD, Balancing the generalized eigenvalue problem,


                 SIAM J. Sci. Stat. Comp. 2 (1981), 141-152.

 SLA_GBAMV  performs one of the matrix-vector operations


         y := alpha*abs(A)*abs(x) + beta*abs(y),


    or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),


 where alpha and beta are scalars, x and y are vectors and A is an


 m by n matrix.


 This function is primarily used in calculating error bounds.


 To protect against underflow during evaluation, components in


 the resulting vector are perturbed away from zero by (N+1)


 times the underflow threshold.  To prevent unnecessarily large


 errors for block-structure embedded in general matrices,


 'symbolically' zero components are not perturbed.  A zero


 entry is considered 'symbolic' if all multiplications involved


 in computing that entry have at least one zero multiplicand.

TRANS

          TRANS is INTEGER


           On entry, TRANS specifies the operation to be performed as


           follows:


             BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)


             BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)


             BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)


           Unchanged on exit.

M

          M is INTEGER


           On entry, M specifies the number of rows of the matrix A.


           M must be at least zero.


           Unchanged on exit.

N

          N is INTEGER


           On entry, N specifies the number of columns of the matrix A.


           N must be at least zero.


           Unchanged on exit.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

ALPHA

          ALPHA is REAL


           On entry, ALPHA specifies the scalar alpha.


           Unchanged on exit.

AB

          AB is REAL array, dimension ( LDAB, n )


           Before entry, the leading m by n part of the array AB must


           contain the matrix of coefficients.


           Unchanged on exit.

LDAB

          LDAB is INTEGER


           On entry, LDA specifies the first dimension of AB as declared


           in the calling (sub) program. LDAB must be at least


           max( 1, m ).


           Unchanged on exit.

X

          X is REAL array, dimension


           ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'


           and at least


           ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.


           Before entry, the incremented array X must contain the


           vector x.


           Unchanged on exit.

INCX

          INCX is INTEGER


           On entry, INCX specifies the increment for the elements of


           X. INCX must not be zero.


           Unchanged on exit.

BETA

          BETA is REAL


           On entry, BETA specifies the scalar beta. When BETA is


           supplied as zero then Y need not be set on input.


           Unchanged on exit.

Y

          Y is REAL array, dimension


           ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'


           and at least


           ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.


           Before entry with BETA non-zero, the incremented array Y


           must contain the vector y. On exit, Y is overwritten by the


           updated vector y.

INCY

          INCY is INTEGER


           On entry, INCY specifies the increment for the elements of


           Y. INCY must not be zero.


           Unchanged on exit.


  Level 2 Blas routine.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

    SLA_GBRCOND Estimates the Skeel condition number of  op(A) * op2(C)


    where op2 is determined by CMODE as follows


    CMODE =  1    op2(C) = C


    CMODE =  0    op2(C) = I


    CMODE = -1    op2(C) = inv(C)


    The Skeel condition number  cond(A) = norminf( |inv(A)||A| )


    is computed by computing scaling factors R such that


    diag(R)*A*op2(C) is row equilibrated and computing the standard


    infinity-norm condition number.

TRANS

          TRANS is 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

          N is INTEGER


     The number of linear equations, i.e., the order of the


     matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

AB

          AB is 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)

LDAB

          LDAB is INTEGER


     The leading dimension of the array AB.  LDAB >= KL+KU+1.

AFB

          AFB is REAL array, dimension (LDAFB,N)


     Details of the LU factorization of the band matrix A, as


     computed by SGBTRF.  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

          LDAFB is INTEGER


     The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1.

IPIV

          IPIV is INTEGER array, dimension (N)


     The pivot indices from the factorization A = P*L*U


     as computed by SGBTRF; row i of the matrix was interchanged


     with row IPIV(i).

CMODE

          CMODE is INTEGER


     Determines op2(C) in the formula op(A) * op2(C) as follows:


     CMODE =  1    op2(C) = C


     CMODE =  0    op2(C) = I


     CMODE = -1    op2(C) = inv(C)

C

          C is REAL array, dimension (N)


     The vector C in the formula op(A) * op2(C).

INFO

          INFO is INTEGER


       = 0:  Successful exit.


     i > 0:  The ith argument is invalid.

WORK

          WORK is REAL array, dimension (5*N).


     Workspace.

IWORK

          IWORK is INTEGER array, dimension (N).


     Workspace.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SLA_GBRFSX_EXTENDED improves the computed solution to a system of


 linear equations by performing extra-precise iterative refinement


 and provides error bounds and backward error estimates for the solution.


 This subroutine is called by SGBRFSX to perform iterative refinement.


 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. Note that this


 subroutine is only responsible for setting the second fields of


 ERR_BNDS_NORM and ERR_BNDS_COMP.

PREC_TYPE

          PREC_TYPE is INTEGER


     Specifies the intermediate precision to be used in refinement.


     The value is defined by ILAPREC(P) where P is a CHARACTER and P


          = 'S':  Single


          = 'D':  Double


          = 'I':  Indigenous


          = 'X' or 'E':  Extra

TRANS_TYPE

          TRANS_TYPE is INTEGER


     Specifies the transposition operation on A.


     The value is defined by ILATRANS(T) where T is a CHARACTER and T


          = 'N':  No transpose


          = 'T':  Transpose


          = 'C':  Conjugate transpose

N

          N is INTEGER


     The number of linear equations, i.e., the order of the


     matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

NRHS

          NRHS is INTEGER


     The number of right-hand-sides, i.e., the number of columns of the


     matrix B.

AB

          AB is REAL array, dimension (LDAB,N)


     On entry, the N-by-N matrix AB.

LDAB

          LDAB is INTEGER


     The leading dimension of the array AB.  LDAB >= max(1,N).

AFB

          AFB is REAL array, dimension (LDAFB,N)


     The factors L and U from the factorization


     A = P*L*U as computed by SGBTRF.

LDAFB

          LDAFB is INTEGER


     The leading dimension of the array AF.  LDAFB >= max(1,N).

IPIV

          IPIV is INTEGER array, dimension (N)


     The pivot indices from the factorization A = P*L*U


     as computed by SGBTRF; row i of the matrix was interchanged


     with row IPIV(i).

COLEQU

          COLEQU is LOGICAL


     If .TRUE. then column equilibration was done to A before calling


     this routine. This is needed to compute the solution and error


     bounds correctly.

C

          C is REAL array, dimension (N)


     The column scale factors for A. If COLEQU = .FALSE., C


     is not accessed. 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

          B is REAL array, dimension (LDB,NRHS)


     The right-hand-side matrix B.

LDB

          LDB is INTEGER


     The leading dimension of the array B.  LDB >= max(1,N).

Y

          Y is REAL array, dimension (LDY,NRHS)


     On entry, the solution matrix X, as computed by SGBTRS.


     On exit, the improved solution matrix Y.

LDY

          LDY is INTEGER


     The leading dimension of the array Y.  LDY >= max(1,N).

BERR_OUT

          BERR_OUT is REAL array, dimension (NRHS)


     On exit, BERR_OUT(j) contains the componentwise relative backward


     error for right-hand-side j from the formula


         max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )


     where abs(Z) is the componentwise absolute value of the matrix


     or vector Z. This is computed by SLA_LIN_BERR.

N_NORMS

          N_NORMS is INTEGER


     Determines which error bounds to return (see ERR_BNDS_NORM


     and ERR_BNDS_COMP).


     If N_NORMS >= 1 return normwise error bounds.


     If N_NORMS >= 2 return componentwise error bounds.

ERR_BNDS_NORM

          ERR_BNDS_NORM is 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.


     This subroutine is only responsible for setting the second field


     above.


     See Lapack Working Note 165 for further details and extra


     cautions.

ERR_BNDS_COMP

          ERR_BNDS_COMP is 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 < 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.


     This subroutine is only responsible for setting the second field


     above.


     See Lapack Working Note 165 for further details and extra


     cautions.

RES

          RES is REAL array, dimension (N)


     Workspace to hold the intermediate residual.

AYB

          AYB is REAL array, dimension (N)


     Workspace. This can be the same workspace passed for Y_TAIL.

DY

          DY is REAL array, dimension (N)


     Workspace to hold the intermediate solution.

Y_TAIL

          Y_TAIL is REAL array, dimension (N)


     Workspace to hold the trailing bits of the intermediate solution.

RCOND

          RCOND is 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.

ITHRESH

          ITHRESH is INTEGER


     The maximum number of residual computations allowed for


     refinement. The default is 10. For '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.

RTHRESH

          RTHRESH is REAL


     Determines when to stop refinement if the error estimate stops


     decreasing. Refinement will stop when the next solution no longer


     satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is


     the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The


     default value is 0.5. For 'aggressive' set to 0.9 to permit


     convergence on extremely ill-conditioned matrices. See LAWN 165


     for more details.

DZ_UB

          DZ_UB is REAL


     Determines when to start considering componentwise convergence.


     Componentwise convergence is only considered after each component


     of the solution Y is stable, which we define as the relative


     change in each component being less than DZ_UB. The default value


     is 0.25, requiring the first bit to be stable. See LAWN 165 for


     more details.

IGNORE_CWISE

          IGNORE_CWISE is LOGICAL


     If .TRUE. then ignore componentwise convergence. Default value


     is .FALSE..

INFO

          INFO is INTEGER


       = 0:  Successful exit.


       < 0:  if INFO = -i, the ith argument to SGBTRS had an illegal


             value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SLA_GBRPVGRW computes the reciprocal pivot growth factor


 norm(A)/norm(U). The 'max absolute element' norm is used. If this is


 much less than 1, 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.

N

          N is INTEGER


     The number of linear equations, i.e., the order of the


     matrix A.  N >= 0.

KL

          KL is INTEGER


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

KU

          KU is INTEGER


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

NCOLS

          NCOLS is INTEGER


     The number of columns of the matrix A.  NCOLS >= 0.

AB

          AB is 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)

LDAB

          LDAB is INTEGER


     The leading dimension of the array AB.  LDAB >= KL+KU+1.

AFB

          AFB is REAL array, dimension (LDAFB,N)


     Details of the LU factorization of the band matrix A, as


     computed by SGBTRF.  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

          LDAFB is INTEGER


     The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1.

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

 SORGBR generates one of the real orthogonal matrices Q or P**T


 determined by SGEBRD when reducing a real matrix A to bidiagonal


 form: A = Q * B * P**T.  Q and P**T are defined as products of


 elementary reflectors H(i) or G(i) respectively.


 If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q


 is of order M:


 if m >= k, Q = H(1) H(2) . . . H(k) and SORGBR returns the first n


 columns of Q, where m >= n >= k;


 if m < k, Q = H(1) H(2) . . . H(m-1) and SORGBR returns Q as an


 M-by-M matrix.


 If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**T


 is of order N:


 if k < n, P**T = G(k) . . . G(2) G(1) and SORGBR returns the first m


 rows of P**T, where n >= m >= k;


 if k >= n, P**T = G(n-1) . . . G(2) G(1) and SORGBR returns P**T as


 an N-by-N matrix.

VECT

          VECT is CHARACTER*1


          Specifies whether the matrix Q or the matrix P**T is


          required, as defined in the transformation applied by SGEBRD:


          = 'Q':  generate Q;


          = 'P':  generate P**T.

M

          M is INTEGER


          The number of rows of the matrix Q or P**T to be returned.


          M >= 0.

N

          N is INTEGER


          The number of columns of the matrix Q or P**T to be returned.


          N >= 0.


          If VECT = 'Q', M >= N >= min(M,K);


          if VECT = 'P', N >= M >= min(N,K).

K

          K is INTEGER


          If VECT = 'Q', the number of columns in the original M-by-K


          matrix reduced by SGEBRD.


          If VECT = 'P', the number of rows in the original K-by-N


          matrix reduced by SGEBRD.


          K >= 0.

A

          A is REAL array, dimension (LDA,N)


          On entry, the vectors which define the elementary reflectors,


          as returned by SGEBRD.


          On exit, the M-by-N matrix Q or P**T.

LDA

          LDA is INTEGER


          The leading dimension of the array A. LDA >= max(1,M).

TAU

          TAU is REAL array, dimension


                                (min(M,K)) if VECT = 'Q'


                                (min(N,K)) if VECT = 'P'


          TAU(i) must contain the scalar factor of the elementary


          reflector H(i) or G(i), which determines Q or P**T, as


          returned by SGEBRD in its array argument TAUQ or TAUP.

WORK

          WORK is REAL array, dimension (MAX(1,LWORK))


          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

LWORK

          LWORK is INTEGER


          The dimension of the array WORK. LWORK >= max(1,min(M,N)).


          For optimum performance LWORK >= min(M,N)*NB, where NB


          is the optimal blocksize.


          If LWORK = -1, then a workspace query is assumed; the routine


          only calculates the optimal size of the WORK array, returns


          this value as the first entry of the WORK array, and no error


          message related to LWORK is issued by XERBLA.

INFO

          INFO is INTEGER


          = 0:  successful exit


          < 0:  if INFO = -i, the i-th argument had an illegal value

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.