![]() |
Blaze 3.9
|
LAPACK general matrix eigenvalue functions (geev) | |
void | blaze::geev (char jobvl, char jobvr, blas_int_t n, float *A, blas_int_t lda, float *wr, float *wi, float *VL, blas_int_t ldvl, float *VR, blas_int_t ldvr, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense general single precision column-major matrix. More... | |
void | blaze::geev (char jobvl, char jobvr, blas_int_t n, double *A, blas_int_t lda, double *wr, double *wi, double *VL, blas_int_t ldvl, double *VR, blas_int_t ldvr, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense general double precision column-major matrix. More... | |
void | blaze::geev (char jobvl, char jobvr, blas_int_t n, complex< float > *A, blas_int_t lda, complex< float > *w, complex< float > *VL, blas_int_t ldvl, complex< float > *VR, blas_int_t ldvr, complex< float > *work, blas_int_t lwork, float *rwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense general single precision complex column-major matrix. More... | |
void | blaze::geev (char jobvl, char jobvr, blas_int_t n, complex< double > *A, blas_int_t lda, complex< double > *w, complex< double > *VL, blas_int_t ldvl, complex< double > *VR, blas_int_t ldvr, complex< double > *work, blas_int_t lwork, double *rwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense general double precision complex column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | blaze::geev (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename VT , bool TF> | |
void | blaze::geev (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &VL, DenseVector< VT, TF > &w) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
void | blaze::geev (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &VR) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename VT , bool TF, typename MT3 , bool SO3> | |
void | blaze::geev (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &VL, DenseVector< VT, TF > &w, DenseMatrix< MT3, SO3 > &VR) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
LAPACK generalized Schur decomposition functions (gges) | |
void | blaze::gges (char jobvsl, char jobvsr, char sort, blas_int_t(*selctg)(const float *, const float *, const float *), blas_int_t n, float *A, blas_int_t lda, float *B, blas_int_t ldb, blas_int_t *sdim, float *alphar, float *alphai, float *beta, float *VSL, blas_int_t ldvsl, float *VSR, blas_int_t ldvsr, float *work, blas_int_t lwork, blas_int_t *bwork, blas_int_t *info) |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric single precision column-major matrices. More... | |
void | blaze::gges (char jobvsl, char jobvsr, char sort, blas_int_t(*selctg)(const double *, const double *, const double *), blas_int_t n, double *A, blas_int_t lda, double *B, blas_int_t ldb, blas_int_t *sdim, double *alphar, double *alphai, double *beta, double *VSL, blas_int_t ldvsl, double *VSR, blas_int_t ldvsr, double *work, blas_int_t lwork, blas_int_t *bwork, blas_int_t *info) |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric double precision column-major matrices. More... | |
void | blaze::gges (char jobvsl, char jobvsr, char sort, blas_int_t(*selctg)(const complex< float > *, const complex< float > *), blas_int_t n, complex< float > *A, blas_int_t lda, complex< float > *B, blas_int_t ldb, blas_int_t *sdim, complex< float > *alpha, complex< float > *beta, complex< float > *VSL, blas_int_t ldvsl, complex< float > *VSR, blas_int_t ldvsr, complex< float > *work, blas_int_t lwork, float *rwork, blas_int_t *bwork, blas_int_t *info) |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric single precision complex column-major matrices. More... | |
void | blaze::gges (char jobvsl, char jobvsr, char sort, blas_int_t(*selctg)(const complex< double > *, const complex< double > *), blas_int_t n, complex< double > *A, blas_int_t lda, complex< double > *B, blas_int_t ldb, blas_int_t *sdim, complex< double > *alpha, complex< double > *beta, complex< double > *VSL, blas_int_t ldvsl, complex< double > *VSR, blas_int_t ldvsr, complex< double > *work, blas_int_t lwork, double *rwork, blas_int_t *bwork, blas_int_t *info) |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric double precision complex column-major matrices. More... | |
LAPACK Hermitian matrix eigenvalue functions (heev) | |
void | blaze::heev (char jobz, char uplo, blas_int_t n, complex< float > *A, blas_int_t lda, float *w, complex< float > *work, blas_int_t lwork, float *rwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision column-major matrix. More... | |
void | blaze::heev (char jobz, char uplo, blas_int_t n, complex< double > *A, blas_int_t lda, double *w, complex< double > *work, blas_int_t lwork, double *rwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | blaze::heev (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
LAPACK Hermitian matrix eigenvalue functions (heevd) | |
void | blaze::heevd (char jobz, char uplo, blas_int_t n, complex< float > *A, blas_int_t lda, float *w, complex< float > *work, blas_int_t lwork, float *rwork, blas_int_t lrwork, blas_int_t *iwork, blas_int_t liwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision column-major matrix. More... | |
void | blaze::heevd (char jobz, char uplo, blas_int_t n, complex< double > *A, blas_int_t lda, double *w, complex< double > *work, blas_int_t lwork, double *rwork, blas_int_t lrwork, blas_int_t *iwork, blas_int_t liwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | blaze::heevd (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
LAPACK Hermitian matrix eigenvalue functions (heevx) | |
void | blaze::heevx (char jobz, char range, char uplo, blas_int_t n, complex< float > *A, blas_int_t lda, float vl, float vu, blas_int_t il, blas_int_t iu, float abstol, blas_int_t *m, float *w, complex< float > *Z, blas_int_t ldz, complex< float > *work, blas_int_t lwork, float *rwork, blas_int_t *iwork, blas_int_t *ifail, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision complex column-major matrix. More... | |
void | blaze::heevx (char jobz, char range, char uplo, blas_int_t n, complex< double > *A, blas_int_t lda, double vl, double vu, blas_int_t il, blas_int_t iu, double abstol, blas_int_t *m, double *w, complex< double > *Z, blas_int_t ldz, complex< double > *work, blas_int_t lwork, double *rwork, blas_int_t *iwork, blas_int_t *ifail, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision complex column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
size_t | blaze::heevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo) |
LAPACK kernel for the eigenvalue computation of the given dense Hermitian matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF, typename ST > | |
size_t | blaze::heevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
size_t | blaze::heevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2, typename ST > | |
size_t | blaze::heevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
LAPACK symmetric matrix eigenvalue functions (syev) | |
void | blaze::syev (char jobz, char uplo, blas_int_t n, float *A, blas_int_t lda, float *w, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix. More... | |
void | blaze::syev (char jobz, char uplo, blas_int_t n, double *A, blas_int_t lda, double *w, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | blaze::syev (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
LAPACK symmetric matrix eigenvalue functions (syevd) | |
void | blaze::syevd (char jobz, char uplo, blas_int_t n, float *A, blas_int_t lda, float *w, float *work, blas_int_t lwork, blas_int_t *iwork, blas_int_t liwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix. More... | |
void | blaze::syevd (char jobz, char uplo, blas_int_t n, double *A, blas_int_t lda, double *w, double *work, blas_int_t lwork, blas_int_t *iwork, blas_int_t liwork, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | blaze::syevd (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
LAPACK symmetric matrix eigenvalue functions (syevx) | |
void | blaze::syevx (char jobz, char range, char uplo, blas_int_t n, float *A, blas_int_t lda, float vl, float vu, blas_int_t il, blas_int_t iu, float abstol, blas_int_t *m, float *w, float *Z, blas_int_t ldz, float *work, blas_int_t lwork, blas_int_t *iwork, blas_int_t *ifail, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix. More... | |
void | blaze::syevx (char jobz, char range, char uplo, blas_int_t n, double *A, blas_int_t lda, double vl, double vu, blas_int_t il, blas_int_t iu, double abstol, blas_int_t *m, double *w, double *Z, blas_int_t ldz, double *work, blas_int_t lwork, blas_int_t *iwork, blas_int_t *ifail, blas_int_t *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
size_t | blaze::syevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF, typename ST > | |
size_t | blaze::syevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
size_t | blaze::syevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2, typename ST > | |
size_t | blaze::syevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
LAPACK generalized Schur factorization functions (gges) | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename VT1 , bool TF1, typename VT2 , bool TF2> | |
void | blaze::gges (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, DenseVector< VT1, TF1 > &alpha, DenseVector< VT2, TF2 > &beta) |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename VT1 , bool TF1, typename VT2 , bool TF2, typename Select > | |
void | blaze::gges (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, DenseVector< VT1, TF1 > &alpha, DenseVector< VT2, TF2 > &beta, Select select) |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3, typename VT1 , bool TF1, typename VT2 , bool TF2, typename MT4 , bool SO4> | |
void | blaze::gges (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, DenseMatrix< MT3, SO3 > &VSL, DenseVector< VT1, TF1 > &alpha, DenseVector< VT2, TF2 > &beta, DenseMatrix< MT4, SO4 > &VSR) |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3, typename VT1 , bool TF1, typename VT2 , bool TF2, typename MT4 , bool SO4, typename Select > | |
void | blaze::gges (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, DenseMatrix< MT3, SO3 > &VSL, DenseVector< VT1, TF1 > &alpha, DenseVector< VT2, TF2 > &beta, DenseMatrix< MT4, SO4 > &VSR, Select select) |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices. More... | |
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general double precision complex column-major matrix.
jobvl | 'V' to compute the left eigenvectors of A, 'N' to not compute them. |
jobvr | 'V' to compute the right eigenvectors of A, 'N' to not compute them. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision complex column-major matrix. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
w | Pointer to the first element of the vector for the eigenvalues. |
VL | Pointer to the first element of the column-major matrix for the left eigenvectors. |
ldvl | The total number of elements between two columns of the matrix VL ![]() |
VR | Pointer to the first element of the column-major matrix for the right eigenvectors. |
ldvr | The total number of elements between two columns of the matrix VR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= 2*n. |
info | Return code of the function call. |
This function computes the eigenvalues of a non-symmetric n-by-n double precision complex column-major matrix based on the LAPACK zgeev() function. Optionally, it computes the left and/or right eigenvectors. The right eigenvector of satisfies
\f[ A * v[j] = lambda[j] * v[j], \f]
where is its eigenvalue. The left eigenvector
of A satisfies
\f[ u[j]^{H} * A = lambda[j] * u[j]^{H}, \f]
where denotes the conjugate transpose of
.
Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
The parameter jobvl specifies the computation of the left eigenvectors:
'V'
: The left eigenvectors of A are computed and returned in VL.'N'
: The left eigenvectors of A are not computed.The parameter jobvr specifies the computation of the right eigenvectors:
'V'
: The right eigenvectors of A are computed and returned in VR.'N'
: The right eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the zgeev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general single precision complex column-major matrix.
jobvl | 'V' to compute the left eigenvectors of A, 'N' to not compute them. |
jobvr | 'V' to compute the right eigenvectors of A, 'N' to not compute them. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision complex column-major matrix. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
w | Pointer to the first element of the vector for the eigenvalues. |
VL | Pointer to the first element of the column-major matrix for the left eigenvectors. |
ldvl | The total number of elements between two columns of the matrix VL ![]() |
VR | Pointer to the first element of the column-major matrix for the right eigenvectors. |
ldvr | The total number of elements between two columns of the matrix VR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= 2*n. |
info | Return code of the function call. |
This function computes the eigenvalues of a non-symmetric n-by-n single precision complex column-major matrix based on the LAPACK cgeev() function. Optionally, it computes the left and/or right eigenvectors. The right eigenvector of satisfies
\f[ A * v[j] = lambda[j] * v[j], \f]
where is its eigenvalue. The left eigenvector
of A satisfies
\f[ u[j]^{H} * A = lambda[j] * u[j]^{H}, \f]
where denotes the conjugate transpose of
.
Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
The parameter jobvl specifies the computation of the left eigenvectors:
'V'
: The left eigenvectors of A are computed and returned in VL.'N'
: The left eigenvectors of A are not computed.The parameter jobvr specifies the computation of the right eigenvectors:
'V'
: The right eigenvectors of A are computed and returned in VR.'N'
: The right eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the cgeev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general double precision column-major matrix.
jobvl | 'V' to compute the left eigenvectors of A, 'N' to not compute them. |
jobvr | 'V' to compute the right eigenvectors of A, 'N' to not compute them. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
wr | Pointer to the first element of the vector for the real part of the eigenvalues. |
wi | Pointer to the first element of the vector for the imaginary part of the eigenvalues. |
VL | Pointer to the first element of the column-major matrix for the left eigenvectors. |
ldvl | The total number of elements between two columns of the matrix VL ![]() |
VR | Pointer to the first element of the column-major matrix for the right eigenvectors. |
ldvr | The total number of elements between two columns of the matrix VR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of a non-symmetric n-by-n double precision column-major matrix based on the LAPACK dgeev() function. Optionally, it computes the left and/or right eigenvectors. The right eigenvector of satisfies
\f[ A * v[j] = lambda[j] * v[j], \f]
where is its eigenvalue. The left eigenvector
of A satisfies
\f[ u[j]^{H} * A = lambda[j] * u[j]^{H}, \f]
where denotes the conjugate transpose of
.
Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
The parameter jobvl specifies the computation of the left eigenvectors:
'V'
: The left eigenvectors of A are computed and returned in VL.'N'
: The left eigenvectors of A are not computed.The parameter jobvr specifies the computation of the right eigenvectors:
'V'
: The right eigenvectors of A are computed and returned in VR.'N'
: The right eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the dgeev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general single precision column-major matrix.
jobvl | 'V' to compute the left eigenvectors of A, 'N' to not compute them. |
jobvr | 'V' to compute the right eigenvectors of A, 'N' to not compute them. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
wr | Pointer to the first element of the vector for the real part of the eigenvalues. |
wi | Pointer to the first element of the vector for the imaginary part of the eigenvalues. |
VL | Pointer to the first element of the column-major matrix for the left eigenvectors. |
ldvl | The total number of elements between two columns of the matrix VL ![]() |
VR | Pointer to the first element of the column-major matrix for the right eigenvectors. |
ldvr | The total number of elements between two columns of the matrix VR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of a non-symmetric n-by-n single precision column-major matrix based on the LAPACK sgeev() function. Optionally, it computes the left and/or right eigenvectors. The right eigenvector of satisfies
\f[ A * v[j] = lambda[j] * v[j], \f]
where is its eigenvalue. The left eigenvector
of A satisfies
\f[ u[j]^{H} * A = lambda[j] * u[j]^{H}, \f]
where denotes the conjugate transpose of
.
Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
The parameter jobvl specifies the computation of the left eigenvectors:
'V'
: The left eigenvectors of A are computed and returned in VL.'N'
: The left eigenvectors of A are not computed.The parameter jobvr specifies the computation of the right eigenvectors:
'V'
: The right eigenvectors of A are computed and returned in VR.'N'
: The right eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the sgeev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general matrix.
A | The given general matrix. |
w | The resulting vector of complex eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a non-symmetric, non-Hermitian n-by-n matrix based on the LAPACK geev() functions. The complex eigenvalues are returned in the given vector w, which is resized to the correct size (if possible and necessary). Please note that no order of eigenvalues can be assumed, except that complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the geev() functions (i.e. sgeev(), dgeev(), cgeev(), and zgeev()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general matrix.
A | The given general matrix. |
VL | The resulting matrix of left eigenvectors. |
w | The resulting vector of complex eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a non-symmetric, non-Hermitian n-by-n matrix based on the LAPACK geev() functions. Additionally, it computes the left eigenvectors. The left eigenvector of A satisfies
\f[ u[j]^{H} * A = lambda[j] * u[j]^{H}, \f]
where denotes the conjugate transpose of
.
The complex eigenvalues are returned in the given vector w. The left eigenvectors are returned in the rows of VL in case VL is a row-major matrix and in the columns of VL in case VL is a column-major matrix. Both w and VL are resized to the correct dimensions (if possible and necessary). Please note that no order of eigenvalues can be assumed, except that complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the geev() functions (i.e. sgeev(), dgeev(), cgeev(), and zgeev()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general matrix.
A | The given general matrix. |
VL | The resulting matrix of left eigenvectors. |
w | The resulting vector of complex eigenvalues. |
VR | The resulting matrix of right eigenvectors. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a non-symmetric, non-Hermitian n-by-n matrix based on the LAPACK geev() functions. Additionally, it computes the left and right eigenvectors. The right eigenvector of A satisfies
\f[ A * v[j] = lambda[j] * v[j], \f]
where is its eigenvalue. The left eigenvector
of A satisfies
\f[ u[j]^{H} * A = lambda[j] * u[j]^{H}, \f]
where denotes the conjugate transpose of
.
The complex eigenvalues are returned in the given vector w. The left eigenvectors are returned in the rows of VL in case VL is a row-major matrix and in the columns of VL in case VL is a column-major matrix. The right eigenvectors are returned in the rows of VR in case VR is a row-major matrix and in the columns of VR in case VR is a column-major matrix. w, VL, and VR are resized to the correct dimensions (if possible and necessary). Please note that no order of eigenvalues can be assumed, except that complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the geev() functions (i.e. sgeev(), dgeev(), cgeev(), and zgeev()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense general matrix.
A | The given general matrix. |
w | The resulting vector of complex eigenvalues. |
VR | The resulting matrix of right eigenvectors. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a non-symmetric, non-Hermitian n-by-n matrix based on the LAPACK geev() functions. Additionally, it computes the right eigenvectors. The right eigenvector of A satisfies
\f[ A * v[j] = lambda[j] * v[j], \f]
where is its eigenvalue.
The complex eigenvalues are returned in the given vector w. The right eigenvectors are returned in the rows of VR in case VR is a row-major matrix and in the columns of VR in case VR is a column-major matrix. Both w and VL are resized to the correct dimensions (if possible and necessary). Please note that no order of eigenvalues can be assumed, except that complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the geev() functions (i.e. sgeev(), dgeev(), cgeev(), and zgeev()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric double precision complex column-major matrices.
jobvsl | 'V' to compute the left Schur vectors, 'N' to not compute them. |
jobvsr | 'V' to compute the right Schur vectors, 'N' to not compute them. |
sort | 'S' to order the eigenvalues on the diagonal, 'N' to not order them (see selctg). |
selctg | Logical function of two double precision complex arguments. |
n | The order of the matrices A, B, VSL, and VSR ![]() |
A | Pointer to the first element of the double precision complex column-major matrix A. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
B | Pointer to the first element of the double precision complex column-major matrix B. |
ldb | The total number of elements between two columns of the matrix B; size >= max( 1, n ). |
sdim | Returns the number of eigenvalues (after sorting) for which selctg is true. |
alpha | Pointer to the first element of the eigenvalue numerator; size == n. |
beta | Pointer to the first element of the eigenvalue denominator; size == n. |
VSL | Pointer to the first element of the column-major matrix for the left Schur vectors. |
ldvsl | The total number of elements between two columns of the matrix VSL ![]() |
VSR | Pointer to the first element of the column-major matrix for the right Schur vectors. |
ldvsr | The total number of elements between two columns of the matrix VSR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size == 8*n. |
bwork | Auxiliary array; size == n. |
info | Return code of the function call. |
This function computes for a pair of n-by-n double precision complex non-symmetric matrices (A,B) the generalized eigenvalues, the generalized real Schur form (S, T), and optionally the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization
\f[ (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T ). \f]
Optionally, it also orders the eigenvalues such that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces).
The parameter jobvsl specifies the computation of the left Schur vectors:
'V'
: The left Schur vectors of (A,B) are computed and returned in VSL.'N'
: The left Schur vectors of (A,B) are not computed.The parameter jobvsr specifies the computation of the right Schur vectors:
'V'
: The right Schur vectors of (A,B) are computed and returned in VSR.'N'
: The right Schur vectors of (A,B) are not computed.Via the parameter selctg it is possible to select specific eigenvalues. selctg is a pointer to a function of two double precision complex arguments returning an blas_int_t
value. In case sort is set to 'N'
, selctg is not referenced, else if sort is set to 'S'
selctg is used to select eigenvalues to sort to the top left of the Schur form. An eigenvalue is selected if
evaluates to true; i.e. if either one of a complex conjugate pair of eigenvalues is selected, then both complex eigenvalues are selected. On exit, the parameter sdim will contain the number of eigenvalues (after sorting) for which selctg is true. Note that complex conjugate pairs for which selctg is true for either eigenvalue count as 2.
The info argument provides feedback on the success of the function call:
For more information on the sgges() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric single precision complex column-major matrices.
jobvsl | 'V' to compute the left Schur vectors, 'N' to not compute them. |
jobvsr | 'V' to compute the right Schur vectors, 'N' to not compute them. |
sort | 'S' to order the eigenvalues on the diagonal, 'N' to not order them (see selctg). |
selctg | Logical function of two single precision complex arguments. |
n | The order of the matrices A, B, VSL, and VSR ![]() |
A | Pointer to the first element of the single precision complex column-major matrix A. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
B | Pointer to the first element of the single precision complex column-major matrix B. |
ldb | The total number of elements between two columns of the matrix B; size >= max( 1, n ). |
sdim | Returns the number of eigenvalues (after sorting) for which selctg is true. |
alpha | Pointer to the first element of the eigenvalue numerator; size == n. |
beta | Pointer to the first element of the eigenvalue denominator; size == n. |
VSL | Pointer to the first element of the column-major matrix for the left Schur vectors. |
ldvsl | The total number of elements between two columns of the matrix VSL ![]() |
VSR | Pointer to the first element of the column-major matrix for the right Schur vectors. |
ldvsr | The total number of elements between two columns of the matrix VSR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size == 8*n. |
bwork | Auxiliary array; size == n. |
info | Return code of the function call. |
This function computes for a pair of n-by-n single precision complex non-symmetric matrices (A,B) the generalized eigenvalues, the generalized real Schur form (S, T), and optionally the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization
\f[ (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T ). \f]
Optionally, it also orders the eigenvalues such that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces).
The parameter jobvsl specifies the computation of the left Schur vectors:
'V'
: The left Schur vectors of (A,B) are computed and returned in VSL.'N'
: The left Schur vectors of (A,B) are not computed.The parameter jobvsr specifies the computation of the right Schur vectors:
'V'
: The right Schur vectors of (A,B) are computed and returned in VSR.'N'
: The right Schur vectors of (A,B) are not computed.Via the parameter selctg it is possible to select specific eigenvalues. selctg is a pointer to a function of two single precision complex arguments returning an blas_int_t
value. In case sort is set to 'N'
, selctg is not referenced, else if sort is set to 'S'
selctg is used to select eigenvalues to sort to the top left of the Schur form. An eigenvalue is selected if
evaluates to true; i.e. if either one of a complex conjugate pair of eigenvalues is selected, then both complex eigenvalues are selected. On exit, the parameter sdim will contain the number of eigenvalues (after sorting) for which selctg is true. Note that complex conjugate pairs for which selctg is true for either eigenvalue count as 2.
The info argument provides feedback on the success of the function call:
For more information on the sgges() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric double precision column-major matrices.
jobvsl | 'V' to compute the left Schur vectors, 'N' to not compute them. |
jobvsr | 'V' to compute the right Schur vectors, 'N' to not compute them. |
sort | 'S' to order the eigenvalues on the diagonal, 'N' to not order them (see selctg). |
selctg | Logical function of three double precision arguments. |
n | The order of the matrices A, B, VSL, and VSR ![]() |
A | Pointer to the first element of the double precision column-major matrix A. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
B | Pointer to the first element of the double precision column-major matrix B. |
ldb | The total number of elements between two columns of the matrix B; size >= max( 1, n ). |
sdim | Returns the number of eigenvalues (after sorting) for which selctg is true. |
alphar | Pointer to the first element of the real part of the eigenvalue numerator; size == n. |
alphai | Pointer to the first element of the imaginary part of the eigenvalue numerator; size == n. |
beta | Pointer to the first element of the eigenvalue denominator; size == n. |
VSL | Pointer to the first element of the column-major matrix for the left Schur vectors. |
ldvsl | The total number of elements between two columns of the matrix VSL ![]() |
VSR | Pointer to the first element of the column-major matrix for the right Schur vectors. |
ldvsr | The total number of elements between two columns of the matrix VSR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
bwork | Auxiliary array; size == n. |
info | Return code of the function call. |
This function computes for a pair of n-by-n double precision non-symmetric matrices (A,B) the generalized eigenvalues, the generalized real Schur form (S, T), and optionally the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization
\f[ (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T ). \f]
Optionally, it also orders the eigenvalues such that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces).
The parameter jobvsl specifies the computation of the left Schur vectors:
'V'
: The left Schur vectors of (A,B) are computed and returned in VSL.'N'
: The left Schur vectors of (A,B) are not computed.The parameter jobvsr specifies the computation of the right Schur vectors:
'V'
: The right Schur vectors of (A,B) are computed and returned in VSR.'N'
: The right Schur vectors of (A,B) are not computed.Via the parameter selctg it is possible to select specific eigenvalues. selctg is a pointer to a function of three double precision floating point arguments returning an blas_int_t
value. In case sort is set to 'N'
, selctg is not referenced, else if sort is set to 'S'
selctg is used to select eigenvalues to sort to the top left of the Schur form. An eigenvalue is selected if
evaluates to true; i.e. if either one of a complex conjugate pair of eigenvalues is selected, then both complex eigenvalues are selected. On exit, the parameter sdim will contain the number of eigenvalues (after sorting) for which selctg is true. Note that complex conjugate pairs for which selctg is true for either eigenvalue count as 2.
The info argument provides feedback on the success of the function call:
For more information on the sgges() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur decomposition for a pair of non-symmetric single precision column-major matrices.
jobvsl | 'V' to compute the left Schur vectors, 'N' to not compute them. |
jobvsr | 'V' to compute the right Schur vectors, 'N' to not compute them. |
sort | 'S' to order the eigenvalues on the diagonal, 'N' to not order them (see selctg). |
selctg | Logical function of three single precision arguments. |
n | The order of the matrices A, B, VSL, and VSR ![]() |
A | Pointer to the first element of the single precision column-major matrix A. |
lda | The total number of elements between two columns of the matrix A; size >= max( 1, n ). |
B | Pointer to the first element of the single precision column-major matrix B. |
ldb | The total number of elements between two columns of the matrix B; size >= max( 1, n ). |
sdim | Returns the number of eigenvalues (after sorting) for which selctg is true. |
alphar | Pointer to the first element of the real part of the eigenvalue numerator; size == n. |
alphai | Pointer to the first element of the imaginary part of the eigenvalue numerator; size == n. |
beta | Pointer to the first element of the eigenvalue denominator; size == n. |
VSL | Pointer to the first element of the column-major matrix for the left Schur vectors. |
ldvsl | The total number of elements between two columns of the matrix VSL ![]() |
VSR | Pointer to the first element of the column-major matrix for the right Schur vectors. |
ldvsr | The total number of elements between two columns of the matrix VSR ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
bwork | Auxiliary array; size == n. |
info | Return code of the function call. |
This function computes for a pair of n-by-n single precision non-symmetric matrices (A,B) the generalized eigenvalues, the generalized real Schur form (S, T), and optionally the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization
\f[ (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T ). \f]
Optionally, it also orders the eigenvalues such that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces).
The parameter jobvsl specifies the computation of the left Schur vectors:
'V'
: The left Schur vectors of (A,B) are computed and returned in VSL.'N'
: The left Schur vectors of (A,B) are not computed.The parameter jobvsr specifies the computation of the right Schur vectors:
'V'
: The right Schur vectors of (A,B) are computed and returned in VSR.'N'
: The right Schur vectors of (A,B) are not computed.Via the parameter selctg it is possible to select specific eigenvalues. selctg is a pointer to a function of three single precision floating point arguments returning a blas_int_t
value. In case sort is set to 'N'
, selctg is not referenced, else if sort is set to 'S'
selctg is used to select eigenvalues to sort to the top left of the Schur form. An eigenvalue is selected if
evaluates to true; i.e. if either one of a complex conjugate pair of eigenvalues is selected, then both complex eigenvalues are selected. On exit, the parameter sdim will contain the number of eigenvalues (after sorting) for which selctg is true. Note that complex conjugate pairs for which selctg is true for either eigenvalue count as 2.
The info argument provides feedback on the success of the function call:
For more information on the sgges() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices.
A | The first matrix of the given pair of complex general matrices. |
B | The second matrix of the given pair of complex general matrices. |
VSL | The resulting complex matrix of left Schur vectors. |
alpha | The resulting complex vector of eigenvalue numerators. |
beta | The resulting complex vector of eigenvalue denominators. |
VSR | The resulting complex matrix of right Schur vectors. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Matrix sizes do not match. |
std::invalid_argument | Vector or matrix cannot be resized. |
std::runtime_error | Schur factorization computation failed. |
This function computes for a pair of n-by-n real non-symmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), which on exit replaces (A, B), and the left and right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization
\f[ (A^FA,B^FB) = ( (VSL^FL)*(S^FA)*(VSR^FR)^T, (VSL^FL)*T*(VSR^FR)^T ) \f]
where FA, FB, FL, FR are transposition flags:
A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio , such that
is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. The complex eigenvalues are returned as numerators and denominators in the given vectors alpha, beta, which are resized to the correct size (if possible and necessary).
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the gges() functions (i.e. sgges(), dgges(), cgges(), and zgges()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices.
A | The first matrix of the given pair of complex general matrices. |
B | The second matrix of the given pair of complex general matrices. |
VSL | The resulting complex matrix of left Schur vectors. |
alpha | The resulting complex vector of eigenvalue numerators. |
beta | The resulting complex vector of eigenvalue denominators. |
VSR | The resulting complex matrix of right Schur vectors. |
select | Logical function for the eigenvalue selection. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Matrix sizes do not match. |
std::invalid_argument | Vector or matrix cannot be resized. |
std::runtime_error | Schur factorization computation failed. |
This function computes for a pair of n-by-n real non-symmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), which on exit replaces (A, B), and the left and right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization
\f[ (A^FA,B^FB) = ( (VSL^FL)*(S^FA)*(VSR^FR)^T, (VSL^FL)*T*(VSR^FR)^T ) \f]
where FA, FB, FL, FR are transposition flags:
A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio , such that
is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. The complex eigenvalues are returned as numerators and denominators in the given vectors alpha, beta, which are resized to the correct size (if possible and necessary).
It also orders the eigenvalues such that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). The according selection of eigenvalues is performed via the given select function. In case the given pair of matrices is a pair of real matrices the function is required to accept three pointers to real arguments, in case the given pair of matrices is a pair of complex matrices the function is required to accept two pointers to complex arguments.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the gges() functions (i.e. sgges(), dgges(), cgges(), and zgges()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices.
A | The first matrix of the given pair of complex general matrices. |
B | The second matrix of the given pair of complex general matrices. |
alpha | The resulting complex vector of eigenvalue numerators. |
beta | The resulting complex vector of eigenvalue denominators. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Matrix sizes do not match. |
std::invalid_argument | Vector or matrix cannot be resized. |
std::runtime_error | Schur factorization computation failed. |
This function computes for a pair of n-by-n real non-symmetric matrices (A,B), the generalized eigenvalues and the generalized real Schur form (S,T), which on exit replaces (A, B).
A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio , such that
is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. The complex eigenvalues are returned as numerators and denominators in the given vectors alpha, beta, which are resized to the correct size (if possible and necessary).
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the gges() functions (i.e. sgges(), dgges(), cgges(), and zgges()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general matrices.
A | The first matrix of the given pair of complex general matrices. |
B | The second matrix of the given pair of complex general matrices. |
alpha | The resulting complex vector of eigenvalue numerators. |
beta | The resulting complex vector of eigenvalue denominators. |
select | Logical function for the eigenvalue selection. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Matrix sizes do not match. |
std::invalid_argument | Vector or matrix cannot be resized. |
std::runtime_error | Schur factorization computation failed. |
This function computes for a pair of n-by-n real non-symmetric matrices (A,B), the generalized eigenvalues and the generalized real Schur form (S,T), which on exit replaces (A, B).
A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio , such that
is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. The complex eigenvalues are returned as numerators and denominators in the given vectors alpha, beta, which are resized to the correct size (if possible and necessary).
It also orders the eigenvalues such that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The according selection of eigenvalues is performed via the given select function. In case the given pair of matrices is a pair of real matrices the function is required to accept three pointers to real arguments, in case the given pair of matrices is a pair of complex matrices the function is required to accept two pointers to complex arguments.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
In all failure cases an exception is thrown.
Examples:
For more information on the gges() functions (i.e. sgges(), dgges(), cgges(), and zgges()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= max(1,3*n-2). |
info | Return code of the function call. |
This function computes the eigenvalues of an Hermitian n-by-n double precision complex column-major matrix based on the LAPACK zheev() function. Optionally, it computes the left and right eigenvectors. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the zheev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= max(1,3*n-2). |
info | Return code of the function call. |
This function computes the eigenvalues of an Hermitian n-by-n single precision complex column-major matrix based on the LAPACK cheev() function. Optionally, it computes the left and right eigenvectors. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the cheev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix.
A | The given Hermitian matrix. |
w | The resulting vector of eigenvalues. |
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid jobz argument provided. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a Hermitian n-by-n matrix based on the LAPACK heev() functions. Optionally, it computes the left and right eigenvectors.
The real eigenvalues are returned in ascending order in the given vector w. w is resized to the correct size (if possible and necessary). In case A is a row-major matrix, the left eigenvectors are returned in the rows of A, in case A is a column-major matrix, the right eigenvectors are returned in the columns of A.
The function fails if ...
'V'
nor 'N'
;'L'
nor 'U'
;In all failure cases a std::invalid_argument exception is thrown.
Examples:
For more information on the heev() functions (i.e. cheev() and zheev()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= max( 1, lrwork ). |
lrwork | The dimension of the array rwork; see online reference for details. |
iwork | Auxiliary array; size >= max( 1, liwork ). |
liwork | The dimension of the array iwork; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of an Hermitian n-by-n double precision complex column-major matrix based on the LAPACK cheevd() function. Optionally, it computes the left and right eigenvectors using a divide-and-conquer strategy. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the cheevd() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= max( 1, lrwork ). |
lrwork | The dimension of the array rwork; see online reference for details. |
iwork | Auxiliary array; size >= max( 1, liwork ). |
liwork | The dimension of the array iwork; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of an Hermitian n-by-n single precision complex column-major matrix based on the LAPACK cheevd() function. Optionally, it computes the left and right eigenvectors using a divide-and-conquer strategy. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the cheevd() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix.
A | The given Hermitian matrix. |
w | The resulting vector of eigenvalues. |
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid jobz argument provided. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a Hermitian n-by-n matrix based on the LAPACK heevd() functions, which use a divide-and-conquer strategy. Optionally, it computes the left and right eigenvectors.
The real eigenvalues are returned in ascending order in the given vector w. w is resized to the correct size (if possible and necessary). In case A is a row-major matrix, the left eigenvectors are returned in the rows of A, in case A is a column-major matrix, the right eigenvectors are returned in the columns of A.
The function fails if ...
'V'
nor 'N'
;'L'
nor 'U'
;In all failure cases a std::invalid_argument exception is thrown.
Examples:
For more information on the heevd() functions (i.e. cheevd() and zheevd()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision complex column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
range | Specifies the range of eigenvalues to find ('A' , 'V' , or 'I' ). |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision complex column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
vl | The lower bound of the interval to be searched for eigenvalues (vl < vu). |
vu | The upper bound of the interval to be searched for eigenvalues (vl < vu). |
il | The index of the smallest eigenvalue to be returned (0 <= il <= iu). |
iu | The index of the largest eigenvalue to be returned (0 <= il <= iu). |
abstol | The absolute error tolerance for the computation of the eigenvalues. |
m | The total number of eigenvalues found (0 <= m <= n). |
w | Pointer to the first element of the vector for the eigenvalues. |
Z | Pointer to the first element of the column-major matrix for the eigenvectors. |
ldz | The total number of elements between two columns of the matrix Z ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= 7*n. |
iwork | Auxiliary array; size >= 5*n. |
ifail | Index array of eigenvectors that failed to converge. |
info | Return code of the function call. |
This function computes a specified number of eigenvalues of a Hermitian n-by-n double precision complex column-major matrix based on the LAPACK cheevx() function. Optionally, it computes a specified number of eigenvectors. The selected real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix Z.'N'
: The eigenvectors of A are not computed.The parameter range specifies the amount of eigenvalues/eigenvectors to be found:
'A'
: All eigenvalues will be found.'V'
: All eigenvalues in the half-open interval 'I'
: The il-th through iu-th eigenvalues will be found.The info argument provides feedback on the success of the function call:
For more information on the cheevx() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision complex column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
range | Specifies the range of eigenvalues to find ('A' , 'V' , or 'I' ). |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision complex column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
vl | The lower bound of the interval to be searched for eigenvalues (vl < vu). |
vu | The upper bound of the interval to be searched for eigenvalues (vl < vu). |
il | The index of the smallest eigenvalue to be returned (0 <= il <= iu). |
iu | The index of the largest eigenvalue to be returned (0 <= il <= iu). |
abstol | The absolute error tolerance for the computation of the eigenvalues. |
m | The total number of eigenvalues found (0 <= m <= n). |
w | Pointer to the first element of the vector for the eigenvalues. |
Z | Pointer to the first element of the column-major matrix for the eigenvectors. |
ldz | The total number of elements between two columns of the matrix Z ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
rwork | Auxiliary array; size >= 7*n. |
iwork | Auxiliary array; size >= 5*n. |
ifail | Index array of eigenvectors that failed to converge. |
info | Return code of the function call. |
This function computes a specified number of eigenvalues of a Hermitian n-by-n single precision complex column-major matrix based on the LAPACK cheevx() function. Optionally, it computes a specified number of eigenvectors. The selected real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix Z.'N'
: The eigenvectors of A are not computed.The parameter range specifies the amount of eigenvalues/eigenvectors to be found:
'A'
: All eigenvalues will be found.'V'
: All eigenvalues in the half-open interval 'I'
: The il-th through iu-th eigenvalues will be found.The info argument provides feedback on the success of the function call:
For more information on the cheevx() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the eigenvalue computation of the given dense Hermitian matrix.
A | The given Hermitian matrix. |
w | The resulting vector of eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes all eigenvalues of a Hermitian n-by-n matrix based on the LAPACK heevx() functions. The real eigenvalues are returned in ascending order in the given vector w. w is resized to the correct size (if possible and necessary).
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the heevx() functions (i.e. cheevx() and zheevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix.
A | The given Hermitian matrix. |
w | The resulting vector of eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
low | The lower bound of the interval to be searched for eigenvalues. |
upp | The upper bound of the interval to be searched for eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::invalid_argument | Invalid value range provided. |
std::invalid_argument | Invalid index range provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes a specific number of eigenvalues of a Hermitian n-by-n matrix based on the LAPACK heevx() functions. The number of eigenvalues to be computed is specified by the lower bound low and the upper bound upp, which either form an integral or a floating point range.
In case low and upp are of integral type, the function computes all eigenvalues in the index range . The num resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be a num-dimensional vector.
In case low and upp are of floating point type, the function computes all eigenvalues in the half-open interval . The resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be an n-dimensional vector.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the heevx() functions (i.e. cheevx() and zheevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix.
A | The given Hermitian matrix. |
w | The resulting vector of eigenvalues. |
Z | The resulting matrix of eigenvectors. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes all eigenvalues of a Hermitian n-by-n matrix based on the LAPACK heevx() functions. Additionally, it computes all eigenvectors of A. The real eigenvalues are returned in ascending order in the given vector w. The eigenvectors are returned in the rows of Z in case Z is a row-major matrix and in the columns of Z in case Z is a column-major matrix. Both w and Z are resized to the correct dimensions (if possible and necessary).
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the heevx() functions (i.e. cheevx() and zheevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix.
A | The given Hermitian matrix. |
w | The resulting vector of eigenvalues. |
Z | The resulting matrix of eigenvectors. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
low | The lower bound of the interval to be searched for eigenvalues. |
upp | The upper bound of the interval to be searched for eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::invalid_argument | Invalid value range provided. |
std::invalid_argument | Invalid index range provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes a specific number of eigenvalues of a Hermitian n-by-n matrix based on the LAPACK heevx() functions. Additionally, it computes a specific number of eigenvectors of A. The number of eigenvalues to be computed is specified by the lower bound low and the upper bound upp, which either form an integral or a floating point range.
In case low and upp are of integral type, the function computes all eigenvalues in the index range . The num resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be a num-dimensional vector. The eigenvectors are returned in the rows of Z in case Z is row-major matrix and in the columns of Z in case Z is a column-major matrix. Z is resized (if possible) or expected to be a num-by-n row-major matrix or a n-by-num column-major matrix.
In case low and upp are of floating point type, the function computes all eigenvalues in the half-open interval . The resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be an n-dimensional vector. The eigenvectors are returned in the rows of Z in case Z is a row-major matrix and in the columns of Z in case Z is a column-major matrix. Z is resized (if possible) or expected to be a n-by-n matrix.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the heevx() functions (i.e. cheevx() and zheevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of a symmetric n-by-n double precision column-major matrix based on the LAPACK dsyev() function. Optionally, it computes the left and right eigenvectors. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the dsyev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of a symmetric n-by-n single precision column-major matrix based on the LAPACK ssyev() function. Optionally, it computes the left and right eigenvectors. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the ssyev() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix.
A | The given symmetric matrix. |
w | The resulting vector of eigenvalues. |
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid jobz argument provided. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a symmetric n-by-n matrix based on the LAPACK syev() functions. Optionally, it computes the left or right eigenvectors.
The real eigenvalues are returned in ascending order in the given vector w. w is resized to the correct size (if possible and necessary). In case A is a row-major matrix, the left eigenvectors are returned in the rows of A, in case A is a column-major matrix, the right eigenvectors are returned in the columns of A.
The function fails if ...
'V'
nor 'N'
;'L'
nor 'U'
;In all failure cases a std::invalid_argument exception is thrown.
Examples:
For more information on the syev() functions (i.e. ssyev() and dsyev()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
iwork | Auxiliary array; size >= max( 1, liwork ). |
liwork | The dimension of the array iwork; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of a symmetric n-by-n double precision column-major matrix based on the LAPACK ssyevd() function. Optionally, it computes the left and right eigenvectors using a divide-and-conquer strategy. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the ssyevd() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
w | Pointer to the first element of the vector for the eigenvalues. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
iwork | Auxiliary array; size >= max( 1, liwork ). |
liwork | The dimension of the array iwork; see online reference for details. |
info | Return code of the function call. |
This function computes the eigenvalues of a symmetric n-by-n single precision column-major matrix based on the LAPACK ssyevd() function. Optionally, it computes the left and right eigenvectors using a divide-and-conquer strategy. The real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix A.'N'
: The eigenvectors of A are not computed.The info argument provides feedback on the success of the function call:
For more information on the ssyevd() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix.
A | The given symmetric matrix. |
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
w | The resulting vector of eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid jobz argument provided. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of a symmetric n-by-n matrix based on the LAPACK syevd() functions, which use a divide-and-conquer strategy. Optionally, it computes the left or right eigenvectors.
The real eigenvalues are returned in ascending order in the given vector w. w is resized to the correct size (if possible and necessary). In case A is a row-major matrix, the left eigenvectors are returned in the rows of A, in case A is a column-major matrix, the right eigenvectors are returned in the columns of A.
The function fails if ...
'V'
nor 'N'
;'L'
nor 'U'
;In all failure cases a std::invalid_argument exception is thrown.
Examples:
For more information on the syevd() functions (i.e. ssyevd() and dsyevd()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
range | Specifies the range of eigenvalues to find ('A' , 'V' , or 'I' ). |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
vl | The lower bound of the interval to be searched for eigenvalues (vl < vu). |
vu | The upper bound of the interval to be searched for eigenvalues (vl < vu). |
il | The index of the smallest eigenvalue to be returned (0 <= il <= iu). |
iu | The index of the largest eigenvalue to be returned (0 <= il <= iu). |
abstol | The absolute error tolerance for the computation of the eigenvalues. |
m | The total number of eigenvalues found (0 <= m <= n). |
w | Pointer to the first element of the vector for the eigenvalues. |
Z | Pointer to the first element of the column-major matrix for the eigenvectors. |
ldz | The total number of elements between two columns of the matrix Z ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
iwork | Auxiliary array; size >= 5*n. |
ifail | Index array of eigenvectors that failed to converge. |
info | Return code of the function call. |
This function computes a specified number of eigenvalues of a symmetric n-by-n double precision column-major matrix based on the LAPACK dsyevx() function. Optionally, it computes a specified number of eigenvectors. The selected real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix Z.'N'
: The eigenvectors of A are not computed.The parameter range specifies the amount of eigenvalues/eigenvectors to be found:
'A'
: All eigenvalues will be found.'V'
: All eigenvalues in the half-open interval 'I'
: The il-th through iu-th eigenvalues will be found.The info argument provides feedback on the success of the function call:
For more information on the dsyevx() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix.
jobz | 'V' to compute the eigenvectors of A, 'N' to only compute the eigenvalues. |
range | Specifies the range of eigenvalues to find ('A' , 'V' , or 'I' ). |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows and columns of the given matrix ![]() |
A | Pointer to the first element of the single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
vl | The lower bound of the interval to be searched for eigenvalues (vl < vu). |
vu | The upper bound of the interval to be searched for eigenvalues (vl < vu). |
il | The index of the smallest eigenvalue to be returned (0 <= il <= iu). |
iu | The index of the largest eigenvalue to be returned (0 <= il <= iu). |
abstol | The absolute error tolerance for the computation of the eigenvalues. |
m | The total number of eigenvalues found (0 <= m <= n). |
w | Pointer to the first element of the vector for the eigenvalues. |
Z | Pointer to the first element of the column-major matrix for the eigenvectors. |
ldz | The total number of elements between two columns of the matrix Z ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; see online reference for details. |
iwork | Auxiliary array; size >= 5*n. |
ifail | Index array of eigenvectors that failed to converge. |
info | Return code of the function call. |
This function computes a specified number of eigenvalues of a symmetric n-by-n single precision column-major matrix based on the LAPACK ssyevx() function. Optionally, it computes a specified number of eigenvectors. The selected real eigenvalues are returned in ascending order in the given n-dimensional vector w.
The parameter jobz specifies the computation of the orthonormal eigenvectors of A:
'V'
: The eigenvectors of A are computed and returned within the matrix Z.'N'
: The eigenvectors of A are not computed.The parameter range specifies the amount of eigenvalues/eigenvectors to be found:
'A'
: All eigenvalues will be found.'V'
: All eigenvalues in the half-open interval 'I'
: The il-th through iu-th eigenvalues will be found.The info argument provides feedback on the success of the function call:
For more information on the ssyevx() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix.
A | The given symmetric matrix. |
w | The resulting vector of eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes all eigenvalues of a symmetric n-by-n matrix based on the LAPACK syevx() functions. The real eigenvalues are returned in ascending order in the given vector w. w is resized to the correct size (if possible and necessary).
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the syevx() functions (i.e. ssyevx() and dsyevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix.
A | The given symmetric matrix. |
w | The resulting vector of eigenvalues. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
low | The lower bound of the interval to be searched for eigenvalues. |
upp | The upper bound of the interval to be searched for eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::invalid_argument | Invalid value range provided. |
std::invalid_argument | Invalid index range provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes a specific number of eigenvalues of a symmetric n-by-n matrix based on the LAPACK syevx() functions. The number of eigenvalues to be computed is specified by the lower bound low and the upper bound upp, which either form an integral or a floating point range.
In case low and upp are of integral type, the function computes all eigenvalues in the index range . The num resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be a num-dimensional vector.
In case low and upp are of floating point type, the function computes all eigenvalues in the half-open interval . The resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be an n-dimensional vector.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the syevx() functions (i.e. ssyevx() and dsyevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix.
A | The given symmetric matrix. |
w | The resulting vector of eigenvalues. |
Z | The resulting matrix of eigenvectors. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes all eigenvalues of a symmetric n-by-n matrix based on the LAPACK syevx() functions. Additionally, it computes all eigenvectors of A. The real eigenvalues are returned in ascending order in the given vector w. The eigenvectors are returned in the rows of Z in case Z is a row-major matrix and in the columns of Z in case Z is a column-major matrix. Both w and Z are resized to the correct dimensions (if possible and necessary).
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the syevx() functions (i.e. ssyevx() and dsyevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix.
A | The given symmetric matrix. |
w | The resulting vector of eigenvalues. |
Z | The resulting matrix of eigenvectors. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
low | The lower bound of the interval to be searched for eigenvalues. |
upp | The upper bound of the interval to be searched for eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::invalid_argument | Invalid uplo argument provided. |
std::invalid_argument | Invalid value range provided. |
std::invalid_argument | Invalid index range provided. |
std::runtime_error | Eigenvalue computation failed. |
This function computes a specific number of eigenvalues of a symmetric n-by-n matrix based on the LAPACK syevx() functions. Additionally, it computes a specific number of eigenvectors of A. The number of eigenvalues to be computed is specified by the lower bound low and the upper bound upp, which either form an integral or a floating point range.
In case low and upp are of integral type, the function computes all eigenvalues in the index range . The num resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be a num-dimensional vector. The eigenvectors are returned in the rows of Z in case Z is row-major matrix and in the columns of Z in case Z is a column-major matrix. Z is resized (if possible) or expected to be a num-by-n row-major matrix or a n-by-num column-major matrix.
In case low and upp are of floating point type, the function computes all eigenvalues in the half-open interval . The resulting real eigenvalues are stored in ascending order in the given vector w, which is either resized (if possible) or expected to be an n-dimensional vector. The eigenvectors are returned in the rows of Z in case Z is a row-major matrix and in the columns of Z in case Z is a column-major matrix. Z is resized (if possible) or expected to be a n-by-n matrix.
Note that this function can only be used for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with any adapted matrix or matrices of any other element type results in a compile time error!
The function fails if ...
'L'
nor 'U'
;In all failure cases an exception is thrown.
Examples:
For more information on the syevx() functions (i.e. ssyevx() and dsyevx()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/