|
template void | madness::cholesky (Tensor< double > &A) |
|
template void | madness::cholesky (Tensor< double_complex > &A) |
|
template<typename T > |
void | madness::cholesky (Tensor< T > &A) |
| Compute the Cholesky factorization. More...
|
|
template void | madness::geev (const Tensor< double > &A, Tensor< double > &V, Tensor< double_complex > &e) |
|
template<typename T > |
void | madness::geev (const Tensor< T > &A, Tensor< T > &VR, Tensor< std::complex< T >> &e) |
| Real non-symmetric or complex non-Hermitian eigenproblem. More...
|
|
STATIC void | geev_ (const char *jobz, const char *uplo, integer *n, complex_real4 *a, integer *lda, complex_real4 *w, complex_real4 *w_imag, complex_real4 *v, integer *ldv, complex_real4 *vr, integer *ldvr, complex_real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | geev_ (const char *jobz, const char *uplo, integer *n, complex_real8 *a, integer *lda, complex_real8 *w, complex_real8 *w_imag, complex_real8 *v, integer *ldv, complex_real8 *vr, integer *ldvr, complex_real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | geev_ (const char *jobz, const char *uplo, integer *n, real4 *a, integer *lda, real4 *w_real, real4 *w_imag, real4 *v, integer *ldv, real4 *vr, integer *ldvr, real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | geev_ (const char *jobz, const char *uplo, integer *n, real8 *a, integer *lda, real8 *w_real, real8 *w_imag, real8 *v, integer *ldv, real8 *vr, integer *ldvr, real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
template void | madness::gelss (const Tensor< double > &a, const Tensor< double > &b, double rcond, Tensor< double > &x, Tensor< Tensor< double >::scalar_type > &s, long &rank, Tensor< Tensor< double >::scalar_type > &sumsq) |
|
template void | madness::gelss (const Tensor< double_complex > &a, const Tensor< double_complex > &b, double rcond, Tensor< double_complex > &x, Tensor< Tensor< double_complex >::scalar_type > &s, long &rank, Tensor< Tensor< double_complex >::scalar_type > &sumsq) |
|
template<typename T > |
void | madness::gelss (const Tensor< T > &a, const Tensor< T > &b, double rcond, Tensor< T > &x, Tensor< typename Tensor< T >::scalar_type > &s, long &rank, Tensor< typename Tensor< T >::scalar_type > &sumsq) |
| Solve Ax = b for general A using the LAPACK *gelss routines. More...
|
|
STATIC void | gelss_ (integer *m, integer *n, integer *nrhs, double_complex *a, integer *lda, double_complex *b, integer *ldb, double *sOUT, double *rcondIN, integer *rankOUT, double_complex *work, integer *lwork, integer *infoOUT) |
|
STATIC void | gelss_ (integer *m, integer *n, integer *nrhs, float_complex *a, integer *lda, float_complex *b, integer *ldb, float *sOUT, float *rcondIN, integer *rankOUT, float_complex *work, integer *lwork, integer *infoOUT) |
|
STATIC void | gelss_ (integer *m, integer *n, integer *nrhs, real4 *a, integer *lda, real4 *b, integer *ldb, real4 *sOUT, real4 *rcondIN, integer *rankOUT, real4 *work, integer *lwork, integer *infoOUT) |
|
STATIC void | gelss_ (integer *m, integer *n, integer *nrhs, real8 *a, integer *lda, real8 *b, integer *ldb, real8 *sOUT, real8 *rcondIN, integer *rankOUT, real8 *work, integer *lwork, integer *infoOUT) |
|
template void | madness::geqp3 (Tensor< double > &A, Tensor< double > &tau, Tensor< integer > &jpvt) |
|
template void | madness::geqp3 (Tensor< double_complex > &A, Tensor< double_complex > &tau, Tensor< integer > &jpvt) |
|
template<typename T > |
void | madness::geqp3 (Tensor< T > &A, Tensor< T > &tau, Tensor< integer > &jpvt) |
| Compute the QR factorization. More...
|
|
STATIC void | geqp3_ (integer *m, integer *n, complex_real4 *a, integer *lda, integer *jpvt, complex_real4 *tau, complex_real4 *work, integer *lwork, integer *infoOUT) |
|
STATIC void | geqp3_ (integer *m, integer *n, complex_real8 *a, integer *lda, integer *jpvt, complex_real8 *tau, complex_real8 *work, integer *lwork, integer *infoOUT) |
|
STATIC void | geqp3_ (integer *m, integer *n, real4 *a, integer *lda, integer *jpvt, real4 *tau, real4 *work, integer *lwork, integer *infoOUT) |
|
STATIC void | geqp3_ (integer *m, integer *n, real8 *a, integer *lda, integer *jpvt, real8 *tau, real8 *work, integer *lwork, integer *infoOUT) |
|
template<typename T > |
void | madness::geqp3_result (Tensor< T > &A, Tensor< T > &tau, Tensor< integer > &jpvt, Tensor< T > &work) |
|
STATIC void | geqrf_ (integer *m, integer *n, double_complex *a, integer *lda, double_complex *tau, double_complex *work, integer *lwork, integer *infoOUT) |
|
STATIC void | geqrf_ (integer *m, integer *n, float_complex *a, integer *lda, float_complex *tau, float_complex *work, integer *lwork, integer *infoOUT) |
|
STATIC void | geqrf_ (integer *m, integer *n, real4 *a, integer *lda, real4 *tau, real4 *work, integer *lwork, integer *infoOUT) |
|
STATIC void | geqrf_ (integer *m, integer *n, real8 *a, integer *lda, real8 *tau, real8 *work, integer *lwork, integer *infoOUT) |
|
template void | madness::gesv (const Tensor< double > &a, const Tensor< double > &b, Tensor< double > &x) |
|
template void | madness::gesv (const Tensor< double_complex > &a, const Tensor< double_complex > &b, Tensor< double_complex > &x) |
|
template<typename T > |
void | madness::gesv (const Tensor< T > &a, const Tensor< T > &b, Tensor< T > &x) |
| Solve Ax = b for general A using the LAPACK *gesv routines. More...
|
|
STATIC void | gesv_ (integer *n, integer *nrhs, double_complex *AT, integer *lda, integer *piv, double_complex *x, integer *ldx, integer *info) |
|
STATIC void | gesv_ (integer *n, integer *nrhs, float_complex *AT, integer *lda, integer *piv, float_complex *x, integer *ldx, integer *info) |
|
STATIC void | gesv_ (integer *n, integer *nrhs, real4 *AT, integer *lda, integer *piv, real4 *x, integer *ldx, integer *info) |
|
STATIC void | gesv_ (integer *n, integer *nrhs, real8 *AT, integer *lda, integer *piv, real8 *x, integer *ldx, integer *info) |
|
STATIC void | gesvd_ (const char *jobu, const char *jobvt, integer *m, integer *n, complex_real4 *a, integer *lda, real4 *s, complex_real4 *u, integer *ldu, complex_real4 *vt, integer *ldvt, complex_real4 *work, integer *lwork, integer *info, char_len jobulen, char_len jobvtlen) |
|
STATIC void | gesvd_ (const char *jobu, const char *jobvt, integer *m, integer *n, complex_real8 *a, integer *lda, real8 *s, complex_real8 *u, integer *ldu, complex_real8 *vt, integer *ldvt, complex_real8 *work, integer *lwork, integer *info, char_len jobulen, char_len jobvtlen) |
|
STATIC void | gesvd_ (const char *jobu, const char *jobvt, integer *m, integer *n, real4 *a, integer *lda, real4 *s, real4 *u, integer *ldu, real4 *vt, integer *ldvt, real4 *work, integer *lwork, integer *info, char_len jobulen, char_len jobvtlen) |
|
STATIC void | gesvd_ (const char *jobu, const char *jobvt, integer *m, integer *n, real8 *a, integer *lda, real8 *s, real8 *u, integer *ldu, real8 *vt, integer *ldvt, real8 *work, integer *lwork, integer *info, char_len jobulen, char_len jobvtlen) |
|
STATIC void | getrf_ (integer *m, integer *n, complex_real4 *a, integer *lda, integer *ipiv, integer *info) |
|
STATIC void | getrf_ (integer *m, integer *n, complex_real8 *a, integer *lda, integer *ipiv, integer *info) |
|
STATIC void | getrf_ (integer *m, integer *n, real4 *a, integer *lda, integer *ipiv, integer *info) |
|
STATIC void | getrf_ (integer *m, integer *n, real8 *a, integer *lda, integer *ipiv, integer *info) |
|
STATIC void | getri_ (integer *n, complex_real4 *a, integer *lda, integer *ipiv, complex_real4 *work, integer *lwork, integer *info) |
|
STATIC void | getri_ (integer *n, complex_real8 *a, integer *lda, integer *ipiv, complex_real8 *work, integer *lwork, integer *info) |
|
STATIC void | getri_ (integer *n, real4 *a, integer *lda, integer *ipiv, real4 *work, integer *lwork, integer *info) |
|
STATIC void | getri_ (integer *n, real8 *a, integer *lda, integer *ipiv, real8 *work, integer *lwork, integer *info) |
|
template void | madness::ggev (const Tensor< double > &A, Tensor< double > &B, Tensor< double > &V, Tensor< double_complex > &e) |
|
template<typename T > |
void | madness::ggev (const Tensor< T > &A, Tensor< T > &B, Tensor< T > &VR, Tensor< std::complex< T >> &e) |
| Generalized real-non-symmetric or complex-non-Hermitian eigenproblem. More...
|
|
STATIC void | ggev_ (const char *jobl, const char *jobr, integer *n, complex_real4 *a, integer *lda, complex_real4 *b, integer *ldb, complex_real4 *w, complex_real4 *w_imag, complex_real4 *beta, complex_real4 *vl, integer *ldvl, complex_real4 *vr, integer *ldvr, complex_real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | ggev_ (const char *jobl, const char *jobr, integer *n, complex_real8 *a, integer *lda, complex_real8 *b, integer *ldb, complex_real8 *w, complex_real8 *w_imag, complex_real8 *beta, complex_real8 *vl, integer *ldvl, complex_real8 *vr, integer *ldvr, complex_real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | ggev_ (const char *jobl, const char *jobr, integer *n, real4 *a, integer *lda, real4 *b, integer *ldb, real4 *w_real, real4 *w_imag, real4 *beta, real4 *vl, integer *ldvl, real4 *vr, integer *ldvr, real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | ggev_ (const char *jobl, const char *jobr, integer *n, real8 *a, integer *lda, real8 *b, integer *ldb, real8 *w_real, real8 *w_imag, real8 *beta, real8 *vl, integer *ldvl, real8 *vr, integer *ldvr, real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
void | madness::init_tensor_lapack () |
| World/MRA initialization calls this before going multithreaded due to static data in dlamch . More...
|
|
template Tensor< double > | madness::inverse (const Tensor< double > &A) |
|
template Tensor< double_complex > | madness::inverse (const Tensor< double_complex > &A) |
|
template<typename T > |
Tensor< T > | madness::inverse (const Tensor< T > &a_in) |
| invert general square matrix A More...
|
|
template void | madness::lq (Tensor< double > &A, Tensor< double > &L) |
|
template void | madness::lq (Tensor< double_complex > &A, Tensor< double_complex > &L) |
|
template<typename T > |
void | madness::lq (Tensor< T > &A, Tensor< T > &R) |
| compute the LQ decomposition of the matrix A = L Q More...
|
|
template void | madness::lq_result (Tensor< double > &A, Tensor< double > &R, Tensor< double > &tau, Tensor< double > &work, bool do_qr) |
|
template void | madness::lq_result (Tensor< double_complex > &A, Tensor< double_complex > &R, Tensor< double_complex > &tau, Tensor< double_complex > &work, bool do_qr) |
|
template<typename T > |
void | madness::lq_result (Tensor< T > &A, Tensor< T > &R, Tensor< T > &tau, Tensor< T > &work, bool do_qr) |
| compute the LQ decomposition of the matrix A = L Q More...
|
|
static void | madness::mask_info (integer &info) |
|
STATIC Tensor< double > | madness::my_conj_transpose (Tensor< double > a) |
|
STATIC Tensor< double_complex > | madness::my_conj_transpose (Tensor< double_complex > a) |
|
STATIC Tensor< float > | madness::my_conj_transpose (Tensor< float > a) |
|
STATIC Tensor< float_complex > | madness::my_conj_transpose (Tensor< float_complex > a) |
|
template void | madness::orgqr (Tensor< complex_real4 > &A, const Tensor< complex_real4 > &tau) |
|
template void | madness::orgqr (Tensor< double > &A, const Tensor< double > &tau) |
|
template void | madness::orgqr (Tensor< double_complex > &A, const Tensor< double_complex > &tau) |
|
template void | madness::orgqr (Tensor< float > &A, const Tensor< float > &tau) |
|
template<typename T > |
void | madness::orgqr (Tensor< T > &A, const Tensor< T > &tau) |
| reconstruct the orthogonal matrix Q (e.g. from QR factorization) More...
|
|
STATIC void | orgqr_ (integer *m, integer *n, integer *k, complex_real4 *a, integer *lda, complex_real4 *tau, complex_real4 *work, integer *lwork, integer *info) |
|
STATIC void | orgqr_ (integer *m, integer *n, integer *k, complex_real8 *a, integer *lda, complex_real8 *tau, complex_real8 *work, integer *lwork, integer *info) |
|
STATIC void | orgqr_ (integer *m, integer *n, integer *k, real4 *a, integer *lda, real4 *tau, real4 *work, integer *lwork, integer *info) |
|
STATIC void | orgqr_ (integer *m, integer *n, integer *k, real8 *a, integer *lda, real8 *tau, real8 *work, integer *lwork, integer *info) |
|
STATIC void | potrf_ (const char *UPLO, integer *n, complex_real4 *a, integer *lda, integer *info) |
|
STATIC void | potrf_ (const char *UPLO, integer *n, complex_real8 *a, integer *lda, integer *info) |
|
STATIC void | potrf_ (const char *UPLO, integer *n, real4 *a, integer *lda, integer *info) |
|
STATIC void | potrf_ (const char *UPLO, integer *n, real8 *a, integer *lda, integer *info) |
|
STATIC void | pstrf_ (const char *UPLO, integer *n, complex_real4 *a, integer *lda, integer *piv, integer *rank, real4 *tol, complex_real4 *work, integer *info) |
|
STATIC void | pstrf_ (const char *UPLO, integer *n, complex_real8 *a, integer *lda, integer *piv, integer *rank, real8 *tol, complex_real8 *work, integer *info) |
|
STATIC void | pstrf_ (const char *UPLO, integer *n, real4 *a, integer *lda, integer *piv, integer *rank, real4 *tol, real4 *work, integer *info) |
|
STATIC void | pstrf_ (const char *UPLO, integer *n, real8 *a, integer *lda, integer *piv, integer *rank, real8 *tol, real8 *work, integer *info) |
|
template void | madness::qr (Tensor< double > &A, Tensor< double > &R) |
|
template void | madness::qr (Tensor< double_complex > &A, Tensor< double_complex > &R) |
|
template void | madness::qr (Tensor< float > &A, Tensor< float > &R) |
|
template void | madness::qr (Tensor< float_complex > &A, Tensor< float_complex > &R) |
|
template<typename T > |
void | madness::qr (Tensor< T > &A, Tensor< T > &R) |
| compute the QR decomposition of the matrix A More...
|
|
template void | madness::rr_cholesky (Tensor< double > &A, typename Tensor< double >::scalar_type tol, Tensor< integer > &piv, int &rank) |
|
template void | madness::rr_cholesky (Tensor< double_complex > &A, typename Tensor< double_complex >::scalar_type tol, Tensor< integer > &piv, int &rank) |
|
template<typename T > |
void | madness::rr_cholesky (Tensor< T > &A, typename Tensor< T >::scalar_type tol, Tensor< integer > &piv, int &rank) |
| Compute the rank-revealing Cholesky factorization. More...
|
|
template void | madness::svd (const Tensor< double > &a, Tensor< double > &U, Tensor< Tensor< double >::scalar_type > &s, Tensor< double > &VT) |
|
template void | madness::svd (const Tensor< double_complex > &a, Tensor< double_complex > &U, Tensor< Tensor< double_complex >::scalar_type > &s, Tensor< double_complex > &VT) |
|
template void | madness::svd (const Tensor< float > &a, Tensor< float > &U, Tensor< Tensor< float >::scalar_type > &s, Tensor< float > &VT) |
|
template void | madness::svd (const Tensor< float_complex > &a, Tensor< float_complex > &U, Tensor< Tensor< float_complex >::scalar_type > &s, Tensor< float_complex > &VT) |
|
template<typename T > |
void | madness::svd (const Tensor< T > &a, Tensor< T > &U, Tensor< typename Tensor< T >::scalar_type > &s, Tensor< T > &VT) |
| Compute the singluar value decomposition of an n-by-m matrix using *gesvd. More...
|
|
template void | madness::svd_result (Tensor< double > &a, Tensor< double > &U, Tensor< Tensor< double >::scalar_type > &s, Tensor< double > &VT, Tensor< double > &work) |
|
template void | madness::svd_result (Tensor< double_complex > &a, Tensor< double_complex > &U, Tensor< Tensor< double_complex >::scalar_type > &s, Tensor< double_complex > &VT, Tensor< double_complex > &work) |
|
template void | madness::svd_result (Tensor< float > &a, Tensor< float > &U, Tensor< Tensor< float >::scalar_type > &s, Tensor< float > &VT, Tensor< float > &work) |
|
template void | madness::svd_result (Tensor< float_complex > &a, Tensor< float_complex > &U, Tensor< Tensor< float_complex >::scalar_type > &s, Tensor< float_complex > &VT, Tensor< float_complex > &work) |
|
template<typename T > |
void | madness::svd_result (Tensor< T > &a, Tensor< T > &U, Tensor< typename Tensor< T >::scalar_type > &s, Tensor< T > &VT, Tensor< T > &work) |
| same as svd, but it optimizes away the tensor construction: a = U * diag(s) * VT More...
|
|
template void | madness::syev (const Tensor< double > &A, Tensor< double > &V, Tensor< Tensor< double >::scalar_type > &e) |
|
template void | madness::syev (const Tensor< double_complex > &A, Tensor< double_complex > &V, Tensor< Tensor< double_complex >::scalar_type > &e) |
|
template<typename T > |
void | madness::syev (const Tensor< T > &A, Tensor< T > &V, Tensor< typename Tensor< T >::scalar_type > &e) |
| Real-symmetric or complex-Hermitian eigenproblem. More...
|
|
STATIC void | syev_ (const char *jobz, const char *uplo, integer *n, complex_real4 *a, integer *lda, real4 *w, complex_real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | syev_ (const char *jobz, const char *uplo, integer *n, complex_real8 *a, integer *lda, real8 *w, complex_real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | syev_ (const char *jobz, const char *uplo, integer *n, real4 *a, integer *lda, real4 *w, real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | syev_ (const char *jobz, const char *uplo, integer *n, real8 *a, integer *lda, real8 *w, real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
template void | madness::sygv (const Tensor< double > &A, const Tensor< double > &B, int itype, Tensor< double > &V, Tensor< Tensor< double >::scalar_type > &e) |
|
template void | madness::sygv (const Tensor< double_complex > &A, const Tensor< double_complex > &B, int itype, Tensor< double_complex > &V, Tensor< Tensor< double_complex >::scalar_type > &e) |
|
template<typename T > |
void | madness::sygv (const Tensor< T > &A, const Tensor< T > &B, int itype, Tensor< T > &V, Tensor< typename Tensor< T >::scalar_type > &e) |
| Generalized real-symmetric or complex-Hermitian eigenproblem. More...
|
|
STATIC void | sygv_ (integer *itype, const char *jobz, const char *uplo, integer *n, complex_real4 *a, integer *lda, complex_real4 *b, integer *ldb, real4 *w, complex_real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | sygv_ (integer *itype, const char *jobz, const char *uplo, integer *n, complex_real8 *a, integer *lda, complex_real8 *b, integer *ldb, real8 *w, complex_real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | sygv_ (integer *itype, const char *jobz, const char *uplo, integer *n, real4 *a, integer *lda, real4 *b, integer *ldb, real4 *w, real4 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
STATIC void | sygv_ (integer *itype, const char *jobz, const char *uplo, integer *n, real8 *a, integer *lda, real8 *b, integer *ldb, real8 *w, real8 *work, integer *lwork, integer *info, char_len jobzlen, char_len uplo_len) |
|
template<typename T > |
double | madness::test_cholesky (int n) |
|
template<typename T > |
double | madness::test_gelss (int n, int nrhs) |
|
template<typename T > |
double | madness::test_gesv (int n, int nrhs) |
|
template<typename T > |
double | madness::test_inverse (int n) |
| Example and test code for interface to LAPACK SVD interfae. More...
|
|
template<typename T > |
double | madness::test_qr () |
|
template<typename T > |
double | madness::test_rr_cholesky (int n) |
|
template<typename T > |
double | madness::test_svd (int n, int m) |
| Example and test code for interface to LAPACK SVD interfae. More...
|
|
template<typename T > |
double | madness::test_syev (int n) |
|
template<typename T > |
double | madness::test_sygv (int n) |
|
bool | madness::test_tensor_lapack () |
| Test the Tensor-LAPACK interface ... currently always returns true! More...
|
|