 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

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```
Date
June 2016
Contributors:
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: