LAPACK  3.6.1 LAPACK: Linear Algebra PACKage
 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 ). 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 336 of file ssyevr.f.

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