LAPACK  3.6.1 LAPACK: Linear Algebra PACKage
dtgsna.f
Go to the documentation of this file.
1 *> \brief \b DTGSNA
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dtgsna.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dtgsna.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dtgsna.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE DTGSNA( JOB, HOWMNY, SELECT, N, A, LDA, B, LDB, VL,
22 * LDVL, VR, LDVR, S, DIF, MM, M, WORK, LWORK,
23 * IWORK, INFO )
24 *
25 * .. Scalar Arguments ..
26 * CHARACTER HOWMNY, JOB
27 * INTEGER INFO, LDA, LDB, LDVL, LDVR, LWORK, M, MM, N
28 * ..
29 * .. Array Arguments ..
30 * LOGICAL SELECT( * )
31 * INTEGER IWORK( * )
32 * DOUBLE PRECISION A( LDA, * ), B( LDB, * ), DIF( * ), S( * ),
33 * \$ VL( LDVL, * ), VR( LDVR, * ), WORK( * )
34 * ..
35 *
36 *
37 *> \par Purpose:
38 * =============
39 *>
40 *> \verbatim
41 *>
42 *> DTGSNA estimates reciprocal condition numbers for specified
43 *> eigenvalues and/or eigenvectors of a matrix pair (A, B) in
44 *> generalized real Schur canonical form (or of any matrix pair
45 *> (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where
46 *> Z**T denotes the transpose of Z.
47 *>
48 *> (A, B) must be in generalized real Schur form (as returned by DGGES),
49 *> i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal
50 *> blocks. B is upper triangular.
51 *>
52 *> \endverbatim
53 *
54 * Arguments:
55 * ==========
56 *
57 *> \param[in] JOB
58 *> \verbatim
59 *> JOB is CHARACTER*1
60 *> Specifies whether condition numbers are required for
61 *> eigenvalues (S) or eigenvectors (DIF):
62 *> = 'E': for eigenvalues only (S);
63 *> = 'V': for eigenvectors only (DIF);
64 *> = 'B': for both eigenvalues and eigenvectors (S and DIF).
65 *> \endverbatim
66 *>
67 *> \param[in] HOWMNY
68 *> \verbatim
69 *> HOWMNY is CHARACTER*1
70 *> = 'A': compute condition numbers for all eigenpairs;
71 *> = 'S': compute condition numbers for selected eigenpairs
72 *> specified by the array SELECT.
73 *> \endverbatim
74 *>
75 *> \param[in] SELECT
76 *> \verbatim
77 *> SELECT is LOGICAL array, dimension (N)
78 *> If HOWMNY = 'S', SELECT specifies the eigenpairs for which
79 *> condition numbers are required. To select condition numbers
80 *> for the eigenpair corresponding to a real eigenvalue w(j),
81 *> SELECT(j) must be set to .TRUE.. To select condition numbers
82 *> corresponding to a complex conjugate pair of eigenvalues w(j)
83 *> and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be
84 *> set to .TRUE..
85 *> If HOWMNY = 'A', SELECT is not referenced.
86 *> \endverbatim
87 *>
88 *> \param[in] N
89 *> \verbatim
90 *> N is INTEGER
91 *> The order of the square matrix pair (A, B). N >= 0.
92 *> \endverbatim
93 *>
94 *> \param[in] A
95 *> \verbatim
96 *> A is DOUBLE PRECISION array, dimension (LDA,N)
97 *> The upper quasi-triangular matrix A in the pair (A,B).
98 *> \endverbatim
99 *>
100 *> \param[in] LDA
101 *> \verbatim
102 *> LDA is INTEGER
103 *> The leading dimension of the array A. LDA >= max(1,N).
104 *> \endverbatim
105 *>
106 *> \param[in] B
107 *> \verbatim
108 *> B is DOUBLE PRECISION array, dimension (LDB,N)
109 *> The upper triangular matrix B in the pair (A,B).
110 *> \endverbatim
111 *>
112 *> \param[in] LDB
113 *> \verbatim
114 *> LDB is INTEGER
115 *> The leading dimension of the array B. LDB >= max(1,N).
116 *> \endverbatim
117 *>
118 *> \param[in] VL
119 *> \verbatim
120 *> VL is DOUBLE PRECISION array, dimension (LDVL,M)
121 *> If JOB = 'E' or 'B', VL must contain left eigenvectors of
122 *> (A, B), corresponding to the eigenpairs specified by HOWMNY
123 *> and SELECT. The eigenvectors must be stored in consecutive
124 *> columns of VL, as returned by DTGEVC.
125 *> If JOB = 'V', VL is not referenced.
126 *> \endverbatim
127 *>
128 *> \param[in] LDVL
129 *> \verbatim
130 *> LDVL is INTEGER
131 *> The leading dimension of the array VL. LDVL >= 1.
132 *> If JOB = 'E' or 'B', LDVL >= N.
133 *> \endverbatim
134 *>
135 *> \param[in] VR
136 *> \verbatim
137 *> VR is DOUBLE PRECISION array, dimension (LDVR,M)
138 *> If JOB = 'E' or 'B', VR must contain right eigenvectors of
139 *> (A, B), corresponding to the eigenpairs specified by HOWMNY
140 *> and SELECT. The eigenvectors must be stored in consecutive
141 *> columns ov VR, as returned by DTGEVC.
142 *> If JOB = 'V', VR is not referenced.
143 *> \endverbatim
144 *>
145 *> \param[in] LDVR
146 *> \verbatim
147 *> LDVR is INTEGER
148 *> The leading dimension of the array VR. LDVR >= 1.
149 *> If JOB = 'E' or 'B', LDVR >= N.
150 *> \endverbatim
151 *>
152 *> \param[out] S
153 *> \verbatim
154 *> S is DOUBLE PRECISION array, dimension (MM)
155 *> If JOB = 'E' or 'B', the reciprocal condition numbers of the
156 *> selected eigenvalues, stored in consecutive elements of the
157 *> array. For a complex conjugate pair of eigenvalues two
158 *> consecutive elements of S are set to the same value. Thus
159 *> S(j), DIF(j), and the j-th columns of VL and VR all
160 *> correspond to the same eigenpair (but not in general the
161 *> j-th eigenpair, unless all eigenpairs are selected).
162 *> If JOB = 'V', S is not referenced.
163 *> \endverbatim
164 *>
165 *> \param[out] DIF
166 *> \verbatim
167 *> DIF is DOUBLE PRECISION array, dimension (MM)
168 *> If JOB = 'V' or 'B', the estimated reciprocal condition
169 *> numbers of the selected eigenvectors, stored in consecutive
170 *> elements of the array. For a complex eigenvector two
171 *> consecutive elements of DIF are set to the same value. If
172 *> the eigenvalues cannot be reordered to compute DIF(j), DIF(j)
173 *> is set to 0; this can only occur when the true value would be
174 *> very small anyway.
175 *> If JOB = 'E', DIF is not referenced.
176 *> \endverbatim
177 *>
178 *> \param[in] MM
179 *> \verbatim
180 *> MM is INTEGER
181 *> The number of elements in the arrays S and DIF. MM >= M.
182 *> \endverbatim
183 *>
184 *> \param[out] M
185 *> \verbatim
186 *> M is INTEGER
187 *> The number of elements of the arrays S and DIF used to store
188 *> the specified condition numbers; for each selected real
189 *> eigenvalue one element is used, and for each selected complex
190 *> conjugate pair of eigenvalues, two elements are used.
191 *> If HOWMNY = 'A', M is set to N.
192 *> \endverbatim
193 *>
194 *> \param[out] WORK
195 *> \verbatim
196 *> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
197 *> On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
198 *> \endverbatim
199 *>
200 *> \param[in] LWORK
201 *> \verbatim
202 *> LWORK is INTEGER
203 *> The dimension of the array WORK. LWORK >= max(1,N).
204 *> If JOB = 'V' or 'B' LWORK >= 2*N*(N+2)+16.
205 *>
206 *> If LWORK = -1, then a workspace query is assumed; the routine
207 *> only calculates the optimal size of the WORK array, returns
208 *> this value as the first entry of the WORK array, and no error
209 *> message related to LWORK is issued by XERBLA.
210 *> \endverbatim
211 *>
212 *> \param[out] IWORK
213 *> \verbatim
214 *> IWORK is INTEGER array, dimension (N + 6)
215 *> If JOB = 'E', IWORK is not referenced.
216 *> \endverbatim
217 *>
218 *> \param[out] INFO
219 *> \verbatim
220 *> INFO is INTEGER
221 *> =0: Successful exit
222 *> <0: If INFO = -i, the i-th argument had an illegal value
223 *> \endverbatim
224 *
225 * Authors:
226 * ========
227 *
228 *> \author Univ. of Tennessee
229 *> \author Univ. of California Berkeley
230 *> \author Univ. of Colorado Denver
231 *> \author NAG Ltd.
232 *
233 *> \date November 2011
234 *
235 *> \ingroup doubleOTHERcomputational
236 *
237 *> \par Further Details:
238 * =====================
239 *>
240 *> \verbatim
241 *>
242 *> The reciprocal of the condition number of a generalized eigenvalue
243 *> w = (a, b) is defined as
244 *>
245 *> S(w) = (|u**TAv|**2 + |u**TBv|**2)**(1/2) / (norm(u)*norm(v))
246 *>
247 *> where u and v are the left and right eigenvectors of (A, B)
248 *> corresponding to w; |z| denotes the absolute value of the complex
249 *> number, and norm(u) denotes the 2-norm of the vector u.
250 *> The pair (a, b) corresponds to an eigenvalue w = a/b (= u**TAv/u**TBv)
251 *> of the matrix pair (A, B). If both a and b equal zero, then (A B) is
252 *> singular and S(I) = -1 is returned.
253 *>
254 *> An approximate error bound on the chordal distance between the i-th
255 *> computed generalized eigenvalue w and the corresponding exact
256 *> eigenvalue lambda is
257 *>
258 *> chord(w, lambda) <= EPS * norm(A, B) / S(I)
259 *>
260 *> where EPS is the machine precision.
261 *>
262 *> The reciprocal of the condition number DIF(i) of right eigenvector u
263 *> and left eigenvector v corresponding to the generalized eigenvalue w
264 *> is defined as follows:
265 *>
266 *> a) If the i-th eigenvalue w = (a,b) is real
267 *>
268 *> Suppose U and V are orthogonal transformations such that
269 *>
270 *> U**T*(A, B)*V = (S, T) = ( a * ) ( b * ) 1
271 *> ( 0 S22 ),( 0 T22 ) n-1
272 *> 1 n-1 1 n-1
273 *>
274 *> Then the reciprocal condition number DIF(i) is
275 *>
276 *> Difl((a, b), (S22, T22)) = sigma-min( Zl ),
277 *>
278 *> where sigma-min(Zl) denotes the smallest singular value of the
279 *> 2(n-1)-by-2(n-1) matrix
280 *>
281 *> Zl = [ kron(a, In-1) -kron(1, S22) ]
282 *> [ kron(b, In-1) -kron(1, T22) ] .
283 *>
284 *> Here In-1 is the identity matrix of size n-1. kron(X, Y) is the
285 *> Kronecker product between the matrices X and Y.
286 *>
287 *> Note that if the default method for computing DIF(i) is wanted
288 *> (see DLATDF), then the parameter DIFDRI (see below) should be
289 *> changed from 3 to 4 (routine DLATDF(IJOB = 2 will be used)).
290 *> See DTGSYL for more details.
291 *>
292 *> b) If the i-th and (i+1)-th eigenvalues are complex conjugate pair,
293 *>
294 *> Suppose U and V are orthogonal transformations such that
295 *>
296 *> U**T*(A, B)*V = (S, T) = ( S11 * ) ( T11 * ) 2
297 *> ( 0 S22 ),( 0 T22) n-2
298 *> 2 n-2 2 n-2
299 *>
300 *> and (S11, T11) corresponds to the complex conjugate eigenvalue
301 *> pair (w, conjg(w)). There exist unitary matrices U1 and V1 such
302 *> that
303 *>
304 *> U1**T*S11*V1 = ( s11 s12 ) and U1**T*T11*V1 = ( t11 t12 )
305 *> ( 0 s22 ) ( 0 t22 )
306 *>
307 *> where the generalized eigenvalues w = s11/t11 and
308 *> conjg(w) = s22/t22.
309 *>
310 *> Then the reciprocal condition number DIF(i) is bounded by
311 *>
312 *> min( d1, max( 1, |real(s11)/real(s22)| )*d2 )
313 *>
314 *> where, d1 = Difl((s11, t11), (s22, t22)) = sigma-min(Z1), where
315 *> Z1 is the complex 2-by-2 matrix
316 *>
317 *> Z1 = [ s11 -s22 ]
318 *> [ t11 -t22 ],
319 *>
320 *> This is done by computing (using real arithmetic) the
321 *> roots of the characteristical polynomial det(Z1**T * Z1 - lambda I),
322 *> where Z1**T denotes the transpose of Z1 and det(X) denotes
323 *> the determinant of X.
324 *>
325 *> and d2 is an upper bound on Difl((S11, T11), (S22, T22)), i.e. an
326 *> upper bound on sigma-min(Z2), where Z2 is (2n-2)-by-(2n-2)
327 *>
328 *> Z2 = [ kron(S11**T, In-2) -kron(I2, S22) ]
329 *> [ kron(T11**T, In-2) -kron(I2, T22) ]
330 *>
331 *> Note that if the default method for computing DIF is wanted (see
332 *> DLATDF), then the parameter DIFDRI (see below) should be changed
333 *> from 3 to 4 (routine DLATDF(IJOB = 2 will be used)). See DTGSYL
334 *> for more details.
335 *>
336 *> For each eigenvalue/vector specified by SELECT, DIF stores a
337 *> Frobenius norm-based estimate of Difl.
338 *>
339 *> An approximate error bound for the i-th computed eigenvector VL(i) or
340 *> VR(i) is given by
341 *>
342 *> EPS * norm(A, B) / DIF(i).
343 *>
344 *> See ref. [2-3] for more details and further references.
345 *> \endverbatim
346 *
347 *> \par Contributors:
348 * ==================
349 *>
350 *> Bo Kagstrom and Peter Poromaa, Department of Computing Science,
351 *> Umea University, S-901 87 Umea, Sweden.
352 *
353 *> \par References:
354 * ================
355 *>
356 *> \verbatim
357 *>
358 *> [1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the
359 *> Generalized Real Schur Form of a Regular Matrix Pair (A, B), in
360 *> M.S. Moonen et al (eds), Linear Algebra for Large Scale and
361 *> Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218.
362 *>
363 *> [2] B. Kagstrom and P. Poromaa; Computing Eigenspaces with Specified
364 *> Eigenvalues of a Regular Matrix Pair (A, B) and Condition
365 *> Estimation: Theory, Algorithms and Software,
366 *> Report UMINF - 94.04, Department of Computing Science, Umea
367 *> University, S-901 87 Umea, Sweden, 1994. Also as LAPACK Working
368 *> Note 87. To appear in Numerical Algorithms, 1996.
369 *>
370 *> [3] B. Kagstrom and P. Poromaa, LAPACK-Style Algorithms and Software
371 *> for Solving the Generalized Sylvester Equation and Estimating the
372 *> Separation between Regular Matrix Pairs, Report UMINF - 93.23,
373 *> Department of Computing Science, Umea University, S-901 87 Umea,
374 *> Sweden, December 1993, Revised April 1994, Also as LAPACK Working
375 *> Note 75. To appear in ACM Trans. on Math. Software, Vol 22,
376 *> No 1, 1996.
377 *> \endverbatim
378 *>
379 * =====================================================================
380  SUBROUTINE dtgsna( JOB, HOWMNY, SELECT, N, A, LDA, B, LDB, VL,
381  \$ ldvl, vr, ldvr, s, dif, mm, m, work, lwork,
382  \$ iwork, info )
383 *
384 * -- LAPACK computational routine (version 3.4.0) --
385 * -- LAPACK is a software package provided by Univ. of Tennessee, --
386 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
387 * November 2011
388 *
389 * .. Scalar Arguments ..
390  CHARACTER HOWMNY, JOB
391  INTEGER INFO, LDA, LDB, LDVL, LDVR, LWORK, M, MM, N
392 * ..
393 * .. Array Arguments ..
394  LOGICAL SELECT( * )
395  INTEGER IWORK( * )
396  DOUBLE PRECISION A( lda, * ), B( ldb, * ), DIF( * ), S( * ),
397  \$ vl( ldvl, * ), vr( ldvr, * ), work( * )
398 * ..
399 *
400 * =====================================================================
401 *
402 * .. Parameters ..
403  INTEGER DIFDRI
404  parameter ( difdri = 3 )
405  DOUBLE PRECISION ZERO, ONE, TWO, FOUR
406  parameter ( zero = 0.0d+0, one = 1.0d+0, two = 2.0d+0,
407  \$ four = 4.0d+0 )
408 * ..
409 * .. Local Scalars ..
410  LOGICAL LQUERY, PAIR, SOMCON, WANTBH, WANTDF, WANTS
411  INTEGER I, IERR, IFST, ILST, IZ, K, KS, LWMIN, N1, N2
412  DOUBLE PRECISION ALPHAI, ALPHAR, ALPRQT, BETA, C1, C2, COND,
413  \$ eps, lnrm, rnrm, root1, root2, scale, smlnum,
414  \$ tmpii, tmpir, tmpri, tmprr, uhav, uhavi, uhbv,
415  \$ uhbvi
416 * ..
417 * .. Local Arrays ..
418  DOUBLE PRECISION DUMMY( 1 ), DUMMY1( 1 )
419 * ..
420 * .. External Functions ..
421  LOGICAL LSAME
422  DOUBLE PRECISION DDOT, DLAMCH, DLAPY2, DNRM2
423  EXTERNAL lsame, ddot, dlamch, dlapy2, dnrm2
424 * ..
425 * .. External Subroutines ..
426  EXTERNAL dgemv, dlacpy, dlag2, dtgexc, dtgsyl, xerbla
427 * ..
428 * .. Intrinsic Functions ..
429  INTRINSIC max, min, sqrt
430 * ..
431 * .. Executable Statements ..
432 *
433 * Decode and test the input parameters
434 *
435  wantbh = lsame( job, 'B' )
436  wants = lsame( job, 'E' ) .OR. wantbh
437  wantdf = lsame( job, 'V' ) .OR. wantbh
438 *
439  somcon = lsame( howmny, 'S' )
440 *
441  info = 0
442  lquery = ( lwork.EQ.-1 )
443 *
444  IF( .NOT.wants .AND. .NOT.wantdf ) THEN
445  info = -1
446  ELSE IF( .NOT.lsame( howmny, 'A' ) .AND. .NOT.somcon ) THEN
447  info = -2
448  ELSE IF( n.LT.0 ) THEN
449  info = -4
450  ELSE IF( lda.LT.max( 1, n ) ) THEN
451  info = -6
452  ELSE IF( ldb.LT.max( 1, n ) ) THEN
453  info = -8
454  ELSE IF( wants .AND. ldvl.LT.n ) THEN
455  info = -10
456  ELSE IF( wants .AND. ldvr.LT.n ) THEN
457  info = -12
458  ELSE
459 *
460 * Set M to the number of eigenpairs for which condition numbers
461 * are required, and test MM.
462 *
463  IF( somcon ) THEN
464  m = 0
465  pair = .false.
466  DO 10 k = 1, n
467  IF( pair ) THEN
468  pair = .false.
469  ELSE
470  IF( k.LT.n ) THEN
471  IF( a( k+1, k ).EQ.zero ) THEN
472  IF( SELECT( k ) )
473  \$ m = m + 1
474  ELSE
475  pair = .true.
476  IF( SELECT( k ) .OR. SELECT( k+1 ) )
477  \$ m = m + 2
478  END IF
479  ELSE
480  IF( SELECT( n ) )
481  \$ m = m + 1
482  END IF
483  END IF
484  10 CONTINUE
485  ELSE
486  m = n
487  END IF
488 *
489  IF( n.EQ.0 ) THEN
490  lwmin = 1
491  ELSE IF( lsame( job, 'V' ) .OR. lsame( job, 'B' ) ) THEN
492  lwmin = 2*n*( n + 2 ) + 16
493  ELSE
494  lwmin = n
495  END IF
496  work( 1 ) = lwmin
497 *
498  IF( mm.LT.m ) THEN
499  info = -15
500  ELSE IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
501  info = -18
502  END IF
503  END IF
504 *
505  IF( info.NE.0 ) THEN
506  CALL xerbla( 'DTGSNA', -info )
507  RETURN
508  ELSE IF( lquery ) THEN
509  RETURN
510  END IF
511 *
512 * Quick return if possible
513 *
514  IF( n.EQ.0 )
515  \$ RETURN
516 *
517 * Get machine constants
518 *
519  eps = dlamch( 'P' )
520  smlnum = dlamch( 'S' ) / eps
521  ks = 0
522  pair = .false.
523 *
524  DO 20 k = 1, n
525 *
526 * Determine whether A(k,k) begins a 1-by-1 or 2-by-2 block.
527 *
528  IF( pair ) THEN
529  pair = .false.
530  GO TO 20
531  ELSE
532  IF( k.LT.n )
533  \$ pair = a( k+1, k ).NE.zero
534  END IF
535 *
536 * Determine whether condition numbers are required for the k-th
537 * eigenpair.
538 *
539  IF( somcon ) THEN
540  IF( pair ) THEN
541  IF( .NOT.SELECT( k ) .AND. .NOT.SELECT( k+1 ) )
542  \$ GO TO 20
543  ELSE
544  IF( .NOT.SELECT( k ) )
545  \$ GO TO 20
546  END IF
547  END IF
548 *
549  ks = ks + 1
550 *
551  IF( wants ) THEN
552 *
553 * Compute the reciprocal condition number of the k-th
554 * eigenvalue.
555 *
556  IF( pair ) THEN
557 *
558 * Complex eigenvalue pair.
559 *
560  rnrm = dlapy2( dnrm2( n, vr( 1, ks ), 1 ),
561  \$ dnrm2( n, vr( 1, ks+1 ), 1 ) )
562  lnrm = dlapy2( dnrm2( n, vl( 1, ks ), 1 ),
563  \$ dnrm2( n, vl( 1, ks+1 ), 1 ) )
564  CALL dgemv( 'N', n, n, one, a, lda, vr( 1, ks ), 1, zero,
565  \$ work, 1 )
566  tmprr = ddot( n, work, 1, vl( 1, ks ), 1 )
567  tmpri = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
568  CALL dgemv( 'N', n, n, one, a, lda, vr( 1, ks+1 ), 1,
569  \$ zero, work, 1 )
570  tmpii = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
571  tmpir = ddot( n, work, 1, vl( 1, ks ), 1 )
572  uhav = tmprr + tmpii
573  uhavi = tmpir - tmpri
574  CALL dgemv( 'N', n, n, one, b, ldb, vr( 1, ks ), 1, zero,
575  \$ work, 1 )
576  tmprr = ddot( n, work, 1, vl( 1, ks ), 1 )
577  tmpri = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
578  CALL dgemv( 'N', n, n, one, b, ldb, vr( 1, ks+1 ), 1,
579  \$ zero, work, 1 )
580  tmpii = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
581  tmpir = ddot( n, work, 1, vl( 1, ks ), 1 )
582  uhbv = tmprr + tmpii
583  uhbvi = tmpir - tmpri
584  uhav = dlapy2( uhav, uhavi )
585  uhbv = dlapy2( uhbv, uhbvi )
586  cond = dlapy2( uhav, uhbv )
587  s( ks ) = cond / ( rnrm*lnrm )
588  s( ks+1 ) = s( ks )
589 *
590  ELSE
591 *
592 * Real eigenvalue.
593 *
594  rnrm = dnrm2( n, vr( 1, ks ), 1 )
595  lnrm = dnrm2( n, vl( 1, ks ), 1 )
596  CALL dgemv( 'N', n, n, one, a, lda, vr( 1, ks ), 1, zero,
597  \$ work, 1 )
598  uhav = ddot( n, work, 1, vl( 1, ks ), 1 )
599  CALL dgemv( 'N', n, n, one, b, ldb, vr( 1, ks ), 1, zero,
600  \$ work, 1 )
601  uhbv = ddot( n, work, 1, vl( 1, ks ), 1 )
602  cond = dlapy2( uhav, uhbv )
603  IF( cond.EQ.zero ) THEN
604  s( ks ) = -one
605  ELSE
606  s( ks ) = cond / ( rnrm*lnrm )
607  END IF
608  END IF
609  END IF
610 *
611  IF( wantdf ) THEN
612  IF( n.EQ.1 ) THEN
613  dif( ks ) = dlapy2( a( 1, 1 ), b( 1, 1 ) )
614  GO TO 20
615  END IF
616 *
617 * Estimate the reciprocal condition number of the k-th
618 * eigenvectors.
619  IF( pair ) THEN
620 *
621 * Copy the 2-by 2 pencil beginning at (A(k,k), B(k, k)).
622 * Compute the eigenvalue(s) at position K.
623 *
624  work( 1 ) = a( k, k )
625  work( 2 ) = a( k+1, k )
626  work( 3 ) = a( k, k+1 )
627  work( 4 ) = a( k+1, k+1 )
628  work( 5 ) = b( k, k )
629  work( 6 ) = b( k+1, k )
630  work( 7 ) = b( k, k+1 )
631  work( 8 ) = b( k+1, k+1 )
632  CALL dlag2( work, 2, work( 5 ), 2, smlnum*eps, beta,
633  \$ dummy1( 1 ), alphar, dummy( 1 ), alphai )
634  alprqt = one
635  c1 = two*( alphar*alphar+alphai*alphai+beta*beta )
636  c2 = four*beta*beta*alphai*alphai
637  root1 = c1 + sqrt( c1*c1-4.0d0*c2 )
638  root2 = c2 / root1
639  root1 = root1 / two
640  cond = min( sqrt( root1 ), sqrt( root2 ) )
641  END IF
642 *
643 * Copy the matrix (A, B) to the array WORK and swap the
644 * diagonal block beginning at A(k,k) to the (1,1) position.
645 *
646  CALL dlacpy( 'Full', n, n, a, lda, work, n )
647  CALL dlacpy( 'Full', n, n, b, ldb, work( n*n+1 ), n )
648  ifst = k
649  ilst = 1
650 *
651  CALL dtgexc( .false., .false., n, work, n, work( n*n+1 ), n,
652  \$ dummy, 1, dummy1, 1, ifst, ilst,
653  \$ work( n*n*2+1 ), lwork-2*n*n, ierr )
654 *
655  IF( ierr.GT.0 ) THEN
656 *
657 * Ill-conditioned problem - swap rejected.
658 *
659  dif( ks ) = zero
660  ELSE
661 *
662 * Reordering successful, solve generalized Sylvester
663 * equation for R and L,
664 * A22 * R - L * A11 = A12
665 * B22 * R - L * B11 = B12,
666 * and compute estimate of Difl((A11,B11), (A22, B22)).
667 *
668  n1 = 1
669  IF( work( 2 ).NE.zero )
670  \$ n1 = 2
671  n2 = n - n1
672  IF( n2.EQ.0 ) THEN
673  dif( ks ) = cond
674  ELSE
675  i = n*n + 1
676  iz = 2*n*n + 1
677  CALL dtgsyl( 'N', difdri, n2, n1, work( n*n1+n1+1 ),
678  \$ n, work, n, work( n1+1 ), n,
679  \$ work( n*n1+n1+i ), n, work( i ), n,
680  \$ work( n1+i ), n, scale, dif( ks ),
681  \$ work( iz+1 ), lwork-2*n*n, iwork, ierr )
682 *
683  IF( pair )
684  \$ dif( ks ) = min( max( one, alprqt )*dif( ks ),
685  \$ cond )
686  END IF
687  END IF
688  IF( pair )
689  \$ dif( ks+1 ) = dif( ks )
690  END IF
691  IF( pair )
692  \$ ks = ks + 1
693 *
694  20 CONTINUE
695  work( 1 ) = lwmin
696  RETURN
697 *
698 * End of DTGSNA
699 *
700  END
subroutine dgemv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
DGEMV
Definition: dgemv.f:158
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY copies all or part of one two-dimensional array to another.
Definition: dlacpy.f:105
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine dlag2(A, LDA, B, LDB, SAFMIN, SCALE1, SCALE2, WR1, WR2, WI)
DLAG2 computes the eigenvalues of a 2-by-2 generalized eigenvalue problem, with scaling as necessary ...
Definition: dlag2.f:158
subroutine dtgexc(WANTQ, WANTZ, N, A, LDA, B, LDB, Q, LDQ, Z, LDZ, IFST, ILST, WORK, LWORK, INFO)
DTGEXC
Definition: dtgexc.f:222
subroutine dtgsyl(TRANS, IJOB, M, N, A, LDA, B, LDB, C, LDC, D, LDD, E, LDE, F, LDF, SCALE, DIF, WORK, LWORK, IWORK, INFO)
DTGSYL
Definition: dtgsyl.f:301
subroutine dtgsna(JOB, HOWMNY, SELECT, N, A, LDA, B, LDB, VL, LDVL, VR, LDVR, S, DIF, MM, M, WORK, LWORK, IWORK, INFO)
DTGSNA
Definition: dtgsna.f:383