LAPACK  3.10.0
LAPACK: Linear Algebra PACKage
dlaqz3.f
Go to the documentation of this file.
1 *> \brief \b DLAQZ3
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download DLAQZ3 + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlaqz3.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlaqz3.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlaqz3.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE DLAQZ3( ILSCHUR, ILQ, ILZ, N, ILO, IHI, NW, A, LDA, B,
22 * $ LDB, Q, LDQ, Z, LDZ, NS, ND, ALPHAR, ALPHAI, BETA, QC, LDQC,
23 * $ ZC, LDZC, WORK, LWORK, REC, INFO )
24 * IMPLICIT NONE
25 *
26 * Arguments
27 * LOGICAL, INTENT( IN ) :: ILSCHUR, ILQ, ILZ
28 * INTEGER, INTENT( IN ) :: N, ILO, IHI, NW, LDA, LDB, LDQ, LDZ,
29 * $ LDQC, LDZC, LWORK, REC
30 *
31 * DOUBLE PRECISION, INTENT( INOUT ) :: A( LDA, * ), B( LDB, * ),
32 * $ Q( LDQ, * ), Z( LDZ, * ), ALPHAR( * ), ALPHAI( * ), BETA( * )
33 * INTEGER, INTENT( OUT ) :: NS, ND, INFO
34 * DOUBLE PRECISION :: QC( LDQC, * ), ZC( LDZC, * ), WORK( * )
35 * ..
36 *
37 *
38 *> \par Purpose:
39 * =============
40 *>
41 *> \verbatim
42 *>
43 *> DLAQZ3 performs AED
44 *> \endverbatim
45 *
46 * Arguments:
47 * ==========
48 *
49 *> \param[in] ILSCHUR
50 *> \verbatim
51 *> ILSCHUR is LOGICAL
52 *> Determines whether or not to update the full Schur form
53 *> \endverbatim
54 *>
55 *> \param[in] ILQ
56 *> \verbatim
57 *> ILQ is LOGICAL
58 *> Determines whether or not to update the matrix Q
59 *> \endverbatim
60 *>
61 *> \param[in] ILZ
62 *> \verbatim
63 *> ILZ is LOGICAL
64 *> Determines whether or not to update the matrix Z
65 *> \endverbatim
66 *>
67 *> \param[in] N
68 *> \verbatim
69 *> N is INTEGER
70 *> The order of the matrices A, B, Q, and Z. N >= 0.
71 *> \endverbatim
72 *>
73 *> \param[in] ILO
74 *> \verbatim
75 *> ILO is INTEGER
76 *> \endverbatim
77 *>
78 *> \param[in] IHI
79 *> \verbatim
80 *> IHI is INTEGER
81 *> ILO and IHI mark the rows and columns of (A,B) which
82 *> are to be normalized
83 *> \endverbatim
84 *>
85 *> \param[in] NW
86 *> \verbatim
87 *> NW is INTEGER
88 *> The desired size of the deflation window.
89 *> \endverbatim
90 *>
91 *> \param[in,out] A
92 *> \verbatim
93 *> A is DOUBLE PRECISION array, dimension (LDA, N)
94 *> \endverbatim
95 *>
96 *> \param[in] LDA
97 *> \verbatim
98 *> LDA is INTEGER
99 *> The leading dimension of the array A. LDA >= max( 1, N ).
100 *> \endverbatim
101 *>
102 *> \param[in,out] B
103 *> \verbatim
104 *> B is DOUBLE PRECISION array, dimension (LDB, N)
105 *> \endverbatim
106 *>
107 *> \param[in] LDB
108 *> \verbatim
109 *> LDB is INTEGER
110 *> The leading dimension of the array B. LDB >= max( 1, N ).
111 *> \endverbatim
112 *>
113 *> \param[in,out] Q
114 *> \verbatim
115 *> Q is DOUBLE PRECISION array, dimension (LDQ, N)
116 *> \endverbatim
117 *>
118 *> \param[in] LDQ
119 *> \verbatim
120 *> LDQ is INTEGER
121 *> \endverbatim
122 *>
123 *> \param[in,out] Z
124 *> \verbatim
125 *> Z is DOUBLE PRECISION array, dimension (LDZ, N)
126 *> \endverbatim
127 *>
128 *> \param[in] LDZ
129 *> \verbatim
130 *> LDZ is INTEGER
131 *> \endverbatim
132 *>
133 *> \param[out] NS
134 *> \verbatim
135 *> NS is INTEGER
136 *> The number of unconverged eigenvalues available to
137 *> use as shifts.
138 *> \endverbatim
139 *>
140 *> \param[out] ND
141 *> \verbatim
142 *> ND is INTEGER
143 *> The number of converged eigenvalues found.
144 *> \endverbatim
145 *>
146 *> \param[out] ALPHAR
147 *> \verbatim
148 *> ALPHAR is DOUBLE PRECISION array, dimension (N)
149 *> The real parts of each scalar alpha defining an eigenvalue
150 *> of GNEP.
151 *> \endverbatim
152 *>
153 *> \param[out] ALPHAI
154 *> \verbatim
155 *> ALPHAI is DOUBLE PRECISION array, dimension (N)
156 *> The imaginary parts of each scalar alpha defining an
157 *> eigenvalue of GNEP.
158 *> If ALPHAI(j) is zero, then the j-th eigenvalue is real; if
159 *> positive, then the j-th and (j+1)-st eigenvalues are a
160 *> complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).
161 *> \endverbatim
162 *>
163 *> \param[out] BETA
164 *> \verbatim
165 *> BETA is DOUBLE PRECISION array, dimension (N)
166 *> The scalars beta that define the eigenvalues of GNEP.
167 *> Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and
168 *> beta = BETA(j) represent the j-th eigenvalue of the matrix
169 *> pair (A,B), in one of the forms lambda = alpha/beta or
170 *> mu = beta/alpha. Since either lambda or mu may overflow,
171 *> they should not, in general, be computed.
172 *> \endverbatim
173 *>
174 *> \param[in,out] QC
175 *> \verbatim
176 *> QC is DOUBLE PRECISION array, dimension (LDQC, NW)
177 *> \endverbatim
178 *>
179 *> \param[in] LDQC
180 *> \verbatim
181 *> LDQC is INTEGER
182 *> \endverbatim
183 *>
184 *> \param[in,out] ZC
185 *> \verbatim
186 *> ZC is DOUBLE PRECISION array, dimension (LDZC, NW)
187 *> \endverbatim
188 *>
189 *> \param[in] LDZC
190 *> \verbatim
191 *> LDZ is INTEGER
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 *>
205 *> If LWORK = -1, then a workspace query is assumed; the routine
206 *> only calculates the optimal size of the WORK array, returns
207 *> this value as the first entry of the WORK array, and no error
208 *> message related to LWORK is issued by XERBLA.
209 *> \endverbatim
210 *>
211 *> \param[in] REC
212 *> \verbatim
213 *> REC is INTEGER
214 *> REC indicates the current recursion level. Should be set
215 *> to 0 on first call.
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 Thijs Steel, KU Leuven
229 *
230 *> \date May 2020
231 *
232 *> \ingroup doubleGEcomputational
233 *>
234 * =====================================================================
235  RECURSIVE SUBROUTINE dlaqz3( ILSCHUR, ILQ, ILZ, N, ILO, IHI, NW,
236  $ A, LDA, B, LDB, Q, LDQ, Z, LDZ, NS,
237  $ ND, ALPHAR, ALPHAI, BETA, QC, LDQC,
238  $ ZC, LDZC, WORK, LWORK, REC, INFO )
239  IMPLICIT NONE
240 
241 * Arguments
242  LOGICAL, INTENT( IN ) :: ilschur, ilq, ilz
243  INTEGER, INTENT( IN ) :: n, ilo, ihi, nw, lda, ldb, ldq, ldz,
244  $ ldqc, ldzc, lwork, rec
245 
246  DOUBLE PRECISION, INTENT( INOUT ) :: a( lda, * ), b( ldb, * ),
247  $ q( ldq, * ), z( ldz, * ), alphar( * ),
248  $ alphai( * ), beta( * )
249  INTEGER, INTENT( OUT ) :: ns, nd, info
250  DOUBLE PRECISION :: qc( ldqc, * ), zc( ldzc, * ), work( * )
251 
252 * Parameters
253  DOUBLE PRECISION :: zero, one, half
254  PARAMETER( zero = 0.0d0, one = 1.0d0, half = 0.5d0 )
255 
256 * Local Scalars
257  LOGICAL :: bulge
258  INTEGER :: jw, kwtop, kwbot, istopm, istartm, k, k2, dtgexc_info,
259  $ ifst, ilst, lworkreq, qz_small_info
260  DOUBLE PRECISION :: s, smlnum, ulp, safmin, safmax, c1, s1, temp
261 
262 * External Functions
263  EXTERNAL :: xerbla, dtgexc, dlabad, dlaqz0, dlacpy, dlaset,
265  DOUBLE PRECISION, EXTERNAL :: dlamch
266 
267  info = 0
268 
269 * Set up deflation window
270  jw = min( nw, ihi-ilo+1 )
271  kwtop = ihi-jw+1
272  IF ( kwtop .EQ. ilo ) THEN
273  s = zero
274  ELSE
275  s = a( kwtop, kwtop-1 )
276  END IF
277 
278 * Determine required workspace
279  ifst = 1
280  ilst = jw
281  CALL dtgexc( .true., .true., jw, a, lda, b, ldb, qc, ldqc, zc,
282  $ ldzc, ifst, ilst, work, -1, dtgexc_info )
283  lworkreq = int( work( 1 ) )
284  CALL dlaqz0( 'S', 'V', 'V', jw, 1, jw, a( kwtop, kwtop ), lda,
285  $ b( kwtop, kwtop ), ldb, alphar, alphai, beta, qc,
286  $ ldqc, zc, ldzc, work, -1, rec+1, qz_small_info )
287  lworkreq = max( lworkreq, int( work( 1 ) )+2*jw**2 )
288  lworkreq = max( lworkreq, n*nw, 2*nw**2+n )
289  IF ( lwork .EQ.-1 ) THEN
290 * workspace query, quick return
291  work( 1 ) = lworkreq
292  RETURN
293  ELSE IF ( lwork .LT. lworkreq ) THEN
294  info = -26
295  END IF
296 
297  IF( info.NE.0 ) THEN
298  CALL xerbla( 'DLAQZ3', -info )
299  RETURN
300  END IF
301 
302 * Get machine constants
303  safmin = dlamch( 'SAFE MINIMUM' )
304  safmax = one/safmin
305  CALL dlabad( safmin, safmax )
306  ulp = dlamch( 'PRECISION' )
307  smlnum = safmin*( dble( n )/ulp )
308 
309  IF ( ihi .EQ. kwtop ) THEN
310 * 1 by 1 deflation window, just try a regular deflation
311  alphar( kwtop ) = a( kwtop, kwtop )
312  alphai( kwtop ) = zero
313  beta( kwtop ) = b( kwtop, kwtop )
314  ns = 1
315  nd = 0
316  IF ( abs( s ) .LE. max( smlnum, ulp*abs( a( kwtop,
317  $ kwtop ) ) ) ) THEN
318  ns = 0
319  nd = 1
320  IF ( kwtop .GT. ilo ) THEN
321  a( kwtop, kwtop-1 ) = zero
322  END IF
323  END IF
324  END IF
325 
326 
327 * Store window in case of convergence failure
328  CALL dlacpy( 'ALL', jw, jw, a( kwtop, kwtop ), lda, work, jw )
329  CALL dlacpy( 'ALL', jw, jw, b( kwtop, kwtop ), ldb, work( jw**2+
330  $ 1 ), jw )
331 
332 * Transform window to real schur form
333  CALL dlaset( 'FULL', jw, jw, zero, one, qc, ldqc )
334  CALL dlaset( 'FULL', jw, jw, zero, one, zc, ldzc )
335  CALL dlaqz0( 'S', 'V', 'V', jw, 1, jw, a( kwtop, kwtop ), lda,
336  $ b( kwtop, kwtop ), ldb, alphar, alphai, beta, qc,
337  $ ldqc, zc, ldzc, work( 2*jw**2+1 ), lwork-2*jw**2,
338  $ rec+1, qz_small_info )
339 
340  IF( qz_small_info .NE. 0 ) THEN
341 * Convergence failure, restore the window and exit
342  nd = 0
343  ns = jw-qz_small_info
344  CALL dlacpy( 'ALL', jw, jw, work, jw, a( kwtop, kwtop ), lda )
345  CALL dlacpy( 'ALL', jw, jw, work( jw**2+1 ), jw, b( kwtop,
346  $ kwtop ), ldb )
347  RETURN
348  END IF
349 
350 * Deflation detection loop
351  IF ( kwtop .EQ. ilo .OR. s .EQ. zero ) THEN
352  kwbot = kwtop-1
353  ELSE
354  kwbot = ihi
355  k = 1
356  k2 = 1
357  DO WHILE ( k .LE. jw )
358  bulge = .false.
359  IF ( kwbot-kwtop+1 .GE. 2 ) THEN
360  bulge = a( kwbot, kwbot-1 ) .NE. zero
361  END IF
362  IF ( bulge ) THEN
363 
364 * Try to deflate complex conjugate eigenvalue pair
365  temp = abs( a( kwbot, kwbot ) )+sqrt( abs( a( kwbot,
366  $ kwbot-1 ) ) )*sqrt( abs( a( kwbot-1, kwbot ) ) )
367  IF( temp .EQ. zero )THEN
368  temp = abs( s )
369  END IF
370  IF ( max( abs( s*qc( 1, kwbot-kwtop ) ), abs( s*qc( 1,
371  $ kwbot-kwtop+1 ) ) ) .LE. max( smlnum,
372  $ ulp*temp ) ) THEN
373 * Deflatable
374  kwbot = kwbot-2
375  ELSE
376 * Not deflatable, move out of the way
377  ifst = kwbot-kwtop+1
378  ilst = k2
379  CALL dtgexc( .true., .true., jw, a( kwtop, kwtop ),
380  $ lda, b( kwtop, kwtop ), ldb, qc, ldqc,
381  $ zc, ldzc, ifst, ilst, work, lwork,
382  $ dtgexc_info )
383  k2 = k2+2
384  END IF
385  k = k+2
386  ELSE
387 
388 * Try to deflate real eigenvalue
389  temp = abs( a( kwbot, kwbot ) )
390  IF( temp .EQ. zero ) THEN
391  temp = abs( s )
392  END IF
393  IF ( ( abs( s*qc( 1, kwbot-kwtop+1 ) ) ) .LE. max( ulp*
394  $ temp, smlnum ) ) THEN
395 * Deflatable
396  kwbot = kwbot-1
397  ELSE
398 * Not deflatable, move out of the way
399  ifst = kwbot-kwtop+1
400  ilst = k2
401  CALL dtgexc( .true., .true., jw, a( kwtop, kwtop ),
402  $ lda, b( kwtop, kwtop ), ldb, qc, ldqc,
403  $ zc, ldzc, ifst, ilst, work, lwork,
404  $ dtgexc_info )
405  k2 = k2+1
406  END IF
407 
408  k = k+1
409 
410  END IF
411  END DO
412  END IF
413 
414 * Store eigenvalues
415  nd = ihi-kwbot
416  ns = jw-nd
417  k = kwtop
418  DO WHILE ( k .LE. ihi )
419  bulge = .false.
420  IF ( k .LT. ihi ) THEN
421  IF ( a( k+1, k ) .NE. zero ) THEN
422  bulge = .true.
423  END IF
424  END IF
425  IF ( bulge ) THEN
426 * 2x2 eigenvalue block
427  CALL dlag2( a( k, k ), lda, b( k, k ), ldb, safmin,
428  $ beta( k ), beta( k+1 ), alphar( k ),
429  $ alphar( k+1 ), alphai( k ) )
430  alphai( k+1 ) = -alphai( k )
431  k = k+2
432  ELSE
433 * 1x1 eigenvalue block
434  alphar( k ) = a( k, k )
435  alphai( k ) = zero
436  beta( k ) = b( k, k )
437  k = k+1
438  END IF
439  END DO
440 
441  IF ( kwtop .NE. ilo .AND. s .NE. zero ) THEN
442 * Reflect spike back, this will create optimally packed bulges
443  a( kwtop:kwbot, kwtop-1 ) = a( kwtop, kwtop-1 )*qc( 1,
444  $ 1:jw-nd )
445  DO k = kwbot-1, kwtop, -1
446  CALL dlartg( a( k, kwtop-1 ), a( k+1, kwtop-1 ), c1, s1,
447  $ temp )
448  a( k, kwtop-1 ) = temp
449  a( k+1, kwtop-1 ) = zero
450  k2 = max( kwtop, k-1 )
451  CALL drot( ihi-k2+1, a( k, k2 ), lda, a( k+1, k2 ), lda, c1,
452  $ s1 )
453  CALL drot( ihi-( k-1 )+1, b( k, k-1 ), ldb, b( k+1, k-1 ),
454  $ ldb, c1, s1 )
455  CALL drot( jw, qc( 1, k-kwtop+1 ), 1, qc( 1, k+1-kwtop+1 ),
456  $ 1, c1, s1 )
457  END DO
458 
459 * Chase bulges down
460  istartm = kwtop
461  istopm = ihi
462  k = kwbot-1
463  DO WHILE ( k .GE. kwtop )
464  IF ( ( k .GE. kwtop+1 ) .AND. a( k+1, k-1 ) .NE. zero ) THEN
465 
466 * Move double pole block down and remove it
467  DO k2 = k-1, kwbot-2
468  CALL dlaqz2( .true., .true., k2, kwtop, kwtop+jw-1,
469  $ kwbot, a, lda, b, ldb, jw, kwtop, qc,
470  $ ldqc, jw, kwtop, zc, ldzc )
471  END DO
472 
473  k = k-2
474  ELSE
475 
476 * k points to single shift
477  DO k2 = k, kwbot-2
478 
479 * Move shift down
480  CALL dlartg( b( k2+1, k2+1 ), b( k2+1, k2 ), c1, s1,
481  $ temp )
482  b( k2+1, k2+1 ) = temp
483  b( k2+1, k2 ) = zero
484  CALL drot( k2+2-istartm+1, a( istartm, k2+1 ), 1,
485  $ a( istartm, k2 ), 1, c1, s1 )
486  CALL drot( k2-istartm+1, b( istartm, k2+1 ), 1,
487  $ b( istartm, k2 ), 1, c1, s1 )
488  CALL drot( jw, zc( 1, k2+1-kwtop+1 ), 1, zc( 1,
489  $ k2-kwtop+1 ), 1, c1, s1 )
490 
491  CALL dlartg( a( k2+1, k2 ), a( k2+2, k2 ), c1, s1,
492  $ temp )
493  a( k2+1, k2 ) = temp
494  a( k2+2, k2 ) = zero
495  CALL drot( istopm-k2, a( k2+1, k2+1 ), lda, a( k2+2,
496  $ k2+1 ), lda, c1, s1 )
497  CALL drot( istopm-k2, b( k2+1, k2+1 ), ldb, b( k2+2,
498  $ k2+1 ), ldb, c1, s1 )
499  CALL drot( jw, qc( 1, k2+1-kwtop+1 ), 1, qc( 1,
500  $ k2+2-kwtop+1 ), 1, c1, s1 )
501 
502  END DO
503 
504 * Remove the shift
505  CALL dlartg( b( kwbot, kwbot ), b( kwbot, kwbot-1 ), c1,
506  $ s1, temp )
507  b( kwbot, kwbot ) = temp
508  b( kwbot, kwbot-1 ) = zero
509  CALL drot( kwbot-istartm, b( istartm, kwbot ), 1,
510  $ b( istartm, kwbot-1 ), 1, c1, s1 )
511  CALL drot( kwbot-istartm+1, a( istartm, kwbot ), 1,
512  $ a( istartm, kwbot-1 ), 1, c1, s1 )
513  CALL drot( jw, zc( 1, kwbot-kwtop+1 ), 1, zc( 1,
514  $ kwbot-1-kwtop+1 ), 1, c1, s1 )
515 
516  k = k-1
517  END IF
518  END DO
519 
520  END IF
521 
522 * Apply Qc and Zc to rest of the matrix
523  IF ( ilschur ) THEN
524  istartm = 1
525  istopm = n
526  ELSE
527  istartm = ilo
528  istopm = ihi
529  END IF
530 
531  IF ( istopm-ihi > 0 ) THEN
532  CALL dgemm( 'T', 'N', jw, istopm-ihi, jw, one, qc, ldqc,
533  $ a( kwtop, ihi+1 ), lda, zero, work, jw )
534  CALL dlacpy( 'ALL', jw, istopm-ihi, work, jw, a( kwtop,
535  $ ihi+1 ), lda )
536  CALL dgemm( 'T', 'N', jw, istopm-ihi, jw, one, qc, ldqc,
537  $ b( kwtop, ihi+1 ), ldb, zero, work, jw )
538  CALL dlacpy( 'ALL', jw, istopm-ihi, work, jw, b( kwtop,
539  $ ihi+1 ), ldb )
540  END IF
541  IF ( ilq ) THEN
542  CALL dgemm( 'N', 'N', n, jw, jw, one, q( 1, kwtop ), ldq, qc,
543  $ ldqc, zero, work, n )
544  CALL dlacpy( 'ALL', n, jw, work, n, q( 1, kwtop ), ldq )
545  END IF
546 
547  IF ( kwtop-1-istartm+1 > 0 ) THEN
548  CALL dgemm( 'N', 'N', kwtop-istartm, jw, jw, one, a( istartm,
549  $ kwtop ), lda, zc, ldzc, zero, work,
550  $ kwtop-istartm )
551  CALL dlacpy( 'ALL', kwtop-istartm, jw, work, kwtop-istartm,
552  $ a( istartm, kwtop ), lda )
553  CALL dgemm( 'N', 'N', kwtop-istartm, jw, jw, one, b( istartm,
554  $ kwtop ), ldb, zc, ldzc, zero, work,
555  $ kwtop-istartm )
556  CALL dlacpy( 'ALL', kwtop-istartm, jw, work, kwtop-istartm,
557  $ b( istartm, kwtop ), ldb )
558  END IF
559  IF ( ilz ) THEN
560  CALL dgemm( 'N', 'N', n, jw, jw, one, z( 1, kwtop ), ldz, zc,
561  $ ldzc, zero, work, n )
562  CALL dlacpy( 'ALL', n, jw, work, n, z( 1, kwtop ), ldz )
563  END IF
564 
565  END SUBROUTINE
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
subroutine dlabad(SMALL, LARGE)
DLABAD
Definition: dlabad.f:74
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY copies all or part of one two-dimensional array to another.
Definition: dlacpy.f:103
subroutine dlartg(f, g, c, s, r)
DLARTG generates a plane rotation with real cosine and real sine.
Definition: dlartg.f90:113
subroutine dlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: dlaset.f:110
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine drot(N, DX, INCX, DY, INCY, C, S)
DROT
Definition: drot.f:92
subroutine dgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
DGEMM
Definition: dgemm.f:187
subroutine dtgexc(WANTQ, WANTZ, N, A, LDA, B, LDB, Q, LDQ, Z, LDZ, IFST, ILST, WORK, LWORK, INFO)
DTGEXC
Definition: dtgexc.f:220
recursive subroutine dlaqz0(WANTS, WANTQ, WANTZ, N, ILO, IHI, A, LDA, B, LDB, ALPHAR, ALPHAI, BETA, Q, LDQ, Z, LDZ, WORK, LWORK, REC, INFO)
DLAQZ0
Definition: dlaqz0.f:306
recursive subroutine dlaqz3(ILSCHUR, ILQ, ILZ, N, ILO, IHI, NW, A, LDA, B, LDB, Q, LDQ, Z, LDZ, NS, ND, ALPHAR, ALPHAI, BETA, QC, LDQC, ZC, LDZC, WORK, LWORK, REC, INFO)
DLAQZ3
Definition: dlaqz3.f:239
subroutine dlaqz2(ILQ, ILZ, K, ISTARTM, ISTOPM, IHI, A, LDA, B, LDB, NQ, QSTART, Q, LDQ, NZ, ZSTART, Z, LDZ)
DLAQZ2
Definition: dlaqz2.f:174
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:156