LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ cheevr()

subroutine cheevr ( character  JOBZ,
character  RANGE,
character  UPLO,
integer  N,
complex, dimension( lda, * )  A,
integer  LDA,
real  VL,
real  VU,
integer  IL,
integer  IU,
real  ABSTOL,
integer  M,
real, dimension( * )  W,
complex, dimension( ldz, * )  Z,
integer  LDZ,
integer, dimension( * )  ISUPPZ,
complex, dimension( * )  WORK,
integer  LWORK,
real, dimension( * )  RWORK,
integer  LRWORK,
integer, dimension( * )  IWORK,
integer  LIWORK,
integer  INFO 
)

CHEEVR computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices

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

Purpose:
 CHEEVR computes selected eigenvalues and, optionally, eigenvectors
 of a complex Hermitian matrix A.  Eigenvalues and eigenvectors can
 be selected by specifying either a range of values or a range of
 indices for the desired eigenvalues.

 CHEEVR first reduces the matrix A to tridiagonal form T with a call
 to CHETRD.  Then, whenever possible, CHEEVR calls CSTEMR to compute
 the eigenspectrum using Relatively Robust Representations.  CSTEMR
 computes eigenvalues by the dqds algorithm, while orthogonal
 eigenvectors are computed from various "good" L D L^T representations
 (also known as Relatively Robust Representations). Gram-Schmidt
 orthogonalization is avoided as far as possible. More specifically,
 the various steps of the algorithm are as follows.

 For each unreduced block (submatrix) of T,
    (a) Compute T - sigma I  = L D L^T, so that L and D
        define all the wanted eigenvalues to high relative accuracy.
        This means that small relative changes in the entries of D and L
        cause only small relative changes in the eigenvalues and
        eigenvectors. The standard (unfactored) representation of the
        tridiagonal matrix T does not have this property in general.
    (b) Compute the eigenvalues to suitable accuracy.
        If the eigenvectors are desired, the algorithm attains full
        accuracy of the computed eigenvalues only right before
        the corresponding vectors have to be computed, see steps c) and d).
    (c) For each cluster of close eigenvalues, select a new
        shift close to the cluster, find a new factorization, and refine
        the shifted eigenvalues to suitable accuracy.
    (d) For each eigenvalue with a large enough relative separation compute
        the corresponding eigenvector by forming a rank revealing twisted
        factorization. Go back to (c) for any clusters that remain.

 The desired accuracy of the output can be specified by the input
 parameter ABSTOL.

 For more details, see DSTEMR's documentation and:
 - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations
   to compute orthogonal eigenvectors of symmetric tridiagonal matrices,"
   Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
 - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and
   Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,
   2004.  Also LAPACK Working Note 154.
 - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric
   tridiagonal eigenvalue/eigenvector problem",
   Computer Science Division Technical Report No. UCB/CSD-97-971,
   UC Berkeley, May 1997.


 Note 1 : CHEEVR calls CSTEMR when the full spectrum is requested
 on machines which conform to the ieee-754 floating point standard.
 CHEEVR calls SSTEBZ and CSTEIN on non-ieee machines and
 when partial spectrum requests are made.

 Normal execution of CSTEMR may create NaNs and infinities and
 hence may abort due to a floating point exception in environments
 which do not handle NaNs and infinities in the ieee standard default
 manner.
Parameters
[in]JOBZ
          JOBZ is CHARACTER*1
          = 'N':  Compute eigenvalues only;
          = 'V':  Compute eigenvalues and eigenvectors.
[in]RANGE
          RANGE is CHARACTER*1
          = 'A': all eigenvalues will be found.
          = 'V': all eigenvalues in the half-open interval (VL,VU]
                 will be found.
          = 'I': the IL-th through IU-th eigenvalues will be found.
          For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and
          CSTEIN are called
[in]UPLO
          UPLO is CHARACTER*1
          = 'U':  Upper triangle of A is stored;
          = 'L':  Lower triangle of A is stored.
[in]N
          N is INTEGER
          The order of the matrix A.  N >= 0.
