LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ sstevd()

 subroutine sstevd ( character JOBZ, integer N, real, dimension( * ) D, real, dimension( * ) E, real, dimension( ldz, * ) Z, integer LDZ, real, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, integer INFO )

SSTEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices

Purpose:
``` SSTEVD computes all eigenvalues and, optionally, eigenvectors of a
real symmetric tridiagonal matrix. If eigenvectors are desired, it
uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about
floating point arithmetic. It will work on machines with a guard
digit in add/subtract, or on those binary machines without guard
digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or
Cray-2. It could conceivably fail on hexadecimal or decimal machines
without guard digits, but we know of none.```
Parameters
 [in] JOBZ ``` JOBZ is CHARACTER*1 = 'N': Compute eigenvalues only; = 'V': Compute eigenvalues and eigenvectors.``` [in] N ``` N is INTEGER The order of the matrix. N >= 0.``` [in,out] D ``` D is REAL array, dimension (N) On entry, the n diagonal elements of the tridiagonal matrix A. On exit, if INFO = 0, the eigenvalues in ascending order.``` [in,out] E ``` E is REAL array, dimension (N-1) On entry, the (n-1) subdiagonal elements of the tridiagonal matrix A, stored in elements 1 to N-1 of E. On exit, the contents of E are destroyed.``` [out] Z ``` Z is REAL array, dimension (LDZ, N) If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal eigenvectors of the matrix A, with the i-th column of Z holding the eigenvector associated with D(i). If JOBZ = 'N', then Z is not referenced.``` [in] LDZ ``` LDZ is INTEGER The leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', LDZ >= max(1,N).``` [out] WORK ``` WORK is REAL array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.``` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. If JOBZ = 'N' or N <= 1 then LWORK must be at least 1. If JOBZ = 'V' and N > 1 then LWORK must be at least ( 1 + 4*N + N**2 ). 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 LIWORK.``` [in] LIWORK ``` LIWORK is INTEGER The dimension of the array IWORK. If JOBZ = 'N' or N <= 1 then LIWORK must be at least 1. If JOBZ = 'V' and N > 1 then LIWORK must be at least 3+5*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: if INFO = i, the algorithm failed to converge; i off-diagonal elements of E did not converge to zero.```

Definition at line 161 of file sstevd.f.

163 *
164 * -- LAPACK driver routine --
165 * -- LAPACK is a software package provided by Univ. of Tennessee, --
166 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
167 *
168 * .. Scalar Arguments ..
169  CHARACTER JOBZ
170  INTEGER INFO, LDZ, LIWORK, LWORK, N
171 * ..
172 * .. Array Arguments ..
173  INTEGER IWORK( * )
174  REAL D( * ), E( * ), WORK( * ), Z( LDZ, * )
175 * ..
176 *
177 * =====================================================================
178 *
179 * .. Parameters ..
180  REAL ZERO, ONE
181  parameter( zero = 0.0e0, one = 1.0e0 )
182 * ..
183 * .. Local Scalars ..
184  LOGICAL LQUERY, WANTZ
185  INTEGER ISCALE, LIWMIN, LWMIN
186  REAL BIGNUM, EPS, RMAX, RMIN, SAFMIN, SIGMA, SMLNUM,
187  \$ TNRM
188 * ..
189 * .. External Functions ..
190  LOGICAL LSAME
191  REAL SLAMCH, SLANST
192  EXTERNAL lsame, slamch, slanst
193 * ..
194 * .. External Subroutines ..
195  EXTERNAL sscal, sstedc, ssterf, xerbla
196 * ..
197 * .. Intrinsic Functions ..
198  INTRINSIC sqrt
199 * ..
200 * .. Executable Statements ..
201 *
202 * Test the input parameters.
203 *
204  wantz = lsame( jobz, 'V' )
205  lquery = ( lwork.EQ.-1 .OR. liwork.EQ.-1 )
206 *
207  info = 0
208  liwmin = 1
209  lwmin = 1
210  IF( n.GT.1 .AND. wantz ) THEN
211  lwmin = 1 + 4*n + n**2
212  liwmin = 3 + 5*n
213  END IF
214 *
215  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
216  info = -1
217  ELSE IF( n.LT.0 ) THEN
218  info = -2
219  ELSE IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
220  info = -6
221  END IF
222 *
223  IF( info.EQ.0 ) THEN
224  work( 1 ) = lwmin
225  iwork( 1 ) = liwmin
226 *
227  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
228  info = -8
229  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
230  info = -10
231  END IF
232  END IF
233 *
234  IF( info.NE.0 ) THEN
235  CALL xerbla( 'SSTEVD', -info )
236  RETURN
237  ELSE IF( lquery ) THEN
238  RETURN
239  END IF
240 *
241 * Quick return if possible
242 *
243  IF( n.EQ.0 )
244  \$ RETURN
245 *
246  IF( n.EQ.1 ) THEN
247  IF( wantz )
248  \$ z( 1, 1 ) = one
249  RETURN
250  END IF
251 *
252 * Get machine constants.
253 *
254  safmin = slamch( 'Safe minimum' )
255  eps = slamch( 'Precision' )
256  smlnum = safmin / eps
257  bignum = one / smlnum
258  rmin = sqrt( smlnum )
259  rmax = sqrt( bignum )
260 *
261 * Scale matrix to allowable range, if necessary.
262 *
263  iscale = 0
264  tnrm = slanst( 'M', n, d, e )
265  IF( tnrm.GT.zero .AND. tnrm.LT.rmin ) THEN
266  iscale = 1
267  sigma = rmin / tnrm
268  ELSE IF( tnrm.GT.rmax ) THEN
269  iscale = 1
270  sigma = rmax / tnrm
271  END IF
272  IF( iscale.EQ.1 ) THEN
273  CALL sscal( n, sigma, d, 1 )
274  CALL sscal( n-1, sigma, e( 1 ), 1 )
275  END IF
276 *
277 * For eigenvalues only, call SSTERF. For eigenvalues and
278 * eigenvectors, call SSTEDC.
279 *
280  IF( .NOT.wantz ) THEN
281  CALL ssterf( n, d, e, info )
282  ELSE
283  CALL sstedc( 'I', n, d, e, z, ldz, work, lwork, iwork, liwork,
284  \$ info )
285  END IF
286 *
287 * If matrix was scaled, then rescale eigenvalues appropriately.
288 *
289  IF( iscale.EQ.1 )
290  \$ CALL sscal( n, one / sigma, d, 1 )
291 *
292  work( 1 ) = lwmin
293  iwork( 1 ) = liwmin
294 *
295  RETURN
296 *
297 * End of SSTEVD
298 *
real function slanst(NORM, N, D, E)
SLANST returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: slanst.f:100
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine sstedc(COMPZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
SSTEDC
Definition: sstedc.f:188
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:86
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:79
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68
Here is the call graph for this function:
Here is the caller graph for this function: