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_qsb2st_kernels (uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work) |
| QSB2ST_KERNELS: is an internal routine used by the QSYTRD_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_qsytd2 (uplo, n, a, lda, d, e, tau, info) |
| QSYTD2: 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_qsytrd (uplo, n, a, lda, d, e, tau, work, lwork, info) |
| QSYTRD: 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_qsytrd_sb2st (stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info) |
| QSYTRD_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_qorgtr (uplo, n, a, lda, tau, work, lwork, info) |
| QORGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by QSYTRD: 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_qormtr (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) |
| QORMTR: 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 QSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1). | |
| 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. | |
| 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. | |
| subroutine, public | la_qsbev (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info) |
| QSBEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsbevx (jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) |
| QSBEVX: 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_qsbgv (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info) |
| QSBGV: 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_qsbgvx (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) |
| QSBGVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qspev (jobz, uplo, n, ap, w, z, ldz, work, info) |
| QSPEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. | |
| 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. | |
| 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. | |
| subroutine, public | la_qspevx (jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) |
| QSPEVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qspgv (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info) |
| QSPGV: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qspgvx (itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) |
| QSPGVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsyev (jobz, uplo, n, a, lda, w, work, lwork, info) |
| QSYEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsyevx (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info) |
| QSYEVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsygv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info) |
| QSYGV: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsygvx (itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info) |
| QSYGVX: 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_qsytrd_sy2sb (uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info) |
| QSYTRD_SY2SB: reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsyevd (jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info) |
| QSYEVD: 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, QSYEVD needs N**2 more workspace than QSYEVX. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsygvd (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info) |
| QSYGVD: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qsbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info) |
| QSBEVD: 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_qsbgvd (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info) |
| QSBGVD: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qspevd (jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info) |
| QSPEVD: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_qspgvd (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info) |
| QSPGVD: 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. | |
| 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: | |
| 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: | |
| subroutine, public | la_qsyevr (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) |
| QSYEVR: 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. QSYEVR first reduces the matrix A to tridiagonal form T with a call to QSYTRD. Then, whenever possible, QSYEVR calls QSTEMR to compute the eigenspectrum using Relatively Robust Representations. QSTEMR 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 QSTEMR'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_whb2st_kernels (uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, work) |
| WHB2ST_KERNELS: is an internal routine used by the WHETRD_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_whetd2 (uplo, n, a, lda, d, e, tau, info) |
| WHETD2: 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_whetrd (uplo, n, a, lda, d, e, tau, work, lwork, info) |
| WHETRD: 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_whetrd_hb2st (stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, info) |
| WHETRD_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_whetrd_he2hb (uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info) |
| WHETRD_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_wungtr (uplo, n, a, lda, tau, work, lwork, info) |
| WUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by WHETRD: 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_wunmtr (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) |
| WUNMTR: 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 WHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1). | |
| 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. | |
| 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. | |
| subroutine, public | la_wheev (jobz, uplo, n, a, lda, w, work, lwork, rwork, info) |
| WHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. | |
| 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: | |
| 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: | |
| subroutine, public | la_wheevr (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info) |
| WHEEVR: 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. WHEEVR first reduces the matrix A to tridiagonal form T with a call to WHETRD. Then, whenever possible, WHEEVR calls WSTEMR to compute eigenspectrum using Relatively Robust Representations. WSTEMR 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 WSTEMR's documentation and: | |
| 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. | |
| 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. | |
| subroutine, public | la_wheevx (jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) |
| WHEEVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whegv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info) |
| WHEGV: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whegvx (itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) |
| WHEGVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whpev (jobz, uplo, n, ap, w, z, ldz, work, rwork, info) |
| WHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage. | |
| 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. | |
| 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. | |
| subroutine, public | la_whpevx (jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) |
| WHPEVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whpgv (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info) |
| WHPGV: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whpgvx (itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) |
| WHPGVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whbev (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info) |
| WHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. | |
| 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. | |
| 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. | |
| subroutine, public | la_whbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) |
| WHBEVD: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whbevx (jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) |
| WHBEVX: 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_whbgv (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info) |
| WHBGV: 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_whbgvd (jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) |
| WHBGVD: 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_whbgvx (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) |
| WHBGVX: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_wheevd (jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info) |
| WHEEVD: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whegvd (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info) |
| WHEGVD: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whpevd (jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) |
| WHPEVD: 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. | |
| 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. | |
| 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. | |
| subroutine, public | la_whpgvd (itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) |
| WHPGVD: 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.
◆ la_chbev()
| 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.
◆ la_chbevd()
| 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.
◆ la_chbevx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_cheev()
| 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.
◆ la_cheevd()
| 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.
◆ la_cheevr()
| 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,
- 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.
◆ la_cheevx()
| 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.
◆ la_chegv()
| 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.
◆ la_chegvd()
| 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.
◆ la_chegvx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_chpev()
| 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.
◆ la_chpevd()
| 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.
◆ la_chpevx()
| 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.
◆ la_chpgv()
| 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.
◆ la_chpgvd()
| 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.
◆ la_chpgvx()
| 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.
◆ 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).
◆ 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).
◆ 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).
◆ 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).
◆ 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.
◆ la_dsbev()
| 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.
◆ la_dsbevd()
| 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.
◆ la_dsbevx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_dspev()
| 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.
◆ la_dspevd()
| 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.
◆ la_dspevx()
| 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.
◆ la_dspgv()
| 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.
◆ la_dspgvd()
| 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.
◆ la_dspgvx()
| 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.
◆ la_dsyev()
| 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.
◆ la_dsyevd()
| 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.
◆ la_dsyevr()
| 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,
- 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.
◆ la_dsyevx()
| 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.
◆ la_dsygv()
| 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.
◆ la_dsygvd()
| 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.
◆ la_dsygvx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_qorgtr()
| pure subroutine, public la_lapack_eigv_sym::la_qorgtr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | tau, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by QSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
◆ la_qormtr()
| pure subroutine, public la_lapack_eigv_sym::la_qormtr | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | tau, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORMTR: 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 QSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
◆ la_qsb2st_kernels()
| pure subroutine, public la_lapack_eigv_sym::la_qsb2st_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(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | v, | ||
| real(qp), dimension(*), intent(out) | tau, | ||
| integer(ilp), intent(in) | ldvt, | ||
| real(qp), dimension(*), intent(out) | work ) |
QSB2ST_KERNELS: is an internal routine used by the QSYTRD_SB2ST subroutine.
◆ la_qsbev()
| subroutine, public la_lapack_eigv_sym::la_qsbev | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QSBEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.
◆ la_qsbevd()
| subroutine, public la_lapack_eigv_sym::la_qsbevd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), 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 ) |
QSBEVD: 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.
◆ la_qsbevx()
| subroutine, public la_lapack_eigv_sym::la_qsbevx | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldq,*), intent(out) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
QSBEVX: 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.
◆ la_qsbgv()
| pure subroutine, public la_lapack_eigv_sym::la_qsbgv | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ka, | ||
| integer(ilp), intent(in) | kb, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldbb,*), intent(inout) | bb, | ||
| integer(ilp), intent(in) | ldbb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QSBGV: 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.
◆ la_qsbgvd()
| pure subroutine, public la_lapack_eigv_sym::la_qsbgvd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ka, | ||
| integer(ilp), intent(in) | kb, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldbb,*), intent(inout) | bb, | ||
| integer(ilp), intent(in) | ldbb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), 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 ) |
QSBGVD: 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.
◆ la_qsbgvx()
| pure subroutine, public la_lapack_eigv_sym::la_qsbgvx | ( | 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(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldbb,*), intent(inout) | bb, | ||
| integer(ilp), intent(in) | ldbb, | ||
| real(qp), dimension(ldq,*), intent(out) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
QSBGVX: 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.
◆ la_qspev()
| subroutine, public la_lapack_eigv_sym::la_qspev | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QSPEV: computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.
◆ la_qspevd()
| subroutine, public la_lapack_eigv_sym::la_qspevd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), 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 ) |
QSPEVD: 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.
◆ la_qspevx()
| subroutine, public la_lapack_eigv_sym::la_qspevx | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
QSPEVX: 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.
◆ la_qspgv()
| subroutine, public la_lapack_eigv_sym::la_qspgv | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(inout) | bp, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QSPGV: 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.
◆ la_qspgvd()
| subroutine, public la_lapack_eigv_sym::la_qspgvd | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(inout) | bp, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), 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 ) |
QSPGVD: 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.
◆ la_qspgvx()
| subroutine, public la_lapack_eigv_sym::la_qspgvx | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(inout) | bp, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
QSPGVX: 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.
◆ la_qsyev()
| subroutine, public la_lapack_eigv_sym::la_qsyev | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QSYEV: computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
◆ la_qsyevd()
| subroutine, public la_lapack_eigv_sym::la_qsyevd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), 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 ) |
QSYEVD: 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, QSYEVD needs N**2 more workspace than QSYEVX.
◆ la_qsyevr()
| subroutine, public la_lapack_eigv_sym::la_qsyevr | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), dimension(*), intent(out) | isuppz, | ||
| real(qp), 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 ) |
QSYEVR: 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. QSYEVR first reduces the matrix A to tridiagonal form T with a call to QSYTRD. Then, whenever possible, QSYEVR calls QSTEMR to compute the eigenspectrum using Relatively Robust Representations. QSTEMR 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 QSTEMR'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,
- 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 : QSYEVR calls QSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. QSYEVR calls QSTEBZ and QSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of QSTEMR 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.
◆ la_qsyevx()
| subroutine, public la_lapack_eigv_sym::la_qsyevx | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), 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 ) |
QSYEVX: 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.
◆ la_qsygv()
| subroutine, public la_lapack_eigv_sym::la_qsygv | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QSYGV: 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.
◆ la_qsygvd()
| subroutine, public la_lapack_eigv_sym::la_qsygvd | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), 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 ) |
QSYGVD: 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.
◆ la_qsygvx()
| subroutine, public la_lapack_eigv_sym::la_qsygvx | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| real(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), 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 ) |
QSYGVX: 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.
◆ la_qsytd2()
| pure subroutine, public la_lapack_eigv_sym::la_qsytd2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| real(qp), dimension(*), intent(out) | tau, | ||
| integer(ilp), intent(out) | info ) |
QSYTD2: reduces a real symmetric matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
◆ la_qsytrd()
| pure subroutine, public la_lapack_eigv_sym::la_qsytrd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| real(qp), dimension(*), intent(out) | tau, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QSYTRD: reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
◆ la_qsytrd_sb2st()
| pure subroutine, public la_lapack_eigv_sym::la_qsytrd_sb2st | ( | character, intent(in) | stage1, |
| character, intent(in) | vect, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| real(qp), dimension(*), intent(out) | hous, | ||
| integer(ilp), intent(in) | lhous, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QSYTRD_SB2ST: reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.
◆ la_qsytrd_sy2sb()
| pure subroutine, public la_lapack_eigv_sym::la_qsytrd_sy2sb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldab,*), intent(out) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | tau, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QSYTRD_SY2SB: reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.
◆ 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).
◆ 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).
◆ 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.
◆ la_ssbev()
| 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.
◆ la_ssbevd()
| 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.
◆ la_ssbevx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_sspev()
| 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.
◆ la_sspevd()
| 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.
◆ la_sspevx()
| 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.
◆ la_sspgv()
| 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.
◆ la_sspgvd()
| 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.
◆ la_sspgvx()
| 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.
◆ la_ssyev()
| 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.
◆ la_ssyevd()
| 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.
◆ la_ssyevr()
| 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,
- 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.
◆ la_ssyevx()
| 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.
◆ la_ssygv()
| 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.
◆ la_ssygvd()
| 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.
◆ la_ssygvx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_whb2st_kernels()
| pure subroutine, public la_lapack_eigv_sym::la_whb2st_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(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(out) | v, | ||
| complex(qp), dimension(*), intent(out) | tau, | ||
| integer(ilp), intent(in) | ldvt, | ||
| complex(qp), dimension(*), intent(out) | work ) |
WHB2ST_KERNELS: is an internal routine used by the WHETRD_HB2ST subroutine.
◆ la_whbev()
| subroutine, public la_lapack_eigv_sym::la_whbev | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WHBEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.
◆ la_whbevd()
| subroutine, public la_lapack_eigv_sym::la_whbevd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), 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 ) |
WHBEVD: 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.
◆ la_whbevx()
| subroutine, public la_lapack_eigv_sym::la_whbevx | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldq,*), intent(out) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
WHBEVX: 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.
◆ la_whbgv()
| pure subroutine, public la_lapack_eigv_sym::la_whbgv | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ka, | ||
| integer(ilp), intent(in) | kb, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldbb,*), intent(inout) | bb, | ||
| integer(ilp), intent(in) | ldbb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WHBGV: 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.
◆ la_whbgvd()
| pure subroutine, public la_lapack_eigv_sym::la_whbgvd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ka, | ||
| integer(ilp), intent(in) | kb, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldbb,*), intent(inout) | bb, | ||
| integer(ilp), intent(in) | ldbb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), 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 ) |
WHBGVD: 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.
◆ la_whbgvx()
| pure subroutine, public la_lapack_eigv_sym::la_whbgvx | ( | 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(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldbb,*), intent(inout) | bb, | ||
| integer(ilp), intent(in) | ldbb, | ||
| complex(qp), dimension(ldq,*), intent(out) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
WHBGVX: 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.
◆ la_wheev()
| subroutine, public la_lapack_eigv_sym::la_wheev | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WHEEV: computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
◆ la_wheevd()
| subroutine, public la_lapack_eigv_sym::la_wheevd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), 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 ) |
WHEEVD: 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.
◆ la_wheevr()
| subroutine, public la_lapack_eigv_sym::la_wheevr | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), dimension(*), intent(out) | isuppz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), 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 ) |
WHEEVR: 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. WHEEVR first reduces the matrix A to tridiagonal form T with a call to WHETRD. Then, whenever possible, WHEEVR calls WSTEMR to compute eigenspectrum using Relatively Robust Representations. WSTEMR 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 WSTEMR'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,
- 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 : WHEEVR calls WSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. WHEEVR calls QSTEBZ and WSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of WSTEMR 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.
◆ la_wheevx()
| subroutine, public la_lapack_eigv_sym::la_wheevx | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
WHEEVX: 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.
◆ la_whegv()
| subroutine, public la_lapack_eigv_sym::la_whegv | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WHEGV: 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.
◆ la_whegvd()
| subroutine, public la_lapack_eigv_sym::la_whegvd | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), 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 ) |
WHEGVD: 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.
◆ la_whegvx()
| subroutine, public la_lapack_eigv_sym::la_whegvx | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
WHEGVX: 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.
◆ la_whetd2()
| pure subroutine, public la_lapack_eigv_sym::la_whetd2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| complex(qp), dimension(*), intent(out) | tau, | ||
| integer(ilp), intent(out) | info ) |
WHETD2: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
◆ la_whetrd()
| pure subroutine, public la_lapack_eigv_sym::la_whetrd | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| complex(qp), dimension(*), intent(out) | tau, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WHETRD: reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
◆ la_whetrd_hb2st()
| pure subroutine, public la_lapack_eigv_sym::la_whetrd_hb2st | ( | character, intent(in) | stage1, |
| character, intent(in) | vect, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | d, | ||
| real(qp), dimension(*), intent(out) | e, | ||
| complex(qp), dimension(*), intent(out) | hous, | ||
| integer(ilp), intent(in) | lhous, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WHETRD_HB2ST: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
◆ la_whetrd_he2hb()
| pure subroutine, public la_lapack_eigv_sym::la_whetrd_he2hb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldab,*), intent(out) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(*), intent(out) | tau, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WHETRD_HE2HB: reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.
◆ la_whpev()
| subroutine, public la_lapack_eigv_sym::la_whpev | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WHPEV: computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.
◆ la_whpevd()
| subroutine, public la_lapack_eigv_sym::la_whpevd | ( | character, intent(in) | jobz, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), 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 ) |
WHPEVD: 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.
◆ la_whpevx()
| subroutine, public la_lapack_eigv_sym::la_whpevx | ( | character, intent(in) | jobz, |
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
WHPEVX: 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.
◆ la_whpgv()
| subroutine, public la_lapack_eigv_sym::la_whpgv | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| complex(qp), dimension(*), intent(inout) | bp, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WHPGV: 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.
◆ la_whpgvd()
| subroutine, public la_lapack_eigv_sym::la_whpgvd | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| complex(qp), dimension(*), intent(inout) | bp, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), 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 ) |
WHPGVD: 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.
◆ la_whpgvx()
| subroutine, public la_lapack_eigv_sym::la_whpgvx | ( | integer(ilp), intent(in) | itype, |
| character, intent(in) | jobz, | ||
| character, intent(in) | range, | ||
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| complex(qp), dimension(*), intent(inout) | bp, | ||
| real(qp), intent(in) | vl, | ||
| real(qp), intent(in) | vu, | ||
| integer(ilp), intent(in) | il, | ||
| integer(ilp), intent(in) | iu, | ||
| real(qp), intent(in) | abstol, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | w, | ||
| complex(qp), dimension(ldz,*), intent(out) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), dimension(*), intent(out) | ifail, | ||
| integer(ilp), intent(out) | info ) |
WHPGVX: 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.
◆ la_wungtr()
| pure subroutine, public la_lapack_eigv_sym::la_wungtr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | tau, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by WHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
◆ la_wunmtr()
| pure subroutine, public la_lapack_eigv_sym::la_wunmtr | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | tau, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNMTR: 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 WHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
◆ 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.
◆ la_zhbev()
| 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.
◆ la_zhbevd()
| 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.
◆ la_zhbevx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_zheev()
| 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.
◆ la_zheevd()
| 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.
◆ la_zheevr()
| 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,
- 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.
◆ la_zheevx()
| 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.
◆ la_zhegv()
| 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.
◆ la_zhegvd()
| 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.
◆ la_zhegvx()
| 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.
◆ 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.
◆ 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.
◆ 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.
◆ 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.
◆ la_zhpev()
| 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.
◆ la_zhpevd()
| 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.
◆ la_zhpevx()
| 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.
◆ la_zhpgv()
| 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.
◆ la_zhpgvd()
| 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.
◆ la_zhpgvx()
| 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.
◆ 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).
◆ 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).
