LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ ssyevr()

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

SSYEVR computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices

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

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

 SSYEVR first reduces the matrix A to tridiagonal form T with a call
 to SSYTRD.  Then, whenever possible, SSYEVR calls SSTEMR to compute
 the eigenspectrum using Relatively Robust Representations.  SSTEMR
 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 SSTEMR'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 : SSYEVR calls SSTEMR when the full spectrum is requested
 on machines which conform to the ieee-754 floating point standard.
 SSYEVR calls SSTEBZ and SSTEIN on non-ieee machines and
 when partial spectrum requests are made.

 Normal execution of SSTEMR 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
          SSTEIN 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 REAL array, dimension (LDA, N)
          On entry, the symmetric 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
          future 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 REAL 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.
          Supplying N columns is always safe.
[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 SSTEMR (tridiagonal
          matrix). The support of the eigenvectors of A is typically
          1:N because of the orthogonal transformations applied by SORMTR.
          Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1
[out]WORK
          WORK is REAL array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK.  LWORK >= max(1,26*N).
          For optimal efficiency, LWORK >= (NB+6)*N,
          where NB is the max of the blocksize for SSYTRD and SORMTR
          returned by ILAENV.

          If LWORK = -1, then a workspace query is assumed; the routine
          only calculates the optimal sizes of the WORK and IWORK
          arrays, returns these values as the first entries of the WORK
          and IWORK arrays, and no error message related to LWORK 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 LWORK.
[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 and
          IWORK arrays, returns these values as the first entries of
          the WORK and IWORK arrays, and no error message related to
          LWORK 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 338 of file ssyevr.f.

338 *
339 * -- LAPACK driver routine (version 3.7.0) --
340 * -- LAPACK is a software package provided by Univ. of Tennessee, --
341 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
342 * June 2016
343 *
344 * .. Scalar Arguments ..
345  CHARACTER jobz, range, uplo
346  INTEGER il, info, iu, lda, ldz, liwork, lwork, m, n
347  REAL abstol, vl, vu
348 * ..
349 * .. Array Arguments ..
350  INTEGER isuppz( * ), iwork( * )
351  REAL a( lda, * ), w( * ), work( * ), z( ldz, * )
352 * ..
353 *
354 * =====================================================================
355 *
356 * .. Parameters ..
357  REAL zero, one, two
358  parameter( zero = 0.0e+0, one = 1.0e+0, two = 2.0e+0 )
359 * ..
360 * .. Local Scalars ..
361  LOGICAL alleig, indeig, lower, lquery, test, valeig,
362  $ wantz, tryrac
363  CHARACTER order
364  INTEGER i, ieeeok, iinfo, imax, indd, inddd, inde,
365  $ indee, indibl, indifl, indisp, indiwo, indtau,
366  $ indwk, indwkn, iscale, j, jj, liwmin,
367  $ llwork, llwrkn, lwkopt, lwmin, nb, nsplit
368  REAL abstll, anrm, bignum, eps, rmax, rmin, safmin,
369  $ sigma, smlnum, tmp1, vll, vuu
370 * ..
371 * .. External Functions ..
372  LOGICAL lsame
373  INTEGER ilaenv
374  REAL slamch, slansy
375  EXTERNAL lsame, ilaenv, slamch, slansy
376 * ..
377 * .. External Subroutines ..
378  EXTERNAL scopy, sormtr, sscal, sstebz, sstemr, sstein,
380 * ..
381 * .. Intrinsic Functions ..
382  INTRINSIC max, min, sqrt
383 * ..
384 * .. Executable Statements ..
385 *
386 * Test the input parameters.
387 *
388  ieeeok = ilaenv( 10, 'SSYEVR', 'N', 1, 2, 3, 4 )
389 *
390  lower = lsame( uplo, 'L' )
391  wantz = lsame( jobz, 'V' )
392  alleig = lsame( range, 'A' )
393  valeig = lsame( range, 'V' )
394  indeig = lsame( range, 'I' )
395 *
396  lquery = ( ( lwork.EQ.-1 ) .OR. ( liwork.EQ.-1 ) )
397 *
398  lwmin = max( 1, 26*n )
399  liwmin = max( 1, 10*n )
400 *
401  info = 0
402  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
403  info = -1
404  ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
405  info = -2
406  ELSE IF( .NOT.( lower .OR. lsame( uplo, 'U' ) ) ) THEN
407  info = -3
408  ELSE IF( n.LT.0 ) THEN
409  info = -4
410  ELSE IF( lda.LT.max( 1, n ) ) THEN
411  info = -6
412  ELSE
413  IF( valeig ) THEN
414  IF( n.GT.0 .AND. vu.LE.vl )
415  $ info = -8
416  ELSE IF( indeig ) THEN
417  IF( il.LT.1 .OR. il.GT.max( 1, n ) ) THEN
418  info = -9
419  ELSE IF( iu.LT.min( n, il ) .OR. iu.GT.n ) THEN
420  info = -10
421  END IF
422  END IF
423  END IF
424  IF( info.EQ.0 ) THEN
425  IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
426  info = -15
427  END IF
428  END IF
429 *
430  IF( info.EQ.0 ) THEN
431  nb = ilaenv( 1, 'SSYTRD', uplo, n, -1, -1, -1 )
432  nb = max( nb, ilaenv( 1, 'SORMTR', uplo, n, -1, -1, -1 ) )
433  lwkopt = max( ( nb+1 )*n, lwmin )
434  work( 1 ) = lwkopt
435  iwork( 1 ) = liwmin
436 *
437  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
438  info = -18
439  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
440  info = -20
441  END IF
442  END IF
443 *
444  IF( info.NE.0 ) THEN
445  CALL xerbla( 'SSYEVR', -info )
446  RETURN
447  ELSE IF( lquery ) THEN
448  RETURN
449  END IF
450 *
451 * Quick return if possible
452 *
453  m = 0
454  IF( n.EQ.0 ) THEN
455  work( 1 ) = 1
456  RETURN
457  END IF
458 *
459  IF( n.EQ.1 ) THEN
460  work( 1 ) = 26
461  IF( alleig .OR. indeig ) THEN
462  m = 1
463  w( 1 ) = a( 1, 1 )
464  ELSE
465  IF( vl.LT.a( 1, 1 ) .AND. vu.GE.a( 1, 1 ) ) THEN
466  m = 1
467  w( 1 ) = a( 1, 1 )
468  END IF
469  END IF
470  IF( wantz ) THEN
471  z( 1, 1 ) = one
472  isuppz( 1 ) = 1
473  isuppz( 2 ) = 1
474  END IF
475  RETURN
476  END IF
477 *
478 * Get machine constants.
479 *
480  safmin = slamch( 'Safe minimum' )
481  eps = slamch( 'Precision' )
482  smlnum = safmin / eps
483  bignum = one / smlnum
484  rmin = sqrt( smlnum )
485  rmax = min( sqrt( bignum ), one / sqrt( sqrt( safmin ) ) )
486 *
487 * Scale matrix to allowable range, if necessary.
488 *
489  iscale = 0
490  abstll = abstol
491  IF (valeig) THEN
492  vll = vl
493  vuu = vu
494  END IF
495  anrm = slansy( 'M', uplo, n, a, lda, work )
496  IF( anrm.GT.zero .AND. anrm.LT.rmin ) THEN
497  iscale = 1
498  sigma = rmin / anrm
499  ELSE IF( anrm.GT.rmax ) THEN
500  iscale = 1
501  sigma = rmax / anrm
502  END IF
503  IF( iscale.EQ.1 ) THEN
504  IF( lower ) THEN
505  DO 10 j = 1, n
506  CALL sscal( n-j+1, sigma, a( j, j ), 1 )
507  10 CONTINUE
508  ELSE
509  DO 20 j = 1, n
510  CALL sscal( j, sigma, a( 1, j ), 1 )
511  20 CONTINUE
512  END IF
513  IF( abstol.GT.0 )
514  $ abstll = abstol*sigma
515  IF( valeig ) THEN
516  vll = vl*sigma
517  vuu = vu*sigma
518  END IF
519  END IF
520 
521 * Initialize indices into workspaces. Note: The IWORK indices are
522 * used only if SSTERF or SSTEMR fail.
523 
524 * WORK(INDTAU:INDTAU+N-1) stores the scalar factors of the
525 * elementary reflectors used in SSYTRD.
526  indtau = 1
527 * WORK(INDD:INDD+N-1) stores the tridiagonal's diagonal entries.
528  indd = indtau + n
529 * WORK(INDE:INDE+N-1) stores the off-diagonal entries of the
530 * tridiagonal matrix from SSYTRD.
531  inde = indd + n
532 * WORK(INDDD:INDDD+N-1) is a copy of the diagonal entries over
533 * -written by SSTEMR (the SSTERF path copies the diagonal to W).
534  inddd = inde + n
535 * WORK(INDEE:INDEE+N-1) is a copy of the off-diagonal entries over
536 * -written while computing the eigenvalues in SSTERF and SSTEMR.
537  indee = inddd + n
538 * INDWK is the starting offset of the left-over workspace, and
539 * LLWORK is the remaining workspace size.
540  indwk = indee + n
541  llwork = lwork - indwk + 1
542 
543 * IWORK(INDIBL:INDIBL+M-1) corresponds to IBLOCK in SSTEBZ and
544 * stores the block indices of each of the M<=N eigenvalues.
545  indibl = 1
546 * IWORK(INDISP:INDISP+NSPLIT-1) corresponds to ISPLIT in SSTEBZ and
547 * stores the starting and finishing indices of each block.
548  indisp = indibl + n
549 * IWORK(INDIFL:INDIFL+N-1) stores the indices of eigenvectors
550 * that corresponding to eigenvectors that fail to converge in
551 * SSTEIN. This information is discarded; if any fail, the driver
552 * returns INFO > 0.
553  indifl = indisp + n
554 * INDIWO is the offset of the remaining integer workspace.
555  indiwo = indifl + n
556 
557 *
558 * Call SSYTRD to reduce symmetric matrix to tridiagonal form.
559 *
560  CALL ssytrd( uplo, n, a, lda, work( indd ), work( inde ),
561  $ work( indtau ), work( indwk ), llwork, iinfo )
562 *
563 * If all eigenvalues are desired
564 * then call SSTERF or SSTEMR and SORMTR.
565 *
566  test = .false.
567  IF( indeig ) THEN
568  IF( il.EQ.1 .AND. iu.EQ.n ) THEN
569  test = .true.
570  END IF
571  END IF
572  IF( ( alleig.OR.test ) .AND. ( ieeeok.EQ.1 ) ) THEN
573  IF( .NOT.wantz ) THEN
574  CALL scopy( n, work( indd ), 1, w, 1 )
575  CALL scopy( n-1, work( inde ), 1, work( indee ), 1 )
576  CALL ssterf( n, w, work( indee ), info )
577  ELSE
578  CALL scopy( n-1, work( inde ), 1, work( indee ), 1 )
579  CALL scopy( n, work( indd ), 1, work( inddd ), 1 )
580 *
581  IF (abstol .LE. two*n*eps) THEN
582  tryrac = .true.
583  ELSE
584  tryrac = .false.
585  END IF
586  CALL sstemr( jobz, 'A', n, work( inddd ), work( indee ),
587  $ vl, vu, il, iu, m, w, z, ldz, n, isuppz,
588  $ tryrac, work( indwk ), lwork, iwork, liwork,
589  $ info )
590 *
591 *
592 *
593 * Apply orthogonal matrix used in reduction to tridiagonal
594 * form to eigenvectors returned by SSTEMR.
595 *
596  IF( wantz .AND. info.EQ.0 ) THEN
597  indwkn = inde
598  llwrkn = lwork - indwkn + 1
599  CALL sormtr( 'L', uplo, 'N', n, m, a, lda,
600  $ work( indtau ), z, ldz, work( indwkn ),
601  $ llwrkn, iinfo )
602  END IF
603  END IF
604 *
605 *
606  IF( info.EQ.0 ) THEN
607 * Everything worked. Skip SSTEBZ/SSTEIN. IWORK(:) are
608 * undefined.
609  m = n
610  GO TO 30
611  END IF
612  info = 0
613  END IF
614 *
615 * Otherwise, call SSTEBZ and, if eigenvectors are desired, SSTEIN.
616 * Also call SSTEBZ and SSTEIN if SSTEMR fails.
617 *
618  IF( wantz ) THEN
619  order = 'B'
620  ELSE
621  order = 'E'
622  END IF
623 
624  CALL sstebz( range, order, n, vll, vuu, il, iu, abstll,
625  $ work( indd ), work( inde ), m, nsplit, w,
626  $ iwork( indibl ), iwork( indisp ), work( indwk ),
627  $ iwork( indiwo ), info )
628 *
629  IF( wantz ) THEN
630  CALL sstein( n, work( indd ), work( inde ), m, w,
631  $ iwork( indibl ), iwork( indisp ), z, ldz,
632  $ work( indwk ), iwork( indiwo ), iwork( indifl ),
633  $ info )
634 *
635 * Apply orthogonal matrix used in reduction to tridiagonal
636 * form to eigenvectors returned by SSTEIN.
637 *
638  indwkn = inde
639  llwrkn = lwork - indwkn + 1
640  CALL sormtr( 'L', uplo, 'N', n, m, a, lda, work( indtau ), z,
641  $ ldz, work( indwkn ), llwrkn, iinfo )
642  END IF
643 *
644 * If matrix was scaled, then rescale eigenvalues appropriately.
645 *
646 * Jump here if SSTEMR/SSTEIN succeeded.
647  30 CONTINUE
648  IF( iscale.EQ.1 ) THEN
649  IF( info.EQ.0 ) THEN
650  imax = m
651  ELSE
652  imax = info - 1
653  END IF
654  CALL sscal( imax, one / sigma, w, 1 )
655  END IF
656 *
657 * If eigenvalues are not in order, then sort them, along with
658 * eigenvectors. Note: We do not sort the IFAIL portion of IWORK.
659 * It may not be initialized (if SSTEMR/SSTEIN succeeded), and we do
660 * not return this detailed information to the user.
661 *
662  IF( wantz ) THEN
663  DO 50 j = 1, m - 1
664  i = 0
665  tmp1 = w( j )
666  DO 40 jj = j + 1, m
667  IF( w( jj ).LT.tmp1 ) THEN
668  i = jj
669  tmp1 = w( jj )
670  END IF
671  40 CONTINUE
672 *
673  IF( i.NE.0 ) THEN
674  w( i ) = w( j )
675  w( j ) = tmp1
676  CALL sswap( n, z( 1, i ), 1, z( 1, j ), 1 )
677  END IF
678  50 CONTINUE
679  END IF
680 *
681 * Set WORK(1) to optimal workspace size.
682 *
683  work( 1 ) = lwkopt
684  iwork( 1 ) = liwmin
685 *
686  RETURN
687 *
688 * End of SSYEVR
689 *
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 ssytrd(UPLO, N, A, LDA, D, E, TAU, WORK, LWORK, INFO)
SSYTRD
Definition: ssytrd.f:194
subroutine sormtr(SIDE, UPLO, TRANS, M, N, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
SORMTR
Definition: sormtr.f:174
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
subroutine sstein(N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSTEIN
Definition: sstein.f:176
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:81
subroutine sswap(N, SX, INCX, SY, INCY)
SSWAP
Definition: sswap.f:84
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:88
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:84
subroutine sstemr(JOBZ, RANGE, N, D, E, VL, VU, IL, IU, M, W, Z, LDZ, NZC, ISUPPZ, TRYRAC, WORK, LWORK, IWORK, LIWORK, INFO)
SSTEMR
Definition: sstemr.f:323
real function slansy(NORM, UPLO, N, A, LDA, WORK)
SLANSY returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix.
Definition: slansy.f:124
Here is the call graph for this function:
Here is the caller graph for this function: