LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ zlaqr4()

subroutine zlaqr4 ( logical  WANTT,
logical  WANTZ,
integer  N,
integer  ILO,
integer  IHI,
complex*16, dimension( ldh, * )  H,
integer  LDH,
complex*16, dimension( * )  W,
integer  ILOZ,
integer  IHIZ,
complex*16, dimension( ldz, * )  Z,
integer  LDZ,
complex*16, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

ZLAQR4 computes the eigenvalues of a Hessenberg matrix, and optionally the matrices from the Schur decomposition.

Download ZLAQR4 + dependencies [TGZ] [ZIP] [TXT]

Purpose:
    ZLAQR4 implements one level of recursion for ZLAQR0.
    It is a complete implementation of the small bulge multi-shift
    QR algorithm.  It may be called by ZLAQR0 and, for large enough
    deflation window size, it may be called by ZLAQR3.  This
    subroutine is identical to ZLAQR0 except that it calls ZLAQR2
    instead of ZLAQR3.

    ZLAQR4 computes the eigenvalues of a Hessenberg matrix H
    and, optionally, the matrices T and Z from the Schur decomposition
    H = Z T Z**H, where T is an upper triangular matrix (the
    Schur form), and Z is the unitary matrix of Schur vectors.

    Optionally Z may be postmultiplied into an input unitary
    matrix Q so that this routine can give the Schur factorization
    of a matrix A which has been reduced to the Hessenberg form H
    by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*H*(QZ)**H.
Parameters
[in]WANTT
          WANTT is LOGICAL
          = .TRUE. : the full Schur form T is required;
          = .FALSE.: only eigenvalues are required.
[in]WANTZ
          WANTZ is LOGICAL
          = .TRUE. : the matrix of Schur vectors Z is required;
          = .FALSE.: Schur vectors are not required.
[in]N
          N is INTEGER
           The order of the matrix H.  N .GE. 0.
[in]ILO
          ILO is INTEGER
[in]IHI
          IHI is INTEGER
           It is assumed that H is already upper triangular in rows
           and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,
           H(ILO,ILO-1) is zero. ILO and IHI are normally set by a
           previous call to ZGEBAL, and then passed to ZGEHRD when the
           matrix output by ZGEBAL is reduced to Hessenberg form.
           Otherwise, ILO and IHI should be set to 1 and N,
           respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.
           If N = 0, then ILO = 1 and IHI = 0.
[in,out]H
          H is COMPLEX*16 array, dimension (LDH,N)
           On entry, the upper Hessenberg matrix H.
           On exit, if INFO = 0 and WANTT is .TRUE., then H
           contains the upper triangular matrix T from the Schur
           decomposition (the Schur form). If INFO = 0 and WANT is
           .FALSE., then the contents of H are unspecified on exit.
           (The output value of H when INFO.GT.0 is given under the
           description of INFO below.)

           This subroutine may explicitly set H(i,j) = 0 for i.GT.j and
           j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N.
[in]LDH
          LDH is INTEGER
           The leading dimension of the array H. LDH .GE. max(1,N).
[out]W
          W is COMPLEX*16 array, dimension (N)
           The computed eigenvalues of H(ILO:IHI,ILO:IHI) are stored
           in W(ILO:IHI). If WANTT is .TRUE., then the eigenvalues are
           stored in the same order as on the diagonal of the Schur
           form returned in H, with W(i) = H(i,i).
[in]ILOZ
          ILOZ is INTEGER
[in]IHIZ
          IHIZ is INTEGER
           Specify the rows of Z to which transformations must be
           applied if WANTZ is .TRUE..
           1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N.
[in,out]Z
          Z is COMPLEX*16 array, dimension (LDZ,IHI)
           If WANTZ is .FALSE., then Z is not referenced.
           If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is
           replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the
           orthogonal Schur factor of H(ILO:IHI,ILO:IHI).
           (The output value of Z when INFO.GT.0 is given under
           the description of INFO below.)
[in]LDZ
          LDZ is INTEGER
           The leading dimension of the array Z.  if WANTZ is .TRUE.
           then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1.
[out]WORK
          WORK is COMPLEX*16 array, dimension LWORK
           On exit, if LWORK = -1, WORK(1) returns an estimate of
           the optimal value for LWORK.
[in]LWORK
          LWORK is INTEGER
           The dimension of the array WORK.  LWORK .GE. max(1,N)
           is sufficient, but LWORK typically as large as 6*N may
           be required for optimal performance.  A workspace query
           to determine the optimal workspace size is recommended.

           If LWORK = -1, then ZLAQR4 does a workspace query.
           In this case, ZLAQR4 checks the input parameters and
           estimates the optimal workspace size for the given
           values of N, ILO and IHI.  The estimate is returned
           in WORK(1).  No error message related to LWORK is
           issued by XERBLA.  Neither H nor Z are accessed.
[out]INFO
          INFO is INTEGER
             =  0:  successful exit
           .GT. 0:  if INFO = i, ZLAQR4 failed to compute all of
                the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR
                and WI contain those eigenvalues which have been
                successfully computed.  (Failures are rare.)

                If INFO .GT. 0 and WANT is .FALSE., then on exit,
                the remaining unconverged eigenvalues are the eigen-
                values of the upper Hessenberg matrix rows and
                columns ILO through INFO of the final, output
                value of H.

                If INFO .GT. 0 and WANTT is .TRUE., then on exit

           (*)  (initial value of H)*U  = U*(final value of H)

                where U is a unitary matrix.  The final
                value of  H is upper Hessenberg and triangular in
                rows and columns INFO+1 through IHI.

                If INFO .GT. 0 and WANTZ is .TRUE., then on exit

                  (final value of Z(ILO:IHI,ILOZ:IHIZ)
                   =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U

                where U is the unitary matrix in (*) (regard-
                less of the value of WANTT.)

                If INFO .GT. 0 and WANTZ is .FALSE., then Z is not
                accessed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
December 2016
Contributors:
Karen Braman and Ralph Byers, Department of Mathematics, University of Kansas, USA
References:
K. Braman, R. Byers and R. Mathias, The Multi-Shift QR Algorithm Part I: Maintaining Well Focused Shifts, and Level 3 Performance, SIAM Journal of Matrix Analysis, volume 23, pages 929–947, 2002.
K. Braman, R. Byers and R. Mathias, The Multi-Shift QR Algorithm Part II: Aggressive Early Deflation, SIAM Journal of Matrix Analysis, volume 23, pages 948–973, 2002.

Definition at line 249 of file zlaqr4.f.

249 *
250 * -- LAPACK auxiliary routine (version 3.7.0) --
251 * -- LAPACK is a software package provided by Univ. of Tennessee, --
252 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
253 * December 2016
254 *
255 * .. Scalar Arguments ..
256  INTEGER ihi, ihiz, ilo, iloz, info, ldh, ldz, lwork, n
257  LOGICAL wantt, wantz
258 * ..
259 * .. Array Arguments ..
260  COMPLEX*16 h( ldh, * ), w( * ), work( * ), z( ldz, * )
261 * ..
262 *
263 * ================================================================
264 *
265 * .. Parameters ..
266 *
267 * ==== Matrices of order NTINY or smaller must be processed by
268 * . ZLAHQR because of insufficient subdiagonal scratch space.
269 * . (This is a hard limit.) ====
270  INTEGER ntiny
271  parameter( ntiny = 11 )
272 *
273 * ==== Exceptional deflation windows: try to cure rare
274 * . slow convergence by varying the size of the
275 * . deflation window after KEXNW iterations. ====
276  INTEGER kexnw
277  parameter( kexnw = 5 )
278 *
279 * ==== Exceptional shifts: try to cure rare slow convergence
280 * . with ad-hoc exceptional shifts every KEXSH iterations.
281 * . ====
282  INTEGER kexsh
283  parameter( kexsh = 6 )
284 *
285 * ==== The constant WILK1 is used to form the exceptional
286 * . shifts. ====
287  DOUBLE PRECISION wilk1
288  parameter( wilk1 = 0.75d0 )
289  COMPLEX*16 zero, one
290  parameter( zero = ( 0.0d0, 0.0d0 ),
291  $ one = ( 1.0d0, 0.0d0 ) )
292  DOUBLE PRECISION two
293  parameter( two = 2.0d0 )
294 * ..
295 * .. Local Scalars ..
296  COMPLEX*16 aa, bb, cc, cdum, dd, det, rtdisc, swap, tr2
297  DOUBLE PRECISION s
298  INTEGER i, inf, it, itmax, k, kacc22, kbot, kdu, ks,
299  $ kt, ktop, ku, kv, kwh, kwtop, kwv, ld, ls,
300  $ lwkopt, ndec, ndfl, nh, nho, nibble, nmin, ns,
301  $ nsmax, nsr, nve, nw, nwmax, nwr, nwupbd
302  LOGICAL sorted
303  CHARACTER jbcmpz*2
304 * ..
305 * .. External Functions ..
306  INTEGER ilaenv
307  EXTERNAL ilaenv
308 * ..
309 * .. Local Arrays ..
310  COMPLEX*16 zdum( 1, 1 )
311 * ..
312 * .. External Subroutines ..
313  EXTERNAL zlacpy, zlahqr, zlaqr2, zlaqr5
314 * ..
315 * .. Intrinsic Functions ..
316  INTRINSIC abs, dble, dcmplx, dimag, int, max, min, mod,
317  $ sqrt
318 * ..
319 * .. Statement Functions ..
320  DOUBLE PRECISION cabs1
321 * ..
322 * .. Statement Function definitions ..
323  cabs1( cdum ) = abs( dble( cdum ) ) + abs( dimag( cdum ) )
324 * ..
325 * .. Executable Statements ..
326  info = 0
327 *
328 * ==== Quick return for N = 0: nothing to do. ====
329 *
330  IF( n.EQ.0 ) THEN
331  work( 1 ) = one
332  RETURN
333  END IF
334 *
335  IF( n.LE.ntiny ) THEN
336 *
337 * ==== Tiny matrices must use ZLAHQR. ====
338 *
339  lwkopt = 1
340  IF( lwork.NE.-1 )
341  $ CALL zlahqr( wantt, wantz, n, ilo, ihi, h, ldh, w, iloz,
342  $ ihiz, z, ldz, info )
343  ELSE
344 *
345 * ==== Use small bulge multi-shift QR with aggressive early
346 * . deflation on larger-than-tiny matrices. ====
347 *
348 * ==== Hope for the best. ====
349 *
350  info = 0
351 *
352 * ==== Set up job flags for ILAENV. ====
353 *
354  IF( wantt ) THEN
355  jbcmpz( 1: 1 ) = 'S'
356  ELSE
357  jbcmpz( 1: 1 ) = 'E'
358  END IF
359  IF( wantz ) THEN
360  jbcmpz( 2: 2 ) = 'V'
361  ELSE
362  jbcmpz( 2: 2 ) = 'N'
363  END IF
364 *
365 * ==== NWR = recommended deflation window size. At this
366 * . point, N .GT. NTINY = 11, so there is enough
367 * . subdiagonal workspace for NWR.GE.2 as required.
368 * . (In fact, there is enough subdiagonal space for
369 * . NWR.GE.3.) ====
370 *
371  nwr = ilaenv( 13, 'ZLAQR4', jbcmpz, n, ilo, ihi, lwork )
372  nwr = max( 2, nwr )
373  nwr = min( ihi-ilo+1, ( n-1 ) / 3, nwr )
374 *
375 * ==== NSR = recommended number of simultaneous shifts.
376 * . At this point N .GT. NTINY = 11, so there is at
377 * . enough subdiagonal workspace for NSR to be even
378 * . and greater than or equal to two as required. ====
379 *
380  nsr = ilaenv( 15, 'ZLAQR4', jbcmpz, n, ilo, ihi, lwork )
381  nsr = min( nsr, ( n+6 ) / 9, ihi-ilo )
382  nsr = max( 2, nsr-mod( nsr, 2 ) )
383 *
384 * ==== Estimate optimal workspace ====
385 *
386 * ==== Workspace query call to ZLAQR2 ====
387 *
388  CALL zlaqr2( wantt, wantz, n, ilo, ihi, nwr+1, h, ldh, iloz,
389  $ ihiz, z, ldz, ls, ld, w, h, ldh, n, h, ldh, n, h,
390  $ ldh, work, -1 )
391 *
392 * ==== Optimal workspace = MAX(ZLAQR5, ZLAQR2) ====
393 *
394  lwkopt = max( 3*nsr / 2, int( work( 1 ) ) )
395 *
396 * ==== Quick return in case of workspace query. ====
397 *
398  IF( lwork.EQ.-1 ) THEN
399  work( 1 ) = dcmplx( lwkopt, 0 )
400  RETURN
401  END IF
402 *
403 * ==== ZLAHQR/ZLAQR0 crossover point ====
404 *
405  nmin = ilaenv( 12, 'ZLAQR4', jbcmpz, n, ilo, ihi, lwork )
406  nmin = max( ntiny, nmin )
407 *
408 * ==== Nibble crossover point ====
409 *
410  nibble = ilaenv( 14, 'ZLAQR4', jbcmpz, n, ilo, ihi, lwork )
411  nibble = max( 0, nibble )
412 *
413 * ==== Accumulate reflections during ttswp? Use block
414 * . 2-by-2 structure during matrix-matrix multiply? ====
415 *
416  kacc22 = ilaenv( 16, 'ZLAQR4', jbcmpz, n, ilo, ihi, lwork )
417  kacc22 = max( 0, kacc22 )
418  kacc22 = min( 2, kacc22 )
419 *
420 * ==== NWMAX = the largest possible deflation window for
421 * . which there is sufficient workspace. ====
422 *
423  nwmax = min( ( n-1 ) / 3, lwork / 2 )
424  nw = nwmax
425 *
426 * ==== NSMAX = the Largest number of simultaneous shifts
427 * . for which there is sufficient workspace. ====
428 *
429  nsmax = min( ( n+6 ) / 9, 2*lwork / 3 )
430  nsmax = nsmax - mod( nsmax, 2 )
431 *
432 * ==== NDFL: an iteration count restarted at deflation. ====
433 *
434  ndfl = 1
435 *
436 * ==== ITMAX = iteration limit ====
437 *
438  itmax = max( 30, 2*kexsh )*max( 10, ( ihi-ilo+1 ) )
439 *
440 * ==== Last row and column in the active block ====
441 *
442  kbot = ihi
443 *
444 * ==== Main Loop ====
445 *
446  DO 70 it = 1, itmax
447 *
448 * ==== Done when KBOT falls below ILO ====
449 *
450  IF( kbot.LT.ilo )
451  $ GO TO 80
452 *
453 * ==== Locate active block ====
454 *
455  DO 10 k = kbot, ilo + 1, -1
456  IF( h( k, k-1 ).EQ.zero )
457  $ GO TO 20
458  10 CONTINUE
459  k = ilo
460  20 CONTINUE
461  ktop = k
462 *
463 * ==== Select deflation window size:
464 * . Typical Case:
465 * . If possible and advisable, nibble the entire
466 * . active block. If not, use size MIN(NWR,NWMAX)
467 * . or MIN(NWR+1,NWMAX) depending upon which has
468 * . the smaller corresponding subdiagonal entry
469 * . (a heuristic).
470 * .
471 * . Exceptional Case:
472 * . If there have been no deflations in KEXNW or
473 * . more iterations, then vary the deflation window
474 * . size. At first, because, larger windows are,
475 * . in general, more powerful than smaller ones,
476 * . rapidly increase the window to the maximum possible.
477 * . Then, gradually reduce the window size. ====
478 *
479  nh = kbot - ktop + 1
480  nwupbd = min( nh, nwmax )
481  IF( ndfl.LT.kexnw ) THEN
482  nw = min( nwupbd, nwr )
483  ELSE
484  nw = min( nwupbd, 2*nw )
485  END IF
486  IF( nw.LT.nwmax ) THEN
487  IF( nw.GE.nh-1 ) THEN
488  nw = nh
489  ELSE
490  kwtop = kbot - nw + 1
491  IF( cabs1( h( kwtop, kwtop-1 ) ).GT.
492  $ cabs1( h( kwtop-1, kwtop-2 ) ) )nw = nw + 1
493  END IF
494  END IF
495  IF( ndfl.LT.kexnw ) THEN
496  ndec = -1
497  ELSE IF( ndec.GE.0 .OR. nw.GE.nwupbd ) THEN
498  ndec = ndec + 1
499  IF( nw-ndec.LT.2 )
500  $ ndec = 0
501  nw = nw - ndec
502  END IF
503 *
504 * ==== Aggressive early deflation:
505 * . split workspace under the subdiagonal into
506 * . - an nw-by-nw work array V in the lower
507 * . left-hand-corner,
508 * . - an NW-by-at-least-NW-but-more-is-better
509 * . (NW-by-NHO) horizontal work array along
510 * . the bottom edge,
511 * . - an at-least-NW-but-more-is-better (NHV-by-NW)
512 * . vertical work array along the left-hand-edge.
513 * . ====
514 *
515  kv = n - nw + 1
516  kt = nw + 1
517  nho = ( n-nw-1 ) - kt + 1
518  kwv = nw + 2
519  nve = ( n-nw ) - kwv + 1
520 *
521 * ==== Aggressive early deflation ====
522 *
523  CALL zlaqr2( wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz,
524  $ ihiz, z, ldz, ls, ld, w, h( kv, 1 ), ldh, nho,
525  $ h( kv, kt ), ldh, nve, h( kwv, 1 ), ldh, work,
526  $ lwork )
527 *
528 * ==== Adjust KBOT accounting for new deflations. ====
529 *
530  kbot = kbot - ld
531 *
532 * ==== KS points to the shifts. ====
533 *
534  ks = kbot - ls + 1
535 *
536 * ==== Skip an expensive QR sweep if there is a (partly
537 * . heuristic) reason to expect that many eigenvalues
538 * . will deflate without it. Here, the QR sweep is
539 * . skipped if many eigenvalues have just been deflated
540 * . or if the remaining active block is small.
541 *
542  IF( ( ld.EQ.0 ) .OR. ( ( 100*ld.LE.nw*nibble ) .AND. ( kbot-
543  $ ktop+1.GT.min( nmin, nwmax ) ) ) ) THEN
544 *
545 * ==== NS = nominal number of simultaneous shifts.
546 * . This may be lowered (slightly) if ZLAQR2
547 * . did not provide that many shifts. ====
548 *
549  ns = min( nsmax, nsr, max( 2, kbot-ktop ) )
550  ns = ns - mod( ns, 2 )
551 *
552 * ==== If there have been no deflations
553 * . in a multiple of KEXSH iterations,
554 * . then try exceptional shifts.
555 * . Otherwise use shifts provided by
556 * . ZLAQR2 above or from the eigenvalues
557 * . of a trailing principal submatrix. ====
558 *
559  IF( mod( ndfl, kexsh ).EQ.0 ) THEN
560  ks = kbot - ns + 1
561  DO 30 i = kbot, ks + 1, -2
562  w( i ) = h( i, i ) + wilk1*cabs1( h( i, i-1 ) )
563  w( i-1 ) = w( i )
564  30 CONTINUE
565  ELSE
566 *
567 * ==== Got NS/2 or fewer shifts? Use ZLAHQR
568 * . on a trailing principal submatrix to
569 * . get more. (Since NS.LE.NSMAX.LE.(N+6)/9,
570 * . there is enough space below the subdiagonal
571 * . to fit an NS-by-NS scratch array.) ====
572 *
573  IF( kbot-ks+1.LE.ns / 2 ) THEN
574  ks = kbot - ns + 1
575  kt = n - ns + 1
576  CALL zlacpy( 'A', ns, ns, h( ks, ks ), ldh,
577  $ h( kt, 1 ), ldh )
578  CALL zlahqr( .false., .false., ns, 1, ns,
579  $ h( kt, 1 ), ldh, w( ks ), 1, 1, zdum,
580  $ 1, inf )
581  ks = ks + inf
582 *
583 * ==== In case of a rare QR failure use
584 * . eigenvalues of the trailing 2-by-2
585 * . principal submatrix. Scale to avoid
586 * . overflows, underflows and subnormals.
587 * . (The scale factor S can not be zero,
588 * . because H(KBOT,KBOT-1) is nonzero.) ====
589 *
590  IF( ks.GE.kbot ) THEN
591  s = cabs1( h( kbot-1, kbot-1 ) ) +
592  $ cabs1( h( kbot, kbot-1 ) ) +
593  $ cabs1( h( kbot-1, kbot ) ) +
594  $ cabs1( h( kbot, kbot ) )
595  aa = h( kbot-1, kbot-1 ) / s
596  cc = h( kbot, kbot-1 ) / s
597  bb = h( kbot-1, kbot ) / s
598  dd = h( kbot, kbot ) / s
599  tr2 = ( aa+dd ) / two
600  det = ( aa-tr2 )*( dd-tr2 ) - bb*cc
601  rtdisc = sqrt( -det )
602  w( kbot-1 ) = ( tr2+rtdisc )*s
603  w( kbot ) = ( tr2-rtdisc )*s
604 *
605  ks = kbot - 1
606  END IF
607  END IF
608 *
609  IF( kbot-ks+1.GT.ns ) THEN
610 *
611 * ==== Sort the shifts (Helps a little) ====
612 *
613  sorted = .false.
614  DO 50 k = kbot, ks + 1, -1
615  IF( sorted )
616  $ GO TO 60
617  sorted = .true.
618  DO 40 i = ks, k - 1
619  IF( cabs1( w( i ) ).LT.cabs1( w( i+1 ) ) )
620  $ THEN
621  sorted = .false.
622  swap = w( i )
623  w( i ) = w( i+1 )
624  w( i+1 ) = swap
625  END IF
626  40 CONTINUE
627  50 CONTINUE
628  60 CONTINUE
629  END IF
630  END IF
631 *
632 * ==== If there are only two shifts, then use
633 * . only one. ====
634 *
635  IF( kbot-ks+1.EQ.2 ) THEN
636  IF( cabs1( w( kbot )-h( kbot, kbot ) ).LT.
637  $ cabs1( w( kbot-1 )-h( kbot, kbot ) ) ) THEN
638  w( kbot-1 ) = w( kbot )
639  ELSE
640  w( kbot ) = w( kbot-1 )
641  END IF
642  END IF
643 *
644 * ==== Use up to NS of the the smallest magnatiude
645 * . shifts. If there aren't NS shifts available,
646 * . then use them all, possibly dropping one to
647 * . make the number of shifts even. ====
648 *
649  ns = min( ns, kbot-ks+1 )
650  ns = ns - mod( ns, 2 )
651  ks = kbot - ns + 1
652 *
653 * ==== Small-bulge multi-shift QR sweep:
654 * . split workspace under the subdiagonal into
655 * . - a KDU-by-KDU work array U in the lower
656 * . left-hand-corner,
657 * . - a KDU-by-at-least-KDU-but-more-is-better
658 * . (KDU-by-NHo) horizontal work array WH along
659 * . the bottom edge,
660 * . - and an at-least-KDU-but-more-is-better-by-KDU
661 * . (NVE-by-KDU) vertical work WV arrow along
662 * . the left-hand-edge. ====
663 *
664  kdu = 3*ns - 3
665  ku = n - kdu + 1
666  kwh = kdu + 1
667  nho = ( n-kdu+1-4 ) - ( kdu+1 ) + 1
668  kwv = kdu + 4
669  nve = n - kdu - kwv + 1
670 *
671 * ==== Small-bulge multi-shift QR sweep ====
672 *
673  CALL zlaqr5( wantt, wantz, kacc22, n, ktop, kbot, ns,
674  $ w( ks ), h, ldh, iloz, ihiz, z, ldz, work,
675  $ 3, h( ku, 1 ), ldh, nve, h( kwv, 1 ), ldh,
676  $ nho, h( ku, kwh ), ldh )
677  END IF
678 *
679 * ==== Note progress (or the lack of it). ====
680 *
681  IF( ld.GT.0 ) THEN
682  ndfl = 1
683  ELSE
684  ndfl = ndfl + 1
685  END IF
686 *
687 * ==== End of main loop ====
688  70 CONTINUE
689 *
690 * ==== Iteration limit exceeded. Set INFO to show where
691 * . the problem occurred and exit. ====
692 *
693  info = kbot
694  80 CONTINUE
695  END IF
696 *
697 * ==== Return the optimal value of LWORK. ====
698 *
699  work( 1 ) = dcmplx( lwkopt, 0 )
700 *
701 * ==== End of ZLAQR4 ====
702 *
subroutine zlahqr(WANTT, WANTZ, N, ILO, IHI, H, LDH, W, ILOZ, IHIZ, Z, LDZ, INFO)
ZLAHQR computes the eigenvalues and Schur factorization of an upper Hessenberg matrix, using the double-shift/single-shift QR algorithm.
Definition: zlahqr.f:197
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:105
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: tstiee.f:83
subroutine zlaqr5(WANTT, WANTZ, KACC22, N, KTOP, KBOT, NSHFTS, S, H, LDH, ILOZ, IHIZ, Z, LDZ, V, LDV, U, LDU, NV, WV, LDWV, NH, WH, LDWH)
ZLAQR5 performs a single small-bulge multi-shift QR sweep.
Definition: zlaqr5.f:251
subroutine zlaqr2(WANTT, WANTZ, N, KTOP, KBOT, NW, H, LDH, ILOZ, IHIZ, Z, LDZ, NS, ND, SH, V, LDV, NH, T, LDT, NV, WV, LDWV, WORK, LWORK)
ZLAQR2 performs the unitary similarity transformation of a Hessenberg matrix to detect and deflate fu...
Definition: zlaqr2.f:272
Here is the call graph for this function:
Here is the caller graph for this function: