**?syev**
computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix.

```
call ssyev (
```

*jobz, uplo, n, a, lda, w, work, lwork, info*)

call dsyev (*jobz, uplo, n, a, lda, w, work, lwork, info*)

**?heev**
computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix.

```
call cheev (
```

*jobz, uplo, n, a, lda, w, work, lwork, rwork, info*)

call zheev (*jobz, uplo, n, a, lda, w, work, lwork, rwork, info*)

**?syevd**
computes all eigenvalues and, optionally, all eigenvectors of a real symmetric matrix using a divide and conquer algorithm.

```
call ssyevd (
```

*job, uplo, n, a, lda, w, work, lwork, iwork, liwork, info*)

call dsyevd (*job, uplo, n, a, lda, w, work, lwork, iwork, liwork, info*)

**?heevd**
computes all eigenvalues and, optionally, all eigenvectors of a complex Hermitian matrix using a divide and conquer algorithm.

```
call cheevd (
```

*job, uplo, n, a, lda, w, work, lwork, rwork, lrwork,
iwork, liwork, info*)

call zheevd (*job, uplo, n, a, lda, w, work, lwork, rwork, lrwork,
iwork, liwork, info*)

**?syevx**
computes selected eigenvalues and, optionally, eigenvectors of a symmetric matrix.

```
call ssyevx (
```

*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, work, lwork, iwork, ifail, info*)

call dsyevx (*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, work, lwork, iwork, ifail, info*)

**?heevx**
computes selected eigenvalues and, optionally, eigenvectors of a Hermitian matrix.

```
call cheevx (
```

*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, work, lwork, rwork, iwork, ifail, info*)

call zheevx (*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, work, lwork, rwork, iwork, ifail, info*)

**?syevr**
computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix using the Relatively Robust Representations.

```
call ssyevr (
```

*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info*)

call dsyevr (*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info*)

**?heevr**
computes selected eigenvalues and, optionally, eigenvectors of a Hermitian matrix using the Relatively Robust Representations.

```
call cheevr (
```

*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, isuppz, work, lwork, rwork, lrwork,
iwork, liwork, info*)

call zheevr (*jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol,
m, w, z, ldz, isuppz, work, lwork, rwork, lrwork,
iwork, liwork, info*)

**?spev**
computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix in packed storage.

```
call sspev (
```

*jobz, uplo, n, ap, w, z, ldz, work, info*)

call dspev (*jobz, uplo, n, ap, w, z, ldz, work, info*)

**?hpev**
computes all eigenvalues and, optionally, eigenvectors of a Hermitian matrix in packed storage.

```
call chpev (
```

*jobz, uplo, n, ap, w, z, ldz, work, rwork, info*)

call zhpev (*jobz, uplo, n, ap, w, z, ldz, work, rwork, info*)

**?spevd**
uses a divide and conquer algorithm to compute all eigenvalues and, optionally, all eigenvectors of a real symmetric matrix held in packed storage.

```
call sspevd (
```

*job ,uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info*)

call dspevd (*job ,uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info*)

**?hpevd**
uses a divide and conquer algorithm to compute all eigenvalues and, optionally, all eigenvectors of a complex Hermitian matrix held in packed storage.

```
call chpevd (
```

*job, uplo, n, ap, w, z, ldz, work, lwork, rwork,
lrwork, iwork, liwork, info*)

call zhpevd (*job, uplo, n, ap, w, z, ldz, work, lwork, rwork,
lrwork, iwork, liwork, info*)

**?spevx**
computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix in packed storage.

```
call sspevx (
```

*jobz, range, uplo, n, ap, vl, vu, il, iu, abstol,
m, w, z, ldz, work, iwork, ifail, info*)

call dspevx (*jobz, range, uplo, n, ap, vl, vu, il, iu, abstol,
m, w, z, ldz, work, iwork, ifail, info*)

**?hpevx**
computes selected eigenvalues and, optionally, eigenvectors of a Hermitian matrix in packed storage.

```
call chpevx (
```

*jobz, range, uplo, n, ap, vl, vu, il, iu, abstol,
m, w, z, ldz, work, rwork, iwork, ifail, info*)

call zhpevx (*jobz, range, uplo, n, ap, vl, vu, il, iu, abstol,
m, w, z, ldz, work, rwork, iwork, ifail, info*)

**?sbev**
computes all eigenvalues and, optionally, eigenvectors of a real symmetric band matrix.

```
call ssbev (
```

*jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info*)

call dsbev (*jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info*)

**?hbev**
computes all eigenvalues and, optionally, eigenvectors of a Hermitian band matrix.

```
call chbev (
```

*jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info*)

call zhbev (*jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info*)

**?sbevd**
computes all eigenvalues and, optionally, all eigenvectors of a real symmetric band matrix using a divide and conquer algorithm.

```
call ssbevd (
```

*job, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork,
iwork, liwork, info*)

call dsbevd (*job, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork,
iwork, liwork, info*)

**?hbevd**
computes all eigenvalues and, optionally, all eigenvectors of a complex Hermitian band matrix using a divide and conquer algorithm.

```
call chbevd (
```

*job, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork,
rwork, lrwork, iwork, liwork, info*)

call zhbevd (*job, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork,
rwork, lrwork, iwork, liwork, info*)

**?sbevx**
computes selected eigenvalues and, optionally, eigenvectors of a real symmetric band matrix.

```
call ssbevx (
```

*jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il,
iu, abstol, m, w, z, ldz, work, iwork, ifail, info*)

call dsbevx (*jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il,
iu, abstol, m, w, z, ldz, work, iwork, ifail, info*)

**?hbevx**
computes selected eigenvalues and, optionally, eigenvectors of a Hermitian band matrix.

```
call chbevx (
```

*jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il,
iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info*)

call zhbevx (*jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il,
iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info*)

**?stev**
computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix.

```
call sstev (
```

*jobz, n, d, e, z, ldz, work, info*)

call dstev (*jobz, n, d, e, z, ldz, work, info*)

**?stevd**
computes all eigenvalues and, optionally, all eigenvectors of a real symmetric tridiagonal matrix using a divide and conquer algorithm.

```
call sstevd (
```

*job, n, d, e, z, ldz, work, lwork, iwork, liwork, info*)

call dstevd (*job, n, d, e, z, ldz, work, lwork, iwork, liwork, info*)

**?stevx**
computes selected eigenvalues and eigenvectors of a real symmetric tridiagonal matrix.

```
call sstevx (
```

*jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
ldz, work, iwork, ifail, info*)

call dstevx (*jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
ldz, work, iwork, ifail, info*)

**?stevr**
computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix using the Relatively Robust Representations.

```
call sstevr (
```

*jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
ldz, isuppz, work, lwork, iwork, liwork, info*)

call dstevr (*jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z,
ldz, isuppz, work, lwork, iwork, liwork, info*)

* *Legal Information*
© 1999, 2002-2004, Intel Corporation