 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ sspevd()

 subroutine sspevd ( character JOBZ, character UPLO, integer N, real, dimension( * ) AP, real, dimension( * ) W, real, dimension( ldz, * ) Z, integer LDZ, real, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, integer INFO )

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

Purpose:
``` SSPEVD computes all the eigenvalues and, optionally, eigenvectors
of a real symmetric matrix A in packed storage. 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] 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] AP ``` AP is REAL array, dimension (N*(N+1)/2) On entry, the upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows: if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n. On exit, AP is overwritten by values generated during the reduction to tridiagonal form. If UPLO = 'U', the diagonal and first superdiagonal of the tridiagonal matrix T overwrite the corresponding elements of A, and if UPLO = 'L', the diagonal and first subdiagonal of T overwrite the corresponding elements of A.``` [out] W ``` W is REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.``` [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 W(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 (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the required LWORK.``` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. If N <= 1, LWORK must be at least 1. If JOBZ = 'N' and N > 1, LWORK must be at least 2*N. If JOBZ = 'V' and N > 1, LWORK must be at least 1 + 6*N + N**2. If LWORK = -1, then a workspace query is assumed; the routine only calculates the required 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 required LIWORK.``` [in] LIWORK ``` LIWORK is INTEGER The dimension of the array IWORK. If JOBZ = 'N' or N <= 1, LIWORK must be at least 1. If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the required 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 an intermediate tridiagonal form did not converge to zero.```

Definition at line 176 of file sspevd.f.

178 *
179 * -- LAPACK driver routine --
180 * -- LAPACK is a software package provided by Univ. of Tennessee, --
181 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
182 *
183 * .. Scalar Arguments ..
184  CHARACTER JOBZ, UPLO
185  INTEGER INFO, LDZ, LIWORK, LWORK, N
186 * ..
187 * .. Array Arguments ..
188  INTEGER IWORK( * )
189  REAL AP( * ), W( * ), WORK( * ), Z( LDZ, * )
190 * ..
191 *
192 * =====================================================================
193 *
194 * .. Parameters ..
195  REAL ZERO, ONE
196  parameter( zero = 0.0e+0, one = 1.0e+0 )
197 * ..
198 * .. Local Scalars ..
199  LOGICAL LQUERY, WANTZ
200  INTEGER IINFO, INDE, INDTAU, INDWRK, ISCALE, LIWMIN,
201  \$ LLWORK, LWMIN
202  REAL ANRM, BIGNUM, EPS, RMAX, RMIN, SAFMIN, SIGMA,
203  \$ SMLNUM
204 * ..
205 * .. External Functions ..
206  LOGICAL LSAME
207  REAL SLAMCH, SLANSP
208  EXTERNAL lsame, slamch, slansp
209 * ..
210 * .. External Subroutines ..
211  EXTERNAL sopmtr, sscal, ssptrd, sstedc, ssterf, xerbla
212 * ..
213 * .. Intrinsic Functions ..
214  INTRINSIC sqrt
215 * ..
216 * .. Executable Statements ..
217 *
218 * Test the input parameters.
219 *
220  wantz = lsame( jobz, 'V' )
221  lquery = ( lwork.EQ.-1 .OR. liwork.EQ.-1 )
222 *
223  info = 0
224  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
225  info = -1
226  ELSE IF( .NOT.( lsame( uplo, 'U' ) .OR. lsame( uplo, 'L' ) ) )
227  \$ THEN
228  info = -2
229  ELSE IF( n.LT.0 ) THEN
230  info = -3
231  ELSE IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
232  info = -7
233  END IF
234 *
235  IF( info.EQ.0 ) THEN
236  IF( n.LE.1 ) THEN
237  liwmin = 1
238  lwmin = 1
239  ELSE
240  IF( wantz ) THEN
241  liwmin = 3 + 5*n
242  lwmin = 1 + 6*n + n**2
243  ELSE
244  liwmin = 1
245  lwmin = 2*n
246  END IF
247  END IF
248  iwork( 1 ) = liwmin
249  work( 1 ) = lwmin
250 *
251  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
252  info = -9
253  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
254  info = -11
255  END IF
256  END IF
257 *
258  IF( info.NE.0 ) THEN
259  CALL xerbla( 'SSPEVD', -info )
260  RETURN
261  ELSE IF( lquery ) THEN
262  RETURN
263  END IF
264 *
265 * Quick return if possible
266 *
267  IF( n.EQ.0 )
268  \$ RETURN
269 *
270  IF( n.EQ.1 ) THEN
271  w( 1 ) = ap( 1 )
272  IF( wantz )
273  \$ z( 1, 1 ) = one
274  RETURN
275  END IF
276 *
277 * Get machine constants.
278 *
279  safmin = slamch( 'Safe minimum' )
280  eps = slamch( 'Precision' )
281  smlnum = safmin / eps
282  bignum = one / smlnum
283  rmin = sqrt( smlnum )
284  rmax = sqrt( bignum )
285 *
286 * Scale matrix to allowable range, if necessary.
287 *
288  anrm = slansp( 'M', uplo, n, ap, work )
289  iscale = 0
290  IF( anrm.GT.zero .AND. anrm.LT.rmin ) THEN
291  iscale = 1
292  sigma = rmin / anrm
293  ELSE IF( anrm.GT.rmax ) THEN
294  iscale = 1
295  sigma = rmax / anrm
296  END IF
297  IF( iscale.EQ.1 ) THEN
298  CALL sscal( ( n*( n+1 ) ) / 2, sigma, ap, 1 )
299  END IF
300 *
301 * Call SSPTRD to reduce symmetric packed matrix to tridiagonal form.
302 *
303  inde = 1
304  indtau = inde + n
305  CALL ssptrd( uplo, n, ap, w, work( inde ), work( indtau ), iinfo )
306 *
307 * For eigenvalues only, call SSTERF. For eigenvectors, first call
308 * SSTEDC to generate the eigenvector matrix, WORK(INDWRK), of the
309 * tridiagonal matrix, then call SOPMTR to multiply it by the
310 * Householder transformations represented in AP.
311 *
312  IF( .NOT.wantz ) THEN
313  CALL ssterf( n, w, work( inde ), info )
314  ELSE
315  indwrk = indtau + n
316  llwork = lwork - indwrk + 1
317  CALL sstedc( 'I', n, w, work( inde ), z, ldz, work( indwrk ),
318  \$ llwork, iwork, liwork, info )
319  CALL sopmtr( 'L', uplo, 'N', n, n, ap, work( indtau ), z, ldz,
320  \$ work( indwrk ), iinfo )
321  END IF
322 *
323 * If matrix was scaled, then rescale eigenvalues appropriately.
324 *
325  IF( iscale.EQ.1 )
326  \$ CALL sscal( n, one / sigma, w, 1 )
327 *
328  work( 1 ) = lwmin
329  iwork( 1 ) = liwmin
330  RETURN
331 *
332 * End of SSPEVD
333 *
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
real function slansp(NORM, UPLO, N, AP, WORK)
SLANSP returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: slansp.f:114
subroutine ssptrd(UPLO, N, AP, D, E, TAU, INFO)
SSPTRD
Definition: ssptrd.f:150
subroutine sopmtr(SIDE, UPLO, TRANS, M, N, AP, TAU, C, LDC, WORK, INFO)
SOPMTR
Definition: sopmtr.f:150
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: