LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ claqr0()

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

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

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

Purpose:
    CLAQR0 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 >= 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 > 1,
           H(ILO,ILO-1) is zero. ILO and IHI are normally set by a
           previous call to CGEBAL, and then passed to CGEHRD when the
           matrix output by CGEBAL is reduced to Hessenberg form.
           Otherwise, ILO and IHI should be set to 1 and N,
           respectively.  If N > 0, then 1 <= ILO <= IHI <= N.
           If N = 0, then ILO = 1 and IHI = 0.
[in,out]H
          H is COMPLEX 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 > 0 is given under the
           description of INFO below.)

           This subroutine may explicitly set H(i,j) = 0 for i > 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 >= max(1,N).
[out]W
          W is COMPLEX 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 <= ILOZ <= ILO; IHI <= IHIZ <= N.
[in,out]Z
          Z is COMPLEX 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 > 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 >= MAX(1,IHIZ).  Otherwise, LDZ >= 1.
[out]WORK
          WORK is COMPLEX 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 >= 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 CLAQR0 does a workspace query.
           In this case, CLAQR0 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
             > 0:  if INFO = i, CLAQR0 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 > 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 > 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 > 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 > 0 and WANTZ is .FALSE., then Z is not
                accessed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
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 238 of file claqr0.f.

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