[in,out]A
          A is COMPLEX array, dimension (LDA, N)
          On entry, the Hermitian matrix A.  If UPLO = 'U', the
          leading N-by-N upper triangular part of A contains the
          upper triangular part of the matrix A.  If UPLO = 'L',
          the leading N-by-N lower triangular part of A contains
          the lower triangular part of the matrix A.
          On exit, the lower triangle (if UPLO='L') or the upper
          triangle (if UPLO='U') of A, including the diagonal, is
          destroyed.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).
[in]VL
          VL is REAL
          If RANGE='V', the lower bound of the interval to
          be searched for eigenvalues. VL < VU.
          Not referenced if RANGE = 'A' or 'I'.
[in]VU
          VU is REAL
          If RANGE='V', the upper bound of the interval to
          be searched for eigenvalues. VL < VU.
          Not referenced if RANGE = 'A' or 'I'.
[in]IL
          IL is INTEGER
          If RANGE='I', the index of the
          smallest eigenvalue to be returned.
          1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.
          Not referenced if RANGE = 'A' or 'V'.
[in]IU
          IU is INTEGER
          If RANGE='I', the index of the
          largest eigenvalue to be returned.
          1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.
          Not referenced if RANGE = 'A' or 'V'.
[in]ABSTOL
          ABSTOL is REAL
          The absolute error tolerance for the eigenvalues.
          An approximate eigenvalue is accepted as converged
          when it is determined to lie in an interval [a,b]
          of width less than or equal to

                  ABSTOL + EPS *   max( |a|,|b| ) ,

          where EPS is the machine precision.  If ABSTOL is less than
          or equal to zero, then  EPS*|T|  will be used in its place,
          where |T| is the 1-norm of the tridiagonal matrix obtained
          by reducing A to tridiagonal form.

          See "Computing Small Singular Values of Bidiagonal Matrices
          with Guaranteed High Relative Accuracy," by Demmel and
          Kahan, LAPACK Working Note #3.

          If high relative accuracy is important, set ABSTOL to
          SLAMCH( 'Safe minimum' ).  Doing so will guarantee that
          eigenvalues are computed to high relative accuracy when
          possible in future releases.  The current code does not
          make any guarantees about high relative accuracy, but
          furutre releases will. See J. Barlow and J. Demmel,
          "Computing Accurate Eigensystems of Scaled Diagonally
          Dominant Matrices", LAPACK Working Note #7, for a discussion
          of which matrices define their eigenvalues to high relative
          accuracy.
[out]M
          M is INTEGER
          The total number of eigenvalues found.  0 <= M <= N.
          If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.
[out]W
          W is REAL array, dimension (N)
          The first M elements contain the selected eigenvalues in
          ascending order.
[out]Z
          Z is COMPLEX array, dimension (LDZ, max(1,M))
          If JOBZ = 'V', then if INFO = 0, the first M columns of Z
          contain the orthonormal eigenvectors of the matrix A
          corresponding to the selected eigenvalues, with the i-th
          column of Z holding the eigenvector associated with W(i).
          If JOBZ = 'N', then Z is not referenced.
          Note: the user must ensure that at least max(1,M) columns are
          supplied in the array Z; if RANGE = 'V', the exact value of M
          is not known in advance and an upper bound must be used.
[in]LDZ
          LDZ is INTEGER
          The leading dimension of the array Z.  LDZ >= 1, and if
          JOBZ = 'V', LDZ >= max(1,N).
[out]ISUPPZ
          ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )
          The support of the eigenvectors in Z, i.e., the indices
          indicating the nonzero elements in Z. The i-th eigenvector
          is nonzero only in elements ISUPPZ( 2*i-1 ) through
          ISUPPZ( 2*i ). This is an output of CSTEMR (tridiagonal
          matrix). The support of the eigenvectors of A is typically
          1:N because of the unitary transformations applied by CUNMTR.
          Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1
[out]WORK
          WORK is COMPLEX array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]LWORK
          LWORK is INTEGER
          The length of the array WORK.  LWORK >= max(1,2*N).
          For optimal efficiency, LWORK >= (NB+1)*N,
          where NB is the max of the blocksize for CHETRD and for
          CUNMTR as returned by ILAENV.

          If LWORK = -1, then a workspace query is assumed; the routine
          only calculates the optimal sizes of the WORK, RWORK and
          IWORK arrays, returns these values as the first entries of
          the WORK, RWORK and IWORK arrays, and no error message
          related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]RWORK
          RWORK is REAL array, dimension (MAX(1,LRWORK))
          On exit, if INFO = 0, RWORK(1) returns the optimal
          (and minimal) LRWORK.
