/* Subroutine */ int stgsna_(char *job, char *howmny, logical *select,
integer *n, real *a, integer *lda, real *b, integer *ldb, real *vl,
integer *ldvl, real *vr, integer *ldvr, real *s, real *dif, integer *
mm, integer *m, real *work, integer *lwork, integer *iwork, integer *
info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2;
real r__1, r__2;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
integer i__, k;
real c1, c2;
integer n1, n2, ks, iz;
real eps, beta, cond;
logical pair;
integer ierr;
real uhav, uhbv;
integer ifst;
real lnrm;
extern doublereal sdot_(integer *, real *, integer *, real *, integer *);
integer ilst;
real rnrm;
extern /* Subroutine */ int slag2_(real *, integer *, real *, integer *,
real *, real *, real *, real *, real *, real *);
extern doublereal snrm2_(integer *, real *, integer *);
real root1, root2, scale;
extern logical lsame_(char *, char *);
real uhavi, uhbvi;
extern /* Subroutine */ int sgemv_(char *, integer *, integer *, real *,
real *, integer *, real *, integer *, real *, real *, integer *);
real tmpii;
integer lwmin;
logical wants;
real tmpir, tmpri, dummy[1], tmprr;
extern doublereal slapy2_(real *, real *);
real dummy1[1], alphai, alphar;
extern doublereal slamch_(char *);
extern /* Subroutine */ int xerbla_(char *, integer *);
logical wantbh, wantdf;
extern /* Subroutine */ int slacpy_(char *, integer *, integer *, real *,
integer *, real *, integer *), stgexc_(logical *, logical
*, integer *, real *, integer *, real *, integer *, real *,
integer *, real *, integer *, integer *, integer *, real *,
integer *, integer *);
logical somcon;
real alprqt, smlnum;
logical lquery;
extern /* Subroutine */ int stgsyl_(char *, integer *, integer *, integer
*, real *, integer *, real *, integer *, real *, integer *, real *
, integer *, real *, integer *, real *, integer *, real *, real *,
real *, integer *, integer *, integer *);
/* -- LAPACK routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* STGSNA estimates reciprocal condition numbers for specified */
/* eigenvalues and/or eigenvectors of a matrix pair (A, B) in */
/* generalized real Schur canonical form (or of any matrix pair */
/* (Q*A*Z', Q*B*Z') with orthogonal matrices Q and Z, where */
/* Z' denotes the transpose of Z. */
/* (A, B) must be in generalized real Schur form (as returned by SGGES), */
/* i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal */
/* blocks. B is upper triangular. */
/* Arguments */
/* ========= */
/* JOB (input) CHARACTER*1 */
/* Specifies whether condition numbers are required for */
/* eigenvalues (S) or eigenvectors (DIF): */
/* = 'E': for eigenvalues only (S); */
/* = 'V': for eigenvectors only (DIF); */
/* = 'B': for both eigenvalues and eigenvectors (S and DIF). */
/* 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), */
/* SELECT(j) must be set to .TRUE.. To select condition numbers */
/* 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 */
/* set to .TRUE.. */
/* If HOWMNY = 'A', SELECT is not referenced. */
/* N (input) INTEGER */
/* The order of the square matrix pair (A, B). N >= 0. */
/* A (input) REAL array, dimension (LDA,N) */
/* The upper quasi-triangular matrix A in the pair (A,B). */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,N). */
/* B (input) REAL array, dimension (LDB,N) */
/* The upper triangular matrix B in the pair (A,B). */
/* LDB (input) INTEGER */
/* The leading dimension of the array B. LDB >= max(1,N). */
/* VL (input) REAL array, dimension (LDVL,M) */
/* If JOB = 'E' or 'B', VL must contain left eigenvectors of */
/* (A, B), corresponding to the eigenpairs specified by HOWMNY */
/* and SELECT. The eigenvectors must be stored in consecutive */
/* columns of VL, as returned by STGEVC. */
/* If JOB = 'V', VL is not referenced. */
/* LDVL (input) INTEGER */
/* The leading dimension of the array VL. LDVL >= 1. */
/* 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 */
/* (A, B), corresponding to the eigenpairs specified by HOWMNY */
/* and SELECT. The eigenvectors must be stored in consecutive */
/* columns ov VR, as returned by STGEVC. */
/* If JOB = 'V', VR is not referenced. */
/* LDVR (input) INTEGER */
/* The leading dimension of the array VR. LDVR >= 1. */
/* 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), DIF(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. */
/* DIF (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 DIF are set to the same value. If */
/* the eigenvalues cannot be reordered to compute DIF(j), DIF(j) */
/* is set to 0; this can only occur when the true value would be */
/* very small anyway. */
/* If JOB = 'E', DIF is not referenced. */
/* MM (input) INTEGER */
/* The number of elements in the arrays S and DIF. MM >= M. */
/* M (output) INTEGER */
/* The number of elements of the arrays S and DIF used to store */
/* the specified condition numbers; for each selected real */
/* eigenvalue one element is used, and for each selected complex */
/* conjugate pair of eigenvalues, two elements are used. */
/* If HOWMNY = 'A', M is set to N. */
/* WORK (workspace/output) REAL array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= max(1,N). */
/* If JOB = 'V' or 'B' LWORK >= 2*N*(N+2)+16. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* IWORK (workspace) INTEGER array, dimension (N + 6) */
/* 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 a generalized eigenvalue */
/* w = (a, b) is defined as */
/* S(w) = (|u'Av|**2 + |u'Bv|**2)**(1/2) / (norm(u)*norm(v)) */
/* where u and v are the left and right eigenvectors of (A, B) */
/* corresponding to w; |z| denotes the absolute value of the complex */
/* number, and norm(u) denotes the 2-norm of the vector u. */
/* The pair (a, b) corresponds to an eigenvalue w = a/b (= u'Av/u'Bv) */
/* of the matrix pair (A, B). If both a and b equal zero, then (A B) is */
/* singular and S(I) = -1 is returned. */
/* An approximate error bound on the chordal distance between the i-th */
/* computed generalized eigenvalue w and the corresponding exact */
/* eigenvalue lambda is */
/* chord(w, lambda) <= EPS * norm(A, B) / S(I) */
/* where EPS is the machine precision. */
/* The reciprocal of the condition number DIF(i) of right eigenvector u */
/* and left eigenvector v corresponding to the generalized eigenvalue w */
/* is defined as follows: */
/* a) If the i-th eigenvalue w = (a,b) is real */
/* Suppose U and V are orthogonal transformations such that */
/* U'*(A, B)*V = (S, T) = ( a * ) ( b * ) 1 */
/* ( 0 S22 ),( 0 T22 ) n-1 */
/* 1 n-1 1 n-1 */
/* Then the reciprocal condition number DIF(i) is */
/* Difl((a, b), (S22, T22)) = sigma-min( Zl ), */
/* where sigma-min(Zl) denotes the smallest singular value of the */
/* 2(n-1)-by-2(n-1) matrix */
/* Zl = [ kron(a, In-1) -kron(1, S22) ] */
/* [ kron(b, In-1) -kron(1, T22) ] . */
/* Here In-1 is the identity matrix of size n-1. kron(X, Y) is the */
/* Kronecker product between the matrices X and Y. */
/* Note that if the default method for computing DIF(i) is wanted */
/* (see SLATDF), then the parameter DIFDRI (see below) should be */
/* changed from 3 to 4 (routine SLATDF(IJOB = 2 will be used)). */
/* See STGSYL for more details. */
/* b) If the i-th and (i+1)-th eigenvalues are complex conjugate pair, */
/* Suppose U and V are orthogonal transformations such that */
/* U'*(A, B)*V = (S, T) = ( S11 * ) ( T11 * ) 2 */
/* ( 0 S22 ),( 0 T22) n-2 */
/* 2 n-2 2 n-2 */
/* and (S11, T11) corresponds to the complex conjugate eigenvalue */
/* pair (w, conjg(w)). There exist unitary matrices U1 and V1 such */
/* that */
/* U1'*S11*V1 = ( s11 s12 ) and U1'*T11*V1 = ( t11 t12 ) */
/* ( 0 s22 ) ( 0 t22 ) */
/* where the generalized eigenvalues w = s11/t11 and */
/* conjg(w) = s22/t22. */
/* Then the reciprocal condition number DIF(i) is bounded by */
/* min( d1, max( 1, |real(s11)/real(s22)| )*d2 ) */
/* where, d1 = Difl((s11, t11), (s22, t22)) = sigma-min(Z1), where */
/* Z1 is the complex 2-by-2 matrix */
/* Z1 = [ s11 -s22 ] */
/* [ t11 -t22 ], */
/* This is done by computing (using real arithmetic) the */
/* roots of the characteristical polynomial det(Z1' * Z1 - lambda I), */
/* where Z1' denotes the conjugate transpose of Z1 and det(X) denotes */
/* the determinant of X. */
/* and d2 is an upper bound on Difl((S11, T11), (S22, T22)), i.e. an */
/* upper bound on sigma-min(Z2), where Z2 is (2n-2)-by-(2n-2) */
/* Z2 = [ kron(S11', In-2) -kron(I2, S22) ] */
/* [ kron(T11', In-2) -kron(I2, T22) ] */
/* Note that if the default method for computing DIF is wanted (see */
/* SLATDF), then the parameter DIFDRI (see below) should be changed */
/* from 3 to 4 (routine SLATDF(IJOB = 2 will be used)). See STGSYL */
/* for more details. */
/* For each eigenvalue/vector specified by SELECT, DIF stores a */
/* Frobenius norm-based estimate of Difl. */
/* An approximate error bound for the i-th computed eigenvector VL(i) or */
/* VR(i) is given by */
/* EPS * norm(A, B) / DIF(i). */
/* See ref. [2-3] for more details and further references. */
/* Based on contributions by */
/* Bo Kagstrom and Peter Poromaa, Department of Computing Science, */
/* Umea University, S-901 87 Umea, Sweden. */
/* References */
/* ========== */
/* [1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the */
/* Generalized Real Schur Form of a Regular Matrix Pair (A, B), in */
/* M.S. Moonen et al (eds), Linear Algebra for Large Scale and */
/* Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218. */
/* [2] B. Kagstrom and P. Poromaa; Computing Eigenspaces with Specified */
/* Eigenvalues of a Regular Matrix Pair (A, B) and Condition */
/* Estimation: Theory, Algorithms and Software, */
/* Report UMINF - 94.04, Department of Computing Science, Umea */
/* University, S-901 87 Umea, Sweden, 1994. Also as LAPACK Working */
/* Note 87. To appear in Numerical Algorithms, 1996. */
/* [3] B. Kagstrom and P. Poromaa, LAPACK-Style Algorithms and Software */
/* for Solving the Generalized Sylvester Equation and Estimating the */
/* Separation between Regular Matrix Pairs, Report UMINF - 93.23, */
/* Department of Computing Science, Umea University, S-901 87 Umea, */
/* Sweden, December 1993, Revised April 1994, Also as LAPACK Working */
/* Note 75. To appear in ACM Trans. on Math. Software, Vol 22, */
/* No 1, 1996. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Decode and test the input parameters */
/* Parameter adjustments */
--select;
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--s;
--dif;
--work;
--iwork;
/* Function Body */
wantbh = lsame_(job, "B");
wants = lsame_(job, "E") || wantbh;
wantdf = lsame_(job, "V") || wantbh;
somcon = lsame_(howmny, "S");
*info = 0;
lquery = *lwork == -1;
if (! wants && ! wantdf) {
*info = -1;
} else if (! lsame_(howmny, "A") && ! somcon) {
*info = -2;
} else if (*n < 0) {
*info = -4;
} else if (*lda < max(1,*n)) {
*info = -6;
} else if (*ldb < max(1,*n)) {
*info = -8;
} else if (wants && *ldvl < *n) {
*info = -10;
} else if (wants && *ldvr < *n) {
*info = -12;
} 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 (a[k + 1 + k * a_dim1] == 0.f) {
if (select[k]) {
++(*m);
}
} else {
pair = TRUE_;
if (select[k] || select[k + 1]) {
*m += 2;
}
}
} else {
if (select[*n]) {
++(*m);
}
}
}
/* L10: */
}
} else {
*m = *n;
}
if (*n == 0) {
lwmin = 1;
} else if (lsame_(job, "V") || lsame_(job,
"B")) {
lwmin = (*n << 1) * (*n + 2) + 16;
} else {
lwmin = *n;
}
work[1] = (real) lwmin;
if (*mm < *m) {
*info = -15;
} else if (*lwork < lwmin && ! lquery) {
*info = -18;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("STGSNA", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Get machine constants */
eps = slamch_("P");
smlnum = slamch_("S") / eps;
ks = 0;
pair = FALSE_;
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
/* Determine whether A(k,k) begins a 1-by-1 or 2-by-2 block. */
if (pair) {
pair = FALSE_;
goto L20;
} else {
if (k < *n) {
pair = a[k + 1 + k * a_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 L20;
}
} else {
if (! select[k]) {
goto L20;
}
}
}
++ks;
if (wants) {
/* Compute the reciprocal condition number of the k-th */
/* eigenvalue. */
if (pair) {
/* Complex eigenvalue pair. */
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);
sgemv_("N", n, n, &c_b19, &a[a_offset], lda, &vr[ks * vr_dim1
+ 1], &c__1, &c_b21, &work[1], &c__1);
tmprr = sdot_(n, &work[1], &c__1, &vl[ks * vl_dim1 + 1], &
c__1);
tmpri = sdot_(n, &work[1], &c__1, &vl[(ks + 1) * vl_dim1 + 1],
&c__1);
sgemv_("N", n, n, &c_b19, &a[a_offset], lda, &vr[(ks + 1) *
vr_dim1 + 1], &c__1, &c_b21, &work[1], &c__1);
tmpii = sdot_(n, &work[1], &c__1, &vl[(ks + 1) * vl_dim1 + 1],
&c__1);
tmpir = sdot_(n, &work[1], &c__1, &vl[ks * vl_dim1 + 1], &
c__1);
uhav = tmprr + tmpii;
uhavi = tmpir - tmpri;
sgemv_("N", n, n, &c_b19, &b[b_offset], ldb, &vr[ks * vr_dim1
+ 1], &c__1, &c_b21, &work[1], &c__1);
tmprr = sdot_(n, &work[1], &c__1, &vl[ks * vl_dim1 + 1], &
c__1);
tmpri = sdot_(n, &work[1], &c__1, &vl[(ks + 1) * vl_dim1 + 1],
&c__1);
sgemv_("N", n, n, &c_b19, &b[b_offset], ldb, &vr[(ks + 1) *
vr_dim1 + 1], &c__1, &c_b21, &work[1], &c__1);
tmpii = sdot_(n, &work[1], &c__1, &vl[(ks + 1) * vl_dim1 + 1],
&c__1);
tmpir = sdot_(n, &work[1], &c__1, &vl[ks * vl_dim1 + 1], &
c__1);
uhbv = tmprr + tmpii;
uhbvi = tmpir - tmpri;
uhav = slapy2_(&uhav, &uhavi);
uhbv = slapy2_(&uhbv, &uhbvi);
cond = slapy2_(&uhav, &uhbv);
s[ks] = cond / (rnrm * lnrm);
s[ks + 1] = s[ks];
} else {
/* Real eigenvalue. */
rnrm = snrm2_(n, &vr[ks * vr_dim1 + 1], &c__1);
lnrm = snrm2_(n, &vl[ks * vl_dim1 + 1], &c__1);
sgemv_("N", n, n, &c_b19, &a[a_offset], lda, &vr[ks * vr_dim1
+ 1], &c__1, &c_b21, &work[1], &c__1);
uhav = sdot_(n, &work[1], &c__1, &vl[ks * vl_dim1 + 1], &c__1)
;
sgemv_("N", n, n, &c_b19, &b[b_offset], ldb, &vr[ks * vr_dim1
+ 1], &c__1, &c_b21, &work[1], &c__1);
uhbv = sdot_(n, &work[1], &c__1, &vl[ks * vl_dim1 + 1], &c__1)
;
cond = slapy2_(&uhav, &uhbv);
if (cond == 0.f) {
s[ks] = -1.f;
} else {
s[ks] = cond / (rnrm * lnrm);
}
}
}
if (wantdf) {
if (*n == 1) {
dif[ks] = slapy2_(&a[a_dim1 + 1], &b[b_dim1 + 1]);
goto L20;
}
/* Estimate the reciprocal condition number of the k-th */
/* eigenvectors. */
if (pair) {
/* Copy the 2-by 2 pencil beginning at (A(k,k), B(k, k)). */
/* Compute the eigenvalue(s) at position K. */
work[1] = a[k + k * a_dim1];
work[2] = a[k + 1 + k * a_dim1];
work[3] = a[k + (k + 1) * a_dim1];
work[4] = a[k + 1 + (k + 1) * a_dim1];
work[5] = b[k + k * b_dim1];
work[6] = b[k + 1 + k * b_dim1];
work[7] = b[k + (k + 1) * b_dim1];
work[8] = b[k + 1 + (k + 1) * b_dim1];
r__1 = smlnum * eps;
slag2_(&work[1], &c__2, &work[5], &c__2, &r__1, &beta, dummy1,
&alphar, dummy, &alphai);
alprqt = 1.f;
c1 = (alphar * alphar + alphai * alphai + beta * beta) * 2.f;
c2 = beta * 4.f * beta * alphai * alphai;
root1 = c1 + sqrt(c1 * c1 - c2 * 4.f);
root2 = c2 / root1;
root1 /= 2.f;
/* Computing MIN */
r__1 = sqrt(root1), r__2 = sqrt(root2);
cond = dmin(r__1,r__2);
}
/* Copy the matrix (A, B) to the array WORK and swap the */
/* diagonal block beginning at A(k,k) to the (1,1) position. */
slacpy_("Full", n, n, &a[a_offset], lda, &work[1], n);
slacpy_("Full", n, n, &b[b_offset], ldb, &work[*n * *n + 1], n);
ifst = k;
ilst = 1;
i__2 = *lwork - (*n << 1) * *n;
stgexc_(&c_false, &c_false, n, &work[1], n, &work[*n * *n + 1], n,
dummy, &c__1, dummy1, &c__1, &ifst, &ilst, &work[(*n * *
n << 1) + 1], &i__2, &ierr);
if (ierr > 0) {
/* Ill-conditioned problem - swap rejected. */
dif[ks] = 0.f;
} else {
/* Reordering successful, solve generalized Sylvester */
/* equation for R and L, */
/* A22 * R - L * A11 = A12 */
/* B22 * R - L * B11 = B12, */
/* and compute estimate of Difl((A11,B11), (A22, B22)). */
n1 = 1;
if (work[2] != 0.f) {
n1 = 2;
}
n2 = *n - n1;
if (n2 == 0) {
dif[ks] = cond;
} else {
i__ = *n * *n + 1;
iz = (*n << 1) * *n + 1;
i__2 = *lwork - (*n << 1) * *n;
stgsyl_("N", &c__3, &n2, &n1, &work[*n * n1 + n1 + 1], n,
&work[1], n, &work[n1 + 1], n, &work[*n * n1 + n1
+ i__], n, &work[i__], n, &work[n1 + i__], n, &
scale, &dif[ks], &work[iz + 1], &i__2, &iwork[1],
&ierr);
if (pair) {
/* Computing MIN */
r__1 = dmax(1.f,alprqt) * dif[ks];
dif[ks] = dmin(r__1,cond);
}
}
}
if (pair) {
dif[ks + 1] = dif[ks];
}
}
if (pair) {
++ks;
}
L20:
;
}
work[1] = (real) lwmin;
return 0;
/* End of STGSNA */
} /* stgsna_ */
/* Subroutine */ int stgsen_(integer *ijob, logical *wantq, logical *wantz,
logical *select, integer *n, real *a, integer *lda, real *b, integer *
ldb, real *alphar, real *alphai, real *beta, real *q, integer *ldq,
real *z__, integer *ldz, integer *m, real *pl, real *pr, real *dif,
real *work, integer *lwork, integer *iwork, integer *liwork, integer *
info)
{
/* -- LAPACK routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
June 30, 1999
Purpose
=======
STGSEN reorders the generalized real Schur decomposition of a real
matrix pair (A, B) (in terms of an orthonormal equivalence trans-
formation Q' * (A, B) * Z), so that a selected cluster of eigenvalues
appears in the leading diagonal blocks of the upper quasi-triangular
matrix A and the upper triangular B. The leading columns of Q and
Z form orthonormal bases of the corresponding left and right eigen-
spaces (deflating subspaces). (A, B) must be in generalized real
Schur canonical form (as returned by SGGES), i.e. A is block upper
triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper
triangular.
STGSEN also computes the generalized eigenvalues
w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j)
of the reordered matrix pair (A, B).
Optionally, STGSEN computes the estimates of reciprocal condition
numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11),
(A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s)
between the matrix pairs (A11, B11) and (A22,B22) that correspond to
the selected cluster and the eigenvalues outside the cluster, resp.,
and norms of "projections" onto left and right eigenspaces w.r.t.
the selected cluster in the (1,1)-block.
Arguments
=========
IJOB (input) INTEGER
Specifies whether condition numbers are required for the
cluster of eigenvalues (PL and PR) or the deflating subspaces
(Difu and Difl):
=0: Only reorder w.r.t. SELECT. No extras.
=1: Reciprocal of norms of "projections" onto left and right
eigenspaces w.r.t. the selected cluster (PL and PR).
=2: Upper bounds on Difu and Difl. F-norm-based estimate
(DIF(1:2)).
=3: Estimate of Difu and Difl. 1-norm-based estimate
(DIF(1:2)).
About 5 times as expensive as IJOB = 2.
=4: Compute PL, PR and DIF (i.e. 0, 1 and 2 above): Economic
version to get it all.
=5: Compute PL, PR and DIF (i.e. 0, 1 and 3 above)
WANTQ (input) LOGICAL
.TRUE. : update the left transformation matrix Q;
.FALSE.: do not update Q.
WANTZ (input) LOGICAL
.TRUE. : update the right transformation matrix Z;
.FALSE.: do not update Z.
SELECT (input) LOGICAL array, dimension (N)
SELECT specifies the eigenvalues in the selected cluster.
To select a real eigenvalue w(j), SELECT(j) must be set to
.TRUE.. To select a complex conjugate pair of eigenvalues
w(j) and w(j+1), corresponding to a 2-by-2 diagonal block,
either SELECT(j) or SELECT(j+1) or both must be set to
.TRUE.; a complex conjugate pair of eigenvalues must be
either both included in the cluster or both excluded.
N (input) INTEGER
The order of the matrices A and B. N >= 0.
A (input/output) REAL array, dimension(LDA,N)
On entry, the upper quasi-triangular matrix A, with (A, B) in
generalized real Schur canonical form.
On exit, A is overwritten by the reordered matrix A.
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B (input/output) REAL array, dimension(LDB,N)
On entry, the upper triangular matrix B, with (A, B) in
generalized real Schur canonical form.
On exit, B is overwritten by the reordered matrix B.
LDB (input) INTEGER
The leading dimension of the array B. LDB >= max(1,N).
ALPHAR (output) REAL array, dimension (N)
ALPHAI (output) REAL array, dimension (N)
BETA (output) REAL array, dimension (N)
On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will
be the generalized eigenvalues. ALPHAR(j) + ALPHAI(j)*i
and BETA(j),j=1,...,N are the diagonals of the complex Schur
form (S,T) that would result if the 2-by-2 diagonal blocks of
the real generalized Schur form of (A,B) were further reduced
to triangular form using complex unitary transformations.
If ALPHAI(j) is zero, then the j-th eigenvalue is real; if
positive, then the j-th and (j+1)-st eigenvalues are a
complex conjugate pair, with ALPHAI(j+1) negative.
Q (input/output) REAL array, dimension (LDQ,N)
On entry, if WANTQ = .TRUE., Q is an N-by-N matrix.
On exit, Q has been postmultiplied by the left orthogonal
transformation matrix which reorder (A, B); The leading M
columns of Q form orthonormal bases for the specified pair of
left eigenspaces (deflating subspaces).
If WANTQ = .FALSE., Q is not referenced.
LDQ (input) INTEGER
The leading dimension of the array Q. LDQ >= 1;
and if WANTQ = .TRUE., LDQ >= N.
Z (input/output) REAL array, dimension (LDZ,N)
On entry, if WANTZ = .TRUE., Z is an N-by-N matrix.
On exit, Z has been postmultiplied by the left orthogonal
transformation matrix which reorder (A, B); The leading M
columns of Z form orthonormal bases for the specified pair of
left eigenspaces (deflating subspaces).
If WANTZ = .FALSE., Z is not referenced.
LDZ (input) INTEGER
The leading dimension of the array Z. LDZ >= 1;
If WANTZ = .TRUE., LDZ >= N.
M (output) INTEGER
The dimension of the specified pair of left and right eigen-
spaces (deflating subspaces). 0 <= M <= N.
PL, PR (output) REAL
If IJOB = 1, 4 or 5, PL, PR are lower bounds on the
reciprocal of the norm of "projections" onto left and right
eigenspaces with respect to the selected cluster.
0 < PL, PR <= 1.
If M = 0 or M = N, PL = PR = 1.
If IJOB = 0, 2 or 3, PL and PR are not referenced.
DIF (output) REAL array, dimension (2).
If IJOB >= 2, DIF(1:2) store the estimates of Difu and Difl.
If IJOB = 2 or 4, DIF(1:2) are F-norm-based upper bounds on
Difu and Difl. If IJOB = 3 or 5, DIF(1:2) are 1-norm-based
estimates of Difu and Difl.
If M = 0 or N, DIF(1:2) = F-norm([A, B]).
If IJOB = 0 or 1, DIF is not referenced.
WORK (workspace/output) REAL array, dimension (LWORK)
IF IJOB = 0, WORK is not referenced. Otherwise,
on exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK. LWORK >= 4*N+16.
If IJOB = 1, 2 or 4, LWORK >= MAX(4*N+16, 2*M*(N-M)).
If IJOB = 3 or 5, LWORK >= MAX(4*N+16, 4*M*(N-M)).
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
IWORK (workspace/output) INTEGER array, dimension (LIWORK)
IF IJOB = 0, IWORK is not referenced. Otherwise,
on exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
LIWORK (input) INTEGER
The dimension of the array IWORK. LIWORK >= 1.
If IJOB = 1, 2 or 4, LIWORK >= N+6.
If IJOB = 3 or 5, LIWORK >= MAX(2*M*(N-M), N+6).
If LIWORK = -1, then a workspace query is assumed; the
routine only calculates the optimal size of the IWORK array,
returns this value as the first entry of the IWORK array, and
no error message related to LIWORK is issued by XERBLA.
INFO (output) INTEGER
=0: Successful exit.
<0: If INFO = -i, the i-th argument had an illegal value.
=1: Reordering of (A, B) failed because the transformed
matrix pair (A, B) would be too far from generalized
Schur form; the problem is very ill-conditioned.
(A, B) may have been partially reordered.
If requested, 0 is returned in DIF(*), PL and PR.
Further Details
===============
STGSEN first collects the selected eigenvalues by computing
orthogonal U and W that move them to the top left corner of (A, B).
In other words, the selected eigenvalues are the eigenvalues of
(A11, B11) in:
U'*(A, B)*W = (A11 A12) (B11 B12) n1
( 0 A22),( 0 B22) n2
n1 n2 n1 n2
where N = n1+n2 and U' means the transpose of U. The first n1 columns
of U and W span the specified pair of left and right eigenspaces
(deflating subspaces) of (A, B).
If (A, B) has been obtained from the generalized real Schur
decomposition of a matrix pair (C, D) = Q*(A, B)*Z', then the
reordered generalized real Schur form of (C, D) is given by
(C, D) = (Q*U)*(U'*(A, B)*W)*(Z*W)',
and the first n1 columns of Q*U and Z*W span the corresponding
deflating subspaces of (C, D) (Q and Z store Q*U and Z*W, resp.).
Note that if the selected eigenvalue is sufficiently ill-conditioned,
then its value may differ significantly from its value before
reordering.
The reciprocal condition numbers of the left and right eigenspaces
spanned by the first n1 columns of U and W (or Q*U and Z*W) may
be returned in DIF(1:2), corresponding to Difu and Difl, resp.
The Difu and Difl are defined as:
Difu[(A11, B11), (A22, B22)] = sigma-min( Zu )
and
Difl[(A11, B11), (A22, B22)] = Difu[(A22, B22), (A11, B11)],
where sigma-min(Zu) is the smallest singular value of the
(2*n1*n2)-by-(2*n1*n2) matrix
Zu = [ kron(In2, A11) -kron(A22', In1) ]
[ kron(In2, B11) -kron(B22', In1) ].
Here, Inx is the identity matrix of size nx and A22' is the
transpose of A22. kron(X, Y) is the Kronecker product between
the matrices X and Y.
When DIF(2) is small, small changes in (A, B) can cause large changes
in the deflating subspace. An approximate (asymptotic) bound on the
maximum angular error in the computed deflating subspaces is
EPS * norm((A, B)) / DIF(2),
where EPS is the machine precision.
The reciprocal norm of the projectors on the left and right
eigenspaces associated with (A11, B11) may be returned in PL and PR.
They are computed as follows. First we compute L and R so that
P*(A, B)*Q is block diagonal, where
P = ( I -L ) n1 Q = ( I R ) n1
( 0 I ) n2 and ( 0 I ) n2
n1 n2 n1 n2
and (L, R) is the solution to the generalized Sylvester equation
A11*R - L*A22 = -A12
B11*R - L*B22 = -B12
Then PL = (F-norm(L)**2+1)**(-1/2) and PR = (F-norm(R)**2+1)**(-1/2).
An approximate (asymptotic) bound on the average absolute error of
the selected eigenvalues is
EPS * norm((A, B)) / PL.
There are also global error bounds which valid for perturbations up
to a certain restriction: A lower bound (x) on the smallest
F-norm(E,F) for which an eigenvalue of (A11, B11) may move and
coalesce with an eigenvalue of (A22, B22) under perturbation (E,F),
(i.e. (A + E, B + F), is
x = min(Difu,Difl)/((1/(PL*PL)+1/(PR*PR))**(1/2)+2*max(1/PL,1/PR)).
An approximate bound on x can be computed from DIF(1:2), PL and PR.
If y = ( F-norm(E,F) / x) <= 1, the angles between the perturbed
(L', R') and unperturbed (L, R) left and right deflating subspaces
associated with the selected cluster in the (1,1)-blocks can be
bounded as
max-angle(L, L') <= arctan( y * PL / (1 - y * (1 - PL * PL)**(1/2))
max-angle(R, R') <= arctan( y * PR / (1 - y * (1 - PR * PR)**(1/2))
See LAPACK User's Guide section 4.11 or the following references
for more information.
Note that if the default method for computing the Frobenius-norm-
based estimate DIF is not wanted (see SLATDF), then the parameter
IDIFJB (see below) should be changed from 3 to 4 (routine SLATDF
(IJOB = 2 will be used)). See STGSYL for more details.
Based on contributions by
Bo Kagstrom and Peter Poromaa, Department of Computing Science,
Umea University, S-901 87 Umea, Sweden.
References
==========
[1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the
Generalized Real Schur Form of a Regular Matrix Pair (A, B), in
M.S. Moonen et al (eds), Linear Algebra for Large Scale and
Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218.
[2] B. Kagstrom and P. Poromaa; Computing Eigenspaces with Specified
Eigenvalues of a Regular Matrix Pair (A, B) and Condition
Estimation: Theory, Algorithms and Software,
Report UMINF - 94.04, Department of Computing Science, Umea
University, S-901 87 Umea, Sweden, 1994. Also as LAPACK Working
Note 87. To appear in Numerical Algorithms, 1996.
[3] B. Kagstrom and P. Poromaa, LAPACK-Style Algorithms and Software
for Solving the Generalized Sylvester Equation and Estimating the
Separation between Regular Matrix Pairs, Report UMINF - 93.23,
Department of Computing Science, Umea University, S-901 87 Umea,
Sweden, December 1993, Revised April 1994, Also as LAPACK Working
Note 75. To appear in ACM Trans. on Math. Software, Vol 22, No 1,
1996.
=====================================================================
Decode and test the input parameters
Parameter adjustments */
/* Table of constant values */
static integer c__1 = 1;
static integer c__2 = 2;
static real c_b28 = 1.f;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, q_dim1, q_offset, z_dim1,
z_offset, i__1, i__2;
real r__1;
/* Builtin functions */
double sqrt(doublereal), r_sign(real *, real *);
/* Local variables */
static integer kase;
static logical pair;
static integer ierr;
static real dsum;
static logical swap;
extern /* Subroutine */ int slag2_(real *, integer *, real *, integer *,
real *, real *, real *, real *, real *, real *);
static integer i__, k;
static logical wantd;
static integer lwmin;
static logical wantp;
static integer n1, n2;
static logical wantd1, wantd2;
static integer kk;
static real dscale;
static integer ks;
static real rdscal;
extern doublereal slamch_(char *);
extern /* Subroutine */ int xerbla_(char *, integer *), slacon_(
integer *, real *, real *, integer *, real *, integer *), slacpy_(
char *, integer *, integer *, real *, integer *, real *, integer *
), stgexc_(logical *, logical *, integer *, real *,
integer *, real *, integer *, real *, integer *, real *, integer *
, integer *, integer *, real *, integer *, integer *);
static integer liwmin;
extern /* Subroutine */ int slassq_(integer *, real *, integer *, real *,
real *);
static real smlnum;
static integer mn2;
static logical lquery;
extern /* Subroutine */ int stgsyl_(char *, integer *, integer *, integer
*, real *, integer *, real *, integer *, real *, integer *, real *
, integer *, real *, integer *, real *, integer *, real *, real *,
real *, integer *, integer *, integer *);
static integer ijb;
static real eps;
#define a_ref(a_1,a_2) a[(a_2)*a_dim1 + a_1]
#define b_ref(a_1,a_2) b[(a_2)*b_dim1 + a_1]
#define q_ref(a_1,a_2) q[(a_2)*q_dim1 + a_1]
--select;
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--alphar;
--alphai;
--beta;
q_dim1 = *ldq;
q_offset = 1 + q_dim1 * 1;
q -= q_offset;
z_dim1 = *ldz;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
--dif;
--work;
--iwork;
/* Function Body */
*info = 0;
lquery = *lwork == -1 || *liwork == -1;
if (*ijob < 0 || *ijob > 5) {
*info = -1;
} else if (*n < 0) {
*info = -5;
} else if (*lda < max(1,*n)) {
*info = -7;
} else if (*ldb < max(1,*n)) {
*info = -9;
} else if (*ldq < 1 || *wantq && *ldq < *n) {
*info = -14;
} else if (*ldz < 1 || *wantz && *ldz < *n) {
*info = -16;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("STGSEN", &i__1);
return 0;
}
/* Get machine constants */
eps = slamch_("P");
smlnum = slamch_("S") / eps;
ierr = 0;
wantp = *ijob == 1 || *ijob >= 4;
wantd1 = *ijob == 2 || *ijob == 4;
wantd2 = *ijob == 3 || *ijob == 5;
wantd = wantd1 || wantd2;
/* Set M to the dimension of the specified pair of deflating
subspaces. */
*m = 0;
pair = FALSE_;
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
if (pair) {
pair = FALSE_;
} else {
if (k < *n) {
if (a_ref(k + 1, k) == 0.f) {
if (select[k]) {
++(*m);
}
} else {
pair = TRUE_;
if (select[k] || select[k + 1]) {
*m += 2;
}
}
} else {
if (select[*n]) {
++(*m);
}
}
}
/* L10: */
}
if (*ijob == 1 || *ijob == 2 || *ijob == 4) {
/* Computing MAX */
i__1 = 1, i__2 = (*n << 2) + 16, i__1 = max(i__1,i__2), i__2 = (*m <<
1) * (*n - *m);
lwmin = max(i__1,i__2);
/* Computing MAX */
i__1 = 1, i__2 = *n + 6;
liwmin = max(i__1,i__2);
} else if (*ijob == 3 || *ijob == 5) {
/* Computing MAX */
i__1 = 1, i__2 = (*n << 2) + 16, i__1 = max(i__1,i__2), i__2 = (*m <<
2) * (*n - *m);
lwmin = max(i__1,i__2);
/* Computing MAX */
i__1 = 1, i__2 = (*m << 1) * (*n - *m), i__1 = max(i__1,i__2), i__2 =
*n + 6;
liwmin = max(i__1,i__2);
} else {
/* Computing MAX */
i__1 = 1, i__2 = (*n << 2) + 16;
lwmin = max(i__1,i__2);
liwmin = 1;
}
work[1] = (real) lwmin;
iwork[1] = liwmin;
if (*lwork < lwmin && ! lquery) {
*info = -22;
} else if (*liwork < liwmin && ! lquery) {
*info = -24;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("STGSEN", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible. */
if (*m == *n || *m == 0) {
if (wantp) {
*pl = 1.f;
*pr = 1.f;
}
if (wantd) {
dscale = 0.f;
dsum = 1.f;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
slassq_(n, &a_ref(1, i__), &c__1, &dscale, &dsum);
slassq_(n, &b_ref(1, i__), &c__1, &dscale, &dsum);
/* L20: */
}
dif[1] = dscale * sqrt(dsum);
dif[2] = dif[1];
}
goto L60;
}
/* Collect the selected blocks at the top-left corner of (A, B). */
ks = 0;
pair = FALSE_;
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
if (pair) {
pair = FALSE_;
} else {
swap = select[k];
if (k < *n) {
if (a_ref(k + 1, k) != 0.f) {
pair = TRUE_;
swap = swap || select[k + 1];
}
}
if (swap) {
++ks;
/* Swap the K-th block to position KS.
Perform the reordering of diagonal blocks in (A, B)
by orthogonal transformation matrices and update
Q and Z accordingly (if requested): */
kk = k;
if (k != ks) {
stgexc_(wantq, wantz, n, &a[a_offset], lda, &b[b_offset],
ldb, &q[q_offset], ldq, &z__[z_offset], ldz, &kk,
&ks, &work[1], lwork, &ierr);
}
if (ierr > 0) {
/* Swap is rejected: exit. */
*info = 1;
if (wantp) {
*pl = 0.f;
*pr = 0.f;
}
if (wantd) {
dif[1] = 0.f;
dif[2] = 0.f;
}
goto L60;
}
if (pair) {
++ks;
}
}
}
/* L30: */
}
if (wantp) {
/* Solve generalized Sylvester equation for R and L
and compute PL and PR. */
n1 = *m;
n2 = *n - *m;
i__ = n1 + 1;
ijb = 0;
slacpy_("Full", &n1, &n2, &a_ref(1, i__), lda, &work[1], &n1);
slacpy_("Full", &n1, &n2, &b_ref(1, i__), ldb, &work[n1 * n2 + 1], &
n1);
i__1 = *lwork - (n1 << 1) * n2;
stgsyl_("N", &ijb, &n1, &n2, &a[a_offset], lda, &a_ref(i__, i__), lda,
&work[1], &n1, &b[b_offset], ldb, &b_ref(i__, i__), ldb, &
work[n1 * n2 + 1], &n1, &dscale, &dif[1], &work[(n1 * n2 << 1)
+ 1], &i__1, &iwork[1], &ierr);
/* Estimate the reciprocal of norms of "projections" onto left
and right eigenspaces. */
rdscal = 0.f;
dsum = 1.f;
i__1 = n1 * n2;
slassq_(&i__1, &work[1], &c__1, &rdscal, &dsum);
*pl = rdscal * sqrt(dsum);
if (*pl == 0.f) {
*pl = 1.f;
} else {
*pl = dscale / (sqrt(dscale * dscale / *pl + *pl) * sqrt(*pl));
}
rdscal = 0.f;
dsum = 1.f;
i__1 = n1 * n2;
slassq_(&i__1, &work[n1 * n2 + 1], &c__1, &rdscal, &dsum);
*pr = rdscal * sqrt(dsum);
if (*pr == 0.f) {
*pr = 1.f;
} else {
*pr = dscale / (sqrt(dscale * dscale / *pr + *pr) * sqrt(*pr));
}
}
if (wantd) {
/* Compute estimates of Difu and Difl. */
if (wantd1) {
n1 = *m;
n2 = *n - *m;
i__ = n1 + 1;
ijb = 3;
/* Frobenius norm-based Difu-estimate. */
i__1 = *lwork - (n1 << 1) * n2;
stgsyl_("N", &ijb, &n1, &n2, &a[a_offset], lda, &a_ref(i__, i__),
lda, &work[1], &n1, &b[b_offset], ldb, &b_ref(i__, i__),
ldb, &work[n1 * n2 + 1], &n1, &dscale, &dif[1], &work[(n1
<< 1) * n2 + 1], &i__1, &iwork[1], &ierr);
/* Frobenius norm-based Difl-estimate. */
i__1 = *lwork - (n1 << 1) * n2;
stgsyl_("N", &ijb, &n2, &n1, &a_ref(i__, i__), lda, &a[a_offset],
lda, &work[1], &n2, &b_ref(i__, i__), ldb, &b[b_offset],
ldb, &work[n1 * n2 + 1], &n2, &dscale, &dif[2], &work[(n1
<< 1) * n2 + 1], &i__1, &iwork[1], &ierr);
} else {
/* Compute 1-norm-based estimates of Difu and Difl using
reversed communication with SLACON. In each step a
generalized Sylvester equation or a transposed variant
is solved. */
kase = 0;
n1 = *m;
n2 = *n - *m;
i__ = n1 + 1;
ijb = 0;
mn2 = (n1 << 1) * n2;
/* 1-norm-based estimate of Difu. */
L40:
slacon_(&mn2, &work[mn2 + 1], &work[1], &iwork[1], &dif[1], &kase)
;
if (kase != 0) {
if (kase == 1) {
/* Solve generalized Sylvester equation. */
i__1 = *lwork - (n1 << 1) * n2;
stgsyl_("N", &ijb, &n1, &n2, &a[a_offset], lda, &a_ref(
i__, i__), lda, &work[1], &n1, &b[b_offset], ldb,
&b_ref(i__, i__), ldb, &work[n1 * n2 + 1], &n1, &
dscale, &dif[1], &work[(n1 << 1) * n2 + 1], &i__1,
&iwork[1], &ierr);
} else {
/* Solve the transposed variant. */
i__1 = *lwork - (n1 << 1) * n2;
stgsyl_("T", &ijb, &n1, &n2, &a[a_offset], lda, &a_ref(
i__, i__), lda, &work[1], &n1, &b[b_offset], ldb,
&b_ref(i__, i__), ldb, &work[n1 * n2 + 1], &n1, &
dscale, &dif[1], &work[(n1 << 1) * n2 + 1], &i__1,
&iwork[1], &ierr);
}
goto L40;
}
dif[1] = dscale / dif[1];
/* 1-norm-based estimate of Difl. */
L50:
slacon_(&mn2, &work[mn2 + 1], &work[1], &iwork[1], &dif[2], &kase)
;
if (kase != 0) {
if (kase == 1) {
/* Solve generalized Sylvester equation. */
i__1 = *lwork - (n1 << 1) * n2;
stgsyl_("N", &ijb, &n2, &n1, &a_ref(i__, i__), lda, &a[
a_offset], lda, &work[1], &n2, &b_ref(i__, i__),
ldb, &b[b_offset], ldb, &work[n1 * n2 + 1], &n2, &
dscale, &dif[2], &work[(n1 << 1) * n2 + 1], &i__1,
&iwork[1], &ierr);
} else {
/* Solve the transposed variant. */
i__1 = *lwork - (n1 << 1) * n2;
stgsyl_("T", &ijb, &n2, &n1, &a_ref(i__, i__), lda, &a[
a_offset], lda, &work[1], &n2, &b_ref(i__, i__),
ldb, &b[b_offset], ldb, &work[n1 * n2 + 1], &n2, &
dscale, &dif[2], &work[(n1 << 1) * n2 + 1], &i__1,
&iwork[1], &ierr);
}
goto L50;
}
dif[2] = dscale / dif[2];
}
}
L60:
/* Compute generalized eigenvalues of reordered pair (A, B) and
normalize the generalized Schur form. */
pair = FALSE_;
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
if (pair) {
pair = FALSE_;
} else {
if (k < *n) {
if (a_ref(k + 1, k) != 0.f) {
pair = TRUE_;
}
}
if (pair) {
/* Compute the eigenvalue(s) at position K. */
work[1] = a_ref(k, k);
work[2] = a_ref(k + 1, k);
work[3] = a_ref(k, k + 1);
work[4] = a_ref(k + 1, k + 1);
work[5] = b_ref(k, k);
work[6] = b_ref(k + 1, k);
work[7] = b_ref(k, k + 1);
work[8] = b_ref(k + 1, k + 1);
r__1 = smlnum * eps;
slag2_(&work[1], &c__2, &work[5], &c__2, &r__1, &beta[k], &
beta[k + 1], &alphar[k], &alphar[k + 1], &alphai[k]);
alphai[k + 1] = -alphai[k];
} else {
if (r_sign(&c_b28, &b_ref(k, k)) < 0.f) {
/* If B(K,K) is negative, make it positive */
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
a_ref(k, i__) = -a_ref(k, i__);
b_ref(k, i__) = -b_ref(k, i__);
q_ref(i__, k) = -q_ref(i__, k);
/* L80: */
}
}
alphar[k] = a_ref(k, k);
alphai[k] = 0.f;
beta[k] = b_ref(k, k);
}
}
/* L70: */
}
work[1] = (real) lwmin;
iwork[1] = liwmin;
return 0;
/* End of STGSEN */
} /* stgsen_ */
/* Subroutine */ int slagv2_(real *a, integer *lda, real *b, integer *ldb,
real *alphar, real *alphai, real *beta, real *csl, real *snl, real *
csr, real *snr)
{
/* -- LAPACK auxiliary routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
June 30, 1999
Purpose
=======
SLAGV2 computes the Generalized Schur factorization of a real 2-by-2
matrix pencil (A,B) where B is upper triangular. This routine
computes orthogonal (rotation) matrices given by CSL, SNL and CSR,
SNR such that
1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0
types), then
[ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ]
[ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ]
[ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ]
[ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ],
2) if the pencil (A,B) has a pair of complex conjugate eigenvalues,
then
[ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ]
[ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ]
[ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ]
[ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ]
where b11 >= b22 > 0.
Arguments
=========
A (input/output) REAL array, dimension (LDA, 2)
On entry, the 2 x 2 matrix A.
On exit, A is overwritten by the ``A-part'' of the
generalized Schur form.
LDA (input) INTEGER
THe leading dimension of the array A. LDA >= 2.
B (input/output) REAL array, dimension (LDB, 2)
On entry, the upper triangular 2 x 2 matrix B.
On exit, B is overwritten by the ``B-part'' of the
generalized Schur form.
LDB (input) INTEGER
THe leading dimension of the array B. LDB >= 2.
ALPHAR (output) REAL array, dimension (2)
ALPHAI (output) REAL array, dimension (2)
BETA (output) REAL array, dimension (2)
(ALPHAR(k)+i*ALPHAI(k))/BETA(k) are the eigenvalues of the
pencil (A,B), k=1,2, i = sqrt(-1). Note that BETA(k) may
be zero.
CSL (output) REAL
The cosine of the left rotation matrix.
SNL (output) REAL
The sine of the left rotation matrix.
CSR (output) REAL
The cosine of the right rotation matrix.
SNR (output) REAL
The sine of the right rotation matrix.
Further Details
===============
Based on contributions by
Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA
=====================================================================
Parameter adjustments */
/* Table of constant values */
static integer c__2 = 2;
static integer c__1 = 1;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset;
real r__1, r__2, r__3, r__4, r__5, r__6;
/* Local variables */
extern /* Subroutine */ int srot_(integer *, real *, integer *, real *,
integer *, real *, real *), slag2_(real *, integer *, real *,
integer *, real *, real *, real *, real *, real *, real *);
static real r__, t, anorm, bnorm, h1, h2, h3, scale1, scale2;
extern /* Subroutine */ int slasv2_(real *, real *, real *, real *, real *
, real *, real *, real *, real *);
extern doublereal slapy2_(real *, real *);
static real ascale, bscale, wi, qq, rr;
extern doublereal slamch_(char *);
static real safmin;
extern /* Subroutine */ int slartg_(real *, real *, real *, real *, real *
);
static real wr1, wr2, ulp;
#define a_ref(a_1,a_2) a[(a_2)*a_dim1 + a_1]
#define b_ref(a_1,a_2) b[(a_2)*b_dim1 + a_1]
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--alphar;
--alphai;
--beta;
/* Function Body */
safmin = slamch_("S");
ulp = slamch_("P");
/* Scale A
Computing MAX */
r__5 = (r__1 = a_ref(1, 1), dabs(r__1)) + (r__2 = a_ref(2, 1), dabs(r__2))
, r__6 = (r__3 = a_ref(1, 2), dabs(r__3)) + (r__4 = a_ref(2, 2),
dabs(r__4)), r__5 = max(r__5,r__6);
anorm = dmax(r__5,safmin);
ascale = 1.f / anorm;
a_ref(1, 1) = ascale * a_ref(1, 1);
a_ref(1, 2) = ascale * a_ref(1, 2);
a_ref(2, 1) = ascale * a_ref(2, 1);
a_ref(2, 2) = ascale * a_ref(2, 2);
/* Scale B
Computing MAX */
r__4 = (r__3 = b_ref(1, 1), dabs(r__3)), r__5 = (r__1 = b_ref(1, 2), dabs(
r__1)) + (r__2 = b_ref(2, 2), dabs(r__2)), r__4 = max(r__4,r__5);
bnorm = dmax(r__4,safmin);
bscale = 1.f / bnorm;
b_ref(1, 1) = bscale * b_ref(1, 1);
b_ref(1, 2) = bscale * b_ref(1, 2);
b_ref(2, 2) = bscale * b_ref(2, 2);
/* Check if A can be deflated */
if ((r__1 = a_ref(2, 1), dabs(r__1)) <= ulp) {
*csl = 1.f;
*snl = 0.f;
*csr = 1.f;
*snr = 0.f;
a_ref(2, 1) = 0.f;
b_ref(2, 1) = 0.f;
/* Check if B is singular */
} else if ((r__1 = b_ref(1, 1), dabs(r__1)) <= ulp) {
slartg_(&a_ref(1, 1), &a_ref(2, 1), csl, snl, &r__);
*csr = 1.f;
*snr = 0.f;
srot_(&c__2, &a_ref(1, 1), lda, &a_ref(2, 1), lda, csl, snl);
srot_(&c__2, &b_ref(1, 1), ldb, &b_ref(2, 1), ldb, csl, snl);
a_ref(2, 1) = 0.f;
b_ref(1, 1) = 0.f;
b_ref(2, 1) = 0.f;
} else if ((r__1 = b_ref(2, 2), dabs(r__1)) <= ulp) {
slartg_(&a_ref(2, 2), &a_ref(2, 1), csr, snr, &t);
*snr = -(*snr);
srot_(&c__2, &a_ref(1, 1), &c__1, &a_ref(1, 2), &c__1, csr, snr);
srot_(&c__2, &b_ref(1, 1), &c__1, &b_ref(1, 2), &c__1, csr, snr);
*csl = 1.f;
*snl = 0.f;
a_ref(2, 1) = 0.f;
b_ref(2, 1) = 0.f;
b_ref(2, 2) = 0.f;
} else {
/* B is nonsingular, first compute the eigenvalues of (A,B) */
slag2_(&a[a_offset], lda, &b[b_offset], ldb, &safmin, &scale1, &
scale2, &wr1, &wr2, &wi);
if (wi == 0.f) {
/* two real eigenvalues, compute s*A-w*B */
h1 = scale1 * a_ref(1, 1) - wr1 * b_ref(1, 1);
h2 = scale1 * a_ref(1, 2) - wr1 * b_ref(1, 2);
h3 = scale1 * a_ref(2, 2) - wr1 * b_ref(2, 2);
rr = slapy2_(&h1, &h2);
r__1 = scale1 * a_ref(2, 1);
qq = slapy2_(&r__1, &h3);
if (rr > qq) {
/* find right rotation matrix to zero 1,1 element of
(sA - wB) */
slartg_(&h2, &h1, csr, snr, &t);
} else {
/* find right rotation matrix to zero 2,1 element of
(sA - wB) */
r__1 = scale1 * a_ref(2, 1);
slartg_(&h3, &r__1, csr, snr, &t);
}
*snr = -(*snr);
srot_(&c__2, &a_ref(1, 1), &c__1, &a_ref(1, 2), &c__1, csr, snr);
srot_(&c__2, &b_ref(1, 1), &c__1, &b_ref(1, 2), &c__1, csr, snr);
/* compute inf norms of A and B
Computing MAX */
r__5 = (r__1 = a_ref(1, 1), dabs(r__1)) + (r__2 = a_ref(1, 2),
dabs(r__2)), r__6 = (r__3 = a_ref(2, 1), dabs(r__3)) + (
r__4 = a_ref(2, 2), dabs(r__4));
h1 = dmax(r__5,r__6);
/* Computing MAX */
r__5 = (r__1 = b_ref(1, 1), dabs(r__1)) + (r__2 = b_ref(1, 2),
dabs(r__2)), r__6 = (r__3 = b_ref(2, 1), dabs(r__3)) + (
r__4 = b_ref(2, 2), dabs(r__4));
h2 = dmax(r__5,r__6);
if (scale1 * h1 >= dabs(wr1) * h2) {
/* find left rotation matrix Q to zero out B(2,1) */
slartg_(&b_ref(1, 1), &b_ref(2, 1), csl, snl, &r__);
} else {
/* find left rotation matrix Q to zero out A(2,1) */
slartg_(&a_ref(1, 1), &a_ref(2, 1), csl, snl, &r__);
}
srot_(&c__2, &a_ref(1, 1), lda, &a_ref(2, 1), lda, csl, snl);
srot_(&c__2, &b_ref(1, 1), ldb, &b_ref(2, 1), ldb, csl, snl);
a_ref(2, 1) = 0.f;
b_ref(2, 1) = 0.f;
} else {
/* a pair of complex conjugate eigenvalues
first compute the SVD of the matrix B */
slasv2_(&b_ref(1, 1), &b_ref(1, 2), &b_ref(2, 2), &r__, &t, snr,
csr, snl, csl);
/* Form (A,B) := Q(A,B)Z' where Q is left rotation matrix and
Z is right rotation matrix computed from SLASV2 */
srot_(&c__2, &a_ref(1, 1), lda, &a_ref(2, 1), lda, csl, snl);
srot_(&c__2, &b_ref(1, 1), ldb, &b_ref(2, 1), ldb, csl, snl);
srot_(&c__2, &a_ref(1, 1), &c__1, &a_ref(1, 2), &c__1, csr, snr);
srot_(&c__2, &b_ref(1, 1), &c__1, &b_ref(1, 2), &c__1, csr, snr);
b_ref(2, 1) = 0.f;
b_ref(1, 2) = 0.f;
}
}
/* Unscaling */
a_ref(1, 1) = anorm * a_ref(1, 1);
a_ref(2, 1) = anorm * a_ref(2, 1);
a_ref(1, 2) = anorm * a_ref(1, 2);
a_ref(2, 2) = anorm * a_ref(2, 2);
b_ref(1, 1) = bnorm * b_ref(1, 1);
b_ref(2, 1) = bnorm * b_ref(2, 1);
b_ref(1, 2) = bnorm * b_ref(1, 2);
b_ref(2, 2) = bnorm * b_ref(2, 2);
if (wi == 0.f) {
alphar[1] = a_ref(1, 1);
alphar[2] = a_ref(2, 2);
alphai[1] = 0.f;
alphai[2] = 0.f;
beta[1] = b_ref(1, 1);
beta[2] = b_ref(2, 2);
} else {
alphar[1] = anorm * wr1 / scale1 / bnorm;
alphai[1] = anorm * wi / scale1 / bnorm;
alphar[2] = alphar[1];
alphai[2] = -alphai[1];
beta[1] = 1.f;
beta[2] = 1.f;
}
/* L10: */
return 0;
/* End of SLAGV2 */
} /* slagv2_ */
/* Subroutine */ int stgevc_(char *side, char *howmny, logical *select,
integer *n, real *s, integer *lds, real *p, integer *ldp, real *vl,
integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, real
*work, integer *info)
{
/* System generated locals */
integer p_dim1, p_offset, s_dim1, s_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2, i__3, i__4, i__5;
real r__1, r__2, r__3, r__4, r__5, r__6;
/* Local variables */
integer i__, j, ja, jc, je, na, im, jr, jw, nw;
real big;
logical lsa, lsb;
real ulp, sum[4] /* was [2][2] */;
integer ibeg, ieig, iend;
real dmin__, temp, xmax, sump[4] /* was [2][2] */, sums[4] /*
was [2][2] */, cim2a, cim2b, cre2a, cre2b;
real temp2, bdiag[2], acoef, scale;
logical ilall;
integer iside;
real sbeta;
logical il2by2;
integer iinfo;
real small;
logical compl;
real anorm, bnorm;
logical compr;
real temp2i, temp2r;
logical ilabad, ilbbad;
real acoefa, bcoefa, cimaga, cimagb;
logical ilback;
real bcoefi, ascale, bscale, creala, crealb, bcoefr;
real salfar, safmin;
real xscale, bignum;
logical ilcomp, ilcplx;
integer ihwmny;
/* -- LAPACK routine (version 3.2) -- */
/* November 2006 */
/* Purpose */
/* ======= */
/* STGEVC computes some or all of the right and/or left eigenvectors of */
/* a pair of real matrices (S,P), where S is a quasi-triangular matrix */
/* and P is upper triangular. Matrix pairs of this type are produced by */
/* the generalized Schur factorization of a matrix pair (A,B): */
/* A = Q*S*Z**T, B = Q*P*Z**T */
/* as computed by SGGHRD + SHGEQZ. */
/* The right eigenvector x and the left eigenvector y of (S,P) */
/* corresponding to an eigenvalue w are defined by: */
/* S*x = w*P*x, (y**H)*S = w*(y**H)*P, */
/* where y**H denotes the conjugate tranpose of y. */
/* The eigenvalues are not input to this routine, but are computed */
/* directly from the diagonal blocks of S and P. */
/* This routine returns the matrices X and/or Y of right and left */
/* eigenvectors of (S,P), or the products Z*X and/or Q*Y, */
/* where Z and Q are input matrices. */
/* If Q and Z are the orthogonal factors from the generalized Schur */
/* factorization of a matrix pair (A,B), then Z*X and Q*Y */
/* are the matrices of right and left eigenvectors of (A,B). */
/* Arguments */
/* ========= */
/* SIDE (input) CHARACTER*1 */
/* = 'R': compute right eigenvectors only; */
/* = 'L': compute left eigenvectors only; */
/* = 'B': compute both right and left eigenvectors. */
/* HOWMNY (input) CHARACTER*1 */
/* = 'A': compute all right and/or left eigenvectors; */
/* = 'B': compute all right and/or left eigenvectors, */
/* backtransformed by the matrices in VR and/or VL; */
/* = 'S': compute selected right and/or left eigenvectors, */
/* specified by the logical array SELECT. */
/* SELECT (input) LOGICAL array, dimension (N) */
/* If HOWMNY='S', SELECT specifies the eigenvectors to be */
/* computed. If w(j) is a real eigenvalue, the corresponding */
/* If w(j) and w(j+1) are the real and imaginary parts of a */
/* complex eigenvalue, the corresponding complex eigenvector */
/* is computed if either SELECT(j) or SELECT(j+1) is .TRUE., */
/* and on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is */
/* Not referenced if HOWMNY = 'A' or 'B'. */
/* N (input) INTEGER */
/* The order of the matrices S and P. N >= 0. */
/* S (input) REAL array, dimension (LDS,N) */
/* The upper quasi-triangular matrix S from a generalized Schur */
/* factorization, as computed by SHGEQZ. */
/* LDS (input) INTEGER */
/* The leading dimension of array S. LDS >= max(1,N). */
/* P (input) REAL array, dimension (LDP,N) */
/* The upper triangular matrix P from a generalized Schur */
/* factorization, as computed by SHGEQZ. */
/* 2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks */
/* of S must be in positive diagonal form. */
/* LDP (input) INTEGER */
/* The leading dimension of array P. LDP >= max(1,N). */
/* VL (input/output) REAL array, dimension (LDVL,MM) */
/* On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must */
/* contain an N-by-N matrix Q (usually the orthogonal matrix Q */
/* of left Schur vectors returned by SHGEQZ). */
/* On exit, if SIDE = 'L' or 'B', VL contains: */
/* if HOWMNY = 'A', the matrix Y of left eigenvectors of (S,P); */
/* if HOWMNY = 'B', the matrix Q*Y; */
/* if HOWMNY = 'S', the left eigenvectors of (S,P) specified by */
/* SELECT, stored consecutively in the columns of */
/* VL, in the same order as their eigenvalues. */
/* A complex eigenvector corresponding to a complex eigenvalue */
/* is stored in two consecutive columns, the first holding the */
/* real part, and the second the imaginary part. */
/* Not referenced if SIDE = 'R'. */
/* LDVL (input) INTEGER */
/* The leading dimension of array VL. LDVL >= 1, and if */
/* SIDE = 'L' or 'B', LDVL >= N. */
/* VR (input/output) REAL array, dimension (LDVR,MM) */
/* On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must */
/* contain an N-by-N matrix Z (usually the orthogonal matrix Z */
/* of right Schur vectors returned by SHGEQZ). */
/* On exit, if SIDE = 'R' or 'B', VR contains: */
/* if HOWMNY = 'A', the matrix X of right eigenvectors of (S,P); */
/* if HOWMNY = 'B' or 'b', the matrix Z*X; */
/* if HOWMNY = 'S' or 's', the right eigenvectors of (S,P) */
/* specified by SELECT, stored consecutively in the */
/* columns of VR, in the same order as their */
/* eigenvalues. */
/* A complex eigenvector corresponding to a complex eigenvalue */
/* is stored in two consecutive columns, the first holding the */
/* real part and the second the imaginary part. */
/* Not referenced if SIDE = 'L'. */
/* LDVR (input) INTEGER */
/* The leading dimension of the array VR. LDVR >= 1, and if */
/* SIDE = 'R' or 'B', LDVR >= N. */
/* MM (input) INTEGER */
/* The number of columns in the arrays VL and/or VR. MM >= M. */
/* M (output) INTEGER */
/* The number of columns in the arrays VL and/or VR actually */
/* used to store the eigenvectors. If HOWMNY = 'A' or 'B', M */
/* is set to N. Each selected real eigenvector occupies one */
/* column and each selected complex eigenvector occupies two */
/* columns. */
/* WORK (workspace) REAL array, dimension (6*N) */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > 0: the 2-by-2 block (INFO:INFO+1) does not have a complex */
/* eigenvalue. */
/* Further Details */
/* =============== */
/* Allocation of workspace: */
/* ---------- -- --------- */
/* WORK( j ) = 1-norm of j-th column of A, above the diagonal */
/* WORK( N+j ) = 1-norm of j-th column of B, above the diagonal */
/* WORK( 2*N+1:3*N ) = real part of eigenvector */
/* WORK( 3*N+1:4*N ) = imaginary part of eigenvector */
/* WORK( 4*N+1:5*N ) = real part of back-transformed eigenvector */
/* WORK( 5*N+1:6*N ) = imaginary part of back-transformed eigenvector */
/* Rowwise vs. columnwise solution methods: */
/* ------- -- ---------- -------- ------- */
/* Finding a generalized eigenvector consists basically of solving the */
/* singular triangular system */
/* (A - w B) x = 0 (for right) or: (A - w B)**H y = 0 (for left) */
/* Consider finding the i-th right eigenvector (assume all eigenvalues */
/* are real). The equation to be solved is: */
/* n i */
/* 0 = sum C(j,k) v(k) = sum C(j,k) v(k) for j = i,. . .,1 */
/* k=j k=j */
/* where C = (A - w B) (The components v(i+1:n) are 0.) */
/* The "rowwise" method is: */
/* (1) v(i) := 1 */
/* for j = i-1,. . .,1: */
/* i */
/* (2) compute s = - sum C(j,k) v(k) and */
/* k=j+1 */
/* (3) v(j) := s / C(j,j) */
/* Step 2 is sometimes called the "dot product" step, since it is an */
/* inner product between the j-th row and the portion of the eigenvector */
/* that has been computed so far. */
/* The "columnwise" method consists basically in doing the sums */
/* for all the rows in parallel. As each v(j) is computed, the */
/* contribution of v(j) times the j-th column of C is added to the */
/* partial sums. Since FORTRAN arrays are stored columnwise, this has */
/* the advantage that at each step, the elements of C that are accessed */
/* are adjacent to one another, whereas with the rowwise method, the */
/* elements accessed at a step are spaced LDS (and LDP) words apart. */
/* When finding left eigenvectors, the matrix in question is the */
/* transpose of the one in storage, so the rowwise method then */
/* actually accesses columns of A and B at each step, and so is the */
/* preferred method. */
/* ===================================================================== */
/* Decode and Test the input parameters */
/* Parameter adjustments */
--select;
s_dim1 = *lds;
s_offset = 1 + s_dim1;
s -= s_offset;
p_dim1 = *ldp;
p_offset = 1 + p_dim1;
p -= p_offset;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--work;
/* Function Body */
if (lsame_(howmny, "A")) {
ihwmny = 1;
ilall = TRUE_;
ilback = FALSE_;
} else if (lsame_(howmny, "S")) {
ihwmny = 2;
ilall = FALSE_;
ilback = FALSE_;
} else if (lsame_(howmny, "B")) {
ihwmny = 3;
ilall = TRUE_;
ilback = TRUE_;
} else {
ihwmny = -1;
ilall = TRUE_;
}
if (lsame_(side, "R")) {
iside = 1;
compl = FALSE_;
compr = TRUE_;
} else if (lsame_(side, "L")) {
iside = 2;
compl = TRUE_;
compr = FALSE_;
} else if (lsame_(side, "B")) {
iside = 3;
compl = TRUE_;
compr = TRUE_;
} else {
iside = -1;
}
*info = 0;
if (iside < 0) {
*info = -1;
} else if (ihwmny < 0) {
*info = -2;
} else if (*n < 0) {
*info = -4;
} else if (*lds < max(1,*n)) {
*info = -6;
} else if (*ldp < max(1,*n)) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("STGEVC", &i__1);
return 0;
}
/* Count the number of eigenvectors to be computed */
if (! ilall) {
im = 0;
ilcplx = FALSE_;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (ilcplx) {
ilcplx = FALSE_;
goto L10;
}
if (j < *n) {
if (s[j + 1 + j * s_dim1] != 0.f) {
ilcplx = TRUE_;
}
}
if (ilcplx) {
if (select[j] || select[j + 1]) {
im += 2;
}
} else {
if (select[j]) {
++im;
}
}
L10:
;
}
} else {
im = *n;
}
/* Check 2-by-2 diagonal blocks of A, B */
ilabad = FALSE_;
ilbbad = FALSE_;
i__1 = *n - 1;
for (j = 1; j <= i__1; ++j) {
if (s[j + 1 + j * s_dim1] != 0.f) {
if (p[j + j * p_dim1] == 0.f || p[j + 1 + (j + 1) * p_dim1] ==
0.f || p[j + (j + 1) * p_dim1] != 0.f) {
ilbbad = TRUE_;
}
if (j < *n - 1) {
if (s[j + 2 + (j + 1) * s_dim1] != 0.f) {
ilabad = TRUE_;
}
}
}
}
if (ilabad) {
*info = -5;
} else if (ilbbad) {
*info = -7;
} else if (compl && *ldvl < *n || *ldvl < 1) {
*info = -10;
} else if (compr && *ldvr < *n || *ldvr < 1) {
*info = -12;
} else if (*mm < im) {
*info = -13;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("STGEVC", &i__1);
return 0;
}
/* Quick return if possible */
*m = im;
if (*n == 0) {
return 0;
}
/* Machine Constants */
safmin = slamch_("Safe minimum");
big = 1.f / safmin;
slabad_(&safmin, &big);
ulp = slamch_("Epsilon") * slamch_("Base");
small = safmin * *n / ulp;
big = 1.f / small;
bignum = 1.f / (safmin * *n);
/* Compute the 1-norm of each column of the strictly upper triangular */
/* part (i.e., excluding all elements belonging to the diagonal */
/* blocks) of A and B to check for possible overflow in the */
/* triangular solver. */
anorm = (r__1 = s[s_dim1 + 1], dabs(r__1));
if (*n > 1) {
anorm += (r__1 = s[s_dim1 + 2], dabs(r__1));
}
bnorm = (r__1 = p[p_dim1 + 1], dabs(r__1));
work[1] = 0.f;
work[*n + 1] = 0.f;
i__1 = *n;
for (j = 2; j <= i__1; ++j) {
temp = 0.f;
temp2 = 0.f;
if (s[j + (j - 1) * s_dim1] == 0.f) {
iend = j - 1;
} else {
iend = j - 2;
}
i__2 = iend;
for (i__ = 1; i__ <= i__2; ++i__) {
temp += (r__1 = s[i__ + j * s_dim1], dabs(r__1));
temp2 += (r__1 = p[i__ + j * p_dim1], dabs(r__1));
}
work[j] = temp;
work[*n + j] = temp2;
/* Computing MIN */
i__3 = j + 1;
i__2 = min(i__3,*n);
for (i__ = iend + 1; i__ <= i__2; ++i__) {
temp += (r__1 = s[i__ + j * s_dim1], dabs(r__1));
temp2 += (r__1 = p[i__ + j * p_dim1], dabs(r__1));
}
anorm = dmax(anorm,temp);
bnorm = dmax(bnorm,temp2);
}
ascale = 1.f / dmax(anorm,safmin);
bscale = 1.f / dmax(bnorm,safmin);
/* Left eigenvectors */
if (compl) {
ieig = 0;
/* Main loop over eigenvalues */
ilcplx = FALSE_;
i__1 = *n;
for (je = 1; je <= i__1; ++je) {
/* Skip this iteration if (a) HOWMNY='S' and SELECT=.FALSE., or */
/* (b) this would be the second of a complex pair. */
/* Check for complex eigenvalue, so as to be sure of which */
/* entry(-ies) of SELECT to look at. */
if (ilcplx) {
ilcplx = FALSE_;
goto L220;
}
nw = 1;
if (je < *n) {
if (s[je + 1 + je * s_dim1] != 0.f) {
ilcplx = TRUE_;
nw = 2;
}
}
if (ilall) {
ilcomp = TRUE_;
} else if (ilcplx) {
ilcomp = select[je] || select[je + 1];
} else {
ilcomp = select[je];
}
if (! ilcomp) {
goto L220;
}
/* Decide if (a) singular pencil, (b) real eigenvalue, or */
/* (c) complex eigenvalue. */
if (! ilcplx) {
if ((r__1 = s[je + je * s_dim1], dabs(r__1)) <= safmin && (
r__2 = p[je + je * p_dim1], dabs(r__2)) <= safmin) {
/* Singular matrix pencil -- return unit eigenvector */
++ieig;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl[jr + ieig * vl_dim1] = 0.f;
}
vl[ieig + ieig * vl_dim1] = 1.f;
goto L220;
}
}
/* Clear vector */
i__2 = nw * *n;
for (jr = 1; jr <= i__2; ++jr) {
work[(*n << 1) + jr] = 0.f;
}
/* T */
/* Compute coefficients in ( a A - b B ) y = 0 */
/* a is ACOEF */
/* b is BCOEFR + i*BCOEFI */
if (! ilcplx) {
/* Real eigenvalue */
/* Computing MAX */
r__3 = (r__1 = s[je + je * s_dim1], dabs(r__1)) * ascale,
r__4 = (r__2 = p[je + je * p_dim1], dabs(r__2)) *
bscale, r__3 = max(r__3,r__4);
temp = 1.f / dmax(r__3,safmin);
salfar = temp * s[je + je * s_dim1] * ascale;
sbeta = temp * p[je + je * p_dim1] * bscale;
acoef = sbeta * ascale;
bcoefr = salfar * bscale;
bcoefi = 0.f;
/* Scale to avoid underflow */
scale = 1.f;
lsa = dabs(sbeta) >= safmin && dabs(acoef) < small;
lsb = dabs(salfar) >= safmin && dabs(bcoefr) < small;
if (lsa) {
scale = small / dabs(sbeta) * dmin(anorm,big);
}
if (lsb) {
/* Computing MAX */
r__1 = scale, r__2 = small / dabs(salfar) * dmin(bnorm,
big);
scale = dmax(r__1,r__2);
}
if (lsa || lsb) {
/* Computing MIN */
/* Computing MAX */
r__3 = 1.f, r__4 = dabs(acoef), r__3 = max(r__3,r__4),
r__4 = dabs(bcoefr);
r__1 = scale, r__2 = 1.f / (safmin * dmax(r__3,r__4));
scale = dmin(r__1,r__2);
if (lsa) {
acoef = ascale * (scale * sbeta);
} else {
acoef = scale * acoef;
}
if (lsb) {
bcoefr = bscale * (scale * salfar);
} else {
bcoefr = scale * bcoefr;
}
}
acoefa = dabs(acoef);
bcoefa = dabs(bcoefr);
/* First component is 1 */
work[(*n << 1) + je] = 1.f;
xmax = 1.f;
} else {
/* Complex eigenvalue */
r__1 = safmin * 100.f;
slag2_(&s[je + je * s_dim1], lds, &p[je + je * p_dim1], ldp, &
r__1, &acoef, &temp, &bcoefr, &temp2, &bcoefi);
bcoefi = -bcoefi;
if (bcoefi == 0.f) {
*info = je;
return 0;
}
/* Scale to avoid over/underflow */
acoefa = dabs(acoef);
bcoefa = dabs(bcoefr) + dabs(bcoefi);
scale = 1.f;
if (acoefa * ulp < safmin && acoefa >= safmin) {
scale = safmin / ulp / acoefa;
}
if (bcoefa * ulp < safmin && bcoefa >= safmin) {
/* Computing MAX */
r__1 = scale, r__2 = safmin / ulp / bcoefa;
scale = dmax(r__1,r__2);
}
if (safmin * acoefa > ascale) {
scale = ascale / (safmin * acoefa);
}
if (safmin * bcoefa > bscale) {
/* Computing MIN */
r__1 = scale, r__2 = bscale / (safmin * bcoefa);
scale = dmin(r__1,r__2);
}
if (scale != 1.f) {
acoef = scale * acoef;
acoefa = dabs(acoef);
bcoefr = scale * bcoefr;
bcoefi = scale * bcoefi;
bcoefa = dabs(bcoefr) + dabs(bcoefi);
}
/* Compute first two components of eigenvector */
temp = acoef * s[je + 1 + je * s_dim1];
temp2r = acoef * s[je + je * s_dim1] - bcoefr * p[je + je *
p_dim1];
temp2i = -bcoefi * p[je + je * p_dim1];
if (dabs(temp) > dabs(temp2r) + dabs(temp2i)) {
work[(*n << 1) + je] = 1.f;
work[*n * 3 + je] = 0.f;
work[(*n << 1) + je + 1] = -temp2r / temp;
work[*n * 3 + je + 1] = -temp2i / temp;
} else {
work[(*n << 1) + je + 1] = 1.f;
work[*n * 3 + je + 1] = 0.f;
temp = acoef * s[je + (je + 1) * s_dim1];
work[(*n << 1) + je] = (bcoefr * p[je + 1 + (je + 1) *
p_dim1] - acoef * s[je + 1 + (je + 1) * s_dim1]) /
temp;
work[*n * 3 + je] = bcoefi * p[je + 1 + (je + 1) * p_dim1]
/ temp;
}
/* Computing MAX */
r__5 = (r__1 = work[(*n << 1) + je], dabs(r__1)) + (r__2 =
work[*n * 3 + je], dabs(r__2)), r__6 = (r__3 = work[(*
n << 1) + je + 1], dabs(r__3)) + (r__4 = work[*n * 3
+ je + 1], dabs(r__4));
xmax = dmax(r__5,r__6);
}
/* Computing MAX */
r__1 = ulp * acoefa * anorm, r__2 = ulp * bcoefa * bnorm, r__1 =
max(r__1,r__2);
dmin__ = dmax(r__1,safmin);
/* T */
/* Triangular solve of (a A - b B) y = 0 */
/* T */
/* (rowwise in (a A - b B) , or columnwise in (a A - b B) ) */
il2by2 = FALSE_;
i__2 = *n;
for (j = je + nw; j <= i__2; ++j) {
if (il2by2) {
il2by2 = FALSE_;
goto L160;
}
na = 1;
bdiag[0] = p[j + j * p_dim1];
if (j < *n) {
if (s[j + 1 + j * s_dim1] != 0.f) {
il2by2 = TRUE_;
bdiag[1] = p[j + 1 + (j + 1) * p_dim1];
na = 2;
}
}
/* Check whether scaling is necessary for dot products */
xscale = 1.f / dmax(1.f,xmax);
/* Computing MAX */
r__1 = work[j], r__2 = work[*n + j], r__1 = max(r__1,r__2),
r__2 = acoefa * work[j] + bcoefa * work[*n + j];
temp = dmax(r__1,r__2);
if (il2by2) {
/* Computing MAX */
r__1 = temp, r__2 = work[j + 1], r__1 = max(r__1,r__2),
r__2 = work[*n + j + 1], r__1 = max(r__1,r__2),
r__2 = acoefa * work[j + 1] + bcoefa * work[*n +
j + 1];
temp = dmax(r__1,r__2);
}
if (temp > bignum * xscale) {
i__3 = nw - 1;
for (jw = 0; jw <= i__3; ++jw) {
i__4 = j - 1;
for (jr = je; jr <= i__4; ++jr) {
work[(jw + 2) * *n + jr] = xscale * work[(jw + 2)
* *n + jr];
}
}
xmax *= xscale;
}
/* Compute dot products */
/* j-1 */
/* SUM = sum conjg( a*S(k,j) - b*P(k,j) )*x(k) */
/* k=je */
/* To reduce the op count, this is done as */
/* _ j-1 _ j-1 */
/* a*conjg( sum S(k,j)*x(k) ) - b*conjg( sum P(k,j)*x(k) ) */
/* k=je k=je */
/* which may cause underflow problems if A or B are close */
/* to underflow. (E.g., less than SMALL.) */
/* A series of compiler directives to defeat vectorization */
/* for the next loop */
/* $PL$ CMCHAR=' ' */
/* DIR$ NEXTSCALAR */
/* $DIR SCALAR */
/* DIR$ NEXT SCALAR */
/* VD$L NOVECTOR */
/* DEC$ NOVECTOR */
/* VD$ NOVECTOR */
/* VDIR NOVECTOR */
/* VOCL LOOP,SCALAR */
/* IBM PREFER SCALAR */
/* $PL$ CMCHAR='*' */
i__3 = nw;
for (jw = 1; jw <= i__3; ++jw) {
/* $PL$ CMCHAR=' ' */
/* DIR$ NEXTSCALAR */
/* $DIR SCALAR */
/* DIR$ NEXT SCALAR */
/* VD$L NOVECTOR */
/* DEC$ NOVECTOR */
/* VD$ NOVECTOR */
/* VDIR NOVECTOR */
/* VOCL LOOP,SCALAR */
/* IBM PREFER SCALAR */
/* $PL$ CMCHAR='*' */
i__4 = na;
for (ja = 1; ja <= i__4; ++ja) {
sums[ja + (jw << 1) - 3] = 0.f;
sump[ja + (jw << 1) - 3] = 0.f;
i__5 = j - 1;
for (jr = je; jr <= i__5; ++jr) {
sums[ja + (jw << 1) - 3] += s[jr + (j + ja - 1) *
s_dim1] * work[(jw + 1) * *n + jr];
sump[ja + (jw << 1) - 3] += p[jr + (j + ja - 1) *
p_dim1] * work[(jw + 1) * *n + jr];
}
}
}
/* $PL$ CMCHAR=' ' */
/* DIR$ NEXTSCALAR */
/* $DIR SCALAR */
/* DIR$ NEXT SCALAR */
/* VD$L NOVECTOR */
/* DEC$ NOVECTOR */
/* VD$ NOVECTOR */
/* VDIR NOVECTOR */
/* VOCL LOOP,SCALAR */
/* IBM PREFER SCALAR */
/* $PL$ CMCHAR='*' */
i__3 = na;
for (ja = 1; ja <= i__3; ++ja) {
if (ilcplx) {
sum[ja - 1] = -acoef * sums[ja - 1] + bcoefr * sump[
ja - 1] - bcoefi * sump[ja + 1];
sum[ja + 1] = -acoef * sums[ja + 1] + bcoefr * sump[
ja + 1] + bcoefi * sump[ja - 1];
} else {
sum[ja - 1] = -acoef * sums[ja - 1] + bcoefr * sump[
ja - 1];
}
}
/* T */
/* Solve ( a A - b B ) y = SUM(,) */
/* with scaling and perturbation of the denominator */
slaln2_(&c_true, &na, &nw, &dmin__, &acoef, &s[j + j * s_dim1]
, lds, bdiag, &bdiag[1], sum, &c__2, &bcoefr, &bcoefi,
&work[(*n << 1) + j], n, &scale, &temp, &iinfo);
if (scale < 1.f) {
i__3 = nw - 1;
for (jw = 0; jw <= i__3; ++jw) {
i__4 = j - 1;
for (jr = je; jr <= i__4; ++jr) {
work[(jw + 2) * *n + jr] = scale * work[(jw + 2) *
*n + jr];
}
}
xmax = scale * xmax;
}
xmax = dmax(xmax,temp);
L160:
;
}
/* Copy eigenvector to VL, back transforming if */
/* HOWMNY='B'. */
++ieig;
if (ilback) {
i__2 = nw - 1;
for (jw = 0; jw <= i__2; ++jw) {
i__3 = *n + 1 - je;
sgemv_("N", n, &i__3, &c_b34, &vl[je * vl_dim1 + 1], ldvl,
&work[(jw + 2) * *n + je], &c__1, &c_b36, &work[(
jw + 4) * *n + 1], &c__1);
}
slacpy_(" ", n, &nw, &work[(*n << 2) + 1], n, &vl[je *
vl_dim1 + 1], ldvl);
ibeg = 1;
} else {
slacpy_(" ", n, &nw, &work[(*n << 1) + 1], n, &vl[ieig *
vl_dim1 + 1], ldvl);
ibeg = je;
}
/* Scale eigenvector */
xmax = 0.f;
if (ilcplx) {
i__2 = *n;
for (j = ibeg; j <= i__2; ++j) {
/* Computing MAX */
r__3 = xmax, r__4 = (r__1 = vl[j + ieig * vl_dim1], dabs(
r__1)) + (r__2 = vl[j + (ieig + 1) * vl_dim1],
dabs(r__2));
xmax = dmax(r__3,r__4);
}
} else {
i__2 = *n;
for (j = ibeg; j <= i__2; ++j) {
/* Computing MAX */
r__2 = xmax, r__3 = (r__1 = vl[j + ieig * vl_dim1], dabs(
r__1));
xmax = dmax(r__2,r__3);
}
}
if (xmax > safmin) {
xscale = 1.f / xmax;
i__2 = nw - 1;
for (jw = 0; jw <= i__2; ++jw) {
i__3 = *n;
for (jr = ibeg; jr <= i__3; ++jr) {
vl[jr + (ieig + jw) * vl_dim1] = xscale * vl[jr + (
ieig + jw) * vl_dim1];
}
}
}
ieig = ieig + nw - 1;
L220:
;
}
}
/* Right eigenvectors */
if (compr) {
ieig = im + 1;
/* Main loop over eigenvalues */
ilcplx = FALSE_;
for (je = *n; je >= 1; --je) {
/* Skip this iteration if (a) HOWMNY='S' and SELECT=.FALSE., or */
/* (b) this would be the second of a complex pair. */
/* Check for complex eigenvalue, so as to be sure of which */
/* entry(-ies) of SELECT to look at -- if complex, SELECT(JE) */
/* or SELECT(JE-1). */
/* If this is a complex pair, the 2-by-2 diagonal block */
/* corresponding to the eigenvalue is in rows/columns JE-1:JE */
if (ilcplx) {
ilcplx = FALSE_;
goto L500;
}
nw = 1;
if (je > 1) {
if (s[je + (je - 1) * s_dim1] != 0.f) {
ilcplx = TRUE_;
nw = 2;
}
}
if (ilall) {
ilcomp = TRUE_;
} else if (ilcplx) {
ilcomp = select[je] || select[je - 1];
} else {
ilcomp = select[je];
}
if (! ilcomp) {
goto L500;
}
/* Decide if (a) singular pencil, (b) real eigenvalue, or */
/* (c) complex eigenvalue. */
if (! ilcplx) {
if ((r__1 = s[je + je * s_dim1], dabs(r__1)) <= safmin && (
r__2 = p[je + je * p_dim1], dabs(r__2)) <= safmin) {
/* Singular matrix pencil -- unit eigenvector */
--ieig;
i__1 = *n;
for (jr = 1; jr <= i__1; ++jr) {
vr[jr + ieig * vr_dim1] = 0.f;
}
vr[ieig + ieig * vr_dim1] = 1.f;
goto L500;
}
}
/* Clear vector */
i__1 = nw - 1;
for (jw = 0; jw <= i__1; ++jw) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
work[(jw + 2) * *n + jr] = 0.f;
}
}
/* Compute coefficients in ( a A - b B ) x = 0 */
/* a is ACOEF */
/* b is BCOEFR + i*BCOEFI */
if (! ilcplx) {
/* Real eigenvalue */
/* Computing MAX */
r__3 = (r__1 = s[je + je * s_dim1], dabs(r__1)) * ascale,
r__4 = (r__2 = p[je + je * p_dim1], dabs(r__2)) *
bscale, r__3 = max(r__3,r__4);
temp = 1.f / dmax(r__3,safmin);
salfar = temp * s[je + je * s_dim1] * ascale;
sbeta = temp * p[je + je * p_dim1] * bscale;
acoef = sbeta * ascale;
bcoefr = salfar * bscale;
bcoefi = 0.f;
/* Scale to avoid underflow */
scale = 1.f;
lsa = dabs(sbeta) >= safmin && dabs(acoef) < small;
lsb = dabs(salfar) >= safmin && dabs(bcoefr) < small;
if (lsa) {
scale = small / dabs(sbeta) * dmin(anorm,big);
}
if (lsb) {
/* Computing MAX */
r__1 = scale, r__2 = small / dabs(salfar) * dmin(bnorm,
big);
scale = dmax(r__1,r__2);
}
if (lsa || lsb) {
/* Computing MIN */
/* Computing MAX */
r__3 = 1.f, r__4 = dabs(acoef), r__3 = max(r__3,r__4),
r__4 = dabs(bcoefr);
r__1 = scale, r__2 = 1.f / (safmin * dmax(r__3,r__4));
scale = dmin(r__1,r__2);
if (lsa) {
acoef = ascale * (scale * sbeta);
} else {
acoef = scale * acoef;
}
if (lsb) {
bcoefr = bscale * (scale * salfar);
} else {
bcoefr = scale * bcoefr;
}
}
acoefa = dabs(acoef);
bcoefa = dabs(bcoefr);
/* First component is 1 */
work[(*n << 1) + je] = 1.f;
xmax = 1.f;
/* Compute contribution from column JE of A and B to sum */
/* (See "Further Details", above.) */
i__1 = je - 1;
for (jr = 1; jr <= i__1; ++jr) {
work[(*n << 1) + jr] = bcoefr * p[jr + je * p_dim1] -
acoef * s[jr + je * s_dim1];
}
} else {
/* Complex eigenvalue */
r__1 = safmin * 100.f;
slag2_(&s[je - 1 + (je - 1) * s_dim1], lds, &p[je - 1 + (je -
1) * p_dim1], ldp, &r__1, &acoef, &temp, &bcoefr, &
temp2, &bcoefi);
if (bcoefi == 0.f) {
*info = je - 1;
return 0;
}
/* Scale to avoid over/underflow */
acoefa = dabs(acoef);
bcoefa = dabs(bcoefr) + dabs(bcoefi);
scale = 1.f;
if (acoefa * ulp < safmin && acoefa >= safmin) {
scale = safmin / ulp / acoefa;
}
if (bcoefa * ulp < safmin && bcoefa >= safmin) {
/* Computing MAX */
r__1 = scale, r__2 = safmin / ulp / bcoefa;
scale = dmax(r__1,r__2);
}
if (safmin * acoefa > ascale) {
scale = ascale / (safmin * acoefa);
}
if (safmin * bcoefa > bscale) {
/* Computing MIN */
r__1 = scale, r__2 = bscale / (safmin * bcoefa);
scale = dmin(r__1,r__2);
}
if (scale != 1.f) {
acoef = scale * acoef;
acoefa = dabs(acoef);
bcoefr = scale * bcoefr;
bcoefi = scale * bcoefi;
bcoefa = dabs(bcoefr) + dabs(bcoefi);
}
/* Compute first two components of eigenvector */
/* and contribution to sums */
temp = acoef * s[je + (je - 1) * s_dim1];
temp2r = acoef * s[je + je * s_dim1] - bcoefr * p[je + je *
p_dim1];
temp2i = -bcoefi * p[je + je * p_dim1];
if (dabs(temp) >= dabs(temp2r) + dabs(temp2i)) {
work[(*n << 1) + je] = 1.f;
work[*n * 3 + je] = 0.f;
work[(*n << 1) + je - 1] = -temp2r / temp;
work[*n * 3 + je - 1] = -temp2i / temp;
} else {
work[(*n << 1) + je - 1] = 1.f;
work[*n * 3 + je - 1] = 0.f;
temp = acoef * s[je - 1 + je * s_dim1];
work[(*n << 1) + je] = (bcoefr * p[je - 1 + (je - 1) *
p_dim1] - acoef * s[je - 1 + (je - 1) * s_dim1]) /
temp;
work[*n * 3 + je] = bcoefi * p[je - 1 + (je - 1) * p_dim1]
/ temp;
}
/* Computing MAX */
r__5 = (r__1 = work[(*n << 1) + je], dabs(r__1)) + (r__2 =
work[*n * 3 + je], dabs(r__2)), r__6 = (r__3 = work[(*
n << 1) + je - 1], dabs(r__3)) + (r__4 = work[*n * 3
+ je - 1], dabs(r__4));
xmax = dmax(r__5,r__6);
/* Compute contribution from columns JE and JE-1 */
/* of A and B to the sums. */
creala = acoef * work[(*n << 1) + je - 1];
cimaga = acoef * work[*n * 3 + je - 1];
crealb = bcoefr * work[(*n << 1) + je - 1] - bcoefi * work[*n
* 3 + je - 1];
cimagb = bcoefi * work[(*n << 1) + je - 1] + bcoefr * work[*n
* 3 + je - 1];
cre2a = acoef * work[(*n << 1) + je];
cim2a = acoef * work[*n * 3 + je];
cre2b = bcoefr * work[(*n << 1) + je] - bcoefi * work[*n * 3
+ je];
cim2b = bcoefi * work[(*n << 1) + je] + bcoefr * work[*n * 3
+ je];
i__1 = je - 2;
for (jr = 1; jr <= i__1; ++jr) {
work[(*n << 1) + jr] = -creala * s[jr + (je - 1) * s_dim1]
+ crealb * p[jr + (je - 1) * p_dim1] - cre2a * s[
jr + je * s_dim1] + cre2b * p[jr + je * p_dim1];
work[*n * 3 + jr] = -cimaga * s[jr + (je - 1) * s_dim1] +
cimagb * p[jr + (je - 1) * p_dim1] - cim2a * s[jr
+ je * s_dim1] + cim2b * p[jr + je * p_dim1];
}
}
/* Computing MAX */
r__1 = ulp * acoefa * anorm, r__2 = ulp * bcoefa * bnorm, r__1 =
max(r__1,r__2);
dmin__ = dmax(r__1,safmin);
/* Columnwise triangular solve of (a A - b B) x = 0 */
il2by2 = FALSE_;
for (j = je - nw; j >= 1; --j) {
/* If a 2-by-2 block, is in position j-1:j, wait until */
/* next iteration to process it (when it will be j:j+1) */
if (! il2by2 && j > 1) {
if (s[j + (j - 1) * s_dim1] != 0.f) {
il2by2 = TRUE_;
goto L370;
}
}
bdiag[0] = p[j + j * p_dim1];
if (il2by2) {
na = 2;
bdiag[1] = p[j + 1 + (j + 1) * p_dim1];
} else {
na = 1;
}
/* Compute x(j) (and x(j+1), if 2-by-2 block) */
slaln2_(&c_false, &na, &nw, &dmin__, &acoef, &s[j + j *
s_dim1], lds, bdiag, &bdiag[1], &work[(*n << 1) + j],
n, &bcoefr, &bcoefi, sum, &c__2, &scale, &temp, &
iinfo);
if (scale < 1.f) {
i__1 = nw - 1;
for (jw = 0; jw <= i__1; ++jw) {
i__2 = je;
for (jr = 1; jr <= i__2; ++jr) {
work[(jw + 2) * *n + jr] = scale * work[(jw + 2) *
*n + jr];
}
}
}
/* Computing MAX */
r__1 = scale * xmax;
xmax = dmax(r__1,temp);
i__1 = nw;
for (jw = 1; jw <= i__1; ++jw) {
i__2 = na;
for (ja = 1; ja <= i__2; ++ja) {
work[(jw + 1) * *n + j + ja - 1] = sum[ja + (jw << 1)
- 3];
}
}
/* w = w + x(j)*(a S(*,j) - b P(*,j) ) with scaling */
if (j > 1) {
/* Check whether scaling is necessary for sum. */
xscale = 1.f / dmax(1.f,xmax);
temp = acoefa * work[j] + bcoefa * work[*n + j];
if (il2by2) {
/* Computing MAX */
r__1 = temp, r__2 = acoefa * work[j + 1] + bcoefa *
work[*n + j + 1];
temp = dmax(r__1,r__2);
}
/* Computing MAX */
r__1 = max(temp,acoefa);
temp = dmax(r__1,bcoefa);
if (temp > bignum * xscale) {
i__1 = nw - 1;
for (jw = 0; jw <= i__1; ++jw) {
i__2 = je;
for (jr = 1; jr <= i__2; ++jr) {
work[(jw + 2) * *n + jr] = xscale * work[(jw
+ 2) * *n + jr];
}
}
xmax *= xscale;
}
/* Compute the contributions of the off-diagonals of */
/* column j (and j+1, if 2-by-2 block) of A and B to the */
/* sums. */
i__1 = na;
for (ja = 1; ja <= i__1; ++ja) {
if (ilcplx) {
creala = acoef * work[(*n << 1) + j + ja - 1];
cimaga = acoef * work[*n * 3 + j + ja - 1];
crealb = bcoefr * work[(*n << 1) + j + ja - 1] -
bcoefi * work[*n * 3 + j + ja - 1];
cimagb = bcoefi * work[(*n << 1) + j + ja - 1] +
bcoefr * work[*n * 3 + j + ja - 1];
i__2 = j - 1;
for (jr = 1; jr <= i__2; ++jr) {
work[(*n << 1) + jr] = work[(*n << 1) + jr] -
creala * s[jr + (j + ja - 1) * s_dim1]
+ crealb * p[jr + (j + ja - 1) *
p_dim1];
work[*n * 3 + jr] = work[*n * 3 + jr] -
cimaga * s[jr + (j + ja - 1) * s_dim1]
+ cimagb * p[jr + (j + ja - 1) *
p_dim1];
}
} else {
creala = acoef * work[(*n << 1) + j + ja - 1];
crealb = bcoefr * work[(*n << 1) + j + ja - 1];
i__2 = j - 1;
for (jr = 1; jr <= i__2; ++jr) {
work[(*n << 1) + jr] = work[(*n << 1) + jr] -
creala * s[jr + (j + ja - 1) * s_dim1]
+ crealb * p[jr + (j + ja - 1) *
p_dim1];
}
}
}
}
il2by2 = FALSE_;
L370:
;
}
/* Copy eigenvector to VR, back transforming if */
/* HOWMNY='B'. */
ieig -= nw;
if (ilback) {
i__1 = nw - 1;
for (jw = 0; jw <= i__1; ++jw) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
work[(jw + 4) * *n + jr] = work[(jw + 2) * *n + 1] *
vr[jr + vr_dim1];
}
/* A series of compiler directives to defeat */
/* vectorization for the next loop */
i__2 = je;
for (jc = 2; jc <= i__2; ++jc) {
i__3 = *n;
for (jr = 1; jr <= i__3; ++jr) {
work[(jw + 4) * *n + jr] += work[(jw + 2) * *n +
jc] * vr[jr + jc * vr_dim1];
}
}
}
i__1 = nw - 1;
for (jw = 0; jw <= i__1; ++jw) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + (ieig + jw) * vr_dim1] = work[(jw + 4) * *n +
jr];
}
}
iend = *n;
} else {
i__1 = nw - 1;
for (jw = 0; jw <= i__1; ++jw) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + (ieig + jw) * vr_dim1] = work[(jw + 2) * *n +
jr];
}
}
iend = je;
}
/* Scale eigenvector */
xmax = 0.f;
if (ilcplx) {
i__1 = iend;
for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
r__3 = xmax, r__4 = (r__1 = vr[j + ieig * vr_dim1], dabs(
r__1)) + (r__2 = vr[j + (ieig + 1) * vr_dim1],
dabs(r__2));
xmax = dmax(r__3,r__4);
}
} else {
i__1 = iend;
for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
r__2 = xmax, r__3 = (r__1 = vr[j + ieig * vr_dim1], dabs(
r__1));
xmax = dmax(r__2,r__3);
}
}
if (xmax > safmin) {
xscale = 1.f / xmax;
i__1 = nw - 1;
for (jw = 0; jw <= i__1; ++jw) {
i__2 = iend;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + (ieig + jw) * vr_dim1] = xscale * vr[jr + (
ieig + jw) * vr_dim1];
}
}
}
L500:
;
}
}
return 0;
/* End of STGEVC */
} /* stgevc_ */
