/* Subroutine */ int strsna_(char *job, char *howmny, logical *select,
integer *n, real *t, integer *ldt, real *vl, integer *ldvl, real *vr,
integer *ldvr, real *s, real *sep, integer *mm, integer *m, real *
work, integer *ldwork, integer *iwork, integer *info)
{
/* System generated locals */
integer t_dim1, t_offset, vl_dim1, vl_offset, vr_dim1, vr_offset,
work_dim1, work_offset, i__1, i__2;
real r__1, r__2;
/* Local variables */
integer i__, j, k, n2;
real cs;
integer nn, ks;
real sn, mu, eps, est;
integer kase;
real cond;
logical pair;
integer ierr;
real dumm, prod;
integer ifst;
real lnrm;
integer ilst;
real rnrm, prod1, prod2;
real scale, delta;
integer isave[3];
logical wants;
real dummy[1];
real bignum;
logical wantbh;
logical somcon;
real smlnum;
logical wantsp;
/* -- LAPACK routine (version 3.2) -- */
/* November 2006 */
/* Modified to call SLACN2 in place of SLACON, 7 Feb 03, SJH. */
/* Purpose */
/* ======= */
/* STRSNA estimates reciprocal condition numbers for specified */
/* eigenvalues and/or right eigenvectors of a real upper */
/* quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q */
/* orthogonal). */
/* T must be in Schur canonical form (as returned by SHSEQR), that is, */
/* block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each */
/* 2-by-2 diagonal block has its diagonal elements equal and its */
/* off-diagonal elements of opposite sign. */
/* Arguments */
/* ========= */
/* JOB (input) CHARACTER*1 */
/* Specifies whether condition numbers are required for */
/* eigenvalues (S) or eigenvectors (SEP): */
/* = 'E': for eigenvalues only (S); */
/* = 'V': for eigenvectors only (SEP); */
/* = 'B': for both eigenvalues and eigenvectors (S and SEP). */
/* HOWMNY (input) CHARACTER*1 */
/* = 'A': compute condition numbers for all eigenpairs; */
/* = 'S': compute condition numbers for selected eigenpairs */
/* specified by the array SELECT. */
/* SELECT (input) LOGICAL array, dimension (N) */
/* If HOWMNY = 'S', SELECT specifies the eigenpairs for which */
/* condition numbers are required. To select condition numbers */
/* for the eigenpair corresponding to a real eigenvalue w(j), */
/* corresponding to a complex conjugate pair of eigenvalues w(j) */
/* and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be */
/* If HOWMNY = 'A', SELECT is not referenced. */
/* N (input) INTEGER */
/* The order of the matrix T. N >= 0. */
/* T (input) REAL array, dimension (LDT,N) */
/* The upper quasi-triangular matrix T, in Schur canonical form. */
/* LDT (input) INTEGER */
/* The leading dimension of the array T. LDT >= max(1,N). */
/* VL (input) REAL array, dimension (LDVL,M) */
/* If JOB = 'E' or 'B', VL must contain left eigenvectors of T */
/* (or of any Q*T*Q**T with Q orthogonal), corresponding to the */
/* eigenpairs specified by HOWMNY and SELECT. The eigenvectors */
/* must be stored in consecutive columns of VL, as returned by */
/* SHSEIN or STREVC. */
/* If JOB = 'V', VL is not referenced. */
/* LDVL (input) INTEGER */
/* The leading dimension of the array VL. */
/* LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N. */
/* VR (input) REAL array, dimension (LDVR,M) */
/* If JOB = 'E' or 'B', VR must contain right eigenvectors of T */
/* (or of any Q*T*Q**T with Q orthogonal), corresponding to the */
/* eigenpairs specified by HOWMNY and SELECT. The eigenvectors */
/* must be stored in consecutive columns of VR, as returned by */
/* SHSEIN or STREVC. */
/* If JOB = 'V', VR is not referenced. */
/* LDVR (input) INTEGER */
/* The leading dimension of the array VR. */
/* LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N. */
/* S (output) REAL array, dimension (MM) */
/* If JOB = 'E' or 'B', the reciprocal condition numbers of the */
/* selected eigenvalues, stored in consecutive elements of the */
/* array. For a complex conjugate pair of eigenvalues two */
/* consecutive elements of S are set to the same value. Thus */
/* S(j), SEP(j), and the j-th columns of VL and VR all */
/* correspond to the same eigenpair (but not in general the */
/* j-th eigenpair, unless all eigenpairs are selected). */
/* If JOB = 'V', S is not referenced. */
/* SEP (output) REAL array, dimension (MM) */
/* If JOB = 'V' or 'B', the estimated reciprocal condition */
/* numbers of the selected eigenvectors, stored in consecutive */
/* elements of the array. For a complex eigenvector two */
/* consecutive elements of SEP are set to the same value. If */
/* the eigenvalues cannot be reordered to compute SEP(j), SEP(j) */
/* is set to 0; this can only occur when the true value would be */
/* very small anyway. */
/* If JOB = 'E', SEP is not referenced. */
/* MM (input) INTEGER */
/* The number of elements in the arrays S (if JOB = 'E' or 'B') */
/* and/or SEP (if JOB = 'V' or 'B'). MM >= M. */
/* M (output) INTEGER */
/* The number of elements of the arrays S and/or SEP actually */
/* used to store the estimated condition numbers. */
/* If HOWMNY = 'A', M is set to N. */
/* WORK (workspace) REAL array, dimension (LDWORK,N+6) */
/* If JOB = 'E', WORK is not referenced. */
/* LDWORK (input) INTEGER */
/* The leading dimension of the array WORK. */
/* LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N. */
/* IWORK (workspace) INTEGER array, dimension (2*(N-1)) */
/* If JOB = 'E', IWORK is not referenced. */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value */
/* Further Details */
/* =============== */
/* The reciprocal of the condition number of an eigenvalue lambda is */
/* defined as */
/* S(lambda) = |v'*u| / (norm(u)*norm(v)) */
/* where u and v are the right and left eigenvectors of T corresponding */
/* to lambda; v' denotes the conjugate-transpose of v, and norm(u) */
/* denotes the Euclidean norm. These reciprocal condition numbers always */
/* lie between zero (very badly conditioned) and one (very well */
/* conditioned). If n = 1, S(lambda) is defined to be 1. */
/* An approximate error bound for a computed eigenvalue W(i) is given by */
/* EPS * norm(T) / S(i) */
/* where EPS is the machine precision. */
/* The reciprocal of the condition number of the right eigenvector u */
/* corresponding to lambda is defined as follows. Suppose */
/* T = ( lambda c ) */
/* ( 0 T22 ) */
/* Then the reciprocal condition number is */
/* SEP( lambda, T22 ) = sigma-min( T22 - lambda*I ) */
/* where sigma-min denotes the smallest singular value. We approximate */
/* the smallest singular value by the reciprocal of an estimate of the */
/* one-norm of the inverse of T22 - lambda*I. If n = 1, SEP(1) is */
/* defined to be abs(T(1,1)). */
/* An approximate error bound for a computed right eigenvector VR(i) */
/* is given by */
/* EPS * norm(T) / SEP(i) */
/* ===================================================================== */
/* Decode and test the input parameters */
/* Parameter adjustments */
--select;
t_dim1 = *ldt;
t_offset = 1 + t_dim1;
t -= t_offset;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--s;
--sep;
work_dim1 = *ldwork;
work_offset = 1 + work_dim1;
work -= work_offset;
--iwork;
/* Function Body */
wantbh = lsame_(job, "B");
wants = lsame_(job, "E") || wantbh;
wantsp = lsame_(job, "V") || wantbh;
somcon = lsame_(howmny, "S");
*info = 0;
if (! wants && ! wantsp) {
*info = -1;
} else if (! lsame_(howmny, "A") && ! somcon) {
*info = -2;
} else if (*n < 0) {
*info = -4;
} else if (*ldt < max(1,*n)) {
*info = -6;
} else if (*ldvl < 1 || wants && *ldvl < *n) {
*info = -8;
} else if (*ldvr < 1 || wants && *ldvr < *n) {
*info = -10;
} else {
/* Set M to the number of eigenpairs for which condition numbers */
/* are required, and test MM. */
if (somcon) {
*m = 0;
pair = FALSE_;
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
if (pair) {
pair = FALSE_;
} else {
if (k < *n) {
if (t[k + 1 + k * t_dim1] == 0.f) {
if (select[k]) {
++(*m);
}
} else {
pair = TRUE_;
if (select[k] || select[k + 1]) {
*m += 2;
}
}
} else {
if (select[*n]) {
++(*m);
}
}
}
}
} else {
*m = *n;
}
if (*mm < *m) {
*info = -13;
} else if (*ldwork < 1 || wantsp && *ldwork < *n) {
*info = -16;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("STRSNA", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
if (*n == 1) {
if (somcon) {
if (! select[1]) {
return 0;
}
}
if (wants) {
s[1] = 1.f;
}
if (wantsp) {
sep[1] = (r__1 = t[t_dim1 + 1], dabs(r__1));
}
return 0;
}
/* Get machine constants */
eps = slamch_("P");
smlnum = slamch_("S") / eps;
bignum = 1.f / smlnum;
slabad_(&smlnum, &bignum);
ks = 0;
pair = FALSE_;
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
/* Determine whether T(k,k) begins a 1-by-1 or 2-by-2 block. */
if (pair) {
pair = FALSE_;
goto L60;
} else {
if (k < *n) {
pair = t[k + 1 + k * t_dim1] != 0.f;
}
}
/* Determine whether condition numbers are required for the k-th */
/* eigenpair. */
if (somcon) {
if (pair) {
if (! select[k] && ! select[k + 1]) {
goto L60;
}
} else {
if (! select[k]) {
goto L60;
}
}
}
++ks;
if (wants) {
/* Compute the reciprocal condition number of the k-th */
/* eigenvalue. */
if (! pair) {
/* Real eigenvalue. */
prod = sdot_(n, &vr[ks * vr_dim1 + 1], &c__1, &vl[ks *
vl_dim1 + 1], &c__1);
rnrm = snrm2_(n, &vr[ks * vr_dim1 + 1], &c__1);
lnrm = snrm2_(n, &vl[ks * vl_dim1 + 1], &c__1);
s[ks] = dabs(prod) / (rnrm * lnrm);
} else {
/* Complex eigenvalue. */
prod1 = sdot_(n, &vr[ks * vr_dim1 + 1], &c__1, &vl[ks *
vl_dim1 + 1], &c__1);
prod1 += sdot_(n, &vr[(ks + 1) * vr_dim1 + 1], &c__1, &vl[(ks
+ 1) * vl_dim1 + 1], &c__1);
prod2 = sdot_(n, &vl[ks * vl_dim1 + 1], &c__1, &vr[(ks + 1) *
vr_dim1 + 1], &c__1);
prod2 -= sdot_(n, &vl[(ks + 1) * vl_dim1 + 1], &c__1, &vr[ks *
vr_dim1 + 1], &c__1);
r__1 = snrm2_(n, &vr[ks * vr_dim1 + 1], &c__1);
r__2 = snrm2_(n, &vr[(ks + 1) * vr_dim1 + 1], &c__1);
rnrm = slapy2_(&r__1, &r__2);
r__1 = snrm2_(n, &vl[ks * vl_dim1 + 1], &c__1);
r__2 = snrm2_(n, &vl[(ks + 1) * vl_dim1 + 1], &c__1);
lnrm = slapy2_(&r__1, &r__2);
cond = slapy2_(&prod1, &prod2) / (rnrm * lnrm);
s[ks] = cond;
s[ks + 1] = cond;
}
}
if (wantsp) {
/* Estimate the reciprocal condition number of the k-th */
/* eigenvector. */
/* Copy the matrix T to the array WORK and swap the diagonal */
/* block beginning at T(k,k) to the (1,1) position. */
slacpy_("Full", n, n, &t[t_offset], ldt, &work[work_offset],
ldwork);
ifst = k;
ilst = 1;
strexc_("No Q", n, &work[work_offset], ldwork, dummy, &c__1, &
ifst, &ilst, &work[(*n + 1) * work_dim1 + 1], &ierr);
if (ierr == 1 || ierr == 2) {
/* Could not swap because blocks not well separated */
scale = 1.f;
est = bignum;
} else {
/* Reordering successful */
if (work[work_dim1 + 2] == 0.f) {
/* Form C = T22 - lambda*I in WORK(2:N,2:N). */
i__2 = *n;
for (i__ = 2; i__ <= i__2; ++i__) {
work[i__ + i__ * work_dim1] -= work[work_dim1 + 1];
}
n2 = 1;
nn = *n - 1;
} else {
/* Triangularize the 2 by 2 block by unitary */
/* transformation U = [ cs i*ss ] */
/* [ i*ss cs ]. */
/* such that the (1,1) position of WORK is complex */
/* eigenvalue lambda with positive imaginary part. (2,2) */
/* position of WORK is the complex eigenvalue lambda */
/* with negative imaginary part. */
mu = sqrt((r__1 = work[(work_dim1 << 1) + 1], dabs(r__1)))
* sqrt((r__2 = work[work_dim1 + 2], dabs(r__2)));
delta = slapy2_(&mu, &work[work_dim1 + 2]);
cs = mu / delta;
sn = -work[work_dim1 + 2] / delta;
/* Form */
/* [ mu ] */
/* [ mu ] */
/* where C' is conjugate transpose of complex matrix C, */
/* and RWORK is stored starting in the N+1-st column of */
/* WORK. */
i__2 = *n;
for (j = 3; j <= i__2; ++j) {
work[j * work_dim1 + 2] = cs * work[j * work_dim1 + 2]
;
work[j + j * work_dim1] -= work[work_dim1 + 1];
}
work[(work_dim1 << 1) + 2] = 0.f;
work[(*n + 1) * work_dim1 + 1] = mu * 2.f;
i__2 = *n - 1;
for (i__ = 2; i__ <= i__2; ++i__) {
work[i__ + (*n + 1) * work_dim1] = sn * work[(i__ + 1)
* work_dim1 + 1];
}
n2 = 2;
nn = *n - 1 << 1;
}
/* Estimate norm(inv(C')) */
est = 0.f;
kase = 0;
L50:
slacn2_(&nn, &work[(*n + 2) * work_dim1 + 1], &work[(*n + 4) *
work_dim1 + 1], &iwork[1], &est, &kase, isave);
if (kase != 0) {
if (kase == 1) {
if (n2 == 1) {
/* Real eigenvalue: solve C'*x = scale*c. */
i__2 = *n - 1;
slaqtr_(&c_true, &c_true, &i__2, &work[(work_dim1
<< 1) + 2], ldwork, dummy, &dumm, &scale,
&work[(*n + 4) * work_dim1 + 1], &work[(*
n + 6) * work_dim1 + 1], &ierr);
} else {
/* Complex eigenvalue: solve */
/* C'*(p+iq) = scale*(c+id) in real arithmetic. */
i__2 = *n - 1;
slaqtr_(&c_true, &c_false, &i__2, &work[(
work_dim1 << 1) + 2], ldwork, &work[(*n +
1) * work_dim1 + 1], &mu, &scale, &work[(*
n + 4) * work_dim1 + 1], &work[(*n + 6) *
work_dim1 + 1], &ierr);
}
} else {
if (n2 == 1) {
/* Real eigenvalue: solve C*x = scale*c. */
i__2 = *n - 1;
slaqtr_(&c_false, &c_true, &i__2, &work[(
work_dim1 << 1) + 2], ldwork, dummy, &
dumm, &scale, &work[(*n + 4) * work_dim1
+ 1], &work[(*n + 6) * work_dim1 + 1], &
ierr);
} else {
/* Complex eigenvalue: solve */
/* C*(p+iq) = scale*(c+id) in real arithmetic. */
i__2 = *n - 1;
slaqtr_(&c_false, &c_false, &i__2, &work[(
work_dim1 << 1) + 2], ldwork, &work[(*n +
1) * work_dim1 + 1], &mu, &scale, &work[(*
n + 4) * work_dim1 + 1], &work[(*n + 6) *
work_dim1 + 1], &ierr);
}
}
goto L50;
}
}
sep[ks] = scale / dmax(est,smlnum);
if (pair) {
sep[ks + 1] = sep[ks];
}
}
if (pair) {
++ks;
}
L60:
;
}
return 0;
/* End of STRSNA */
} /* strsna_ */
/* Subroutine */ int sget39_(real *rmax, integer *lmax, integer *ninfo,
integer *knt)
{
/* Initialized data */
static integer idim[6] = { 4,5,5,5,5,5 };
static integer ival[150] /* was [5][5][6] */ = { 3,0,0,0,0,1,1,-1,0,0,
3,2,1,0,0,4,3,2,2,0,0,0,0,0,0,1,0,0,0,0,2,2,0,0,0,3,3,4,0,0,4,2,2,
3,0,1,1,1,1,5,1,0,0,0,0,2,4,-2,0,0,3,3,4,0,0,4,2,2,3,0,1,1,1,1,1,
1,0,0,0,0,2,1,-1,0,0,9,8,1,0,0,4,9,1,2,-1,2,2,2,2,2,9,0,0,0,0,6,4,
0,0,0,3,2,1,1,0,5,1,-1,1,0,2,2,2,2,2,4,0,0,0,0,2,2,0,0,0,1,4,4,0,
0,2,4,2,2,-1,2,2,2,2,2 };
/* System generated locals */
integer i__1, i__2;
real r__1, r__2;
/* Builtin functions */
double sqrt(doublereal), cos(doublereal), sin(doublereal);
/* Local variables */
real b[10], d__[20];
integer i__, j, k, n;
real t[100] /* was [10][10] */, w, x[20], y[20], vm1[5], vm2[5], vm3[5],
vm4[5], vm5[3], dum[1], eps;
integer ivm1, ivm2, ivm3, ivm4, ivm5, ndim, info;
real dumm;
extern doublereal sdot_(integer *, real *, integer *, real *, integer *);
real norm, work[10], scale, domin, resid;
extern /* Subroutine */ int sgemv_(char *, integer *, integer *, real *,
real *, integer *, real *, integer *, real *, real *, integer *);
extern doublereal sasum_(integer *, real *, integer *);
extern /* Subroutine */ int scopy_(integer *, real *, integer *, real *,
integer *);
real xnorm;
extern /* Subroutine */ int slabad_(real *, real *);
extern doublereal slamch_(char *), slange_(char *, integer *,
integer *, real *, integer *, real *);
real bignum;
extern integer isamax_(integer *, real *, integer *);
real normtb;
extern /* Subroutine */ int slaqtr_(logical *, logical *, integer *, real
*, integer *, real *, real *, real *, real *, real *, integer *);
real smlnum;
/* -- LAPACK test routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SGET39 tests SLAQTR, a routine for solving the real or */
/* special complex quasi upper triangular system */
/* op(T)*p = scale*c, */
/* or */
/* op(T + iB)*(p+iq) = scale*(c+id), */
/* in real arithmetic. T is upper quasi-triangular. */
/* If it is complex, then the first diagonal block of T must be */
/* 1 by 1, B has the special structure */
/* B = [ b(1) b(2) ... b(n) ] */
/* [ w ] */
/* [ w ] */
/* [ . ] */
/* [ w ] */
/* op(A) = A or A', where A' denotes the conjugate transpose of */
/* the matrix A. */
/* On input, X = [ c ]. On output, X = [ p ]. */
/* [ d ] [ q ] */
/* Scale is an output less than or equal to 1, chosen to avoid */
/* overflow in X. */
/* This subroutine is specially designed for the condition number */
/* estimation in the eigenproblem routine STRSNA. */
/* The test code verifies that the following residual is order 1: */
/* ||(T+i*B)*(x1+i*x2) - scale*(d1+i*d2)|| */
/* ----------------------------------------- */
/* max(ulp*(||T||+||B||)*(||x1||+||x2||), */
/* (||T||+||B||)*smlnum/ulp, */
/* smlnum) */
/* (The (||T||+||B||)*smlnum/ulp term accounts for possible */
/* (gradual or nongradual) underflow in x1 and x2.) */
/* Arguments */
/* ========== */
/* RMAX (output) REAL */
/* Value of the largest test ratio. */
/* LMAX (output) INTEGER */
/* Example number where largest test ratio achieved. */
/* NINFO (output) INTEGER */
/* Number of examples where INFO is nonzero. */
/* KNT (output) INTEGER */
/* Total number of examples tested. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. Data statements .. */
/* .. */
/* .. Executable Statements .. */
/* Get machine parameters */
eps = slamch_("P");
smlnum = slamch_("S");
bignum = 1.f / smlnum;
slabad_(&smlnum, &bignum);
/* Set up test case parameters */
vm1[0] = 1.f;
vm1[1] = sqrt(smlnum);
vm1[2] = sqrt(vm1[1]);
vm1[3] = sqrt(bignum);
vm1[4] = sqrt(vm1[3]);
vm2[0] = 1.f;
vm2[1] = sqrt(smlnum);
vm2[2] = sqrt(vm2[1]);
vm2[3] = sqrt(bignum);
vm2[4] = sqrt(vm2[3]);
vm3[0] = 1.f;
vm3[1] = sqrt(smlnum);
vm3[2] = sqrt(vm3[1]);
vm3[3] = sqrt(bignum);
vm3[4] = sqrt(vm3[3]);
vm4[0] = 1.f;
vm4[1] = sqrt(smlnum);
vm4[2] = sqrt(vm4[1]);
vm4[3] = sqrt(bignum);
vm4[4] = sqrt(vm4[3]);
vm5[0] = 1.f;
vm5[1] = eps;
vm5[2] = sqrt(smlnum);
/* Initalization */
*knt = 0;
*rmax = 0.f;
*ninfo = 0;
smlnum /= eps;
/* Begin test loop */
for (ivm5 = 1; ivm5 <= 3; ++ivm5) {
for (ivm4 = 1; ivm4 <= 5; ++ivm4) {
for (ivm3 = 1; ivm3 <= 5; ++ivm3) {
for (ivm2 = 1; ivm2 <= 5; ++ivm2) {
for (ivm1 = 1; ivm1 <= 5; ++ivm1) {
for (ndim = 1; ndim <= 6; ++ndim) {
n = idim[ndim - 1];
i__1 = n;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = n;
for (j = 1; j <= i__2; ++j) {
t[i__ + j * 10 - 11] = (real) ival[i__ + (
j + ndim * 5) * 5 - 31] * vm1[
ivm1 - 1];
if (i__ >= j) {
t[i__ + j * 10 - 11] *= vm5[ivm5 - 1];
}
/* L10: */
}
/* L20: */
}
w = vm2[ivm2 - 1] * 1.f;
i__1 = n;
for (i__ = 1; i__ <= i__1; ++i__) {
b[i__ - 1] = cos((real) i__) * vm3[ivm3 - 1];
/* L30: */
}
i__1 = n << 1;
for (i__ = 1; i__ <= i__1; ++i__) {
d__[i__ - 1] = sin((real) i__) * vm4[ivm4 - 1]
;
/* L40: */
}
norm = slange_("1", &n, &n, t, &c__10, work);
k = isamax_(&n, b, &c__1);
normtb = norm + (r__1 = b[k - 1], dabs(r__1)) +
dabs(w);
scopy_(&n, d__, &c__1, x, &c__1);
++(*knt);
slaqtr_(&c_false, &c_true, &n, t, &c__10, dum, &
dumm, &scale, x, work, &info);
if (info != 0) {
++(*ninfo);
}
/* || T*x - scale*d || / */
/* max(ulp*||T||*||x||,smlnum/ulp*||T||,smlnum) */
scopy_(&n, d__, &c__1, y, &c__1);
r__1 = -scale;
sgemv_("No transpose", &n, &n, &c_b25, t, &c__10,
x, &c__1, &r__1, y, &c__1);
xnorm = sasum_(&n, x, &c__1);
resid = sasum_(&n, y, &c__1);
/* Computing MAX */
r__1 = smlnum, r__2 = smlnum / eps * norm, r__1 =
max(r__1,r__2), r__2 = norm * eps * xnorm;
domin = dmax(r__1,r__2);
resid /= domin;
if (resid > *rmax) {
*rmax = resid;
*lmax = *knt;
}
scopy_(&n, d__, &c__1, x, &c__1);
++(*knt);
slaqtr_(&c_true, &c_true, &n, t, &c__10, dum, &
dumm, &scale, x, work, &info);
if (info != 0) {
++(*ninfo);
}
/* || T*x - scale*d || / */
/* max(ulp*||T||*||x||,smlnum/ulp*||T||,smlnum) */
scopy_(&n, d__, &c__1, y, &c__1);
r__1 = -scale;
sgemv_("Transpose", &n, &n, &c_b25, t, &c__10, x,
&c__1, &r__1, y, &c__1);
xnorm = sasum_(&n, x, &c__1);
resid = sasum_(&n, y, &c__1);
/* Computing MAX */
r__1 = smlnum, r__2 = smlnum / eps * norm, r__1 =
max(r__1,r__2), r__2 = norm * eps * xnorm;
domin = dmax(r__1,r__2);
resid /= domin;
if (resid > *rmax) {
*rmax = resid;
*lmax = *knt;
}
i__1 = n << 1;
scopy_(&i__1, d__, &c__1, x, &c__1);
++(*knt);
slaqtr_(&c_false, &c_false, &n, t, &c__10, b, &w,
&scale, x, work, &info);
if (info != 0) {
++(*ninfo);
}
/* ||(T+i*B)*(x1+i*x2) - scale*(d1+i*d2)|| / */
/* max(ulp*(||T||+||B||)*(||x1||+||x2||), */
/* smlnum/ulp * (||T||+||B||), smlnum ) */
i__1 = n << 1;
scopy_(&i__1, d__, &c__1, y, &c__1);
y[0] = sdot_(&n, b, &c__1, &x[n], &c__1) + scale *
y[0];
i__1 = n;
for (i__ = 2; i__ <= i__1; ++i__) {
y[i__ - 1] = w * x[i__ + n - 1] + scale * y[
i__ - 1];
/* L50: */
}
sgemv_("No transpose", &n, &n, &c_b25, t, &c__10,
x, &c__1, &c_b59, y, &c__1);
y[n] = sdot_(&n, b, &c__1, x, &c__1) - scale * y[
n];
i__1 = n;
for (i__ = 2; i__ <= i__1; ++i__) {
y[i__ + n - 1] = w * x[i__ - 1] - scale * y[
i__ + n - 1];
/* L60: */
}
sgemv_("No transpose", &n, &n, &c_b25, t, &c__10,
&x[n], &c__1, &c_b25, &y[n], &c__1);
i__1 = n << 1;
resid = sasum_(&i__1, y, &c__1);
/* Computing MAX */
i__1 = n << 1;
r__1 = smlnum, r__2 = smlnum / eps * normtb, r__1
= max(r__1,r__2), r__2 = eps * (normtb *
sasum_(&i__1, x, &c__1));
domin = dmax(r__1,r__2);
resid /= domin;
if (resid > *rmax) {
*rmax = resid;
*lmax = *knt;
}
i__1 = n << 1;
scopy_(&i__1, d__, &c__1, x, &c__1);
++(*knt);
slaqtr_(&c_true, &c_false, &n, t, &c__10, b, &w, &
scale, x, work, &info);
if (info != 0) {
++(*ninfo);
}
/* ||(T+i*B)*(x1+i*x2) - scale*(d1+i*d2)|| / */
/* max(ulp*(||T||+||B||)*(||x1||+||x2||), */
/* smlnum/ulp * (||T||+||B||), smlnum ) */
i__1 = n << 1;
scopy_(&i__1, d__, &c__1, y, &c__1);
y[0] = b[0] * x[n] - scale * y[0];
i__1 = n;
for (i__ = 2; i__ <= i__1; ++i__) {
y[i__ - 1] = b[i__ - 1] * x[n] + w * x[i__ +
n - 1] - scale * y[i__ - 1];
/* L70: */
}
sgemv_("Transpose", &n, &n, &c_b25, t, &c__10, x,
&c__1, &c_b25, y, &c__1);
y[n] = b[0] * x[0] + scale * y[n];
i__1 = n;
for (i__ = 2; i__ <= i__1; ++i__) {
y[i__ + n - 1] = b[i__ - 1] * x[0] + w * x[
i__ - 1] + scale * y[i__ + n - 1];
/* L80: */
}
sgemv_("Transpose", &n, &n, &c_b25, t, &c__10, &x[
n], &c__1, &c_b59, &y[n], &c__1);
i__1 = n << 1;
resid = sasum_(&i__1, y, &c__1);
/* Computing MAX */
i__1 = n << 1;
r__1 = smlnum, r__2 = smlnum / eps * normtb, r__1
= max(r__1,r__2), r__2 = eps * (normtb *
sasum_(&i__1, x, &c__1));
domin = dmax(r__1,r__2);
resid /= domin;
if (resid > *rmax) {
*rmax = resid;
*lmax = *knt;
}
/* L90: */
}
/* L100: */
}
/* L110: */
}
/* L120: */
}
/* L130: */
}
/* L140: */
}
return 0;
/* End of SGET39 */
} /* sget39_ */
