|
| pure subroutine, public | la_lapack_eigv_sym_comp::la_slae2 (a, b, c, rt1, rt2) |
| | SLAE2: computes the eigenvalues of a 2-by-2 symmetric matrix [ A B ] [ B C ]. On return, RT1 is the eigenvalue of larger absolute value, and RT2 is the eigenvalue of smaller absolute value.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dlae2 (a, b, c, rt1, rt2) |
| | DLAE2: computes the eigenvalues of a 2-by-2 symmetric matrix [ A B ] [ B C ]. On return, RT1 is the eigenvalue of larger absolute value, and RT2 is the eigenvalue of smaller absolute value.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qlae2 (a, b, c, rt1, rt2) |
| | QLAE2: computes the eigenvalues of a 2-by-2 symmetric matrix [ A B ] [ B C ]. On return, RT1 is the eigenvalue of larger absolute value, and RT2 is the eigenvalue of smaller absolute value.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_slaev2 (a, b, c, rt1, rt2, cs1, sn1) |
| | SLAEV2: computes the eigendecomposition of a 2-by-2 symmetric matrix [ A B ] [ B C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 SN1 ] [ A B ] [ CS1 -SN1 ] = [ RT1 0 ] [-SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dlaev2 (a, b, c, rt1, rt2, cs1, sn1) |
| | DLAEV2: computes the eigendecomposition of a 2-by-2 symmetric matrix [ A B ] [ B C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 SN1 ] [ A B ] [ CS1 -SN1 ] = [ RT1 0 ] [-SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qlaev2 (a, b, c, rt1, rt2, cs1, sn1) |
| | QLAEV2: computes the eigendecomposition of a 2-by-2 symmetric matrix [ A B ] [ B C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 SN1 ] [ A B ] [ CS1 -SN1 ] = [ RT1 0 ] [-SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_slag2 (a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) |
| | SLAG2: computes the eigenvalues of a 2 x 2 generalized eigenvalue problem A - w B, with scaling as necessary to avoid over-/underflow. The scaling factor "s" results in a modified eigenvalue equation s A - w B where s is a non-negative scaling factor chosen so that w, w B, and s A do not overflow and, if possible, do not underflow, either.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dlag2 (a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) |
| | DLAG2: computes the eigenvalues of a 2 x 2 generalized eigenvalue problem A - w B, with scaling as necessary to avoid over-/underflow. The scaling factor "s" results in a modified eigenvalue equation s A - w B where s is a non-negative scaling factor chosen so that w, w B, and s A do not overflow and, if possible, do not underflow, either.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qlag2 (a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) |
| | QLAG2: computes the eigenvalues of a 2 x 2 generalized eigenvalue problem A - w B, with scaling as necessary to avoid over-/underflow. The scaling factor "s" results in a modified eigenvalue equation s A - w B where s is a non-negative scaling factor chosen so that w, w B, and s A do not overflow and, if possible, do not underflow, either.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_sorm22 (side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info) |
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dorm22 (side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info) |
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qorm22 (side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info) |
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_spbstf (uplo, n, kd, ab, ldab, info) |
| | SPBSTF: computes a split Cholesky factorization of a real symmetric positive definite band matrix A. This routine is designed to be used in conjunction with SSBGST. The factorization has the form A = S**T*S where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dpbstf (uplo, n, kd, ab, ldab, info) |
| | DPBSTF: computes a split Cholesky factorization of a real symmetric positive definite band matrix A. This routine is designed to be used in conjunction with DSBGST. The factorization has the form A = S**T*S where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qpbstf (uplo, n, kd, ab, ldab, info) |
| | QPBSTF: computes a split Cholesky factorization of a real symmetric positive definite band matrix A. This routine is designed to be used in conjunction with QSBGST. The factorization has the form A = S**T*S where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_ssbgst (vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info) |
| | SSBGST: reduces a real symmetric-definite banded generalized eigenproblem A*x = lambda*B*x to standard form C*y = lambda*y, such that C has the same bandwidth as A. B must have been previously factorized as S**T*S by SPBSTF, using a split Cholesky factorization. A is overwritten by C = X**T*A*X, where X = S**(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dsbgst (vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info) |
| | DSBGST: reduces a real symmetric-definite banded generalized eigenproblem A*x = lambda*B*x to standard form C*y = lambda*y, such that C has the same bandwidth as A. B must have been previously factorized as S**T*S by DPBSTF, using a split Cholesky factorization. A is overwritten by C = X**T*A*X, where X = S**(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qsbgst (vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info) |
| | QSBGST: reduces a real symmetric-definite banded generalized eigenproblem A*x = lambda*B*x to standard form C*y = lambda*y, such that C has the same bandwidth as A. B must have been previously factorized as S**T*S by QPBSTF, using a split Cholesky factorization. A is overwritten by C = X**T*A*X, where X = S**(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_ssbtrd (vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) |
| | SSBTRD: reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dsbtrd (vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) |
| | DSBTRD: reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qsbtrd (vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) |
| | QSBTRD: reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_sspgst (itype, uplo, n, ap, bp, info) |
| | SSPGST: reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by SPPTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dspgst (itype, uplo, n, ap, bp, info) |
| | DSPGST: reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by DPPTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qspgst (itype, uplo, n, ap, bp, info) |
| | QSPGST: reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by QPPTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_ssygs2 (itype, uplo, n, a, lda, b, ldb, info) |
| | SSYGS2: reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T *A*L. B must have been previously factorized as U**T *U or L*L**T by SPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dsygs2 (itype, uplo, n, a, lda, b, ldb, info) |
| | DSYGS2: reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T *A*L. B must have been previously factorized as U**T *U or L*L**T by DPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qsygs2 (itype, uplo, n, a, lda, b, ldb, info) |
| | QSYGS2: reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T *A*L. B must have been previously factorized as U**T *U or L*L**T by QPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_ssygst (itype, uplo, n, a, lda, b, ldb, info) |
| | SSYGST: reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by SPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dsygst (itype, uplo, n, a, lda, b, ldb, info) |
| | DSYGST: reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by DPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qsygst (itype, uplo, n, a, lda, b, ldb, info) |
| | QSYGST: reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by QPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_sdisna (job, m, n, d, sep, info) |
| | SDISNA: computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by SLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than SLAMCH( 'E' )*ANORM in order to limit the size of the error bound. SDISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_ddisna (job, m, n, d, sep, info) |
| | DDISNA: computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by DLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of the error bound. DDISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qdisna (job, m, n, d, sep, info) |
| | QDISNA: computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by QLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than QLAMCH( 'E' )*ANORM in order to limit the size of the error bound. QDISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_slagtf (n, a, lambda, b, c, tol, d, in, info) |
| | SLAGTF: factorizes the matrix (T - lambda*I), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambda*I = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that SLAGTF may be used, in conjunction with SLAGTS, to obtain eigenvectors of T by inverse iteration.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dlagtf (n, a, lambda, b, c, tol, d, in, info) |
| | DLAGTF: factorizes the matrix (T - lambda*I), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambda*I = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that DLAGTF may be used, in conjunction with DLAGTS, to obtain eigenvectors of T by inverse iteration.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qlagtf (n, a, lambda, b, c, tol, d, in, info) |
| | QLAGTF: factorizes the matrix (T - lambda*I), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambda*I = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that QLAGTF may be used, in conjunction with QLAGTS, to obtain eigenvectors of T by inverse iteration.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_slagts (job, n, a, b, c, d, in, y, tol, info) |
| | SLAGTS: may be used to solve one of the systems of equations (T - lambda*I)*x = y or (T - lambda*I)**T*x = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambda*I) as (T - lambda*I) = P*L*U , by routine SLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dlagts (job, n, a, b, c, d, in, y, tol, info) |
| | DLAGTS: may be used to solve one of the systems of equations (T - lambda*I)*x = y or (T - lambda*I)**T*x = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambda*I) as (T - lambda*I) = P*L*U , by routine DLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qlagts (job, n, a, b, c, d, in, y, tol, info) |
| | QLAGTS: may be used to solve one of the systems of equations (T - lambda*I)*x = y or (T - lambda*I)**T*x = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambda*I) as (T - lambda*I) = P*L*U , by routine QLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_slatrd (uplo, n, nb, a, lda, e, tau, w, ldw) |
| | SLATRD: reduces NB rows and columns of a real symmetric matrix A to symmetric tridiagonal form by an orthogonal similarity transformation Q**T * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', SLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', SLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by SSYTRD.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dlatrd (uplo, n, nb, a, lda, e, tau, w, ldw) |
| | DLATRD: reduces NB rows and columns of a real symmetric matrix A to symmetric tridiagonal form by an orthogonal similarity transformation Q**T * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', DLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', DLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by DSYTRD.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qlatrd (uplo, n, nb, a, lda, e, tau, w, ldw) |
| | QLATRD: reduces NB rows and columns of a real symmetric matrix A to symmetric tridiagonal form by an orthogonal similarity transformation Q**T * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', QLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', QLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by QSYTRD.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_ssptrd (uplo, n, ap, d, e, tau, info) |
| | SSPTRD: reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_dsptrd (uplo, n, ap, d, e, tau, info) |
| | DSPTRD: reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_qsptrd (uplo, n, ap, d, e, tau, info) |
| | QSPTRD: reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_sopgtr (uplo, n, ap, tau, q, ldq, work, info) |
| | SOPGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by SSPTRD using packed storage: 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_lapack_eigv_sym_comp::la_dopgtr (uplo, n, ap, tau, q, ldq, work, info) |
| | DOPGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by DSPTRD using packed storage: 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_lapack_eigv_sym_comp::la_qopgtr (uplo, n, ap, tau, q, ldq, work, info) |
| | QOPGTR: generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by QSPTRD using packed storage: 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_lapack_eigv_sym_comp::la_sopmtr (side, uplo, trans, m, n, ap, tau, c, ldc, work, info) |
| | SOPMTR: 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 SSPTRD using packed storage: 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_lapack_eigv_sym_comp::la_dopmtr (side, uplo, trans, m, n, ap, tau, c, ldc, work, info) |
| | DOPMTR: 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 DSPTRD using packed storage: 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_lapack_eigv_sym_comp::la_qopmtr (side, uplo, trans, m, n, ap, tau, c, ldc, work, info) |
| | QOPMTR: 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 QSPTRD using packed storage: 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_lapack_eigv_sym_comp::la_chpgst (itype, uplo, n, ap, bp, info) |
| | CHPGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by CPPTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zhpgst (itype, uplo, n, ap, bp, info) |
| | ZHPGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by ZPPTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_whpgst (itype, uplo, n, ap, bp, info) |
| | WHPGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by WPPTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_claesy (a, b, c, rt1, rt2, evscal, cs1, sn1) |
| | CLAESY: computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zlaesy (a, b, c, rt1, rt2, evscal, cs1, sn1) |
| | ZLAESY: computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_wlaesy (a, b, c, rt1, rt2, evscal, cs1, sn1) |
| | WLAESY: computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_claev2 (a, b, c, rt1, rt2, cs1, sn1) |
| | CLAEV2: computes the eigendecomposition of a 2-by-2 Hermitian matrix [ A B ] [ CONJG(B) C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 CONJG(SN1) ] [ A B ] [ CS1 -CONJG(SN1) ] = [ RT1 0 ] [-SN1 CS1 ] [ CONJG(B) C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zlaev2 (a, b, c, rt1, rt2, cs1, sn1) |
| | ZLAEV2: computes the eigendecomposition of a 2-by-2 Hermitian matrix [ A B ] [ CONJG(B) C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 CONJG(SN1) ] [ A B ] [ CS1 -CONJG(SN1) ] = [ RT1 0 ] [-SN1 CS1 ] [ CONJG(B) C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_wlaev2 (a, b, c, rt1, rt2, cs1, sn1) |
| | WLAEV2: computes the eigendecomposition of a 2-by-2 Hermitian matrix [ A B ] [ CONJG(B) C ]. On return, RT1 is the eigenvalue of larger absolute value, RT2 is the eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right eigenvector for RT1, giving the decomposition [ CS1 CONJG(SN1) ] [ A B ] [ CS1 -CONJG(SN1) ] = [ RT1 0 ] [-SN1 CS1 ] [ CONJG(B) C ] [ SN1 CS1 ] [ 0 RT2 ].
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_clatrd (uplo, n, nb, a, lda, e, tau, w, ldw) |
| | CLATRD: reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', CLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', CLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by CHETRD.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zlatrd (uplo, n, nb, a, lda, e, tau, w, ldw) |
| | ZLATRD: reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', ZLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', ZLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by ZHETRD.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_wlatrd (uplo, n, nb, a, lda, e, tau, w, ldw) |
| | WLATRD: reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', WLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', WLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by WHETRD.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_cpbstf (uplo, n, kd, ab, ldab, info) |
| | CPBSTF: computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with CHBGST. The factorization has the form A = S**H*S where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zpbstf (uplo, n, kd, ab, ldab, info) |
| | ZPBSTF: computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with ZHBGST. The factorization has the form A = S**H*S where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_wpbstf (uplo, n, kd, ab, ldab, info) |
| | WPBSTF: computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with WHBGST. The factorization has the form A = S**H*S where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_chegs2 (itype, uplo, n, a, lda, b, ldb, info) |
| | CHEGS2: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L. B must have been previously factorized as U**H *U or L*L**H by ZPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zhegs2 (itype, uplo, n, a, lda, b, ldb, info) |
| | ZHEGS2: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L. B must have been previously factorized as U**H *U or L*L**H by ZPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_whegs2 (itype, uplo, n, a, lda, b, ldb, info) |
| | WHEGS2: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L. B must have been previously factorized as U**H *U or L*L**H by WPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_chegst (itype, uplo, n, a, lda, b, ldb, info) |
| | CHEGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by CPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zhegst (itype, uplo, n, a, lda, b, ldb, info) |
| | ZHEGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by ZPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_whegst (itype, uplo, n, a, lda, b, ldb, info) |
| | WHEGST: reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by WPOTRF.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_chptrd (uplo, n, ap, d, e, tau, info) |
| | CHPTRD: reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zhptrd (uplo, n, ap, d, e, tau, info) |
| | ZHPTRD: reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_whptrd (uplo, n, ap, d, e, tau, info) |
| | WHPTRD: reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_cupgtr (uplo, n, ap, tau, q, ldq, work, info) |
| | CUPGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by CHPTRD using packed storage: 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_lapack_eigv_sym_comp::la_zupgtr (uplo, n, ap, tau, q, ldq, work, info) |
| | ZUPGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by ZHPTRD using packed storage: 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_lapack_eigv_sym_comp::la_wupgtr (uplo, n, ap, tau, q, ldq, work, info) |
| | WUPGTR: generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by WHPTRD using packed storage: 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_lapack_eigv_sym_comp::la_cupmtr (side, uplo, trans, m, n, ap, tau, c, ldc, work, info) |
| | CUPMTR: 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 CHPTRD using packed storage: 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_lapack_eigv_sym_comp::la_zupmtr (side, uplo, trans, m, n, ap, tau, c, ldc, work, info) |
| | ZUPMTR: 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 ZHPTRD using packed storage: 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_lapack_eigv_sym_comp::la_wupmtr (side, uplo, trans, m, n, ap, tau, c, ldc, work, info) |
| | WUPMTR: 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 WHPTRD using packed storage: 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_lapack_eigv_sym_comp::la_chbgst (vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info) |
| | CHBGST: reduces a complex Hermitian-definite banded generalized eigenproblem A*x = lambda*B*x to standard form C*y = lambda*y, such that C has the same bandwidth as A. B must have been previously factorized as S**H*S by CPBSTF, using a split Cholesky factorization. A is overwritten by C = X**H*A*X, where X = S**(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_zhbgst (vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info) |
| | ZHBGST: reduces a complex Hermitian-definite banded generalized eigenproblem A*x = lambda*B*x to standard form C*y = lambda*y, such that C has the same bandwidth as A. B must have been previously factorized as S**H*S by ZPBSTF, using a split Cholesky factorization. A is overwritten by C = X**H*A*X, where X = S**(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_whbgst (vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info) |
| | WHBGST: reduces a complex Hermitian-definite banded generalized eigenproblem A*x = lambda*B*x to standard form C*y = lambda*y, such that C has the same bandwidth as A. B must have been previously factorized as S**H*S by WPBSTF, using a split Cholesky factorization. A is overwritten by C = X**H*A*X, where X = S**(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.
|
| |
| pure subroutine, public | la_lapack_eigv_sym_comp::la_chbtrd (vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) |
| | CHBTRD: 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_lapack_eigv_sym_comp::la_zhbtrd (vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) |
| | ZHBTRD: 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_lapack_eigv_sym_comp::la_whbtrd (vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) |
| | WHBTRD: reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
|
| |
1.13.2