[in]LRWORK
          LRWORK is INTEGER
          The length of the array RWORK.  LRWORK >= max(1,24*N).

          If LRWORK = -1, then a workspace query is assumed; the
          routine only calculates the optimal sizes of the WORK, RWORK
          and IWORK arrays, returns these values as the first entries
          of the WORK, RWORK and IWORK arrays, and no error message
          related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]IWORK
          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
          On exit, if INFO = 0, IWORK(1) returns the optimal
          (and minimal) LIWORK.
[in]LIWORK
          LIWORK is INTEGER
          The dimension of the array IWORK.  LIWORK >= max(1,10*N).

          If LIWORK = -1, then a workspace query is assumed; the
          routine only calculates the optimal sizes of the WORK, RWORK
          and IWORK arrays, returns these values as the first entries
          of the WORK, RWORK and IWORK arrays, and no error message
          related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value
          > 0:  Internal error
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
June 2016
Contributors:
Inderjit Dhillon, IBM Almaden, USA
Osni Marques, LBNL/NERSC, USA
Ken Stanley, Computer Science Division, University of California at Berkeley, USA
Jason Riedy, Computer Science Division, University of California at Berkeley, USA

Definition at line 359 of file cheevr.f.

359 *
360 * -- LAPACK driver routine (version 3.7.0) --
361 * -- LAPACK is a software package provided by Univ. of Tennessee, --
362 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
363 * June 2016
364 *
365 * .. Scalar Arguments ..
366  CHARACTER jobz, range, uplo
367  INTEGER il, info, iu, lda, ldz, liwork, lrwork, lwork,
368  $ m, n
369  REAL abstol, vl, vu
370 * ..
371 * .. Array Arguments ..
372  INTEGER isuppz( * ), iwork( * )
373  REAL rwork( * ), w( * )
374  COMPLEX a( lda, * ), work( * ), z( ldz, * )
375 * ..
376 *
377 * =====================================================================
378 *
379 * .. Parameters ..
380  REAL zero, one, two
381  parameter( zero = 0.0e+0, one = 1.0e+0, two = 2.0e+0 )
382 * ..
383 * .. Local Scalars ..
384  LOGICAL alleig, indeig, lower, lquery, test, valeig,
385  $ wantz, tryrac
386  CHARACTER order
387  INTEGER i, ieeeok, iinfo, imax, indibl, indifl, indisp,
388  $ indiwo, indrd, indrdd, indre, indree, indrwk,
389  $ indtau, indwk, indwkn, iscale, itmp1, j, jj,
390  $ liwmin, llwork, llrwork, llwrkn, lrwmin,
391  $ lwkopt, lwmin, nb, nsplit
392  REAL abstll, anrm, bignum, eps, rmax, rmin, safmin,
393  $ sigma, smlnum, tmp1, vll, vuu
394 * ..
395 * .. External Functions ..
396  LOGICAL lsame
397  INTEGER ilaenv
398  REAL clansy, slamch
399  EXTERNAL lsame, ilaenv, clansy, slamch
400 * ..
401 * .. External Subroutines ..
402  EXTERNAL chetrd, csscal, cstemr, cstein, cswap, cunmtr,
404 * ..
405 * .. Intrinsic Functions ..
406  INTRINSIC max, min, REAL, sqrt
407 * ..
408 * .. Executable Statements ..
409 *
410 * Test the input parameters.
411 *
412  ieeeok = ilaenv( 10, 'CHEEVR', 'N', 1, 2, 3, 4 )
413 *
414  lower = lsame( uplo, 'L' )
415  wantz = lsame( jobz, 'V' )
416  alleig = lsame( range, 'A' )
417  valeig = lsame( range, 'V' )
418  indeig = lsame( range, 'I' )
419 *
420  lquery = ( ( lwork.EQ.-1 ) .OR. ( lrwork.EQ.-1 ) .OR.
421  $ ( liwork.EQ.-1 ) )
422 *
423  lrwmin = max( 1, 24*n )
424  liwmin = max( 1, 10*n )
425  lwmin = max( 1, 2*n )
426 *
427  info = 0
428  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
429  info = -1
430  ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
431  info = -2
432  ELSE IF( .NOT.( lower .OR. lsame( uplo, 'U' ) ) ) THEN
433  info = -3
434  ELSE IF( n.LT.0 ) THEN
435  info = -4
436  ELSE IF( lda.LT.max( 1, n ) ) THEN
437  info = -6
438  ELSE
439  IF( valeig ) THEN
440  IF( n.GT.0 .AND. vu.LE.vl )
441  $ info = -8
442  ELSE IF( indeig ) THEN
443  IF( il.LT.1 .OR. il.GT.max( 1, n ) ) THEN
444  info = -9
445  ELSE IF( iu.LT.min( n, il ) .OR. iu.GT.n ) THEN
446  info = -10
447  END IF
448  END IF
449  END IF
450  IF( info.EQ.0 ) THEN
451  IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
452  info = -15
453  END IF
454  END IF
455 *
456  IF( info.EQ.0 ) THEN
457  nb = ilaenv( 1, 'CHETRD', uplo, n, -1, -1, -1 )
458  nb = max( nb, ilaenv( 1, 'CUNMTR', uplo, n, -1, -1, -1 ) )
459  lwkopt = max( ( nb+1 )*n, lwmin )
460  work( 1 ) = lwkopt
461  rwork( 1 ) = lrwmin
462  iwork( 1 ) = liwmin
463 *
464  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
465  info = -18
466  ELSE IF( lrwork.LT.lrwmin .AND. .NOT.lquery ) THEN
467  info = -20
468  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
469  info = -22
470  END IF
471  END IF
472 *
473  IF( info.NE.0 ) THEN
474  CALL xerbla( 'CHEEVR', -info )
475  RETURN
476  ELSE IF( lquery ) THEN
477  RETURN
478  END IF
479 *
480 * Quick return if possible
481 *
482  m = 0
483  IF( n.EQ.0 ) THEN
484  work( 1 ) = 1
485  RETURN
486  END IF
487 *
488  IF( n.EQ.1 ) THEN
489  work( 1 ) = 2
490  IF( alleig .OR. indeig ) THEN
491  m = 1
492  w( 1 ) = REAL( A( 1, 1 ) )
493  ELSE
494  IF( vl.LT.REAL( A( 1, 1 ) ) .AND. vu.GE.REAL( A( 1, 1 ) ) )
495  $ THEN
496  m = 1
497  w( 1 ) = REAL( A( 1, 1 ) )
498  END IF
499  END IF
500  IF( wantz ) THEN
501  z( 1, 1 ) = one
502  isuppz( 1 ) = 1
503  isuppz( 2 ) = 1
504  END IF
505  RETURN
506  END IF
507 *
508 * Get machine constants.
509 *
510  safmin = slamch( 'Safe minimum' )
511  eps = slamch( 'Precision' )
512  smlnum = safmin / eps
513  bignum = one / smlnum
514  rmin = sqrt( smlnum )
515  rmax = min( sqrt( bignum ), one / sqrt( sqrt( safmin ) ) )
516 *
517 * Scale matrix to allowable range, if necessary.
518 *
519  iscale = 0
520  abstll = abstol
521  IF (valeig) THEN
522  vll = vl
523  vuu = vu
524  END IF
525  anrm = clansy( 'M', uplo, n, a, lda, rwork )
526  IF( anrm.GT.zero .AND. anrm.LT.rmin ) THEN
527  iscale = 1
528  sigma = rmin / anrm
529  ELSE IF( anrm.GT.rmax ) THEN
530  iscale = 1
531  sigma = rmax / anrm
532  END IF
533  IF( iscale.EQ.1 ) THEN
534  IF( lower ) THEN
535  DO 10 j = 1, n
536  CALL csscal( n-j+1, sigma, a( j, j ), 1 )
537  10 CONTINUE
538  ELSE
539  DO 20 j = 1, n
540  CALL csscal( j, sigma, a( 1, j ), 1 )
541  20 CONTINUE
542  END IF
543  IF( abstol.GT.0 )
544  $ abstll = abstol*sigma
545  IF( valeig ) THEN
546  vll = vl*sigma
547  vuu = vu*sigma
548  END IF
549  END IF
550 
551 * Initialize indices into workspaces. Note: The IWORK indices are
552 * used only if SSTERF or CSTEMR fail.
553 
554 * WORK(INDTAU:INDTAU+N-1) stores the complex scalar factors of the
555 * elementary reflectors used in CHETRD.
556  indtau = 1
557 * INDWK is the starting offset of the remaining complex workspace,
558 * and LLWORK is the remaining complex workspace size.
559  indwk = indtau + n
560  llwork = lwork - indwk + 1
561 
562 * RWORK(INDRD:INDRD+N-1) stores the real tridiagonal's diagonal
563 * entries.
564  indrd = 1
565 * RWORK(INDRE:INDRE+N-1) stores the off-diagonal entries of the
566 * tridiagonal matrix from CHETRD.
567  indre = indrd + n
568 * RWORK(INDRDD:INDRDD+N-1) is a copy of the diagonal entries over
569 * -written by CSTEMR (the SSTERF path copies the diagonal to W).
570  indrdd = indre + n
571 * RWORK(INDREE:INDREE+N-1) is a copy of the off-diagonal entries over
572 * -written while computing the eigenvalues in SSTERF and CSTEMR.
573  indree = indrdd + n
574 * INDRWK is the starting offset of the left-over real workspace, and
575 * LLRWORK is the remaining workspace size.
576  indrwk = indree + n
577  llrwork = lrwork - indrwk + 1
578 
579 * IWORK(INDIBL:INDIBL+M-1) corresponds to IBLOCK in SSTEBZ and
580 * stores the block indices of each of the M<=N eigenvalues.
581  indibl = 1
582 * IWORK(INDISP:INDISP+NSPLIT-1) corresponds to ISPLIT in SSTEBZ and
583 * stores the starting and finishing indices of each block.
584  indisp = indibl + n
585 * IWORK(INDIFL:INDIFL+N-1) stores the indices of eigenvectors
586 * that corresponding to eigenvectors that fail to converge in
587 * SSTEIN. This information is discarded; if any fail, the driver
588 * returns INFO > 0.
589  indifl = indisp + n
590 * INDIWO is the offset of the remaining integer workspace.
591  indiwo = indifl + n
592 
593 *
594 * Call CHETRD to reduce Hermitian matrix to tridiagonal form.
595 *
596  CALL chetrd( uplo, n, a, lda, rwork( indrd ), rwork( indre ),
597  $ work( indtau ), work( indwk ), llwork, iinfo )
598 *
599 * If all eigenvalues are desired
600 * then call SSTERF or CSTEMR and CUNMTR.
601 *
602  test = .false.
603  IF( indeig ) THEN
604  IF( il.EQ.1 .AND. iu.EQ.n ) THEN
605  test = .true.
606  END IF
607  END IF
608  IF( ( alleig.OR.test ) .AND. ( ieeeok.EQ.1 ) ) THEN
609  IF( .NOT.wantz ) THEN
610  CALL scopy( n, rwork( indrd ), 1, w, 1 )
611  CALL scopy( n-1, rwork( indre ), 1, rwork( indree ), 1 )
612  CALL ssterf( n, w, rwork( indree ), info )
613  ELSE
614  CALL scopy( n-1, rwork( indre ), 1, rwork( indree ), 1 )
615  CALL scopy( n, rwork( indrd ), 1, rwork( indrdd ), 1 )
616 *
617  IF (abstol .LE. two*n*eps) THEN
618  tryrac = .true.
619  ELSE
620  tryrac = .false.
621  END IF
622  CALL cstemr( jobz, 'A', n, rwork( indrdd ),
623  $ rwork( indree ), vl, vu, il, iu, m, w,
624  $ z, ldz, n, isuppz, tryrac,
625  $ rwork( indrwk ), llrwork,
626  $ iwork, liwork, info )
627 *
628 * Apply unitary matrix used in reduction to tridiagonal
629 * form to eigenvectors returned by CSTEMR.
630 *
631  IF( wantz .AND. info.EQ.0 ) THEN
632  indwkn = indwk
633  llwrkn = lwork - indwkn + 1
634  CALL cunmtr( 'L', uplo, 'N', n, m, a, lda,
635  $ work( indtau ), z, ldz, work( indwkn ),
636  $ llwrkn, iinfo )
637  END IF
638  END IF
639 *
640 *
641  IF( info.EQ.0 ) THEN
642  m = n
643  GO TO 30
644  END IF
645  info = 0
646  END IF
647 *
648 * Otherwise, call SSTEBZ and, if eigenvectors are desired, CSTEIN.
649 * Also call SSTEBZ and CSTEIN if CSTEMR fails.
650 *
651  IF( wantz ) THEN
652  order = 'B'
653  ELSE
654  order = 'E'
655  END IF
656 
657  CALL sstebz( range, order, n, vll, vuu, il, iu, abstll,
658  $ rwork( indrd ), rwork( indre ), m, nsplit, w,
659  $ iwork( indibl ), iwork( indisp ), rwork( indrwk ),
660  $ iwork( indiwo ), info )
661 *
662  IF( wantz ) THEN
663  CALL cstein( n, rwork( indrd ), rwork( indre ), m, w,
664  $ iwork( indibl ), iwork( indisp ), z, ldz,
665  $ rwork( indrwk ), iwork( indiwo ), iwork( indifl ),
666  $ info )
667 *
668 * Apply unitary matrix used in reduction to tridiagonal
669 * form to eigenvectors returned by CSTEIN.
670 *
671  indwkn = indwk
672  llwrkn = lwork - indwkn + 1
673  CALL cunmtr( 'L', uplo, 'N', n, m, a, lda, work( indtau ), z,
674  $ ldz, work( indwkn ), llwrkn, iinfo )
675  END IF
676 *
677 * If matrix was scaled, then rescale eigenvalues appropriately.
678 *
679  30 CONTINUE
680  IF( iscale.EQ.1 ) THEN
681  IF( info.EQ.0 ) THEN
682  imax = m
683  ELSE
684  imax = info - 1
685  END IF
686  CALL sscal( imax, one / sigma, w, 1 )
687  END IF
688 *
689 * If eigenvalues are not in order, then sort them, along with
690 * eigenvectors.
691 *
692  IF( wantz ) THEN
693  DO 50 j = 1, m - 1
694  i = 0
695  tmp1 = w( j )
696  DO 40 jj = j + 1, m
697  IF( w( jj ).LT.tmp1 ) THEN
698  i = jj
699  tmp1 = w( jj )
700  END IF
701  40 CONTINUE
702 *
703  IF( i.NE.0 ) THEN
704  itmp1 = iwork( indibl+i-1 )
705  w( i ) = w( j )
706  iwork( indibl+i-1 ) = iwork( indibl+j-1 )
707  w( j ) = tmp1
708  iwork( indibl+j-1 ) = itmp1
709  CALL cswap( n, z( 1, i ), 1, z( 1, j ), 1 )
710  END IF
711  50 CONTINUE
712  END IF
713 *
714 * Set WORK(1) to optimal workspace size.
715 *
716  work( 1 ) = lwkopt
717  rwork( 1 ) = lrwmin
718  iwork( 1 ) = liwmin
719 *
720  RETURN
721 *
722 * End of CHEEVR
723 *
subroutine cunmtr(SIDE, UPLO, TRANS, M, N, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
CUNMTR
Definition: cunmtr.f:174
subroutine sstebz(RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E, M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK, INFO)
SSTEBZ
Definition: sstebz.f:275
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: tstiee.f:83
subroutine chetrd(UPLO, N, A, LDA, D, E, TAU, WORK, LWORK, INFO)
CHETRD
Definition: chetrd.f:194
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
real function clansy(NORM, UPLO, N, A, LDA, WORK)
CLANSY returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix.
Definition: clansy.f:125
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:81
subroutine cstemr(JOBZ, RANGE, N, D, E, VL, VU, IL, IU, M, W, Z, LDZ, NZC, ISUPPZ, TRYRAC, WORK, LWORK, IWORK, LIWORK, INFO)
CSTEMR
Definition: cstemr.f:340
subroutine cswap(N, CX, INCX, CY, INCY)
CSWAP
Definition: cswap.f:83
subroutine cstein(N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
CSTEIN
Definition: cstein.f:184
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:88
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:84
subroutine csscal(N, SA, CX, INCX)
CSSCAL
Definition: csscal.f:80
Here is the call graph for this function:
Here is the caller graph for this function: