fortran-lapack
Loading...
Searching...
No Matches
la_lapack_eigv_sym Module Reference

Symmetric and Hermitian eigenvalue drivers: dense, packed, banded and generalized problems. More...

Functions/Subroutines

pure subroutine, public la_ssb2st_kernels (uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)
 SSB2ST_KERNELS: is an internal routine used by the SSYTRD_SB2ST subroutine.
 
pure subroutine, public la_dsb2st_kernels (uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)
 DSB2ST_KERNELS: is an internal routine used by the DSYTRD_SB2ST subroutine.
 
pure subroutine, public la_ssytd2 (uplo, n, a, lda, d, e, tau, info)
 SSYTD2: reduces a real symmetric matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
 
pure subroutine, public la_dsytd2 (uplo, n, a, lda, d, e, tau, info)
 DSYTD2: reduces a real symmetric matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
 
pure subroutine, public la_ssytrd (uplo, n, a, lda, d, e, tau, work, lwork, info)
 SSYTRD: reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
 
pure subroutine, public la_dsytrd (uplo, n, a, lda, d, e, tau, work, lwork, info)
 DSYTRD: reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
 
pure subroutine, public la_ssytrd_sb2st (stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)
 SSYTRD_SB2ST: reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.
 
pure subroutine, public la_dsytrd_sb2st (stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)
 DSYTRD_SB2ST: reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.
 
pure subroutine, public la_sorgtr (uplo, n, a, lda, tau, work, lwork, info)
 SORGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by SSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
 
pure subroutine, public la_dorgtr (uplo, n, a, lda, tau, work, lwork, info)
 DORGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by DSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
 
pure subroutine, public la_sormtr (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)
 SORMTR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**T * C C * Q**T where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
 
pure subroutine, public la_dormtr (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)
 DORMTR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**T * C C * Q**T where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
 
pure subroutine, public la_ssbev (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info)
 SSBEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.
 
pure subroutine, public la_dsbev (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info)
 DSBEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.
 
pure subroutine, public la_ssbevx (jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 SSBEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_dsbevx (jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 DSBEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_ssbgv (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info)
 SSBGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.
 
pure subroutine, public la_dsbgv (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info)
 DSBGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.
 
pure subroutine, public la_ssbgvx (jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 SSBGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_dsbgvx (jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 DSBGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_sspev (jobz, uplo, n, ap, w, z, ldz, work, info)
 SSPEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.
 
pure subroutine, public la_dspev (jobz, uplo, n, ap, w, z, ldz, work, info)
 DSPEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.
 
pure subroutine, public la_sspevx (jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 SSPEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_dspevx (jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 DSPEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_sspgv (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info)
 SSPGV: computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.
 
pure subroutine, public la_dspgv (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info)
 DSPGV: computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.
 
pure subroutine, public la_sspgvx (itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 SSPGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed storage, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_dspgvx (itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info)
 DSPGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed storage, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_ssyev (jobz, uplo, n, a, lda, w, work, lwork, info)
 SSYEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
 
pure subroutine, public la_dsyev (jobz, uplo, n, a, lda, w, work, lwork, info)
 DSYEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
 
pure subroutine, public la_ssyevx (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info)
 SSYEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_dsyevx (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info)
 DSYEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_ssygv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)
 SSYGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite.
 
pure subroutine, public la_dsygv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)
 DSYGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite.
 
pure subroutine, public la_ssygvx (itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info)
 SSYGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_dsygvx (itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info)
 DSYGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_ssytrd_sy2sb (uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)
 SSYTRD_SY2SB: reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.
 
pure subroutine, public la_dsytrd_sy2sb (uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)
 DSYTRD_SY2SB: reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.
 
pure subroutine, public la_ssyevd (jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)
 SSYEVD: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. 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. Because of large use of BLAS of level 3, SSYEVD needs N**2 more workspace than SSYEVX.
 
pure subroutine, public la_dsyevd (jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)
 DSYEVD: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. 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. Because of large use of BLAS of level 3, DSYEVD needs N**2 more workspace than DSYEVX.
 
pure subroutine, public la_ssygvd (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info)
 SSYGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. 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.
 
pure subroutine, public la_dsygvd (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info)
 DSYGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. 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.
 
pure subroutine, public la_ssbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info)
 SSBEVD: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. 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.
 
pure subroutine, public la_dsbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info)
 DSBEVD: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. 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.
 
pure subroutine, public la_ssbgvd (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info)
 SSBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. 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.
 
pure subroutine, public la_dsbgvd (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info)
 DSBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. 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.
 
pure subroutine, public la_sspevd (jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info)
 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.
 
pure subroutine, public la_dspevd (jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info)
 DSPEVD: 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.
 
pure subroutine, public la_sspgvd (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info)
 SSPGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. 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.
 
pure subroutine, public la_dspgvd (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info)
 DSPGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. 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.
 
pure subroutine, public la_ssyevr (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)
 SSYEVR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SSYEVR first reduces the matrix A to tridiagonal form T with a call to SSYTRD. Then, whenever possible, SSYEVR calls SSTEMR to compute the eigenspectrum using Relatively Robust Representations. SSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see SSTEMR's documentation and:
 
pure subroutine, public la_dsyevr (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info)
 DSYEVR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. DSYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see DSTEMR's documentation and:
 
pure subroutine, public la_chb2st_kernels (uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)
 CHB2ST_KERNELS: is an internal routine used by the CHETRD_HB2ST subroutine.
 
pure subroutine, public la_zhb2st_kernels (uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work)
 ZHB2ST_KERNELS: is an internal routine used by the ZHETRD_HB2ST subroutine.
 
pure subroutine, public la_chetd2 (uplo, n, a, lda, d, e, tau, info)
 CHETD2: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
 
pure subroutine, public la_zhetd2 (uplo, n, a, lda, d, e, tau, info)
 ZHETD2: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
 
pure subroutine, public la_chetrd (uplo, n, a, lda, d, e, tau, work, lwork, info)
 CHETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
 
pure subroutine, public la_zhetrd (uplo, n, a, lda, d, e, tau, work, lwork, info)
 ZHETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
 
pure subroutine, public la_chetrd_hb2st (stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)
 CHETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
 
pure subroutine, public la_zhetrd_hb2st (stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info)
 ZHETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
 
pure subroutine, public la_chetrd_he2hb (uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)
 CHETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.
 
pure subroutine, public la_zhetrd_he2hb (uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info)
 ZHETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.
 
pure subroutine, public la_cungtr (uplo, n, a, lda, tau, work, lwork, info)
 CUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
 
pure subroutine, public la_zungtr (uplo, n, a, lda, tau, work, lwork, info)
 ZUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by ZHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
 
pure subroutine, public la_cunmtr (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)
 CUNMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
 
pure subroutine, public la_zunmtr (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)
 ZUNMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by ZHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
 
pure subroutine, public la_cheev (jobz, uplo, n, a, lda, w, work, lwork, rwork, info)
 CHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
 
pure subroutine, public la_zheev (jobz, uplo, n, a, lda, w, work, lwork, rwork, info)
 ZHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
 
pure subroutine, public la_cheevr (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)
 CHEEVR: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. CHEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and:
 
pure subroutine, public la_zheevr (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)
 ZHEEVR: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. ZHEEVR first reduces the matrix A to tridiagonal form T with a call to ZHETRD. Then, whenever possible, ZHEEVR calls ZSTEMR to compute eigenspectrum using Relatively Robust Representations. ZSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see ZSTEMR's documentation and:
 
pure subroutine, public la_cheevx (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info)
 CHEEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_zheevx (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info)
 ZHEEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_chegv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)
 CHEGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.
 
pure subroutine, public la_zhegv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)
 ZHEGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.
 
pure subroutine, public la_chegvx (itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info)
 CHEGVX: computes selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_zhegvx (itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info)
 ZHEGVX: computes selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_chpev (jobz, uplo, n, ap, w, z, ldz, work, rwork, info)
 CHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.
 
pure subroutine, public la_zhpev (jobz, uplo, n, ap, w, z, ldz, work, rwork, info)
 ZHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.
 
pure subroutine, public la_chpevx (jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 CHPEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_zhpevx (jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 ZHPEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_chpgv (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info)
 CHPGV: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.
 
pure subroutine, public la_zhpgv (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info)
 ZHPGV: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.
 
pure subroutine, public la_chpgvx (itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 CHPGVX: computes selected eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_zhpgvx (itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 ZHPGVX: computes selected eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_chbev (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info)
 CHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.
 
pure subroutine, public la_zhbev (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info)
 ZHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.
 
pure subroutine, public la_chbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 CHBEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. 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.
 
pure subroutine, public la_zhbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 ZHBEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. 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.
 
pure subroutine, public la_chbevx (jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 CHBEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_zhbevx (jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 ZHBEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_chbgv (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info)
 CHBGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.
 
pure subroutine, public la_zhbgv (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info)
 ZHBGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.
 
pure subroutine, public la_chbgvd (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 CHBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. 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.
 
pure subroutine, public la_zhbgvd (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 ZHBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. 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.
 
pure subroutine, public la_chbgvx (jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 CHBGVX: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_zhbgvx (jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info)
 ZHBGVX: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.
 
pure subroutine, public la_cheevd (jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)
 CHEEVD: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. 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.
 
pure subroutine, public la_zheevd (jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)
 ZHEEVD: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. 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.
 
pure subroutine, public la_chegvd (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info)
 CHEGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. 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.
 
pure subroutine, public la_zhegvd (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info)
 ZHEGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. 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.
 
pure subroutine, public la_chpevd (jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 CHPEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian 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.
 
pure subroutine, public la_zhpevd (jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 ZHPEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian 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.
 
pure subroutine, public la_chpgvd (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 CHPGVD: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. 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.
 
pure subroutine, public la_zhpgvd (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
 ZHPGVD: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. 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.
 

Detailed Description

Symmetric and Hermitian eigenvalue drivers: dense, packed, banded and generalized problems.

Function/Subroutine Documentation

◆ la_chb2st_kernels()

pure subroutine, public la_lapack_eigv_sym::la_chb2st_kernels ( character, intent(in) uplo,
logical(lk), intent(in) wantz,
integer(ilp), intent(in) ttype,
integer(ilp), intent(in) st,
integer(ilp), intent(in) ed,
integer(ilp), intent(in) sweep,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nb,
integer(ilp), intent(in) ib,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(*), intent(out) v,
complex(sp), dimension(*), intent(out) tau,
integer(ilp), intent(in) ldvt,
complex(sp), dimension(*), intent(out) work )

CHB2ST_KERNELS: is an internal routine used by the CHETRD_HB2ST subroutine.

Here is the call graph for this function:

◆ la_chbev()

pure subroutine, public la_lapack_eigv_sym::la_chbev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.

Here is the call graph for this function:

◆ la_chbevd()

pure subroutine, public la_lapack_eigv_sym::la_chbevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

CHBEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. 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.

Here is the call graph for this function:

◆ la_chbevx()

pure subroutine, public la_lapack_eigv_sym::la_chbevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

CHBEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chbgv()

pure subroutine, public la_lapack_eigv_sym::la_chbgv ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
complex(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CHBGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.

Here is the call graph for this function:

◆ la_chbgvd()

pure subroutine, public la_lapack_eigv_sym::la_chbgvd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
complex(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

CHBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_chbgvx()

pure subroutine, public la_lapack_eigv_sym::la_chbgvx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
complex(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
complex(sp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

CHBGVX: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_cheev()

pure subroutine, public la_lapack_eigv_sym::la_cheev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

Here is the call graph for this function:

◆ la_cheevd()

pure subroutine, public la_lapack_eigv_sym::la_cheevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

CHEEVD: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. 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.

Here is the call graph for this function:

◆ la_cheevr()

pure subroutine, public la_lapack_eigv_sym::la_cheevr ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
integer(ilp), dimension(*), intent(out) isuppz,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

CHEEVR: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. CHEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and:

  • Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
  • Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,
  1. Also LAPACK Working Note 154.
  • Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : CHEEVR calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. CHEEVR calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
Here is the call graph for this function:

◆ la_cheevx()

pure subroutine, public la_lapack_eigv_sym::la_cheevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

CHEEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chegv()

pure subroutine, public la_lapack_eigv_sym::la_chegv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CHEGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.

Here is the call graph for this function:

◆ la_chegvd()

pure subroutine, public la_lapack_eigv_sym::la_chegvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

CHEGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_chegvx()

pure subroutine, public la_lapack_eigv_sym::la_chegvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

CHEGVX: computes selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chetd2()

pure subroutine, public la_lapack_eigv_sym::la_chetd2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) d,
real(sp), dimension(*), intent(out) e,
complex(sp), dimension(*), intent(out) tau,
integer(ilp), intent(out) info )

CHETD2: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_chetrd()

pure subroutine, public la_lapack_eigv_sym::la_chetrd ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) d,
real(sp), dimension(*), intent(out) e,
complex(sp), dimension(*), intent(out) tau,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

CHETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_chetrd_hb2st()

pure subroutine, public la_lapack_eigv_sym::la_chetrd_hb2st ( character, intent(in) stage1,
character, intent(in) vect,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(out) d,
real(sp), dimension(*), intent(out) e,
complex(sp), dimension(*), intent(out) hous,
integer(ilp), intent(in) lhous,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

CHETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_chetrd_he2hb()

pure subroutine, public la_lapack_eigv_sym::la_chetrd_he2hb ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(ldab,*), intent(out) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(*), intent(out) tau,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

CHETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.

Here is the call graph for this function:

◆ la_chpev()

pure subroutine, public la_lapack_eigv_sym::la_chpev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.

Here is the call graph for this function:

◆ la_chpevd()

pure subroutine, public la_lapack_eigv_sym::la_chpevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

CHPEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian 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.

Here is the call graph for this function:

◆ la_chpevx()

pure subroutine, public la_lapack_eigv_sym::la_chpevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

CHPEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_chpgv()

pure subroutine, public la_lapack_eigv_sym::la_chpgv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
complex(sp), dimension(*), intent(inout) bp,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CHPGV: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.

Here is the call graph for this function:

◆ la_chpgvd()

pure subroutine, public la_lapack_eigv_sym::la_chpgvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
complex(sp), dimension(*), intent(inout) bp,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

CHPGVD: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_chpgvx()

pure subroutine, public la_lapack_eigv_sym::la_chpgvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
complex(sp), dimension(*), intent(inout) bp,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
complex(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

CHPGVX: computes selected eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_cungtr()

pure subroutine, public la_lapack_eigv_sym::la_cungtr ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(*), intent(in) tau,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

CUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

Here is the call graph for this function:

◆ la_cunmtr()

pure subroutine, public la_lapack_eigv_sym::la_cunmtr ( character, intent(in) side,
character, intent(in) uplo,
character, intent(in) trans,
integer(ilp), intent(in) m,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(*), intent(in) tau,
complex(sp), dimension(ldc,*), intent(inout) c,
integer(ilp), intent(in) ldc,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

CUNMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

Here is the call graph for this function:

◆ la_dorgtr()

pure subroutine, public la_lapack_eigv_sym::la_dorgtr ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(in) tau,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

DORGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by DSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

Here is the call graph for this function:

◆ la_dormtr()

pure subroutine, public la_lapack_eigv_sym::la_dormtr ( character, intent(in) side,
character, intent(in) uplo,
character, intent(in) trans,
integer(ilp), intent(in) m,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(in) tau,
real(dp), dimension(ldc,*), intent(inout) c,
integer(ilp), intent(in) ldc,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

DORMTR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**T * C C * Q**T where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

Here is the call graph for this function:

◆ la_dsb2st_kernels()

pure subroutine, public la_lapack_eigv_sym::la_dsb2st_kernels ( character, intent(in) uplo,
logical(lk), intent(in) wantz,
integer(ilp), intent(in) ttype,
integer(ilp), intent(in) st,
integer(ilp), intent(in) ed,
integer(ilp), intent(in) sweep,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nb,
integer(ilp), intent(in) ib,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) v,
real(dp), dimension(*), intent(out) tau,
integer(ilp), intent(in) ldvt,
real(dp), dimension(*), intent(out) work )

DSB2ST_KERNELS: is an internal routine used by the DSYTRD_SB2ST subroutine.

Here is the call graph for this function:

◆ la_dsbev()

pure subroutine, public la_lapack_eigv_sym::la_dsbev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

DSBEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.

Here is the call graph for this function:

◆ la_dsbevd()

pure subroutine, public la_lapack_eigv_sym::la_dsbevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

DSBEVD: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. 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.

Here is the call graph for this function:

◆ la_dsbevx()

pure subroutine, public la_lapack_eigv_sym::la_dsbevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

DSBEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_dsbgv()

pure subroutine, public la_lapack_eigv_sym::la_dsbgv ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
real(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

DSBGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.

Here is the call graph for this function:

◆ la_dsbgvd()

pure subroutine, public la_lapack_eigv_sym::la_dsbgvd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
real(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

DSBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_dsbgvx()

pure subroutine, public la_lapack_eigv_sym::la_dsbgvx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
real(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(dp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

DSBGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_dspev()

pure subroutine, public la_lapack_eigv_sym::la_dspev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(inout) ap,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

DSPEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.

Here is the call graph for this function:

◆ la_dspevd()

pure subroutine, public la_lapack_eigv_sym::la_dspevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(inout) ap,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

DSPEVD: 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.

Here is the call graph for this function:

◆ la_dspevx()

pure subroutine, public la_lapack_eigv_sym::la_dspevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(inout) ap,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

DSPEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_dspgv()

pure subroutine, public la_lapack_eigv_sym::la_dspgv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(inout) ap,
real(dp), dimension(*), intent(inout) bp,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

DSPGV: computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.

Here is the call graph for this function:

◆ la_dspgvd()

pure subroutine, public la_lapack_eigv_sym::la_dspgvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(inout) ap,
real(dp), dimension(*), intent(inout) bp,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

DSPGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_dspgvx()

pure subroutine, public la_lapack_eigv_sym::la_dspgvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(inout) ap,
real(dp), dimension(*), intent(inout) bp,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

DSPGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed storage, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_dsyev()

pure subroutine, public la_lapack_eigv_sym::la_dsyev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

DSYEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

Here is the call graph for this function:

◆ la_dsyevd()

pure subroutine, public la_lapack_eigv_sym::la_dsyevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

DSYEVD: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. 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. Because of large use of BLAS of level 3, DSYEVD needs N**2 more workspace than DSYEVX.

Here is the call graph for this function:

◆ la_dsyevr()

pure subroutine, public la_lapack_eigv_sym::la_dsyevr ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
integer(ilp), dimension(*), intent(out) isuppz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

DSYEVR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. DSYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see DSTEMR's documentation and:

  • Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
  • Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,
  1. Also LAPACK Working Note 154.
  • Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : DSYEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. DSYEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
Here is the call graph for this function:

◆ la_dsyevx()

pure subroutine, public la_lapack_eigv_sym::la_dsyevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

DSYEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_dsygv()

pure subroutine, public la_lapack_eigv_sym::la_dsygv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

DSYGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite.

Here is the call graph for this function:

◆ la_dsygvd()

pure subroutine, public la_lapack_eigv_sym::la_dsygvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

DSYGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_dsygvx()

pure subroutine, public la_lapack_eigv_sym::la_dsygvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
real(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

DSYGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_dsytd2()

pure subroutine, public la_lapack_eigv_sym::la_dsytd2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) d,
real(dp), dimension(*), intent(out) e,
real(dp), dimension(*), intent(out) tau,
integer(ilp), intent(out) info )

DSYTD2: reduces a real symmetric matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

Here is the call graph for this function:

◆ la_dsytrd()

pure subroutine, public la_lapack_eigv_sym::la_dsytrd ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) d,
real(dp), dimension(*), intent(out) e,
real(dp), dimension(*), intent(out) tau,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

DSYTRD: reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

Here is the call graph for this function:

◆ la_dsytrd_sb2st()

pure subroutine, public la_lapack_eigv_sym::la_dsytrd_sb2st ( character, intent(in) stage1,
character, intent(in) vect,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(out) d,
real(dp), dimension(*), intent(out) e,
real(dp), dimension(*), intent(out) hous,
integer(ilp), intent(in) lhous,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

DSYTRD_SB2ST: reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.

Here is the call graph for this function:

◆ la_dsytrd_sy2sb()

pure subroutine, public la_lapack_eigv_sym::la_dsytrd_sy2sb ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(ldab,*), intent(out) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(out) tau,
real(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

DSYTRD_SY2SB: reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.

Here is the call graph for this function:

◆ la_sorgtr()

pure subroutine, public la_lapack_eigv_sym::la_sorgtr ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(in) tau,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

SORGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by SSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

Here is the call graph for this function:

◆ la_sormtr()

pure subroutine, public la_lapack_eigv_sym::la_sormtr ( character, intent(in) side,
character, intent(in) uplo,
character, intent(in) trans,
integer(ilp), intent(in) m,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(in) tau,
real(sp), dimension(ldc,*), intent(inout) c,
integer(ilp), intent(in) ldc,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

SORMTR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**T * C C * Q**T where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

Here is the call graph for this function:

◆ la_ssb2st_kernels()

pure subroutine, public la_lapack_eigv_sym::la_ssb2st_kernels ( character, intent(in) uplo,
logical(lk), intent(in) wantz,
integer(ilp), intent(in) ttype,
integer(ilp), intent(in) st,
integer(ilp), intent(in) ed,
integer(ilp), intent(in) sweep,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nb,
integer(ilp), intent(in) ib,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) v,
real(sp), dimension(*), intent(out) tau,
integer(ilp), intent(in) ldvt,
real(sp), dimension(*), intent(out) work )

SSB2ST_KERNELS: is an internal routine used by the SSYTRD_SB2ST subroutine.

Here is the call graph for this function:

◆ la_ssbev()

pure subroutine, public la_lapack_eigv_sym::la_ssbev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

SSBEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.

Here is the call graph for this function:

◆ la_ssbevd()

pure subroutine, public la_lapack_eigv_sym::la_ssbevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

SSBEVD: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. 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.

Here is the call graph for this function:

◆ la_ssbevx()

pure subroutine, public la_lapack_eigv_sym::la_ssbevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

SSBEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_ssbgv()

pure subroutine, public la_lapack_eigv_sym::la_ssbgv ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
real(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

SSBGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.

Here is the call graph for this function:

◆ la_ssbgvd()

pure subroutine, public la_lapack_eigv_sym::la_ssbgvd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
real(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

SSBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_ssbgvx()

pure subroutine, public la_lapack_eigv_sym::la_ssbgvx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
real(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(sp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

SSBGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_sspev()

pure subroutine, public la_lapack_eigv_sym::la_sspev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(inout) ap,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

SSPEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.

Here is the call graph for this function:

◆ la_sspevd()

pure subroutine, public la_lapack_eigv_sym::la_sspevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(inout) ap,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

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.

Here is the call graph for this function:

◆ la_sspevx()

pure subroutine, public la_lapack_eigv_sym::la_sspevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(inout) ap,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

SSPEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_sspgv()

pure subroutine, public la_lapack_eigv_sym::la_sspgv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(inout) ap,
real(sp), dimension(*), intent(inout) bp,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

SSPGV: computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.

Here is the call graph for this function:

◆ la_sspgvd()

pure subroutine, public la_lapack_eigv_sym::la_sspgvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(inout) ap,
real(sp), dimension(*), intent(inout) bp,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

SSPGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_sspgvx()

pure subroutine, public la_lapack_eigv_sym::la_sspgvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(inout) ap,
real(sp), dimension(*), intent(inout) bp,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

SSPGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric, stored in packed storage, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_ssyev()

pure subroutine, public la_lapack_eigv_sym::la_ssyev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

SSYEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

Here is the call graph for this function:

◆ la_ssyevd()

pure subroutine, public la_lapack_eigv_sym::la_ssyevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

SSYEVD: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. 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. Because of large use of BLAS of level 3, SSYEVD needs N**2 more workspace than SSYEVX.

Here is the call graph for this function:

◆ la_ssyevr()

pure subroutine, public la_lapack_eigv_sym::la_ssyevr ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
integer(ilp), dimension(*), intent(out) isuppz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

SSYEVR: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SSYEVR first reduces the matrix A to tridiagonal form T with a call to SSYTRD. Then, whenever possible, SSYEVR calls SSTEMR to compute the eigenspectrum using Relatively Robust Representations. SSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see SSTEMR's documentation and:

  • Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
  • Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,
  1. Also LAPACK Working Note 154.
  • Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : SSYEVR calls SSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. SSYEVR calls SSTEBZ and SSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of SSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
Here is the call graph for this function:

◆ la_ssyevx()

pure subroutine, public la_lapack_eigv_sym::la_ssyevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

SSYEVX: computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_ssygv()

pure subroutine, public la_lapack_eigv_sym::la_ssygv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

SSYGV: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite.

Here is the call graph for this function:

◆ la_ssygvd()

pure subroutine, public la_lapack_eigv_sym::la_ssygvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

SSYGVD: computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_ssygvx()

pure subroutine, public la_lapack_eigv_sym::la_ssygvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(sp), intent(in) vl,
real(sp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(sp), intent(in) abstol,
integer(ilp), intent(out) m,
real(sp), dimension(*), intent(out) w,
real(sp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

SSYGVX: computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_ssytd2()

pure subroutine, public la_lapack_eigv_sym::la_ssytd2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) d,
real(sp), dimension(*), intent(out) e,
real(sp), dimension(*), intent(out) tau,
integer(ilp), intent(out) info )

SSYTD2: reduces a real symmetric matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

Here is the call graph for this function:

◆ la_ssytrd()

pure subroutine, public la_lapack_eigv_sym::la_ssytrd ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) d,
real(sp), dimension(*), intent(out) e,
real(sp), dimension(*), intent(out) tau,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

SSYTRD: reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.

Here is the call graph for this function:

◆ la_ssytrd_sb2st()

pure subroutine, public la_lapack_eigv_sym::la_ssytrd_sb2st ( character, intent(in) stage1,
character, intent(in) vect,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(sp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(out) d,
real(sp), dimension(*), intent(out) e,
real(sp), dimension(*), intent(out) hous,
integer(ilp), intent(in) lhous,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

SSYTRD_SB2ST: reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.

Here is the call graph for this function:

◆ la_ssytrd_sy2sb()

pure subroutine, public la_lapack_eigv_sym::la_ssytrd_sy2sb ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(sp), dimension(ldab,*), intent(out) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(out) tau,
real(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

SSYTRD_SY2SB: reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.

Here is the call graph for this function:

◆ la_zhb2st_kernels()

pure subroutine, public la_lapack_eigv_sym::la_zhb2st_kernels ( character, intent(in) uplo,
logical(lk), intent(in) wantz,
integer(ilp), intent(in) ttype,
integer(ilp), intent(in) st,
integer(ilp), intent(in) ed,
integer(ilp), intent(in) sweep,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nb,
integer(ilp), intent(in) ib,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(*), intent(out) v,
complex(dp), dimension(*), intent(out) tau,
integer(ilp), intent(in) ldvt,
complex(dp), dimension(*), intent(out) work )

ZHB2ST_KERNELS: is an internal routine used by the ZHETRD_HB2ST subroutine.

Here is the call graph for this function:

◆ la_zhbev()

pure subroutine, public la_lapack_eigv_sym::la_zhbev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.

Here is the call graph for this function:

◆ la_zhbevd()

pure subroutine, public la_lapack_eigv_sym::la_zhbevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

ZHBEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. 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.

Here is the call graph for this function:

◆ la_zhbevx()

pure subroutine, public la_lapack_eigv_sym::la_zhbevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

ZHBEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_zhbgv()

pure subroutine, public la_lapack_eigv_sym::la_zhbgv ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
complex(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZHBGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.

Here is the call graph for this function:

◆ la_zhbgvd()

pure subroutine, public la_lapack_eigv_sym::la_zhbgvd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
complex(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

ZHBGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_zhbgvx()

pure subroutine, public la_lapack_eigv_sym::la_zhbgvx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) ka,
integer(ilp), intent(in) kb,
complex(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(ldbb,*), intent(inout) bb,
integer(ilp), intent(in) ldbb,
complex(dp), dimension(ldq,*), intent(out) q,
integer(ilp), intent(in) ldq,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

ZHBGVX: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either all eigenvalues, a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_zheev()

pure subroutine, public la_lapack_eigv_sym::la_zheev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

Here is the call graph for this function:

◆ la_zheevd()

pure subroutine, public la_lapack_eigv_sym::la_zheevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

ZHEEVD: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. 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.

Here is the call graph for this function:

◆ la_zheevr()

pure subroutine, public la_lapack_eigv_sym::la_zheevr ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
integer(ilp), dimension(*), intent(out) isuppz,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

ZHEEVR: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. ZHEEVR first reduces the matrix A to tridiagonal form T with a call to ZHETRD. Then, whenever possible, ZHEEVR calls ZSTEMR to compute eigenspectrum using Relatively Robust Representations. ZSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see ZSTEMR's documentation and:

  • Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
  • Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,
  1. Also LAPACK Working Note 154.
  • Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : ZHEEVR calls ZSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. ZHEEVR calls DSTEBZ and ZSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of ZSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
Here is the call graph for this function:

◆ la_zheevx()

pure subroutine, public la_lapack_eigv_sym::la_zheevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

ZHEEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_zhegv()

pure subroutine, public la_lapack_eigv_sym::la_zhegv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZHEGV: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.

Here is the call graph for this function:

◆ la_zhegvd()

pure subroutine, public la_lapack_eigv_sym::la_zhegvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

ZHEGVD: computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_zhegvx()

pure subroutine, public la_lapack_eigv_sym::la_zhegvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

ZHEGVX: computes selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_zhetd2()

pure subroutine, public la_lapack_eigv_sym::la_zhetd2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) d,
real(dp), dimension(*), intent(out) e,
complex(dp), dimension(*), intent(out) tau,
integer(ilp), intent(out) info )

ZHETD2: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_zhetrd()

pure subroutine, public la_lapack_eigv_sym::la_zhetrd ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) d,
real(dp), dimension(*), intent(out) e,
complex(dp), dimension(*), intent(out) tau,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

ZHETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_zhetrd_hb2st()

pure subroutine, public la_lapack_eigv_sym::la_zhetrd_hb2st ( character, intent(in) stage1,
character, intent(in) vect,
character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(dp), dimension(ldab,*), intent(inout) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(out) d,
real(dp), dimension(*), intent(out) e,
complex(dp), dimension(*), intent(out) hous,
integer(ilp), intent(in) lhous,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

ZHETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.

Here is the call graph for this function:

◆ la_zhetrd_he2hb()

pure subroutine, public la_lapack_eigv_sym::la_zhetrd_he2hb ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(ldab,*), intent(out) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(*), intent(out) tau,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

ZHETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.

Here is the call graph for this function:

◆ la_zhpev()

pure subroutine, public la_lapack_eigv_sym::la_zhpev ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.

Here is the call graph for this function:

◆ la_zhpevd()

pure subroutine, public la_lapack_eigv_sym::la_zhpevd ( character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

ZHPEVD: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian 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.

Here is the call graph for this function:

◆ la_zhpevx()

pure subroutine, public la_lapack_eigv_sym::la_zhpevx ( character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

ZHPEVX: computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. Eigenvalues/vectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_zhpgv()

pure subroutine, public la_lapack_eigv_sym::la_zhpgv ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
complex(dp), dimension(*), intent(inout) bp,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZHPGV: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.

Here is the call graph for this function:

◆ la_zhpgvd()

pure subroutine, public la_lapack_eigv_sym::la_zhpgvd ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
complex(dp), dimension(*), intent(inout) bp,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(in) lrwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(in) liwork,
integer(ilp), intent(out) info )

ZHPGVD: computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. 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.

Here is the call graph for this function:

◆ la_zhpgvx()

pure subroutine, public la_lapack_eigv_sym::la_zhpgvx ( integer(ilp), intent(in) itype,
character, intent(in) jobz,
character, intent(in) range,
character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
complex(dp), dimension(*), intent(inout) bp,
real(dp), intent(in) vl,
real(dp), intent(in) vu,
integer(ilp), intent(in) il,
integer(ilp), intent(in) iu,
real(dp), intent(in) abstol,
integer(ilp), intent(out) m,
real(dp), dimension(*), intent(out) w,
complex(dp), dimension(ldz,*), intent(out) z,
integer(ilp), intent(in) ldz,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), dimension(*), intent(out) ifail,
integer(ilp), intent(out) info )

ZHPGVX: computes selected eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Here is the call graph for this function:

◆ la_zungtr()

pure subroutine, public la_lapack_eigv_sym::la_zungtr ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(*), intent(in) tau,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

ZUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by ZHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

Here is the call graph for this function:

◆ la_zunmtr()

pure subroutine, public la_lapack_eigv_sym::la_zunmtr ( character, intent(in) side,
character, intent(in) uplo,
character, intent(in) trans,
integer(ilp), intent(in) m,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(*), intent(in) tau,
complex(dp), dimension(ldc,*), intent(inout) c,
integer(ilp), intent(in) ldc,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

ZUNMTR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by ZHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

Here is the call graph for this function: