// Computes the condition number of complex N x N matrix A. // The condition number is defined as the ratio of the largest to the smallest // singular values. Uses LAPACK. // Note: may need to append _ to name of LAPACK functions. double ccondit_num (double complex **A, int N) { double complex *a, *cwork = NULL; double kappa, rcond, anorm; double *rwork = NULL; char NORM = '1'; int info; // Convert A for LAPACK functions a = cmat_to_fortran (A, N, N); // Allocate work, rwork for zgecon (work is not used in anorm with NORM='1') cwork = c_allocvector (2 * N); if (cwork == NULL) throwMemErr ("cwork", "ccondit_num"); rwork = allocvector (2 * N); if (rwork == NULL) throwMemErr ("rwork", "ccondit_num"); // Compute 1-norm of A anorm = zlange_ (&NORM, &N, &N, a, &N, rwork); // Compute reciprocal of condition number zgecon_ (&NORM, &N, a, &N, &anorm, &rcond, cwork, rwork, &info); kappa = 1. / rcond; if (info != 0) throwErr ("Illegal argument to zgecon", "ccondit_num"); free (a); free (cwork); free (rwork); return kappa; }
/* Subroutine */ int zlatdf_(integer *ijob, integer *n, doublecomplex *z__, integer *ldz, doublecomplex *rhs, doublereal *rdsum, doublereal * rdscal, integer *ipiv, integer *jpiv) { /* System generated locals */ integer z_dim1, z_offset, i__1, i__2, i__3, i__4, i__5; doublecomplex z__1, z__2, z__3; /* Builtin functions */ void z_div(doublecomplex *, doublecomplex *, doublecomplex *); double z_abs(doublecomplex *); void z_sqrt(doublecomplex *, doublecomplex *); /* Local variables */ integer i__, j, k; doublecomplex bm, bp, xm[2], xp[2]; integer info; doublecomplex temp, work[8]; doublereal scale; extern /* Subroutine */ int zscal_(integer *, doublecomplex *, doublecomplex *, integer *); doublecomplex pmone; extern /* Double Complex */ VOID zdotc_(doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *); doublereal rtemp, sminu, rwork[2]; extern /* Subroutine */ int zcopy_(integer *, doublecomplex *, integer *, doublecomplex *, integer *); doublereal splus; extern /* Subroutine */ int zaxpy_(integer *, doublecomplex *, doublecomplex *, integer *, doublecomplex *, integer *), zgesc2_( integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, doublereal *), zgecon_(char *, integer *, doublecomplex *, integer *, doublereal *, doublereal *, doublecomplex *, doublereal *, integer *); extern doublereal dzasum_(integer *, doublecomplex *, integer *); extern /* Subroutine */ int zlassq_(integer *, doublecomplex *, integer *, doublereal *, doublereal *), zlaswp_(integer *, doublecomplex *, integer *, integer *, integer *, integer *, integer *); /* -- LAPACK auxiliary routine (version 3.1) -- */ /* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */ /* November 2006 */ /* .. Scalar Arguments .. */ /* .. */ /* .. Array Arguments .. */ /* .. */ /* Purpose */ /* ======= */ /* ZLATDF computes the contribution to the reciprocal Dif-estimate */ /* by solving for x in Z * x = b, where b is chosen such that the norm */ /* of x is as large as possible. It is assumed that LU decomposition */ /* of Z has been computed by ZGETC2. On entry RHS = f holds the */ /* contribution from earlier solved sub-systems, and on return RHS = x. */ /* The factorization of Z returned by ZGETC2 has the form */ /* Z = P * L * U * Q, where P and Q are permutation matrices. L is lower */ /* triangular with unit diagonal elements and U is upper triangular. */ /* Arguments */ /* ========= */ /* IJOB (input) INTEGER */ /* IJOB = 2: First compute an approximative null-vector e */ /* of Z using ZGECON, e is normalized and solve for */ /* Zx = +-e - f with the sign giving the greater value of */ /* 2-norm(x). About 5 times as expensive as Default. */ /* IJOB .ne. 2: Local look ahead strategy where */ /* all entries of the r.h.s. b is choosen as either +1 or */ /* -1. Default. */ /* N (input) INTEGER */ /* The number of columns of the matrix Z. */ /* Z (input) DOUBLE PRECISION array, dimension (LDZ, N) */ /* On entry, the LU part of the factorization of the n-by-n */ /* matrix Z computed by ZGETC2: Z = P * L * U * Q */ /* LDZ (input) INTEGER */ /* The leading dimension of the array Z. LDA >= max(1, N). */ /* RHS (input/output) DOUBLE PRECISION array, dimension (N). */ /* On entry, RHS contains contributions from other subsystems. */ /* On exit, RHS contains the solution of the subsystem with */ /* entries according to the value of IJOB (see above). */ /* RDSUM (input/output) DOUBLE PRECISION */ /* On entry, the sum of squares of computed contributions to */ /* the Dif-estimate under computation by ZTGSYL, where the */ /* scaling factor RDSCAL (see below) has been factored out. */ /* On exit, the corresponding sum of squares updated with the */ /* contributions from the current sub-system. */ /* If TRANS = 'T' RDSUM is not touched. */ /* NOTE: RDSUM only makes sense when ZTGSY2 is called by CTGSYL. */ /* RDSCAL (input/output) DOUBLE PRECISION */ /* On entry, scaling factor used to prevent overflow in RDSUM. */ /* On exit, RDSCAL is updated w.r.t. the current contributions */ /* in RDSUM. */ /* If TRANS = 'T', RDSCAL is not touched. */ /* NOTE: RDSCAL only makes sense when ZTGSY2 is called by */ /* ZTGSYL. */ /* IPIV (input) INTEGER array, dimension (N). */ /* The pivot indices; for 1 <= i <= N, row i of the */ /* matrix has been interchanged with row IPIV(i). */ /* JPIV (input) INTEGER array, dimension (N). */ /* The pivot indices; for 1 <= j <= N, column j of the */ /* matrix has been interchanged with column JPIV(j). */ /* Further Details */ /* =============== */ /* Based on contributions by */ /* Bo Kagstrom and Peter Poromaa, Department of Computing Science, */ /* Umea University, S-901 87 Umea, Sweden. */ /* This routine is a further developed implementation of algorithm */ /* BSOLVE in [1] using complete pivoting in the LU factorization. */ /* [1] Bo Kagstrom and Lars Westin, */ /* Generalized Schur Methods with Condition Estimators for */ /* Solving the Generalized Sylvester Equation, IEEE Transactions */ /* on Automatic Control, Vol. 34, No. 7, July 1989, pp 745-751. */ /* [2] Peter Poromaa, */ /* On Efficient and Robust Estimators for the Separation */ /* between two Regular Matrix Pairs with Applications in */ /* Condition Estimation. Report UMINF-95.05, Department of */ /* Computing Science, Umea University, S-901 87 Umea, Sweden, */ /* 1995. */ /* ===================================================================== */ /* .. Parameters .. */ /* .. */ /* .. Local Scalars .. */ /* .. */ /* .. Local Arrays .. */ /* .. */ /* .. External Subroutines .. */ /* .. */ /* .. External Functions .. */ /* .. */ /* .. Intrinsic Functions .. */ /* .. */ /* .. Executable Statements .. */ /* Parameter adjustments */ z_dim1 = *ldz; z_offset = 1 + z_dim1; z__ -= z_offset; --rhs; --ipiv; --jpiv; /* Function Body */ if (*ijob != 2) { /* Apply permutations IPIV to RHS */ i__1 = *n - 1; zlaswp_(&c__1, &rhs[1], ldz, &c__1, &i__1, &ipiv[1], &c__1); /* Solve for L-part choosing RHS either to +1 or -1. */ z__1.r = -1., z__1.i = -0.; pmone.r = z__1.r, pmone.i = z__1.i; i__1 = *n - 1; for (j = 1; j <= i__1; ++j) { i__2 = j; z__1.r = rhs[i__2].r + 1., z__1.i = rhs[i__2].i + 0.; bp.r = z__1.r, bp.i = z__1.i; i__2 = j; z__1.r = rhs[i__2].r - 1., z__1.i = rhs[i__2].i - 0.; bm.r = z__1.r, bm.i = z__1.i; splus = 1.; /* Lockahead for L- part RHS(1:N-1) = +-1 */ /* SPLUS and SMIN computed more efficiently than in BSOLVE[1]. */ i__2 = *n - j; zdotc_(&z__1, &i__2, &z__[j + 1 + j * z_dim1], &c__1, &z__[j + 1 + j * z_dim1], &c__1); splus += z__1.r; i__2 = *n - j; zdotc_(&z__1, &i__2, &z__[j + 1 + j * z_dim1], &c__1, &rhs[j + 1], &c__1); sminu = z__1.r; i__2 = j; splus *= rhs[i__2].r; if (splus > sminu) { i__2 = j; rhs[i__2].r = bp.r, rhs[i__2].i = bp.i; } else if (sminu > splus) { i__2 = j; rhs[i__2].r = bm.r, rhs[i__2].i = bm.i; } else { /* In this case the updating sums are equal and we can */ /* choose RHS(J) +1 or -1. The first time this happens we */ /* choose -1, thereafter +1. This is a simple way to get */ /* good estimates of matrices like Byers well-known example */ /* (see [1]). (Not done in BSOLVE.) */ i__2 = j; i__3 = j; z__1.r = rhs[i__3].r + pmone.r, z__1.i = rhs[i__3].i + pmone.i; rhs[i__2].r = z__1.r, rhs[i__2].i = z__1.i; pmone.r = 1., pmone.i = 0.; } /* Compute the remaining r.h.s. */ i__2 = j; z__1.r = -rhs[i__2].r, z__1.i = -rhs[i__2].i; temp.r = z__1.r, temp.i = z__1.i; i__2 = *n - j; zaxpy_(&i__2, &temp, &z__[j + 1 + j * z_dim1], &c__1, &rhs[j + 1], &c__1); /* L10: */ } /* Solve for U- part, lockahead for RHS(N) = +-1. This is not done */ /* In BSOLVE and will hopefully give us a better estimate because */ /* any ill-conditioning of the original matrix is transfered to U */ /* and not to L. U(N, N) is an approximation to sigma_min(LU). */ i__1 = *n - 1; zcopy_(&i__1, &rhs[1], &c__1, work, &c__1); i__1 = *n - 1; i__2 = *n; z__1.r = rhs[i__2].r + 1., z__1.i = rhs[i__2].i + 0.; work[i__1].r = z__1.r, work[i__1].i = z__1.i; i__1 = *n; i__2 = *n; z__1.r = rhs[i__2].r - 1., z__1.i = rhs[i__2].i - 0.; rhs[i__1].r = z__1.r, rhs[i__1].i = z__1.i; splus = 0.; sminu = 0.; for (i__ = *n; i__ >= 1; --i__) { z_div(&z__1, &c_b1, &z__[i__ + i__ * z_dim1]); temp.r = z__1.r, temp.i = z__1.i; i__1 = i__ - 1; i__2 = i__ - 1; z__1.r = work[i__2].r * temp.r - work[i__2].i * temp.i, z__1.i = work[i__2].r * temp.i + work[i__2].i * temp.r; work[i__1].r = z__1.r, work[i__1].i = z__1.i; i__1 = i__; i__2 = i__; z__1.r = rhs[i__2].r * temp.r - rhs[i__2].i * temp.i, z__1.i = rhs[i__2].r * temp.i + rhs[i__2].i * temp.r; rhs[i__1].r = z__1.r, rhs[i__1].i = z__1.i; i__1 = *n; for (k = i__ + 1; k <= i__1; ++k) { i__2 = i__ - 1; i__3 = i__ - 1; i__4 = k - 1; i__5 = i__ + k * z_dim1; z__3.r = z__[i__5].r * temp.r - z__[i__5].i * temp.i, z__3.i = z__[i__5].r * temp.i + z__[i__5].i * temp.r; z__2.r = work[i__4].r * z__3.r - work[i__4].i * z__3.i, z__2.i = work[i__4].r * z__3.i + work[i__4].i * z__3.r; z__1.r = work[i__3].r - z__2.r, z__1.i = work[i__3].i - z__2.i; work[i__2].r = z__1.r, work[i__2].i = z__1.i; i__2 = i__; i__3 = i__; i__4 = k; i__5 = i__ + k * z_dim1; z__3.r = z__[i__5].r * temp.r - z__[i__5].i * temp.i, z__3.i = z__[i__5].r * temp.i + z__[i__5].i * temp.r; z__2.r = rhs[i__4].r * z__3.r - rhs[i__4].i * z__3.i, z__2.i = rhs[i__4].r * z__3.i + rhs[i__4].i * z__3.r; z__1.r = rhs[i__3].r - z__2.r, z__1.i = rhs[i__3].i - z__2.i; rhs[i__2].r = z__1.r, rhs[i__2].i = z__1.i; /* L20: */ } splus += z_abs(&work[i__ - 1]); sminu += z_abs(&rhs[i__]); /* L30: */ } if (splus > sminu) { zcopy_(n, work, &c__1, &rhs[1], &c__1); } /* Apply the permutations JPIV to the computed solution (RHS) */ i__1 = *n - 1; zlaswp_(&c__1, &rhs[1], ldz, &c__1, &i__1, &jpiv[1], &c_n1); /* Compute the sum of squares */ zlassq_(n, &rhs[1], &c__1, rdscal, rdsum); return 0; } /* ENTRY IJOB = 2 */ /* Compute approximate nullvector XM of Z */ zgecon_("I", n, &z__[z_offset], ldz, &c_b24, &rtemp, work, rwork, &info); zcopy_(n, &work[*n], &c__1, xm, &c__1); /* Compute RHS */ i__1 = *n - 1; zlaswp_(&c__1, xm, ldz, &c__1, &i__1, &ipiv[1], &c_n1); zdotc_(&z__3, n, xm, &c__1, xm, &c__1); z_sqrt(&z__2, &z__3); z_div(&z__1, &c_b1, &z__2); temp.r = z__1.r, temp.i = z__1.i; zscal_(n, &temp, xm, &c__1); zcopy_(n, xm, &c__1, xp, &c__1); zaxpy_(n, &c_b1, &rhs[1], &c__1, xp, &c__1); z__1.r = -1., z__1.i = -0.; zaxpy_(n, &z__1, xm, &c__1, &rhs[1], &c__1); zgesc2_(n, &z__[z_offset], ldz, &rhs[1], &ipiv[1], &jpiv[1], &scale); zgesc2_(n, &z__[z_offset], ldz, xp, &ipiv[1], &jpiv[1], &scale); if (dzasum_(n, xp, &c__1) > dzasum_(n, &rhs[1], &c__1)) { zcopy_(n, xp, &c__1, &rhs[1], &c__1); } /* Compute the sum of squares */ zlassq_(n, &rhs[1], &c__1, rdscal, rdsum); return 0; /* End of ZLATDF */ } /* zlatdf_ */
/* Subroutine */ int zgerfsx_(char *trans, char *equed, integer *n, integer * nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer * ldaf, integer *ipiv, doublereal *r__, doublereal *c__, doublecomplex * b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *work, doublereal *rwork, integer *info) { /* System generated locals */ integer a_dim1, a_offset, af_dim1, af_offset, b_dim1, b_offset, x_dim1, x_offset, err_bnds_norm_dim1, err_bnds_norm_offset, err_bnds_comp_dim1, err_bnds_comp_offset, i__1; doublereal d__1, d__2; /* Builtin functions */ double sqrt(doublereal); /* Local variables */ doublereal illrcond_thresh__, unstable_thresh__, err_lbnd__; integer ref_type__; extern integer ilatrans_(char *); integer j; doublereal rcond_tmp__; integer prec_type__, trans_type__; doublereal cwise_wrong__; extern /* Subroutine */ int zla_gerfsx_extended__(integer *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, logical *, doublereal *, doublecomplex *, integer *, doublecomplex *, integer *, doublereal *, integer *, doublereal *, doublereal *, doublecomplex *, doublereal *, doublecomplex *, doublecomplex *, doublereal *, integer *, doublereal *, doublereal *, logical *, integer *); char norm[1]; logical ignore_cwise__; extern logical lsame_(char *, char *); doublereal anorm; extern doublereal zla_gercond_c__(char *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, doublereal *, logical *, integer *, doublecomplex *, doublereal *, ftnlen), zla_gercond_x__(char *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, doublereal *, ftnlen), dlamch_(char *); extern /* Subroutine */ int xerbla_(char *, integer *); extern doublereal zlange_(char *, integer *, integer *, doublecomplex *, integer *, doublereal *); extern /* Subroutine */ int zgecon_(char *, integer *, doublecomplex *, integer *, doublereal *, doublereal *, doublecomplex *, doublereal *, integer *); logical colequ, notran, rowequ; extern integer ilaprec_(char *); integer ithresh, n_norms__; doublereal rthresh; /* -- 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. -- */ /* .. */ /* .. Scalar Arguments .. */ /* .. */ /* .. Array Arguments .. */ /* .. */ /* Purpose */ /* ======= */ /* ZGERFSX 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. */ /* NRHS (input) INTEGER */ /* The number of right hand sides, i.e., the number of columns */ /* of the matrices B and X. NRHS >= 0. */ /* A (input) COMPLEX*16 array, dimension (LDA,N) */ /* The original N-by-N matrix A. */ /* LDA (input) INTEGER */ /* The leading dimension of the array A. LDA >= max(1,N). */ /* AF (input) COMPLEX*16 array, dimension (LDAF,N) */ /* The factors L and U from the factorization A = P*L*U */ /* as computed by ZGETRF. */ /* LDAF (input) INTEGER */ /* The leading dimension of the array AF. LDAF >= max(1,N). */ /* IPIV (input) INTEGER array, dimension (N) */ /* The pivot indices from ZGETRF; for 1<=i<=N, row i of the */ /* matrix was interchanged with row IPIV(i). */ /* R (input or output) DOUBLE PRECISION 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) DOUBLE PRECISION 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) COMPLEX*16 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*16 array, dimension (LDX,NRHS) */ /* On entry, the solution matrix X, as computed by ZGETRS. */ /* On exit, the improved solution matrix X. */ /* LDX (input) INTEGER */ /* The leading dimension of the array X. LDX >= max(1,N). */ /* RCOND (output) DOUBLE PRECISION */ /* 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) DOUBLE PRECISION 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) DOUBLE PRECISION 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) * dlamch('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) * dlamch('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) * dlamch('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) DOUBLE PRECISION 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) * dlamch('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) * dlamch('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) * dlamch('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) DOUBLE PRECISION 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.0D+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*16 array, dimension (2*N) */ /* RWORK (workspace) DOUBLE PRECISION 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. */ /* ================================================================== */ /* .. Parameters .. */ /* .. */ /* .. Local Scalars .. */ /* .. */ /* .. External Subroutines .. */ /* .. */ /* .. Intrinsic Functions .. */ /* .. */ /* .. External Functions .. */ /* .. */ /* .. Executable Statements .. */ /* Check the input parameters. */ /* Parameter adjustments */ err_bnds_comp_dim1 = *nrhs; err_bnds_comp_offset = 1 + err_bnds_comp_dim1; err_bnds_comp__ -= err_bnds_comp_offset; err_bnds_norm_dim1 = *nrhs; err_bnds_norm_offset = 1 + err_bnds_norm_dim1; err_bnds_norm__ -= err_bnds_norm_offset; a_dim1 = *lda; a_offset = 1 + a_dim1; a -= a_offset; af_dim1 = *ldaf; af_offset = 1 + af_dim1; af -= af_offset; --ipiv; --r__; --c__; b_dim1 = *ldb; b_offset = 1 + b_dim1; b -= b_offset; x_dim1 = *ldx; x_offset = 1 + x_dim1; x -= x_offset; --berr; --params; --work; --rwork; /* Function Body */ *info = 0; trans_type__ = ilatrans_(trans); ref_type__ = 1; if (*nparams >= 1) { if (params[1] < 0.) { params[1] = 1.; } else { ref_type__ = (integer) params[1]; } } /* Set default parameters. */ illrcond_thresh__ = (doublereal) (*n) * dlamch_("Epsilon"); ithresh = 10; rthresh = .5; unstable_thresh__ = .25; ignore_cwise__ = FALSE_; if (*nparams >= 2) { if (params[2] < 0.) { params[2] = (doublereal) ithresh; } else { ithresh = (integer) params[2]; } } if (*nparams >= 3) { if (params[3] < 0.) { if (ignore_cwise__) { params[3] = 0.; } else { params[3] = 1.; } } else { ignore_cwise__ = params[3] == 0.; } } if (ref_type__ == 0 || *n_err_bnds__ == 0) { n_norms__ = 0; } else if (ignore_cwise__) { n_norms__ = 1; } else { n_norms__ = 2; } notran = lsame_(trans, "N"); rowequ = lsame_(equed, "R") || lsame_(equed, "B"); colequ = lsame_(equed, "C") || lsame_(equed, "B"); /* Test input parameters. */ if (trans_type__ == -1) { *info = -1; } else if (! rowequ && ! colequ && ! lsame_(equed, "N")) { *info = -2; } else if (*n < 0) { *info = -3; } else if (*nrhs < 0) { *info = -4; } else if (*lda < max(1,*n)) { *info = -6; } else if (*ldaf < max(1,*n)) { *info = -8; } else if (*ldb < max(1,*n)) { *info = -13; } else if (*ldx < max(1,*n)) { *info = -15; } if (*info != 0) { i__1 = -(*info); xerbla_("ZGERFSX", &i__1); return 0; } /* Quick return if possible. */ if (*n == 0 || *nrhs == 0) { *rcond = 1.; i__1 = *nrhs; for (j = 1; j <= i__1; ++j) { berr[j] = 0.; if (*n_err_bnds__ >= 1) { err_bnds_norm__[j + err_bnds_norm_dim1] = 1.; err_bnds_comp__[j + err_bnds_comp_dim1] = 1.; } else if (*n_err_bnds__ >= 2) { err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] = 0.; err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] = 0.; } else if (*n_err_bnds__ >= 3) { err_bnds_norm__[j + err_bnds_norm_dim1 * 3] = 1.; err_bnds_comp__[j + err_bnds_comp_dim1 * 3] = 1.; } } return 0; } /* Default to failure. */ *rcond = 0.; i__1 = *nrhs; for (j = 1; j <= i__1; ++j) { berr[j] = 1.; if (*n_err_bnds__ >= 1) { err_bnds_norm__[j + err_bnds_norm_dim1] = 1.; err_bnds_comp__[j + err_bnds_comp_dim1] = 1.; } else if (*n_err_bnds__ >= 2) { err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] = 1.; err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] = 1.; } else if (*n_err_bnds__ >= 3) { err_bnds_norm__[j + err_bnds_norm_dim1 * 3] = 0.; err_bnds_comp__[j + err_bnds_comp_dim1 * 3] = 0.; } } /* Compute the norm of A and the reciprocal of the condition */ /* number of A. */ if (notran) { *(unsigned char *)norm = 'I'; } else { *(unsigned char *)norm = '1'; } anorm = zlange_(norm, n, n, &a[a_offset], lda, &rwork[1]); zgecon_(norm, n, &af[af_offset], ldaf, &anorm, rcond, &work[1], &rwork[1], info); /* Perform refinement on each right-hand side */ if (ref_type__ != 0) { prec_type__ = ilaprec_("E"); if (notran) { zla_gerfsx_extended__(&prec_type__, &trans_type__, n, nrhs, &a[ a_offset], lda, &af[af_offset], ldaf, &ipiv[1], &colequ, & c__[1], &b[b_offset], ldb, &x[x_offset], ldx, &berr[1], & n_norms__, &err_bnds_norm__[err_bnds_norm_offset], & err_bnds_comp__[err_bnds_comp_offset], &work[1], &rwork[1] , &work[*n + 1], (doublecomplex*)(&rwork[1]), rcond, &ithresh, &rthresh, & unstable_thresh__, &ignore_cwise__, info); } else { zla_gerfsx_extended__(&prec_type__, &trans_type__, n, nrhs, &a[ a_offset], lda, &af[af_offset], ldaf, &ipiv[1], &rowequ, & r__[1], &b[b_offset], ldb, &x[x_offset], ldx, &berr[1], & n_norms__, &err_bnds_norm__[err_bnds_norm_offset], & err_bnds_comp__[err_bnds_comp_offset], &work[1], &rwork[1] , &work[*n + 1], (doublecomplex *)(&rwork[1]), rcond, &ithresh, &rthresh, & unstable_thresh__, &ignore_cwise__, info); } } /* Computing MAX */ d__1 = 10., d__2 = sqrt((doublereal) (*n)); err_lbnd__ = max(d__1,d__2) * dlamch_("Epsilon"); if (*n_err_bnds__ >= 1 && n_norms__ >= 1) { /* Compute scaled normwise condition number cond(A*C). */ if (colequ && notran) { rcond_tmp__ = zla_gercond_c__(trans, n, &a[a_offset], lda, &af[ af_offset], ldaf, &ipiv[1], &c__[1], &c_true, info, &work[ 1], &rwork[1], (ftnlen)1); } else if (rowequ && ! notran) { rcond_tmp__ = zla_gercond_c__(trans, n, &a[a_offset], lda, &af[ af_offset], ldaf, &ipiv[1], &r__[1], &c_true, info, &work[ 1], &rwork[1], (ftnlen)1); } else { rcond_tmp__ = zla_gercond_c__(trans, n, &a[a_offset], lda, &af[ af_offset], ldaf, &ipiv[1], &c__[1], &c_false, info, & work[1], &rwork[1], (ftnlen)1); } i__1 = *nrhs; for (j = 1; j <= i__1; ++j) { /* Cap the error at 1.0. */ if (*n_err_bnds__ >= 2 && err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] > 1.) { err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] = 1.; } /* Threshold the error (see LAWN). */ if (rcond_tmp__ < illrcond_thresh__) { err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] = 1.; err_bnds_norm__[j + err_bnds_norm_dim1] = 0.; if (*info <= *n) { *info = *n + j; } } else if (err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] < err_lbnd__) { err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] = err_lbnd__; err_bnds_norm__[j + err_bnds_norm_dim1] = 1.; } /* Save the condition number. */ if (*n_err_bnds__ >= 3) { err_bnds_norm__[j + err_bnds_norm_dim1 * 3] = rcond_tmp__; } } } if (*n_err_bnds__ >= 1 && n_norms__ >= 2) { /* Compute componentwise condition number cond(A*diag(Y(:,J))) for */ /* each right-hand side using the current solution as an estimate of */ /* the true solution. If the componentwise error estimate is too */ /* large, then the solution is a lousy estimate of truth and the */ /* estimated RCOND may be too optimistic. To avoid misleading users, */ /* the inverse condition number is set to 0.0 when the estimated */ /* cwise error is at least CWISE_WRONG. */ cwise_wrong__ = sqrt(dlamch_("Epsilon")); i__1 = *nrhs; for (j = 1; j <= i__1; ++j) { if (err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] < cwise_wrong__) { rcond_tmp__ = zla_gercond_x__(trans, n, &a[a_offset], lda, & af[af_offset], ldaf, &ipiv[1], &x[j * x_dim1 + 1], info, &work[1], &rwork[1], (ftnlen)1); } else { rcond_tmp__ = 0.; } /* Cap the error at 1.0. */ if (*n_err_bnds__ >= 2 && err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] > 1.) { err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] = 1.; } /* Threshold the error (see LAWN). */ if (rcond_tmp__ < illrcond_thresh__) { err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] = 1.; err_bnds_comp__[j + err_bnds_comp_dim1] = 0.; if (params[3] == 1. && *info < *n + j) { *info = *n + j; } } else if (err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] < err_lbnd__) { err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] = err_lbnd__; err_bnds_comp__[j + err_bnds_comp_dim1] = 1.; } /* Save the condition number. */ if (*n_err_bnds__ >= 3) { err_bnds_comp__[j + err_bnds_comp_dim1 * 3] = rcond_tmp__; } } } return 0; /* End of ZGERFSX */ } /* zgerfsx_ */
/* Subroutine */ int zerrge_(char *path, integer *nunit) { /* System generated locals */ integer i__1; doublereal d__1, d__2; doublecomplex z__1; /* Builtin functions */ integer s_wsle(cilist *), e_wsle(void); /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen); /* Local variables */ doublecomplex a[16] /* was [4][4] */, b[4]; integer i__, j; doublereal r__[4]; doublecomplex w[8], x[4]; char c2[2]; doublereal r1[4], r2[4]; doublecomplex af[16] /* was [4][4] */; integer ip[4], info; doublereal anrm, ccond, rcond; extern /* Subroutine */ int zgbtf2_(integer *, integer *, integer *, integer *, doublecomplex *, integer *, integer *, integer *), zgetf2_(integer *, integer *, doublecomplex *, integer *, integer *, integer *), alaesm_(char *, logical *, integer *); extern logical lsamen_(integer *, char *, char *); extern /* Subroutine */ int zgbcon_(char *, integer *, integer *, integer *, doublecomplex *, integer *, integer *, doublereal *, doublereal *, doublecomplex *, doublereal *, integer *), chkxer_(char *, integer *, integer *, logical *, logical *), zgecon_(char *, integer *, doublecomplex *, integer *, doublereal *, doublereal *, doublecomplex *, doublereal *, integer *), zgbequ_(integer *, integer *, integer *, integer *, doublecomplex *, integer *, doublereal *, doublereal *, doublereal *, doublereal *, doublereal *, integer *), zgbrfs_( char *, integer *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublereal *, doublereal *, doublecomplex *, doublereal *, integer *), zgbtrf_(integer *, integer *, integer *, integer *, doublecomplex *, integer *, integer *, integer *), zgeequ_(integer *, integer *, doublecomplex *, integer *, doublereal *, doublereal *, doublereal *, doublereal *, doublereal *, integer *), zgerfs_(char *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublereal *, doublereal *, doublecomplex *, doublereal *, integer *), zgetrf_(integer *, integer *, doublecomplex *, integer *, integer *, integer *), zgetri_(integer *, doublecomplex *, integer *, integer *, doublecomplex *, integer *, integer *), zgbtrs_(char *, integer *, integer *, integer *, integer *, doublecomplex *, integer *, integer *, doublecomplex *, integer *, integer *), zgetrs_(char *, integer *, integer *, doublecomplex *, integer *, integer *, doublecomplex *, integer *, integer *); /* Fortran I/O blocks */ static cilist io___1 = { 0, 0, 0, 0, 0 }; /* -- LAPACK test routine (version 3.1) -- */ /* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */ /* November 2006 */ /* .. Scalar Arguments .. */ /* .. */ /* Purpose */ /* ======= */ /* ZERRGE tests the error exits for the COMPLEX*16 routines */ /* for general matrices. */ /* Arguments */ /* ========= */ /* PATH (input) CHARACTER*3 */ /* The LAPACK path name for the routines to be tested. */ /* NUNIT (input) INTEGER */ /* The unit number for output. */ /* ===================================================================== */ /* .. Parameters .. */ /* .. */ /* .. Local Scalars .. */ /* .. */ /* .. Local Arrays .. */ /* .. */ /* .. External Functions .. */ /* .. */ /* .. External Subroutines .. */ /* .. */ /* .. Scalars in Common .. */ /* .. */ /* .. Common blocks .. */ /* .. */ /* .. Intrinsic Functions .. */ /* .. */ /* .. Executable Statements .. */ infoc_1.nout = *nunit; io___1.ciunit = infoc_1.nout; s_wsle(&io___1); e_wsle(); s_copy(c2, path + 1, (ftnlen)2, (ftnlen)2); /* Set the variables to innocuous values. */ for (j = 1; j <= 4; ++j) { for (i__ = 1; i__ <= 4; ++i__) { i__1 = i__ + (j << 2) - 5; d__1 = 1. / (doublereal) (i__ + j); d__2 = -1. / (doublereal) (i__ + j); z__1.r = d__1, z__1.i = d__2; a[i__1].r = z__1.r, a[i__1].i = z__1.i; i__1 = i__ + (j << 2) - 5; d__1 = 1. / (doublereal) (i__ + j); d__2 = -1. / (doublereal) (i__ + j); z__1.r = d__1, z__1.i = d__2; af[i__1].r = z__1.r, af[i__1].i = z__1.i; /* L10: */ } i__1 = j - 1; b[i__1].r = 0., b[i__1].i = 0.; r1[j - 1] = 0.; r2[j - 1] = 0.; i__1 = j - 1; w[i__1].r = 0., w[i__1].i = 0.; i__1 = j - 1; x[i__1].r = 0., x[i__1].i = 0.; ip[j - 1] = j; /* L20: */ } infoc_1.ok = TRUE_; /* Test error exits of the routines that use the LU decomposition */ /* of a general matrix. */ if (lsamen_(&c__2, c2, "GE")) { /* ZGETRF */ s_copy(srnamc_1.srnamt, "ZGETRF", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgetrf_(&c_n1, &c__0, a, &c__1, ip, &info); chkxer_("ZGETRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgetrf_(&c__0, &c_n1, a, &c__1, ip, &info); chkxer_("ZGETRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgetrf_(&c__2, &c__1, a, &c__1, ip, &info); chkxer_("ZGETRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGETF2 */ s_copy(srnamc_1.srnamt, "ZGETF2", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgetf2_(&c_n1, &c__0, a, &c__1, ip, &info); chkxer_("ZGETF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgetf2_(&c__0, &c_n1, a, &c__1, ip, &info); chkxer_("ZGETF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgetf2_(&c__2, &c__1, a, &c__1, ip, &info); chkxer_("ZGETF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGETRI */ s_copy(srnamc_1.srnamt, "ZGETRI", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgetri_(&c_n1, a, &c__1, ip, w, &c__1, &info); chkxer_("ZGETRI", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgetri_(&c__2, a, &c__1, ip, w, &c__2, &info); chkxer_("ZGETRI", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 6; zgetri_(&c__2, a, &c__2, ip, w, &c__1, &info); chkxer_("ZGETRI", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGETRS */ s_copy(srnamc_1.srnamt, "ZGETRS", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgetrs_("/", &c__0, &c__0, a, &c__1, ip, b, &c__1, &info); chkxer_("ZGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgetrs_("N", &c_n1, &c__0, a, &c__1, ip, b, &c__1, &info); chkxer_("ZGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgetrs_("N", &c__0, &c_n1, a, &c__1, ip, b, &c__1, &info); chkxer_("ZGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 5; zgetrs_("N", &c__2, &c__1, a, &c__1, ip, b, &c__2, &info); chkxer_("ZGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 8; zgetrs_("N", &c__2, &c__1, a, &c__2, ip, b, &c__1, &info); chkxer_("ZGETRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGERFS */ s_copy(srnamc_1.srnamt, "ZGERFS", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgerfs_("/", &c__0, &c__0, a, &c__1, af, &c__1, ip, b, &c__1, x, & c__1, r1, r2, w, r__, &info); chkxer_("ZGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgerfs_("N", &c_n1, &c__0, a, &c__1, af, &c__1, ip, b, &c__1, x, & c__1, r1, r2, w, r__, &info); chkxer_("ZGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgerfs_("N", &c__0, &c_n1, a, &c__1, af, &c__1, ip, b, &c__1, x, & c__1, r1, r2, w, r__, &info); chkxer_("ZGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 5; zgerfs_("N", &c__2, &c__1, a, &c__1, af, &c__2, ip, b, &c__2, x, & c__2, r1, r2, w, r__, &info); chkxer_("ZGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 7; zgerfs_("N", &c__2, &c__1, a, &c__2, af, &c__1, ip, b, &c__2, x, & c__2, r1, r2, w, r__, &info); chkxer_("ZGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 10; zgerfs_("N", &c__2, &c__1, a, &c__2, af, &c__2, ip, b, &c__1, x, & c__2, r1, r2, w, r__, &info); chkxer_("ZGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 12; zgerfs_("N", &c__2, &c__1, a, &c__2, af, &c__2, ip, b, &c__2, x, & c__1, r1, r2, w, r__, &info); chkxer_("ZGERFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGECON */ s_copy(srnamc_1.srnamt, "ZGECON", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgecon_("/", &c__0, a, &c__1, &anrm, &rcond, w, r__, &info) ; chkxer_("ZGECON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgecon_("1", &c_n1, a, &c__1, &anrm, &rcond, w, r__, &info) ; chkxer_("ZGECON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgecon_("1", &c__2, a, &c__1, &anrm, &rcond, w, r__, &info) ; chkxer_("ZGECON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGEEQU */ s_copy(srnamc_1.srnamt, "ZGEEQU", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgeequ_(&c_n1, &c__0, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGEEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgeequ_(&c__0, &c_n1, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGEEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgeequ_(&c__2, &c__2, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGEEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* Test error exits of the routines that use the LU decomposition */ /* of a general band matrix. */ } else if (lsamen_(&c__2, c2, "GB")) { /* ZGBTRF */ s_copy(srnamc_1.srnamt, "ZGBTRF", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgbtrf_(&c_n1, &c__0, &c__0, &c__0, a, &c__1, ip, &info); chkxer_("ZGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgbtrf_(&c__0, &c_n1, &c__0, &c__0, a, &c__1, ip, &info); chkxer_("ZGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgbtrf_(&c__1, &c__1, &c_n1, &c__0, a, &c__1, ip, &info); chkxer_("ZGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgbtrf_(&c__1, &c__1, &c__0, &c_n1, a, &c__1, ip, &info); chkxer_("ZGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 6; zgbtrf_(&c__2, &c__2, &c__1, &c__1, a, &c__3, ip, &info); chkxer_("ZGBTRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGBTF2 */ s_copy(srnamc_1.srnamt, "ZGBTF2", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgbtf2_(&c_n1, &c__0, &c__0, &c__0, a, &c__1, ip, &info); chkxer_("ZGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgbtf2_(&c__0, &c_n1, &c__0, &c__0, a, &c__1, ip, &info); chkxer_("ZGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgbtf2_(&c__1, &c__1, &c_n1, &c__0, a, &c__1, ip, &info); chkxer_("ZGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgbtf2_(&c__1, &c__1, &c__0, &c_n1, a, &c__1, ip, &info); chkxer_("ZGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 6; zgbtf2_(&c__2, &c__2, &c__1, &c__1, a, &c__3, ip, &info); chkxer_("ZGBTF2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGBTRS */ s_copy(srnamc_1.srnamt, "ZGBTRS", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgbtrs_("/", &c__0, &c__0, &c__0, &c__1, a, &c__1, ip, b, &c__1, & info); chkxer_("ZGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgbtrs_("N", &c_n1, &c__0, &c__0, &c__1, a, &c__1, ip, b, &c__1, & info); chkxer_("ZGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgbtrs_("N", &c__1, &c_n1, &c__0, &c__1, a, &c__1, ip, b, &c__1, & info); chkxer_("ZGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgbtrs_("N", &c__1, &c__0, &c_n1, &c__1, a, &c__1, ip, b, &c__1, & info); chkxer_("ZGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 5; zgbtrs_("N", &c__1, &c__0, &c__0, &c_n1, a, &c__1, ip, b, &c__1, & info); chkxer_("ZGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 7; zgbtrs_("N", &c__2, &c__1, &c__1, &c__1, a, &c__3, ip, b, &c__2, & info); chkxer_("ZGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 10; zgbtrs_("N", &c__2, &c__0, &c__0, &c__1, a, &c__1, ip, b, &c__1, & info); chkxer_("ZGBTRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGBRFS */ s_copy(srnamc_1.srnamt, "ZGBRFS", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgbrfs_("/", &c__0, &c__0, &c__0, &c__0, a, &c__1, af, &c__1, ip, b, & c__1, x, &c__1, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgbrfs_("N", &c_n1, &c__0, &c__0, &c__0, a, &c__1, af, &c__1, ip, b, & c__1, x, &c__1, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgbrfs_("N", &c__1, &c_n1, &c__0, &c__0, a, &c__1, af, &c__1, ip, b, & c__1, x, &c__1, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgbrfs_("N", &c__1, &c__0, &c_n1, &c__0, a, &c__1, af, &c__1, ip, b, & c__1, x, &c__1, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 5; zgbrfs_("N", &c__1, &c__0, &c__0, &c_n1, a, &c__1, af, &c__1, ip, b, & c__1, x, &c__1, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 7; zgbrfs_("N", &c__2, &c__1, &c__1, &c__1, a, &c__2, af, &c__4, ip, b, & c__2, x, &c__2, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 9; zgbrfs_("N", &c__2, &c__1, &c__1, &c__1, a, &c__3, af, &c__3, ip, b, & c__2, x, &c__2, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 12; zgbrfs_("N", &c__2, &c__0, &c__0, &c__1, a, &c__1, af, &c__1, ip, b, & c__1, x, &c__2, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 14; zgbrfs_("N", &c__2, &c__0, &c__0, &c__1, a, &c__1, af, &c__1, ip, b, & c__2, x, &c__1, r1, r2, w, r__, &info); chkxer_("ZGBRFS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGBCON */ s_copy(srnamc_1.srnamt, "ZGBCON", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgbcon_("/", &c__0, &c__0, &c__0, a, &c__1, ip, &anrm, &rcond, w, r__, &info); chkxer_("ZGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgbcon_("1", &c_n1, &c__0, &c__0, a, &c__1, ip, &anrm, &rcond, w, r__, &info); chkxer_("ZGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgbcon_("1", &c__1, &c_n1, &c__0, a, &c__1, ip, &anrm, &rcond, w, r__, &info); chkxer_("ZGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgbcon_("1", &c__1, &c__0, &c_n1, a, &c__1, ip, &anrm, &rcond, w, r__, &info); chkxer_("ZGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 6; zgbcon_("1", &c__2, &c__1, &c__1, a, &c__3, ip, &anrm, &rcond, w, r__, &info); chkxer_("ZGBCON", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); /* ZGBEQU */ s_copy(srnamc_1.srnamt, "ZGBEQU", (ftnlen)6, (ftnlen)6); infoc_1.infot = 1; zgbequ_(&c_n1, &c__0, &c__0, &c__0, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 2; zgbequ_(&c__0, &c_n1, &c__0, &c__0, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 3; zgbequ_(&c__1, &c__1, &c_n1, &c__0, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 4; zgbequ_(&c__1, &c__1, &c__0, &c_n1, a, &c__1, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); infoc_1.infot = 6; zgbequ_(&c__2, &c__2, &c__1, &c__1, a, &c__2, r1, r2, &rcond, &ccond, &anrm, &info); chkxer_("ZGBEQU", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, & infoc_1.ok); } /* Print a summary line. */ alaesm_(path, &infoc_1.ok, &infoc_1.nout); return 0; /* End of ZERRGE */ } /* zerrge_ */