Integrating Doxygen in comments

1 files changed, 401 insertions, 254 deletions

diff --git a/SRC/cla_gerfsx_extended.f b/SRC/cla_gerfsx_extended.f
index dba3c059..c1de3a6b 100644
--- a/SRC/cla_gerfsx_extended.f
+++ b/SRC/cla_gerfsx_extended.f
@@ -1,3 +1,400 @@
+*> \brief \b CLA_GERFSX_EXTENDED
+*
+*  =========== DOCUMENTATION ===========
+*
+* Online html documentation available at 
+*            http://www.netlib.org/lapack/explore-html/ 
+*
+*  Definition
+*  ==========
+*
+*       SUBROUTINE CLA_GERFSX_EXTENDED( PREC_TYPE, TRANS_TYPE, N, NRHS, A,
+*                                       LDA, AF, LDAF, IPIV, COLEQU, C, B,
+*                                       LDB, Y, LDY, BERR_OUT, N_NORMS,
+*                                       ERRS_N, ERRS_C, RES, AYB, DY,
+*                                       Y_TAIL, RCOND, ITHRESH, RTHRESH,
+*                                       DZ_UB, IGNORE_CWISE, INFO )
+* 
+*       .. Scalar Arguments ..
+*       INTEGER            INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
+*      $                   TRANS_TYPE, N_NORMS
+*       LOGICAL            COLEQU, IGNORE_CWISE
+*       INTEGER            ITHRESH
+*       REAL               RTHRESH, DZ_UB
+*       ..
+*       .. Array Arguments
+*       INTEGER            IPIV( * )
+*       COMPLEX            A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
+*      $                   Y( LDY, * ), RES( * ), DY( * ), Y_TAIL( * )
+*       REAL               C( * ), AYB( * ), RCOND, BERR_OUT( * ),
+*      $                   ERRS_N( NRHS, * ), ERRS_C( NRHS, * )
+*       ..
+*  
+*  Purpose
+*  =======
+*
+*>\details \b Purpose:
+*>\verbatim
+*> 
+*> CLA_GERFSX_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 CGERFSX 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 resonsible for setting the second fields of
+*> ERR_BNDS_NORM and ERR_BNDS_COMP.
+*>
+*>\endverbatim
+*
+*  Arguments
+*  =========
+*
+*> \param[in] PREC_TYPE
+*> \verbatim
+*>          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', 'E':  Extra
+*> \endverbatim
+*>
+*> \param[in] TRANS_TYPE
+*> \verbatim
+*>          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
+*> \endverbatim
+*>
+*> \param[in] N
+*> \verbatim
+*>          N is INTEGER
+*>     The number of linear equations, i.e., the order of the
+*>     matrix A.  N >= 0.
+*> \endverbatim
+*>
+*> \param[in] NRHS
+*> \verbatim
+*>          NRHS is INTEGER
+*>     The number of right-hand-sides, i.e., the number of columns of the
+*>     matrix B.
+*> \endverbatim
+*>
+*> \param[in] A
+*> \verbatim
+*>          A is COMPLEX array, dimension (LDA,N)
+*>     On entry, the N-by-N matrix A.
+*> \endverbatim
+*>
+*> \param[in] LDA
+*> \verbatim
+*>          LDA is INTEGER
+*>     The leading dimension of the array A.  LDA >= max(1,N).
+*> \endverbatim
+*>
+*> \param[in] AF
+*> \verbatim
+*>          AF is COMPLEX array, dimension (LDAF,N)
+*>     The factors L and U from the factorization
+*>     A = P*L*U as computed by CGETRF.
+*> \endverbatim
+*>
+*> \param[in] LDAF
+*> \verbatim
+*>          LDAF is INTEGER
+*>     The leading dimension of the array AF.  LDAF >= max(1,N).
+*> \endverbatim
+*>
+*> \param[in] IPIV
+*> \verbatim
+*>          IPIV is INTEGER array, dimension (N)
+*>     The pivot indices from the factorization A = P*L*U
+*>     as computed by CGETRF; row i of the matrix was interchanged
+*>     with row IPIV(i).
+*> \endverbatim
+*>
+*> \param[in] COLEQU
+*> \verbatim
+*>          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.
+*> \endverbatim
+*>
+*> \param[in] C
+*> \verbatim
+*>          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.
+*> \endverbatim
+*>
+*> \param[in] B
+*> \verbatim
+*>          B is COMPLEX array, dimension (LDB,NRHS)
+*>     The right-hand-side matrix B.
+*> \endverbatim
+*>
+*> \param[in] LDB
+*> \verbatim
+*>          LDB is INTEGER
+*>     The leading dimension of the array B.  LDB >= max(1,N).
+*> \endverbatim
+*>
+*> \param[in,out] Y
+*> \verbatim
+*>          Y is COMPLEX array, dimension (LDY,NRHS)
+*>     On entry, the solution matrix X, as computed by CGETRS.
+*>     On exit, the improved solution matrix Y.
+*> \endverbatim
+*>
+*> \param[in] LDY
+*> \verbatim
+*>          LDY is INTEGER
+*>     The leading dimension of the array Y.  LDY >= max(1,N).
+*> \endverbatim
+*>
+*> \param[out] BERR_OUT
+*> \verbatim
+*>          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 CLA_LIN_BERR.
+*> \endverbatim
+*>
+*> \param[in] N_NORMS
+*> \verbatim
+*>          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.
+*> \endverbatim
+*>
+*> \param[in,out] ERR_BNDS_NORM
+*> \verbatim
+*>          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:
+*> \endverbatim
+*> \verbatim
+*>     Normwise relative error in the ith solution vector:
+*>             max_j (abs(XTRUE(j,i) - X(j,i)))
+*>            ------------------------------
+*>                  max_j abs(X(j,i))
+*> \endverbatim
+*> \verbatim
+*>     The array is indexed by the type of error information as described
+*>     below. There currently are up to three pieces of information
+*>     returned.
+*> \endverbatim
+*> \verbatim
+*>     The first index in ERR_BNDS_NORM(i,:) corresponds to the ith
+*>     right-hand side.
+*> \endverbatim
+*> \verbatim
+*>     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').
+*> \endverbatim
+*> \verbatim
+*>     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.
+*> \endverbatim
+*> \verbatim
+*>     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.
+*> \endverbatim
+*> \verbatim
+*>     This subroutine is only responsible for setting the second field
+*>     above.
+*>     See Lapack Working Note 165 for further details and extra
+*>     cautions.
+*> \endverbatim
+*>
+*> \param[in,out] ERR_BNDS_COMP
+*> \verbatim
+*>          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:
+*> \endverbatim
+*> \verbatim
+*>     Componentwise relative error in the ith solution vector:
+*>                    abs(XTRUE(j,i) - X(j,i))
+*>             max_j ----------------------
+*>                         abs(X(j,i))
+*> \endverbatim
+*> \verbatim
+*>     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.
+*> \endverbatim
+*> \verbatim
+*>     The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
+*>     right-hand side.
+*> \endverbatim
+*> \verbatim
+*>     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').
+*> \endverbatim
+*> \verbatim
+*>     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.
+*> \endverbatim
+*> \verbatim
+*>     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.
+*> \endverbatim
+*> \verbatim
+*>     This subroutine is only responsible for setting the second field
+*>     above.
+*>     See Lapack Working Note 165 for further details and extra
+*>     cautions.
+*> \endverbatim
+*>
+*> \param[in] RES
+*> \verbatim
+*>          RES is COMPLEX array, dimension (N)
+*>     Workspace to hold the intermediate residual.
+*> \endverbatim
+*>
+*> \param[in] AYB
+*> \verbatim
+*>          AYB is REAL array, dimension (N)
+*>     Workspace.
+*> \endverbatim
+*>
+*> \param[in] DY
+*> \verbatim
+*>          DY is COMPLEX array, dimension (N)
+*>     Workspace to hold the intermediate solution.
+*> \endverbatim
+*>
+*> \param[in] Y_TAIL
+*> \verbatim
+*>          Y_TAIL is COMPLEX array, dimension (N)
+*>     Workspace to hold the trailing bits of the intermediate solution.
+*> \endverbatim
+*>
+*> \param[in] RCOND
+*> \verbatim
+*>          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.
+*> \endverbatim
+*>
+*> \param[in] ITHRESH
+*> \verbatim
+*>          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.
+*> \endverbatim
+*>
+*> \param[in] RTHRESH
+*> \verbatim
+*>          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.
+*> \endverbatim
+*>
+*> \param[in] DZ_UB
+*> \verbatim
+*>          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 definte 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.
+*> \endverbatim
+*>
+*> \param[in] IGNORE_CWISE
+*> \verbatim
+*>          IGNORE_CWISE is LOGICAL
+*>     If .TRUE. then ignore componentwise convergence. Default value
+*>     is .FALSE..
+*> \endverbatim
+*>
+*> \param[out] INFO
+*> \verbatim
+*>          INFO is INTEGER
+*>       = 0:  Successful exit.
+*>       < 0:  if INFO = -i, the ith argument to CGETRS had an illegal
+*>             value
+*> \endverbatim
+*>
+*
+*  Authors
+*  =======
+*
+*> \author Univ. of Tennessee 
+*> \author Univ. of California Berkeley 
+*> \author Univ. of Colorado Denver 
+*> \author NAG Ltd. 
+*
+*> \date November 2011
+*
+*> \ingroup complexGEcomputational
+*
+*  =====================================================================
       SUBROUTINE CLA_GERFSX_EXTENDED( PREC_TYPE, TRANS_TYPE, N, NRHS, A,
      $                                LDA, AF, LDAF, IPIV, COLEQU, C, B,
      $                                LDB, Y, LDY, BERR_OUT, N_NORMS,
@@ -5,16 +402,11 @@
      $                                Y_TAIL, RCOND, ITHRESH, RTHRESH,
      $                                DZ_UB, IGNORE_CWISE, INFO )
 *
-*     -- LAPACK routine (version 3.2.1)                                 --
-*     -- Contributed by James Demmel, Deaglan Halligan, Yozo Hida and --
-*     -- Jason Riedy of Univ. of California Berkeley.                 --
-*     -- April 2009                                                   --
-*
-*     -- LAPACK is a software package provided by Univ. of Tennessee, --
-*     -- Univ. of California Berkeley and NAG Ltd.                    --
+*  -- LAPACK computational routine (version 3.2.1) --
+*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
+*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
+*     November 2011
 *
-      IMPLICIT NONE
-*     ..
 *     .. Scalar Arguments ..
       INTEGER            INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
      $                   TRANS_TYPE, N_NORMS
@@ -30,251 +422,6 @@
      $                   ERRS_N( NRHS, * ), ERRS_C( NRHS, * )
 *     ..
 *
-*  Purpose
-*  =======
-* 
-*  CLA_GERFSX_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 CGERFSX 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 resonsible for setting the second fields of
-*  ERR_BNDS_NORM and ERR_BNDS_COMP.
-*
-*  Arguments
-*  =========
-*
-*     PREC_TYPE      (input) 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', 'E':  Extra
-*
-*     TRANS_TYPE     (input) 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              (input) INTEGER
-*     The number of linear equations, i.e., the order of the
-*     matrix A.  N >= 0.
-*
-*     NRHS           (input) INTEGER
-*     The number of right-hand-sides, i.e., the number of columns of the
-*     matrix B.
-*
-*     A              (input) COMPLEX array, dimension (LDA,N)
-*     On entry, the N-by-N matrix A.
-*
-*     LDA            (input) INTEGER
-*     The leading dimension of the array A.  LDA >= max(1,N).
-*
-*     AF             (input) COMPLEX array, dimension (LDAF,N)
-*     The factors L and U from the factorization
-*     A = P*L*U as computed by CGETRF.
-*
-*     LDAF           (input) INTEGER
-*     The leading dimension of the array AF.  LDAF >= max(1,N).
-*
-*     IPIV           (input) INTEGER array, dimension (N)
-*     The pivot indices from the factorization A = P*L*U
-*     as computed by CGETRF; row i of the matrix was interchanged
-*     with row IPIV(i).
-*
-*     COLEQU         (input) 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              (input) 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              (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).
-*
-*     Y              (input/output) COMPLEX array, dimension (LDY,NRHS)
-*     On entry, the solution matrix X, as computed by CGETRS.
-*     On exit, the improved solution matrix Y.
-*
-*     LDY            (input) INTEGER
-*     The leading dimension of the array Y.  LDY >= max(1,N).
-*
-*     BERR_OUT       (output) 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 CLA_LIN_BERR.
-*
-*     N_NORMS        (input) 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  (input/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.
-*
-*     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  (input/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.
-*
-*     This subroutine is only responsible for setting the second field
-*     above.
-*     See Lapack Working Note 165 for further details and extra
-*     cautions.
-*
-*     RES            (input) COMPLEX array, dimension (N)
-*     Workspace to hold the intermediate residual.
-*
-*     AYB            (input) REAL array, dimension (N)
-*     Workspace.
-*
-*     DY             (input) COMPLEX array, dimension (N)
-*     Workspace to hold the intermediate solution.
-*
-*     Y_TAIL         (input) COMPLEX array, dimension (N)
-*     Workspace to hold the trailing bits of the intermediate solution.
-*
-*     RCOND          (input) 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        (input) 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        (input) 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          (input) REAL
-*     Determines when to start considering componentwise convergence.
-*     Componentwise convergence is only considered after each component
-*     of the solution Y is stable, which we definte 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   (input) LOGICAL
-*     If .TRUE. then ignore componentwise convergence. Default value
-*     is .FALSE..
-*
-*     INFO           (output) INTEGER
-*       = 0:  Successful exit.
-*       < 0:  if INFO = -i, the ith argument to CGETRS had an illegal
-*             value
-*
 *  =====================================================================
 *
 *     .. Local Scalars ..