d2/dbf/sstevx_8f_source.html

 *> \brief <b> SSTEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices</b>
 *
 *  =========== DOCUMENTATION ===========
 *
 * Online html documentation available at
 *            http://www.netlib.org/lapack/explore-html/
 *
 *> \htmlonly
 *> Download SSTEVX + dependencies
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/sstevx.f">
 *> [TGZ]</a>
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/sstevx.f">
 *> [ZIP]</a>
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/sstevx.f">
 *> [TXT]</a>
 *> \endhtmlonly
 *
 *  Definition:
 *  ===========
 *
 *       SUBROUTINE SSTEVX( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL,
 *                          M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO )
 *
 *       .. Scalar Arguments ..
 *       CHARACTER          JOBZ, RANGE
 *       INTEGER            IL, INFO, IU, LDZ, M, N
 *       REAL               ABSTOL, VL, VU
 *       ..
 *       .. Array Arguments ..
 *       INTEGER            IFAIL( * ), IWORK( * )
 *       REAL               D( * ), E( * ), W( * ), WORK( * ), Z( LDZ, * )
 *       ..
 *
 *
 *> \par Purpose:
 *  =============
 *>
 *> \verbatim
 *>
 *> SSTEVX computes selected eigenvalues and, optionally, eigenvectors
 *> of a real symmetric tridiagonal matrix A.  Eigenvalues and
 *> eigenvectors can be selected by specifying either a range of values
 *> or a range of indices for the desired eigenvalues.
 *> \endverbatim
 *
 *  Arguments:
 *  ==========
 *
 *> \param[in] JOBZ
 *> \verbatim
 *>          JOBZ is CHARACTER*1
 *>          = 'N':  Compute eigenvalues only;
 *>          = 'V':  Compute eigenvalues and eigenvectors.
 *> \endverbatim
 *>
 *> \param[in] RANGE
 *> \verbatim
 *>          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.
 *> \endverbatim
 *>
 *> \param[in] N
 *> \verbatim
 *>          N is INTEGER
 *>          The order of the matrix.  N >= 0.
 *> \endverbatim
 *>
 *> \param[in,out] D
 *> \verbatim
 *>          D is REAL array, dimension (N)
 *>          On entry, the n diagonal elements of the tridiagonal matrix
 *>          A.
 *>          On exit, D may be multiplied by a constant factor chosen
 *>          to avoid over/underflow in computing the eigenvalues.
 *> \endverbatim
 *>
 *> \param[in,out] E
 *> \verbatim
 *>          E is REAL array, dimension (max(1,N-1))
 *>          On entry, the (n-1) subdiagonal elements of the tridiagonal
 *>          matrix A in elements 1 to N-1 of E.
 *>          On exit, E may be multiplied by a constant factor chosen
 *>          to avoid over/underflow in computing the eigenvalues.
 *> \endverbatim
 *>
 *> \param[in] VL
 *> \verbatim
 *>          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'.
 *> \endverbatim
 *>
 *> \param[in] VU
 *> \verbatim
 *>          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'.
 *> \endverbatim
 *>
 *> \param[in] IL
 *> \verbatim
 *>          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'.
 *> \endverbatim
 *>
 *> \param[in] IU
 *> \verbatim
 *>          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'.
 *> \endverbatim
 *>
 *> \param[in] ABSTOL
 *> \verbatim
 *>          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.
 *>
 *>          Eigenvalues will be computed most accurately when ABSTOL is
 *>          set to twice the underflow threshold 2*SLAMCH('S'), not zero.
 *>          If this routine returns with INFO>0, indicating that some
 *>          eigenvectors did not converge, try setting ABSTOL to
 *>          2*SLAMCH('S').
 *>
 *>          See "Computing Small Singular Values of Bidiagonal Matrices
 *>          with Guaranteed High Relative Accuracy," by Demmel and
 *>          Kahan, LAPACK Working Note #3.
 *> \endverbatim
 *>
 *> \param[out] M
 *> \verbatim
 *>          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.
 *> \endverbatim
 *>
 *> \param[out] W
 *> \verbatim
 *>          W is REAL array, dimension (N)
 *>          The first M elements contain the selected eigenvalues in
 *>          ascending order.
 *> \endverbatim
 *>
 *> \param[out] Z
 *> \verbatim
 *>          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 an eigenvector fails to converge (INFO > 0), then that
 *>          column of Z contains the latest approximation to the
 *>          eigenvector, and the index of the eigenvector is returned
 *>          in IFAIL.  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.
 *> \endverbatim
 *>
 *> \param[in] LDZ
 *> \verbatim
 *>          LDZ is INTEGER
 *>          The leading dimension of the array Z.  LDZ >= 1, and if
 *>          JOBZ = 'V', LDZ >= max(1,N).
 *> \endverbatim
 *>
 *> \param[out] WORK
 *> \verbatim
 *>          WORK is REAL array, dimension (5*N)
 *> \endverbatim
 *>
 *> \param[out] IWORK
 *> \verbatim
 *>          IWORK is INTEGER array, dimension (5*N)
 *> \endverbatim
 *>
 *> \param[out] IFAIL
 *> \verbatim
 *>          IFAIL is INTEGER array, dimension (N)
 *>          If JOBZ = 'V', then if INFO = 0, the first M elements of
 *>          IFAIL are zero.  If INFO > 0, then IFAIL contains the
 *>          indices of the eigenvectors that failed to converge.
 *>          If JOBZ = 'N', then IFAIL is not referenced.
 *> \endverbatim
 *>
 *> \param[out] INFO
 *> \verbatim
 *>          INFO is INTEGER
 *>          = 0:  successful exit
 *>          < 0:  if INFO = -i, the i-th argument had an illegal value
 *>          > 0:  if INFO = i, then i eigenvectors failed to converge.
 *>                Their indices are stored in array IFAIL.
 *> \endverbatim
 *
 *  Authors:
 *  ========
 *
 *> \author Univ. of Tennessee
 *> \author Univ. of California Berkeley
 *> \author Univ. of Colorado Denver
 *> \author NAG Ltd.
 *
 *> \date June 2016
 *
 *> \ingroup realOTHEReigen
 *
 *  =====================================================================
       SUBROUTINE sstevx( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL,
      $                   M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO )
 *
 *  -- LAPACK driver routine (version 3.7.0) --
 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 *     June 2016
 *
 *     .. Scalar Arguments ..
       CHARACTER          JOBZ, RANGE
       INTEGER            IL, INFO, IU, LDZ, M, N
       REAL               ABSTOL, VL, VU
 *     ..
 *     .. Array Arguments ..
       INTEGER            IFAIL( * ), IWORK( * )
       REAL               D( * ), E( * ), W( * ), WORK( * ), Z( ldz, * )
 *     ..
 *
 *  =====================================================================
 *
 *     .. Parameters ..
       REAL               ZERO, ONE
       parameter( zero = 0.0e0, one = 1.0e0 )
 *     ..
 *     .. Local Scalars ..
       LOGICAL            ALLEIG, INDEIG, TEST, VALEIG, WANTZ
       CHARACTER          ORDER
       INTEGER            I, IMAX, INDIBL, INDISP, INDIWO, INDWRK,
      $                   iscale, itmp1, j, jj, nsplit
       REAL               BIGNUM, EPS, RMAX, RMIN, SAFMIN, SIGMA, SMLNUM,
      $                   tmp1, tnrm, vll, vuu
 *     ..
 *     .. External Functions ..
       LOGICAL            LSAME
       REAL               SLAMCH, SLANST
       EXTERNAL           lsame, slamch, slanst
 *     ..
 *     .. External Subroutines ..
       EXTERNAL           scopy, sscal, sstebz, sstein, ssteqr, ssterf,
      $                   sswap, xerbla
 *     ..
 *     .. Intrinsic Functions ..
       INTRINSIC          max, min, sqrt
 *     ..
 *     .. Executable Statements ..
 *
 *     Test the input parameters.
 *
       wantz = lsame( jobz, 'V' )
       alleig = lsame( range, 'A' )
       valeig = lsame( range, 'V' )
       indeig = lsame( range, 'I' )
 *
       info = 0
       IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
          info = -1
       ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
          info = -2
       ELSE IF( n.LT.0 ) THEN
          info = -3
       ELSE
          IF( valeig ) THEN
             IF( n.GT.0 .AND. vu.LE.vl )
      $         info = -7
          ELSE IF( indeig ) THEN
             IF( il.LT.1 .OR. il.GT.max( 1, n ) ) THEN
                info = -8
             ELSE IF( iu.LT.min( n, il ) .OR. iu.GT.n ) THEN
                info = -9
             END IF
          END IF
       END IF
       IF( info.EQ.0 ) THEN
          IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) )
      $      info = -14
       END IF
 *
       IF( info.NE.0 ) THEN
          CALL xerbla( 'SSTEVX', -info )
          RETURN
       END IF
 *
 *     Quick return if possible
 *
       m = 0
       IF( n.EQ.0 )
      $   RETURN
 *
       IF( n.EQ.1 ) THEN
          IF( alleig .OR. indeig ) THEN
             m = 1
             w( 1 ) = d( 1 )
          ELSE
             IF( vl.LT.d( 1 ) .AND. vu.GE.d( 1 ) ) THEN
                m = 1
                w( 1 ) = d( 1 )
             END IF
          END IF
          IF( wantz )
      $      z( 1, 1 ) = one
          RETURN
       END IF
 *
 *     Get machine constants.
 *
       safmin = slamch( 'Safe minimum' )
       eps = slamch( 'Precision' )
       smlnum = safmin / eps
       bignum = one / smlnum
       rmin = sqrt( smlnum )
       rmax = min( sqrt( bignum ), one / sqrt( sqrt( safmin ) ) )
 *
 *     Scale matrix to allowable range, if necessary.
 *
       iscale = 0
       IF ( valeig ) THEN
          vll = vl
          vuu = vu
       ELSE
          vll = zero
          vuu = zero
       ENDIF
       tnrm = slanst( 'M', n, d, e )
       IF( tnrm.GT.zero .AND. tnrm.LT.rmin ) THEN
          iscale = 1
          sigma = rmin / tnrm
       ELSE IF( tnrm.GT.rmax ) THEN
          iscale = 1
          sigma = rmax / tnrm
       END IF
       IF( iscale.EQ.1 ) THEN
          CALL sscal( n, sigma, d, 1 )
          CALL sscal( n-1, sigma, e( 1 ), 1 )
          IF( valeig ) THEN
             vll = vl*sigma
             vuu = vu*sigma
          END IF
       END IF
 *
 *     If all eigenvalues are desired and ABSTOL is less than zero, then
 *     call SSTERF or SSTEQR.  If this fails for some eigenvalue, then
 *     try SSTEBZ.
 *
       test = .false.
       IF( indeig ) THEN
          IF( il.EQ.1 .AND. iu.EQ.n ) THEN
             test = .true.
          END IF
       END IF
       IF( ( alleig .OR. test ) .AND. ( abstol.LE.zero ) ) THEN
          CALL scopy( n, d, 1, w, 1 )
          CALL scopy( n-1, e( 1 ), 1, work( 1 ), 1 )
          indwrk = n + 1
          IF( .NOT.wantz ) THEN
             CALL ssterf( n, w, work, info )
          ELSE
             CALL ssteqr( 'I', n, w, work, z, ldz, work( indwrk ), info )
             IF( info.EQ.0 ) THEN
                DO 10 i = 1, n
                   ifail( i ) = 0
    10          CONTINUE
             END IF
          END IF
          IF( info.EQ.0 ) THEN
             m = n
             GO TO 20
          END IF
          info = 0
       END IF
 *
 *     Otherwise, call SSTEBZ and, if eigenvectors are desired, SSTEIN.
 *
       IF( wantz ) THEN
          order = 'B'
       ELSE
          order = 'E'
       END IF
       indwrk = 1
       indibl = 1
       indisp = indibl + n
       indiwo = indisp + n
       CALL sstebz( range, order, n, vll, vuu, il, iu, abstol, d, e, m,
      $             nsplit, w, iwork( indibl ), iwork( indisp ),
      $             work( indwrk ), iwork( indiwo ), info )
 *
       IF( wantz ) THEN
          CALL sstein( n, d, e, m, w, iwork( indibl ), iwork( indisp ),
      $                z, ldz, work( indwrk ), iwork( indiwo ), ifail,
      $                info )
       END IF
 *
 *     If matrix was scaled, then rescale eigenvalues appropriately.
 *
    20 CONTINUE
       IF( iscale.EQ.1 ) THEN
          IF( info.EQ.0 ) THEN
             imax = m
          ELSE
             imax = info - 1
          END IF
          CALL sscal( imax, one / sigma, w, 1 )
       END IF
 *
 *     If eigenvalues are not in order, then sort them, along with
 *     eigenvectors.
 *
       IF( wantz ) THEN
          DO 40 j = 1, m - 1
             i = 0
             tmp1 = w( j )
             DO 30 jj = j + 1, m
                IF( w( jj ).LT.tmp1 ) THEN
                   i = jj
                   tmp1 = w( jj )
                END IF
    30       CONTINUE
 *
             IF( i.NE.0 ) THEN
                itmp1 = iwork( indibl+i-1 )
                w( i ) = w( j )
                iwork( indibl+i-1 ) = iwork( indibl+j-1 )
                w( j ) = tmp1
                iwork( indibl+j-1 ) = itmp1
                CALL sswap( n, z( 1, i ), 1, z( 1, j ), 1 )
                IF( info.NE.0 ) THEN
                   itmp1 = ifail( i )
                   ifail( i ) = ifail( j )
                   ifail( j ) = itmp1
                END IF
             END IF
    40    CONTINUE
       END IF
 *
       RETURN
 *
 *     End of SSTEVX
 *
       END
sstebz
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

ssteqr
subroutine ssteqr(COMPZ, N, D, E, Z, LDZ, WORK, INFO)
SSTEQR
Definition: ssteqr.f:133

sstevx
subroutine sstevx(JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO)
 SSTEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matric...
Definition: sstevx.f:229

xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62

sstein
subroutine sstein(N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSTEIN
Definition: sstein.f:176

sscal
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:81

sswap
subroutine sswap(N, SX, INCX, SY, INCY)
SSWAP
Definition: sswap.f:84

ssterf
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:88

scopy
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:84