 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ dstevd()

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

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

Purpose:
``` DSTEVD 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 dstevd.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  DOUBLE PRECISION D( * ), E( * ), WORK( * ), Z( LDZ, * )
175 * ..
176 *
177 * =====================================================================
178 *
179 * .. Parameters ..
180  DOUBLE PRECISION ZERO, ONE
181  parameter( zero = 0.0d0, one = 1.0d0 )
182 * ..
183 * .. Local Scalars ..
184  LOGICAL LQUERY, WANTZ
185  INTEGER ISCALE, LIWMIN, LWMIN
186  DOUBLE PRECISION BIGNUM, EPS, RMAX, RMIN, SAFMIN, SIGMA, SMLNUM,
187  \$ TNRM
188 * ..
189 * .. External Functions ..
190  LOGICAL LSAME
191  DOUBLE PRECISION DLAMCH, DLANST
192  EXTERNAL lsame, dlamch, dlanst
193 * ..
194 * .. External Subroutines ..
195  EXTERNAL dscal, dstedc, dsterf, 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( 'DSTEVD', -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 = dlamch( 'Safe minimum' )
255  eps = dlamch( '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 = dlanst( '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 dscal( n, sigma, d, 1 )
274  CALL dscal( n-1, sigma, e( 1 ), 1 )
275  END IF
276 *
277 * For eigenvalues only, call DSTERF. For eigenvalues and
278 * eigenvectors, call DSTEDC.
279 *
280  IF( .NOT.wantz ) THEN
281  CALL dsterf( n, d, e, info )
282  ELSE
283  CALL dstedc( '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 dscal( n, one / sigma, d, 1 )
291 *
292  work( 1 ) = lwmin
293  iwork( 1 ) = liwmin
294 *
295  RETURN
296 *
297 * End of DSTEVD
298 *
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
double precision function dlanst(NORM, N, D, E)
DLANST returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: dlanst.f:100
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine dstedc(COMPZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
DSTEDC
Definition: dstedc.f:188
subroutine dsterf(N, D, E, INFO)
DSTERF
Definition: dsterf.f:86
subroutine dscal(N, DA, DX, INCX)
DSCAL
Definition: dscal.f:79
Here is the call graph for this function:
Here is the caller graph for this function: