![]() |
Blaze 3.9
|
LAPACK LQ decomposition functions (gelqf) | |
void | blaze::gelqf (blas_int_t m, blas_int_t n, float *A, blas_int_t lda, float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the LQ decomposition of the given dense single precision column-major matrix. More... | |
void | blaze::gelqf (blas_int_t m, blas_int_t n, double *A, blas_int_t lda, double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the LQ decomposition of the given dense double precision column-major matrix. More... | |
void | blaze::gelqf (blas_int_t m, blas_int_t n, complex< float > *A, blas_int_t lda, complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the LQ decomposition of the given dense single precision complex column-major matrix. More... | |
void | blaze::gelqf (blas_int_t m, blas_int_t n, complex< double > *A, blas_int_t lda, complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the LQ decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::gelqf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the LQ decomposition of the given dense matrix. More... | |
LAPACK QL decomposition functions (geqlf) | |
void | blaze::geqlf (blas_int_t m, blas_int_t n, float *A, blas_int_t lda, float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QL decomposition of the given dense single precision column-major matrix. More... | |
void | blaze::geqlf (blas_int_t m, blas_int_t n, double *A, blas_int_t lda, double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QL decomposition of the given dense double precision column-major matrix. More... | |
void | blaze::geqlf (blas_int_t m, blas_int_t n, complex< float > *A, blas_int_t lda, complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QL decomposition of the given dense single precision complex column-major matrix. More... | |
void | blaze::geqlf (blas_int_t m, blas_int_t n, complex< double > *A, blas_int_t lda, complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QL decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::geqlf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the QL decomposition of the given dense matrix. More... | |
LAPACK QR decomposition functions (geqp3) | |
void | blaze::geqp3 (blas_int_t m, blas_int_t n, float *A, blas_int_t lda, blas_int_t *jpvt, float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QR decomposition of the given dense single precision column-major matrix. More... | |
void | blaze::geqp3 (blas_int_t m, blas_int_t n, double *A, blas_int_t lda, blas_int_t *jpvt, double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QR decomposition of the given dense double precision column-major matrix. More... | |
LAPACK QR decomposition functions (geqrf) | |
void | blaze::geqrf (blas_int_t m, blas_int_t n, float *A, blas_int_t lda, float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QR decomposition of the given dense single precision column-major matrix. More... | |
void | blaze::geqrf (blas_int_t m, blas_int_t n, double *A, blas_int_t lda, double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QR decomposition of the given dense double precision column-major matrix. More... | |
void | blaze::geqrf (blas_int_t m, blas_int_t n, complex< float > *A, blas_int_t lda, complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QR decomposition of the given dense single precision complex column-major matrix. More... | |
void | blaze::geqrf (blas_int_t m, blas_int_t n, complex< double > *A, blas_int_t lda, complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the QR decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::geqrf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the QR decomposition of the given dense matrix. More... | |
LAPACK RQ decomposition functions (gerqf) | |
void | blaze::gerqf (blas_int_t m, blas_int_t n, float *A, blas_int_t lda, float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the RQ decomposition of the given dense single precision column-major matrix. More... | |
void | blaze::gerqf (blas_int_t m, blas_int_t n, double *A, blas_int_t lda, double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the RQ decomposition of the given dense single precision column-major matrix. More... | |
void | blaze::gerqf (blas_int_t m, blas_int_t n, complex< float > *A, blas_int_t lda, complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the RQ decomposition of the given dense single precision complex column-major matrix. More... | |
void | blaze::gerqf (blas_int_t m, blas_int_t n, complex< double > *A, blas_int_t lda, complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the RQ decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::gerqf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the RQ decomposition of the given dense matrix. More... | |
LAPACK LU decomposition functions (getrf) | |
void | blaze::getrf (blas_int_t m, blas_int_t n, float *A, blas_int_t lda, blas_int_t *ipiv, blas_int_t *info) |
LAPACK kernel for the LU decomposition of the given dense general single precision column-major matrix. More... | |
void | blaze::getrf (blas_int_t m, blas_int_t n, double *A, blas_int_t lda, blas_int_t *ipiv, blas_int_t *info) |
LAPACK kernel for the LU decomposition of the given dense general double precision column-major matrix. More... | |
void | blaze::getrf (blas_int_t m, blas_int_t n, complex< float > *A, blas_int_t lda, blas_int_t *ipiv, blas_int_t *info) |
LAPACK kernel for the LU decomposition of the given dense general single precision complex column-major matrix. More... | |
void | blaze::getrf (blas_int_t m, blas_int_t n, complex< double > *A, blas_int_t lda, blas_int_t *ipiv, blas_int_t *info) |
LAPACK kernel for the LU decomposition of the given dense general double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::getrf (DenseMatrix< MT, SO > &A, blas_int_t *ipiv) |
LAPACK kernel for the LU decomposition of the given dense general matrix. More... | |
LAPACK LDLH decomposition functions (hetrf) | |
void | blaze::hetrf (char uplo, blas_int_t n, complex< float > *A, blas_int_t lda, blas_int_t *ipiv, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite single precision complex column-major matrix. More... | |
void | blaze::hetrf (char uplo, blas_int_t n, complex< double > *A, blas_int_t lda, blas_int_t *ipiv, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::hetrf (DenseMatrix< MT, SO > &A, char uplo, blas_int_t *ipiv) |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite matrix. More... | |
LAPACK functions to reconstruct Q from a QL decomposition (org2l) | |
void | blaze::org2l (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | blaze::org2l (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::org2l (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (org2r) | |
void | blaze::org2r (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | blaze::org2r (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::org2r (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (orgl2) | |
void | blaze::orgl2 (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | blaze::orgl2 (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::orgl2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (orglq) | |
void | blaze::orglq (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | blaze::orglq (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::orglq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a QL decomposition (orgql) | |
void | blaze::orgql (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | blaze::orgql (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::orgql (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (orgqr) | |
void | blaze::orgqr (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | blaze::orgqr (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::orgqr (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (orgr2) | |
void | blaze::orgr2 (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | blaze::orgr2 (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::orgr2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (orgrq) | |
void | blaze::orgrq (blas_int_t m, blas_int_t n, blas_int_t k, float *A, blas_int_t lda, const float *tau, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | blaze::orgrq (blas_int_t m, blas_int_t n, blas_int_t k, double *A, blas_int_t lda, const double *tau, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::orgrq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to multiply Q from a LQ decomposition with a matrix (ormlq) | |
void | blaze::ormlq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const float *A, blas_int_t lda, const float *tau, float *C, blas_int_t ldc, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision Q from a LQ decomposition with another matrix. More... | |
void | blaze::ormlq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const double *A, blas_int_t lda, const double *tau, double *C, blas_int_t ldc, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | blaze::ormlq (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QL decomposition with a matrix (ormql) | |
void | blaze::ormql (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const float *A, blas_int_t lda, const float *tau, float *C, blas_int_t ldc, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision Q from a QL decomposition with another matrix. More... | |
void | blaze::ormql (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const double *A, blas_int_t lda, const double *tau, double *C, blas_int_t ldc, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | blaze::ormql (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QR decomposition with a matrix (ormqr) | |
void | blaze::ormqr (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const float *A, blas_int_t lda, const float *tau, float *C, blas_int_t ldc, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision Q from a QR decomposition with another matrix. More... | |
void | blaze::ormqr (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const double *A, blas_int_t lda, const double *tau, double *C, blas_int_t ldc, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | blaze::ormqr (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a RQ decomposition with a matrix (ormrq) | |
void | blaze::ormrq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const float *A, blas_int_t lda, const float *tau, float *C, blas_int_t ldc, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision Q from a RQ decomposition with another matrix. More... | |
void | blaze::ormrq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const double *A, blas_int_t lda, const double *tau, double *C, blas_int_t ldc, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | blaze::ormrq (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
LAPACK LLH (Cholesky) decomposition functions (potrf) | |
void | blaze::potrf (char uplo, blas_int_t n, float *A, blas_int_t lda, blas_int_t *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite single precision column-major matrix. More... | |
void | blaze::potrf (char uplo, blas_int_t n, double *A, blas_int_t lda, blas_int_t *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite double precision column-major matrix. More... | |
void | blaze::potrf (char uplo, blas_int_t n, complex< float > *A, blas_int_t lda, blas_int_t *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite single precision complex column-major matrix. More... | |
void | blaze::potrf (char uplo, blas_int_t n, complex< double > *A, blas_int_t lda, blas_int_t *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::potrf (DenseMatrix< MT, SO > &A, char uplo) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite matrix. More... | |
LAPACK LLH (Cholesky) decomposition functions (pstrf) | |
void | blaze::pstrf (char uplo, blas_int_t n, float *A, blas_int_t lda, blaze::blas_int_t *piv, blaze::blas_int_t *rank, float tol, float *work, blas_int_t *info) |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite single precision column-major matrix. More... | |
void | blaze::pstrf (char uplo, blas_int_t n, double *A, blas_int_t lda, blaze::blas_int_t *piv, blaze::blas_int_t *rank, double tol, double *work, blas_int_t *info) |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite double precision column-major matrix. More... | |
void | blaze::pstrf (char uplo, blas_int_t n, complex< float > *A, blas_int_t lda, blaze::blas_int_t *piv, blaze::blas_int_t *rank, float tol, complex< float > *work, blas_int_t *info) |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite single precision complex column-major matrix. More... | |
void | blaze::pstrf (char uplo, blas_int_t n, complex< double > *A, blas_int_t lda, blaze::blas_int_t *piv, blaze::blas_int_t *rank, double tol, complex< double > *work, blas_int_t *info) |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite double precision complex column-major matrix. More... | |
LAPACK LDLT decomposition functions (sytrf) | |
void | blaze::sytrf (char uplo, blas_int_t n, float *A, blas_int_t lda, blas_int_t *ipiv, float *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite single precision column-major matrix. More... | |
void | blaze::sytrf (char uplo, blas_int_t n, double *A, blas_int_t lda, blas_int_t *ipiv, double *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite double precision column-major matrix. More... | |
void | blaze::sytrf (char uplo, blas_int_t n, complex< float > *A, blas_int_t lda, blas_int_t *ipiv, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite single precision complex column-major matrix. More... | |
void | blaze::sytrf (char uplo, blas_int_t n, complex< double > *A, blas_int_t lda, blas_int_t *ipiv, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | blaze::sytrf (DenseMatrix< MT, SO > &A, char uplo, blas_int_t *ipiv) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite matrix. More... | |
LAPACK functions to reconstruct Q from a QL decomposition (ung2l) | |
void | blaze::ung2l (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | blaze::ung2l (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::ung2l (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (ung2r) | |
void | blaze::ung2r (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | blaze::ung2r (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::ung2r (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (ungl2) | |
void | blaze::ungl2 (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | blaze::ungl2 (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::ungl2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (unglq) | |
void | blaze::unglq (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | blaze::unglq (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::unglq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a QL decomposition (ungql) | |
void | blaze::ungql (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | blaze::ungql (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::ungql (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (ungqr) | |
void | blaze::ungqr (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | blaze::ungqr (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::ungqr (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (ungr2) | |
void | blaze::ungr2 (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | blaze::ungr2 (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::ungr2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (ungrq) | |
void | blaze::ungrq (blas_int_t m, blas_int_t n, blas_int_t k, complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | blaze::ungrq (blas_int_t m, blas_int_t n, blas_int_t k, complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | blaze::ungrq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to multiply Q from a LQ decomposition with a matrix (unmlq) | |
void | blaze::unmlq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *C, blas_int_t ldc, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision complex Q from a LQ decomposition with another matrix. More... | |
void | blaze::unmlq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *C, blas_int_t ldc, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision complex Q from a LQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | blaze::unmlq (DenseMatrix< MT1, SO > &C, const DenseMatrix< MT2, SO > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QL decomposition with a matrix (unmql) | |
void | blaze::unmql (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *C, blas_int_t ldc, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision Q from a QL decomposition with another matrix. More... | |
void | blaze::unmql (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *C, blas_int_t ldc, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | blaze::unmql (DenseMatrix< MT1, SO > &C, const DenseMatrix< MT2, SO > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QR decomposition with a matrix (unmqr) | |
void | blaze::unmqr (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *C, blas_int_t ldc, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision Q from a QR decomposition with another matrix. More... | |
void | blaze::unmqr (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *C, blas_int_t ldc, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | blaze::unmqr (DenseMatrix< MT1, SO > &C, DenseMatrix< MT2, SO > &A, char side, char trans, ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a RQ decomposition with a matrix (unmrq) | |
void | blaze::unmrq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< float > *A, blas_int_t lda, const complex< float > *tau, complex< float > *C, blas_int_t ldc, complex< float > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the single precision Q from a RQ decomposition with another matrix. More... | |
void | blaze::unmrq (char side, char trans, blas_int_t m, blas_int_t n, blas_int_t k, const complex< double > *A, blas_int_t lda, const complex< double > *tau, complex< double > *C, blas_int_t ldc, complex< double > *work, blas_int_t lwork, blas_int_t *info) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | blaze::unmrq (DenseMatrix< MT1, SO > &C, const DenseMatrix< MT2, SO > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
LAPACK LLH Pivoting (Cholesky) decomposition functions (pstrf) | |
template<typename MT , bool SO, typename ST > | |
blas_int_t | blaze::pstrf (DenseMatrix< MT, SO > &A, char uplo, blas_int_t *piv, ST tol) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite matrix. More... | |
|
inline |
LAPACK kernel for the LQ decomposition of the given dense double precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix LQ decomposition of a general m-by-n double precision complex column-major matrix based on the LAPACK sgelqf() function. The resulting decomposition has the form
\f[ A = L \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) . . . H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:n)
is stored on exit in A(i,i+1:n)
, and tau
in tau(i)
. Thus on exit the elements on and below the diagonal of the matrix contain the m-by-min(m,n) lower trapezoidal matrix L
(L
is lower triangular if m <= n); the elements above the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgelqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LQ decomposition of the given dense single precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix LQ decomposition of a general m-by-n single precision complex column-major matrix based on the LAPACK sgelqf() function. The resulting decomposition has the form
\f[ A = L \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) . . . H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:n)
is stored on exit in A(i,i+1:n)
, and tau
in tau(i)
. Thus on exit the elements on and below the diagonal of the matrix contain the m-by-min(m,n) lower trapezoidal matrix L
(L
is lower triangular if m <= n); the elements above the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgelqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LQ decomposition of the given dense double precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix LQ decomposition of a general m-by-n double precision column-major matrix based on the LAPACK sgelqf() function. The resulting decomposition has the form
\f[ A = L \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) . . . H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:n)
is stored on exit in A(i,i+1:n)
, and tau
in tau(i)
. Thus on exit the elements on and below the diagonal of the matrix contain the m-by-min(m,n) lower trapezoidal matrix L
(L
is lower triangular if m <= n); the elements above the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgelqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LQ decomposition of the given dense single precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix LQ decomposition of a general m-by-n single precision column-major matrix based on the LAPACK sgelqf() function. The resulting decomposition has the form
\f[ A = L \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) . . . H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:n)
is stored on exit in A(i,i+1:n)
, and tau
in tau(i)
. Thus on exit the elements on and below the diagonal of the matrix contain the m-by-min(m,n) lower trapezoidal matrix L
(L
is lower triangular if m <= n); the elements above the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgelqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LQ decomposition of the given dense matrix.
A | The matrix to be decomposed. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function performs the dense matrix LQ decomposition of a general m-by-n matrix based on the LAPACK gelqf() functions. 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!
In case of a column-major matrix, the resulting decomposition has the form
\f[ A = L \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) . . . H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:n)
is stored on exit in A(i,i+1:n)
, and tau
in tau(i)
. Thus on exit the elements on and below the diagonal of the matrix contain the m-by-min(m,n) lower trapezoidal matrix L
(L
is lower triangular if m <= n); the elements above the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
For more information on the gelqf() functions (i.e. sgelqf(), dgelqf(), cgelqf(), and zgelqf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QL decomposition of the given dense double precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QL decomposition of a general m-by-n double precision complex column-major matrix based on the LAPACK sgeqlf() function. The resulting decomposition has the form
\f[ A = Q \cdot L, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) ... H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(m-k+i+1:m) = 0
and v(m-k+i) = 1
. v(1:m-k+i-1)
is stored on exit in A(1:m-k+i-1,n-k+i)
, and tau
in tau(i)
. Thus in case m >= n, the lower triangle of the subarray A(m-n+1:m,1:n) contains the n-by-n lower triangular matrix L
and in case m <= n, the elements on and below the (n-m)-th subdiagonal contain the m-by-n lower trapezoidal matrix L
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgeqlf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QL decomposition of the given dense single precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QL decomposition of a general m-by-n single precision complex column-major matrix based on the LAPACK sgeqlf() function. The resulting decomposition has the form
\f[ A = Q \cdot L, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) ... H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(m-k+i+1:m) = 0
and v(m-k+i) = 1
. v(1:m-k+i-1)
is stored on exit in A(1:m-k+i-1,n-k+i)
, and tau
in tau(i)
. Thus in case m >= n, the lower triangle of the subarray A(m-n+1:m,1:n) contains the n-by-n lower triangular matrix L
and in case m <= n, the elements on and below the (n-m)-th subdiagonal contain the m-by-n lower trapezoidal matrix L
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgeqlf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QL decomposition of the given dense double precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QL decomposition of a general m-by-n double precision column-major matrix based on the LAPACK sgeqlf() function. The resulting decomposition has the form
\f[ A = Q \cdot L, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) ... H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(m-k+i+1:m) = 0
and v(m-k+i) = 1
. v(1:m-k+i-1)
is stored on exit in A(1:m-k+i-1,n-k+i)
, and tau
in tau(i)
. Thus in case m >= n, the lower triangle of the subarray A(m-n+1:m,1:n) contains the n-by-n lower triangular matrix L
and in case m <= n, the elements on and below the (n-m)-th subdiagonal contain the m-by-n lower trapezoidal matrix L
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgeqlf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QL decomposition of the given dense single precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QL decomposition of a general m-by-n single precision column-major matrix based on the LAPACK sgeqlf() function. The resulting decomposition has the form
\f[ A = Q \cdot L, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) ... H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(m-k+i+1:m) = 0
and v(m-k+i) = 1
. v(1:m-k+i-1)
is stored on exit in A(1:m-k+i-1,n-k+i)
, and tau
in tau(i)
. Thus in case m >= n, the lower triangle of the subarray A(m-n+1:m,1:n) contains the n-by-n lower triangular matrix L
and in case m <= n, the elements on and below the (n-m)-th subdiagonal contain the m-by-n lower trapezoidal matrix L
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgeqlf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QL decomposition of the given dense matrix.
A | The matrix to be decomposed. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function performs the dense matrix QL decomposition of a general m-by-n matrix based on the LAPACK geqlf() functions. 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!
In case of a column-major matrix, the resulting decomposition has the form
\f[ A = Q \cdot L, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(k) ... H(2) H(1) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(m-k+i+1:m) = 0
and v(m-k+i) = 1
. v(1:m-k+i-1)
is stored on exit in A(1:m-k+i-1,n-k+i)
, and tau
in tau(i)
. Thus in case m >= n, the lower triangle of the subarray A(m-n+1:m,1:n) contains the n-by-n lower triangular matrix L
and in case m <= n, the elements on and below the (n-m)-th subdiagonal contain the m-by-n lower trapezoidal matrix L
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
For more information on the geqlf() functions (i.e. sgeqlf(), dgeqlf(), cgeqlf(), and zgeqlf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QR decomposition of the given dense double precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
jpvt | Auxiliary array for the pivot indices; size = n. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= ![]() |
info | Return code of the function call. |
This function performs the dense matrix QR decomposition of a general m-by-n double precision column-major matrix based on the LAPACK dgeqp3() function. The resulting decomposition has the form
\f[ A = Q \cdot R, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:m)
is stored on exit in A(i+1:m,i)
, and tau
in tau(i)
. Thus on exit the elements on and above the diagonal of the matrix contain the min(m,n)-by-n upper trapezoidal matrix R
(R
is upper triangular if m >= n); the elements below the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the dgeqp3() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QR decomposition of the given dense single precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
jpvt | Auxiliary array for the pivot indices; size = n. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= ![]() |
info | Return code of the function call. |
This function performs the dense matrix QR decomposition of a general m-by-n single precision column-major matrix based on the LAPACK sgeqp3() function. The resulting decomposition has the form
\f[ A = Q \cdot R, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:m)
is stored on exit in A(i+1:m,i)
, and tau
in tau(i)
. Thus on exit the elements on and above the diagonal of the matrix contain the min(m,n)-by-n upper trapezoidal matrix R
(R
is upper triangular if m >= n); the elements below the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgeqp3() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QR decomposition of the given dense double precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QR decomposition of a general m-by-n double precision complex column-major matrix based on the LAPACK zgeqrf() function. The resulting decomposition has the form
\f[ A = Q \cdot R, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:m)
is stored on exit in A(i+1:m,i)
, and tau
in tau(i)
. Thus on exit the elements on and above the diagonal of the matrix contain the min(m,n)-by-n upper trapezoidal matrix R
(R
is upper triangular if m >= n); the elements below the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the zgeqrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QR decomposition of the given dense single precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QR decomposition of a general m-by-n single precision complex column-major matrix based on the LAPACK cgeqrf() function. The resulting decomposition has the form
\f[ A = Q \cdot R, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:m)
is stored on exit in A(i+1:m,i)
, and tau
in tau(i)
. Thus on exit the elements on and above the diagonal of the matrix contain the min(m,n)-by-n upper trapezoidal matrix R
(R
is upper triangular if m >= n); the elements below the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the cgeqrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QR decomposition of the given dense double precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QR decomposition of a general m-by-n double precision column-major matrix based on the LAPACK dgeqrf() function. The resulting decomposition has the form
\f[ A = Q \cdot R, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:m)
is stored on exit in A(i+1:m,i)
, and tau
in tau(i)
. Thus on exit the elements on and above the diagonal of the matrix contain the min(m,n)-by-n upper trapezoidal matrix R
(R
is upper triangular if m >= n); the elements below the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the dgeqrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QR decomposition of the given dense single precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix QR decomposition of a general m-by-n single precision column-major matrix based on the LAPACK sgeqrf() function. The resulting decomposition has the form
\f[ A = Q \cdot R, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:m)
is stored on exit in A(i+1:m,i)
, and tau
in tau(i)
. Thus on exit the elements on and above the diagonal of the matrix contain the min(m,n)-by-n upper trapezoidal matrix R
(R
is upper triangular if m >= n); the elements below the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgeqrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the QR decomposition of the given dense matrix.
A | The matrix to be decomposed. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function performs the dense matrix QR decomposition of a general m-by-n matrix based on the LAPACK geqrf() functions. 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!
In case of a column-major matrix, the resulting decomposition has the form
\f[ A = Q \cdot R, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(0:i-1) = 0
and v(i) = 1
. v(i+1:m)
is stored on exit in A(i+1:m,i)
, and tau
in tau(i)
. Thus on exit the elements on and above the diagonal of the matrix contain the min(m,n)-by-n upper trapezoidal matrix R
(R
is upper triangular if m >= n); the elements below the diagonal, with the array tau
, represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
For more information on the geqrf() functions (i.e. sgeqrf(), dgeqrf(), cgeqrf(), and zgeqrf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the RQ decomposition of the given dense double precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix RQ decomposition of a general m-by-n double precision complex column-major matrix based on the LAPACK zgerqf() function. The resulting decomposition has the form
\f[ A = R \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(n-k+i+1:n) = 0
and v(n-k+i) = 1
. v(1:n-k+i-1)
is stored on exit in A(m-k+i,1:n-k+i-1)
, and tau
in tau(i)
. Thus in case m <= n, the upper triangle of the subarray A(1:m,n-m+1:n) contains the m-by-m upper triangular matrix R
and in case m >= n, the elements on and above the (m-n)-th subdiagonal contain the m-by-n upper trapezoidal matrix R
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the zgerqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the RQ decomposition of the given dense single precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix RQ decomposition of a general m-by-n single precision complex column-major matrix based on the LAPACK cgerqf() function. The resulting decomposition has the form
\f[ A = R \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(n-k+i+1:n) = 0
and v(n-k+i) = 1
. v(1:n-k+i-1)
is stored on exit in A(m-k+i,1:n-k+i-1)
, and tau
in tau(i)
. Thus in case m <= n, the upper triangle of the subarray A(1:m,n-m+1:n) contains the m-by-m upper triangular matrix R
and in case m >= n, the elements on and above the (m-n)-th subdiagonal contain the m-by-n upper trapezoidal matrix R
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the cgerqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the RQ decomposition of the given dense single precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix RQ decomposition of a general m-by-n double precision column-major matrix based on the LAPACK dgerqf() function. The resulting decomposition has the form
\f[ A = R \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(n-k+i+1:n) = 0
and v(n-k+i) = 1
. v(1:n-k+i-1)
is stored on exit in A(m-k+i,1:n-k+i-1)
, and tau
in tau(i)
. Thus in case m <= n, the upper triangle of the subarray A(1:m,n-m+1:n) contains the m-by-m upper triangular matrix R
and in case m >= n, the elements on and above the (m-n)-th subdiagonal contain the m-by-n upper trapezoidal matrix R
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the dgerqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the RQ decomposition of the given dense single precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix RQ decomposition of a general m-by-n single precision column-major matrix based on the LAPACK sgerqf() function. The resulting decomposition has the form
\f[ A = R \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(n-k+i+1:n) = 0
and v(n-k+i) = 1
. v(1:n-k+i-1)
is stored on exit in A(m-k+i,1:n-k+i-1)
, and tau
in tau(i)
. Thus in case m <= n, the upper triangle of the subarray A(1:m,n-m+1:n) contains the m-by-m upper triangular matrix R
and in case m >= n, the elements on and above the (m-n)-th subdiagonal contain the m-by-n upper trapezoidal matrix R
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
The info argument provides feedback on the success of the function call:
For more information on the sgerqf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the RQ decomposition of the given dense matrix.
A | The matrix to be decomposed. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function performs the dense matrix RQ decomposition of a general m-by-n matrix based on the LAPACK gerqf() functions. 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!
In case of a column-major matrix, the resulting decomposition has the form
\f[ A = R \cdot Q, \f]
where the Q
is represented as a product of elementary reflectors
\f[ Q = H(1) H(2) . . . H(k) \texttt{, with k = min(m,n).} \f]
Each H(i) has the form
\f[ H(i) = I - tau \cdot v \cdot v^T, \f]
where tau
is a real scalar, and v
is a real vector with v(n-k+i+1:n) = 0
and v(n-k+i) = 1
. v(1:n-k+i-1)
is stored on exit in A(m-k+i,1:n-k+i-1)
, and tau
in tau(i)
. Thus in case m <= n, the upper triangle of the subarray A(1:m,n-m+1:n) contains the m-by-m upper triangular matrix R
and in case m >= n, the elements on and above the (m-n)-th subdiagonal contain the m-by-n upper trapezoidal matrix R
; the remaining elements in combination with the array tau
represent the orthogonal matrix Q
as a product of min(m,n) elementary reflectors.
For more information on the gerqf() functions (i.e. sgerqf(), dgerqf(), cgerqf(), and zgerqf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LU decomposition of the given dense general double precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
ipiv | Auxiliary array for the pivot indices; size >= min( m, n ). |
info | Return code of the function call. |
This function performs the dense matrix LU decomposition of a general m-by-n double precision complex column-major matrix based on the LAPACK zgetrf() function, which uses partial pivoting with row interchanges. The resulting decomposition has the form
\f[ A = P \cdot L \cdot U, \f]
where P
is a permutation matrix, L
is a lower unitriangular matrix (lower trapezoidal if m > n), and U
is an upper triangular matrix (upper trapezoidal if m < n). The resulting decomposition is stored within the matrix A: L
is stored in the lower part of A and U
is stored in the upper part. The unit diagonal elements of L
are not stored.
The info argument provides feedback on the success of the function call:
For more information on the zgetrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LU decomposition of the given dense general single precision complex column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
ipiv | Auxiliary array for the pivot indices; size >= min( m, n ). |
info | Return code of the function call. |
This function performs the dense matrix LU decomposition of a general m-by-n single precision complex column-major matrix based on the LAPACK cgetrf() function, which uses partial pivoting with row interchanges. The resulting decomposition has the form
\f[ A = P \cdot L \cdot U, \f]
where P
is a permutation matrix, L
is a lower unitriangular matrix (lower trapezoidal if m > n), and U
is an upper triangular matrix (upper trapezoidal if m < n). The resulting decomposition is stored within the matrix A: L
is stored in the lower part of A and U
is stored in the upper part. The unit diagonal elements of L
are not stored.
The info argument provides feedback on the success of the function call:
For more information on the cgetrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LU decomposition of the given dense general double precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
ipiv | Auxiliary array for the pivot indices; size >= min( m, n ). |
info | Return code of the function call. |
This function performs the dense matrix LU decomposition of a general m-by-n double precision column-major matrix based on the LAPACK dgetrf() function, which uses partial pivoting with row interchanges. The resulting decomposition has the form
\f[ A = P \cdot L \cdot U, \f]
where P
is a permutation matrix, L
is a lower unitriangular matrix (lower trapezoidal if m > n), and U
is an upper triangular matrix (upper trapezoidal if m < n). The resulting decomposition is stored within the matrix A: L
is stored in the lower part of A and U
is stored in the upper part. The unit diagonal elements of L
are not stored.
The info argument provides feedback on the success of the function call:
For more information on the dgetrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LU decomposition of the given dense general single precision column-major matrix.
m | The number of rows of the given matrix ![]() |
n | The number of 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 ![]() |
ipiv | Auxiliary array for the pivot indices; size >= min( m, n ). |
info | Return code of the function call. |
This function performs the dense matrix LU decomposition of a general m-by-n single precision column-major matrix based on the LAPACK sgetrf() function, which uses partial pivoting with row interchanges. The resulting decomposition has the form
\f[ A = P \cdot L \cdot U, \f]
where P
is a permutation matrix, L
is a lower unitriangular matrix (lower trapezoidal if m > n), and U
is an upper triangular matrix (upper trapezoidal if m < n). The resulting decomposition is stored within the matrix A: L
is stored in the lower part of A and U
is stored in the upper part. The unit diagonal elements of L
are not stored.
The info argument provides feedback on the success of the function call:
For more information on the sgetrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the LU decomposition of the given dense general matrix.
A | The matrix to be decomposed. |
ipiv | Auxiliary array for the pivot indices; size >= min( m, n ). |
This function performs the dense matrix LU decomposition of a general m-by-n matrix based on the LAPACK getrf()
functions, which use partial pivoting with row/column interchanges. Note that the function only works for general, non-adapted matrices with float
, double
, complex<float>
, or complex<double>
element type. The attempt to call the function with adaptors or matrices of any other element type results in a compile time error!
In case of a column-major matrix, the resulting decomposition has the form
\f[ A = P \cdot L \cdot U, \f]
where L
is a lower unitriangular matrix (lower trapezoidal if m > n), U
is an upper triangular matrix (upper trapezoidal if m < n), and P
is an m-by-m permutation matrix, which represents the pivoting indices for the applied row interchanges.
In case of a row-major matrix, the resulting decomposition has the form
\f[ A = L \cdot U \cdot P, \f]
where P
is an n-by-n permutation matrix, which represents the pivoting indices for the applied column interchanges, L
is a lower triangular matrix (lower trapezoidal if m > n), and U
is an upper unitriangular matrix (upper trapezoidal if m < n).
The resulting decomposition is stored within the matrix A: L
is stored in the lower part of A and U
is stored in the upper part. The unit diagonal elements of L
or U
are not stored.
For more information on the getrf() functions (i.e. sgetrf(), dgetrf(), cgetrf(), and zgetrf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite double precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the Hermitian 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 ![]() |
ipiv | Auxiliary array of size n for the pivot indices. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix decomposition of a Hermitian indefinite double precision column-major matrix based on the LAPACK zhetrf() function, which uses the Bunch-Kaufman diagonal pivoting method. The decomposition has the form
\f[ A = U D U^{H} \texttt{ (if uplo = 'U'), or } A = L D L^{H} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
If the function exits successfully (i.e. info = 0) then the first element of the work array returns the optimal lwork. For optimal performance lwork >= n*NB, where NB is the optimal blocksize returned by the LAPACK function ilaenv(). If lwork = -1 then a workspace query is assumed. The function only calculates the optimal size of the work array and returns this value as the first entry of the work array.
For more information on the zhetrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite single precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the Hermitian 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 ![]() |
ipiv | Auxiliary array of size n for the pivot indices. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix decomposition of a Hermitian indefinite single precision column-major matrix based on the LAPACK chetrf() function, which uses the Bunch-Kaufman diagonal pivoting method. The decomposition has the form
\f[ A = U D U^{H} \texttt{ (if uplo = 'U'), or } A = L D L^{H} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
If the function exits successfully (i.e. info = 0) then the first element of the work array returns the optimal lwork. For optimal performance lwork >= n*NB, where NB is the optimal blocksize returned by the LAPACK function ilaenv(). If lwork = -1 then a workspace query is assumed. The function only calculates the optimal size of the work array and returns this value as the first entry of the work array.
For more information on the chetrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite matrix.
A | The matrix to be decomposed. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
ipiv | Auxiliary array of size n for the pivot indices. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Invalid uplo argument provided. |
This function performs the dense matrix decomposition of a Hermitian indefinite matrix based on the LAPACK hetrf() functions, which use the Bunch-Kaufman diagonal pivoting method. Note that the function only works for general, non-adapted matrices with 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 decomposition has the form
\f[ A = U D U^{H} \texttt{ (if uplo = 'U'), or } A = L D L^{H} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The function fails if ...
'L'
nor 'U'
.In all failure cases a std::invalid_argument exception is thrown.
For more information on the hetrf() functions (i.e. chetrf() and zhetrf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK dorg2l() function for double precision column-major matrices that have already been factorized by the dgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the dorg2l() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK sorg2l() function for single precision column-major matrices that have already been factorized by the sgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the sorg2l() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QL decomposition based on the LAPACK org2l() functions from matrices that have already been QL factorized by the geqlf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 m-by-min(m,n) Q matrix is stored within the given matrix A:
For more information on the org2l() functions (i.e. sorg2l() and dorg2l()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK dorg2r() function for double precision column-major matrices that have already been factorized by the dgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the dorg2r() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK sorg2r() function for single precision column-major matrices that have already been factorized by the sgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the sorg2r() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QR decomposition based on the LAPACK org2r() functions from matrices that have already been QR factorized by the geqrf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 m-by-min(m,n) Q matrix is stored within the given matrix A:
For more information on the org2r() functions (i.e. sorg2r() and dorg2r()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK dorgl2() function for double precision column-major matrices that have already been factorized by the dgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the dorgl2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK sorgl2() function for single precision column-major matrices that have already been factorized by the sgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the sorgl2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a LQ decomposition based on the LAPACK orgl2() functions from matrices that have already been LQ factorized by the gelqf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the orgl2() functions (i.e. sorgl2() and dorgl2()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK dorglq() function for double precision column-major matrices that have already been factorized by the dgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the dorglq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK sorglq() function for single precision column-major matrices that have already been factorized by the sgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the sorglq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a LQ decomposition based on the LAPACK orglq() functions from matrices that have already been LQ factorized by the gelqf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the orglq() functions (i.e. sorglq() and dorglq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK dorgql() function for double precision column-major matrices that have already been factorized by the dgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the dorgql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK sorgql() function for single precision column-major matrices that have already been factorized by the sgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the sorgql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QL decomposition based on the LAPACK orgql() functions from matrices that have already been QL factorized by the geqlf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 m-by-min(m,n) Q matrix is stored within the given matrix A:
For more information on the orgql() functions (i.e. sorgql() and dorgql()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK dorgqr() function for double precision column-major matrices that have already been factorized by the dgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the dorgqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK sorgqr() function for single precision column-major matrices that have already been factorized by the sgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the sorgqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QR decomposition based on the LAPACK orgqr() functions from matrices that have already been QR factorized by the geqrf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 m-by-min(m,n) Q matrix is stored within the given matrix A:
For more information on the orgqr() functions (i.e. sorgqr() and dorgqr()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK dorgr2() function for double precision column-major matrices that have already been factorized by the dgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the dorgr2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK sorgr2() function for single precision column-major matrices that have already been factorized by the sgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the sorgr2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a RQ decomposition based on the LAPACK orgr2() functions from matrices that have already been RQ factorized by the gerqf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the orgr2() functions (i.e. sorgr2() and dorgr2()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK dorgrq() function for double precision column-major matrices that have already been factorized by the dgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the dorgrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK sorgrq() function for single precision column-major matrices that have already been factorized by the sgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the sorgrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a RQ decomposition based on the LAPACK orgrq() functions from matrices that have already been RQ factorized by the gerqf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the orgrq() functions (i.e. sorgrq() and dorgrq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the LQ decomposed double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the LQ decomposition of the sgelqf() function with the given general double precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the dormlq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision Q from a LQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the LQ decomposed single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the LQ decomposition of the sgelqf() function with the given general single precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the sormlq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the LQ decomposition of the gelqf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is larger than the number of columns, a std::invalid_argument exception is thrown. Also Note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the ormlq() function:
The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the ormlq() functions (i.e. sormlq() and dormlq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QL decomposed double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QL decomposition of the sgeqlf() function with the given general double precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the dormql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision Q from a QL decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QL decomposed single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QL decomposition of the sgeqlf() function with the given general single precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the sormql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the QL decomposition of the geqlf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is smaller than the number of columns, a std::invalid_argument exception is thrown. Also note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the ormql() function:
/ The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the ormql() functions (i.e. sormql() and dormql()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QR decomposed double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QR decomposition of the sgeqrf() function with the given general double precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the dormqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision Q from a QR decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QR decomposed single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QR decomposition of the sgeqrf() function with the given general single precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the sormqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the QR decomposition of the geqrf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is larger than the number of columns, a std::invalid_argument exception is thrown. Also Note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the ormqr() function:
The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the ormqr() functions (i.e. sormqr() and dormqr()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the RQ decomposed double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the RQ decomposition of the sgerqf() function with the given general double precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the dormrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision Q from a RQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the RQ decomposed single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the RQ decomposition of the sgerqf() function with the given general single precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the sormrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the RQ decomposition of the gerqf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is smaller than the number of columns, a std::invalid_argument exception is thrown. Also note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the ormrq() function:
The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the ormrq() functions (i.e. sormrq() and dormrq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite double precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric positive definite double precision complex column-major matrix based on the LAPACK zpotrf() function. The decomposition has the form
\f[ A = U^{H} U \texttt{ (if uplo = 'U'), or } A = L L^{H} \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
For more information on the zpotrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite single precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric positive definite single precision complex column-major matrix based on the LAPACK cpotrf() function. The decomposition has the form
\f[ A = U^{H} U \texttt{ (if uplo = 'U'), or } A = L L^{H} \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
For more information on the cpotrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite double precision column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric positive definite double precision column-major matrix based on the LAPACK dpotrf() function. The decomposition has the form
\f[ A = U^{T} U \texttt{ (if uplo = 'U'), or } A = L L^{T} \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
For more information on the dpotrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite single precision column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric positive definite single precision column-major matrix based on the LAPACK spotrf() function. The decomposition has the form
\f[ A = U^{T} U \texttt{ (if uplo = 'U'), or } A = L L^{T} \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
For more information on the spotrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite matrix.
A | The matrix to be decomposed. |
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 | Invalid uplo argument provided. |
std::runtime_error | Decomposition of singular matrix failed. |
This function performs the dense matrix Cholesky decomposition of a symmetric positive definite matrix based on the LAPACK potrf() functions. Note that the function only works 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 decomposition has the form
\f[ A = U^{H} U \texttt{ (if uplo = 'U'), or } A = L L^{H} \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The Cholesky decomposition fails if ...
'L'
nor 'U'
.In all failure cases an exception is thrown.
For more information on the potrf() functions (i.e. spotrf(), dpotrf(), cpotrf(), and zpotrf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite double precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
piv | The pivoting indices applied to A ; size >= n. |
rank | The rank of A given by the number of steps the algorithm completed. |
tol | The user-defined tolerance. |
work | Auxiliary array; size >= ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric semi-positive definite double precision complex column-major matrix based on the LAPACK zpstrf() function. The decomposition has the form
\f[ A = P^T U^{H} U P \texttt{ (if uplo = 'U'), or } A = P L L^{H} P^T \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched. The pivoting matrix is stored as vector in the array piv
such that the nonzero entries are .
The info argument provides feedback on the success of the function call:
For more information on the zpstrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite single precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
piv | The pivoting indices applied to A ; size >= n. |
rank | The rank of A given by the number of steps the algorithm completed. |
tol | The user-defined tolerance. |
work | Auxiliary array; size >= ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric semi-positive definite single precision complex column-major matrix based on the LAPACK cpstrf() function. The decomposition has the form
\f[ A = P^T U^{H} U P \texttt{ (if uplo = 'U'), or } A = P L L^{H} P^T \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched. The pivoting matrix is stored as vector in the array piv
such that the nonzero entries are .
The info argument provides feedback on the success of the function call:
For more information on the cpstrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite double precision column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
piv | The pivoting indices applied to A ; size >= n. |
rank | The rank of A given by the number of steps the algorithm completed. |
tol | The user-defined tolerance. |
work | Auxiliary array; size >= ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric semi-positive definite double precision column-major matrix based on the LAPACK dpstrf() function. The decomposition has the form
\f[ A = P^T U^{H} U P \texttt{ (if uplo = 'U'), or } A = P L L^{H} P^T \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched. The pivoting matrix is stored as vector in the array piv
such that the nonzero entries are .
The info argument provides feedback on the success of the function call:
For more information on the dpstrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the pivoting Cholesky decomposition of the given dense semi-positive definite single precision column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the 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 ![]() |
piv | The pivoting indices applied to A ; size >= n. |
rank | The rank of A given by the number of steps the algorithm completed. |
tol | The user-defined tolerance. |
work | Auxiliary array; size >= ![]() |
info | Return code of the function call. |
This function performs the dense matrix Cholesky decomposition of a symmetric semi-positive definite single precision column-major matrix based on the LAPACK spstrf() function. The decomposition has the form
\f[ A = P^T U^{H} U P \texttt{ (if uplo = 'U'), or } A = P L L^{H} P^T \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched. The pivoting matrix is stored as vector in the array piv
such that the nonzero entries are .
The info argument provides feedback on the success of the function call:
For more information on the spstrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite matrix.
A | The matrix to be decomposed. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
piv | The pivoting indices applied to A |
piv | The pivoting indices applied to A ; size >= n. |
tol | The user-defined tolerance. |
A
given by the number of steps the algorithm completed. std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Invalid uplo argument provided. |
std::runtime_error | Decomposition of singular matrix failed. |
This function performs the dense matrix Cholesky decomposition of a symmetric positive semi-definite n-by-n matrix based on the LAPACK pstrf() functions. Note that the function only works 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 decomposition has the form
\f[ A = P^T U^{H} U P \texttt{ (if uplo = 'U'), or } A = P L L^{H} P^T \texttt{ (if uplo = 'L'), } \f]
where U
is an upper triangular matrix and L
is a lower triangular matrix. The pivoting indices are represented by the pivoting matrix P
. The Cholesky decomposition fails if ...
A
is not a symmetric positive semi-definite matrix;'L'
nor 'U'
.In all failure cases an exception is thrown.
For more information on the pstrf() functions (i.e. spstrf(), dpstrf(), cpstrf(), and zpstrf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense symmetric indefinite double precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the symmetric 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 ![]() |
ipiv | Auxiliary array of size n for the pivot indices. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix decomposition of a symmetric indefinite double precision column-major matrix based on the LAPACK zsytrf() function, which uses the Bunch-Kaufman diagonal pivoting method. The decomposition has the form
\f[ A = U D U^{T} \texttt{ (if uplo = 'U'), or } A = L D L^{T} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
If the function exits successfully (i.e. info = 0) then the first element of the work array returns the optimal lwork. For optimal performance lwork >= n*NB, where NB is the optimal blocksize returned by the LAPACK function ilaenv(). If lwork = -1 then a workspace query is assumed. The function only calculates the optimal size of the work array and returns this value as the first entry of the work array.
For more information on the zsytrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense symmetric indefinite single precision complex column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the symmetric 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 ![]() |
ipiv | Auxiliary array of size n for the pivot indices. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix decomposition of a symmetric indefinite single precision column-major matrix based on the LAPACK csytrf() function, which uses the Bunch-Kaufman diagonal pivoting method. The decomposition has the form
\f[ A = U D U^{T} \texttt{ (if uplo = 'U'), or } A = L D L^{T} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
If the function exits successfully (i.e. info = 0) then the first element of the work array returns the optimal lwork. For optimal performance lwork >= n*NB, where NB is the optimal blocksize returned by the LAPACK function ilaenv(). If lwork = -1 then a workspace query is assumed. The function only calculates the optimal size of the work array and returns this value as the first entry of the work array.
For more information on the csytrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense symmetric indefinite double precision column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the symmetric 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 ![]() |
ipiv | Auxiliary array of size n for the pivot indices. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix decomposition of a symmetric indefinite double precision column-major matrix based on the LAPACK dsytrf() function, which uses the Bunch-Kaufman diagonal pivoting method. The decomposition has the form
\f[ A = U D U^{T} \texttt{ (if uplo = 'U'), or } A = L D L^{T} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
If the function exits successfully (i.e. info = 0) then the first element of the work array returns the optimal lwork. For optimal performance lwork >= n*NB, where NB is the optimal blocksize returned by the LAPACK function ilaenv(). If lwork = -1 then a workspace query is assumed. The function only calculates the optimal size of the work array and returns this value as the first entry of the work array.
For more information on the dsytrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense symmetric indefinite single precision column-major matrix.
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
n | The number of rows/columns of the symmetric 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 ![]() |
ipiv | Auxiliary array of size n for the pivot indices. |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function performs the dense matrix decomposition of a symmetric indefinite single precision column-major matrix based on the LAPACK ssytrf() function, which uses the Bunch-Kaufman diagonal pivoting method. The decomposition has the form
\f[ A = U D U^{T} \texttt{ (if uplo = 'U'), or } A = L D L^{T} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The info argument provides feedback on the success of the function call:
If the function exits successfully (i.e. info = 0) then the first element of the work array returns the optimal lwork. For optimal performance lwork >= n*NB, where NB is the optimal blocksize returned by the LAPACK function ilaenv(). If lwork = -1 then a workspace query is assumed. The function only calculates the optimal size of the work array and returns this value as the first entry of the work array.
For more information on the ssytrf() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the decomposition of the given dense symmetric indefinite matrix.
A | The matrix to be decomposed. |
uplo | 'L' to use the lower part of the matrix, 'U' to use the upper part. |
ipiv | Auxiliary array of size n for the pivot indices. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Invalid uplo argument provided. |
This function performs the dense matrix decomposition of a symmetric indefinite matrix based on the LAPACK sytrf() functions, which use the Bunch-Kaufman diagonal pivoting method. Note that the function only works 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 decomposition has the form
\f[ A = U D U^{T} \texttt{ (if uplo = 'U'), or } A = L D L^{T} \texttt{ (if uplo = 'L'), } \f]
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The resulting decomposition is stored within A: In case uplo is set to 'L'
the result is stored in the lower part of the matrix and the upper part remains untouched, in case uplo is set to 'U'
the result is stored in the upper part and the lower part remains untouched.
The function fails if ...
'L'
nor 'U'
.In all failure cases a std::invalid_argument exception is thrown.
For more information on the sytrf() functions (i.e. ssytrf(), dsytrf(), csytrf(), and zsytrf()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK zung2l() function for double precision column-major matrices that have already been factorized by the dgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the zung2l() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK cung2l() function for single precision column-major matrices that have already been factorized by the sgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the cung2l() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QL decomposition based on the LAPACK ung2l() functions from matrices that have already been QL factorized by the geqlf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the ung2l() functions (i.e. cung2l() and zung2l()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK zung2r() function for double precision complex column-major matrices that have already been factorized by the zgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the zung2r() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == n. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK cung2r() function for single precision complex column-major matrices that have already been factorized by the cgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the cung2r() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QR decomposition based on the LAPACK ung2r() functions from matrices that have already been QR factorized by the geqrf() functions. Note that this function can only be used for general, non-adapted matrices with 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 m-by-min(m,n) Q matrix is stored within the given matrix A:
For more information on the ung2r() functions (i.e. cung2r() and zung2r()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK zungl2() function for double precision complex column-major matrices that have already been factorized by the zgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the zungl2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK cungl2() function for single precision complex column-major matrices that have already been factorized by the cgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the cungl2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a LQ decomposition based on the LAPACK ungl2() functions from matrices that have already been LQ factorized by the gelqf() functions. Note that this function can only be used for general, non-adapted matrices with 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the ungl2() functions (i.e. cungl2() and zungl2()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK zunglq() function for double precision complex column-major matrices that have already been factorized by the zgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the zunglq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a LQ decomposition based on the LAPACK cunglq() function for single precision complex column-major matrices that have already been factorized by the cgelqf() function. The info argument provides feedback on the success of the function call:
For more information on the cunglq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a LQ decomposition based on the LAPACK unglq() functions from matrices that have already been LQ factorized by the gelqf() functions. Note that this function can only be used for general, non-adapted matrices with 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the unglq() functions (i.e. cunglq() and zunglq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK zungql() function for double precision column-major matrices that have already been factorized by the dgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the zungql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QL decomposition based on the LAPACK cungql() function for single precision column-major matrices that have already been factorized by the sgeqlf() function. The info argument provides feedback on the success of the function call:
For more information on the cungql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QL decomposition based on the LAPACK ungql() functions from matrices that have already been QL factorized by the geqlf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the ungql() functions (i.e. cungql() and zungql()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK zungqr() function for double precision complex column-major matrices that have already been factorized by the zgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the zungqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a QR decomposition based on the LAPACK cungqr() function for single precision complex column-major matrices that have already been factorized by the cgeqrf() function. The info argument provides feedback on the success of the function call:
For more information on the cungqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a QR decomposition based on the LAPACK ungqr() functions from matrices that have already been QR factorized by the geqrf() functions. Note that this function can only be used for general, non-adapted matrices with 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 m-by-min(m,n) Q matrix is stored within the given matrix A:
For more information on the ungqr() functions (i.e. cungqr() and zungqr()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK zungr2() function for double precision column-major matrices that have already been factorized by the dgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the zungr2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size == m. |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK cungr2() function for single precision column-major matrices that have already been factorized by the sgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the cungr2() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a RQ decomposition based on the LAPACK ungr2() functions from matrices that have already been RQ factorized by the gerqf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the ungr2() functions (i.e. cungr2() and zungr2()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK zungrq() function for double precision column-major matrices that have already been factorized by the dgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the zungrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
m | The number of rows of the given matrix ![]() |
n | The number of columns of the given matrix ![]() |
k | The number of elementary reflectors, whose product defines the 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 ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work; size >= max( 1, n ). |
info | Return code of the function call. |
This function generates all or part of the orthogonal matrix Q from a RQ decomposition based on the LAPACK cungrq() function for single precision column-major matrices that have already been factorized by the sgerqf() function. The info argument provides feedback on the success of the function call:
For more information on the cungrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition.
A | The decomposed matrix. |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
This function reconstructs the orthogonal matrix Q of a RQ decomposition based on the LAPACK ungrq() functions from matrices that have already been RQ factorized by the gerqf() functions. Note that this function can only be used for general, non-adapted matrices with float
or 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 min(m,n)-by-n Q matrix is stored within the given matrix A:
For more information on the ungrq() functions (i.e. cungrq() and zungrq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision complex Q from a LQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the LQ decomposed double precision complex column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision complex column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the LQ decomposition of the sgelqf() function with the given general double precision complex m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the zunmlq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision complex Q from a LQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the LQ decomposed single precision complex column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision complex column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the LQ decomposition of the sgelqf() function with the given general single precision complex m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the cunmlq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the LQ decomposition of the gelqf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is larger than the number of columns, a std::invalid_argument exception is thrown. Also Note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the unmlq() function:
The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the unmlq() functions (i.e. sunmlq() and dunmlq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QL decomposed double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QL decomposition of the sgeqlf() function with the given general double precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the zunmql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision Q from a QL decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QL decomposed single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QL decomposition of the sgeqlf() function with the given general single precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the cunmql() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the QL decomposition of the geqlf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is smaller than the number of columns, a std::invalid_argument exception is thrown. Also note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the unmql() function:
The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the unmql() functions (i.e. cunmql() and zunmql()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QR decomposed double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QR decomposition of the sgeqrf() function with the given general double precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the zunmqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision Q from a QR decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the QR decomposed single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the QR decomposition of the sgeqrf() function with the given general single precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the cunmqr() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the QR decomposition of the geqrf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is larger than the number of columns, a std::invalid_argument exception is thrown. Also Note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the unmqr() function:
The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the unmqr() functions (i.e. cunmqr() and zunmqr()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the RQ decomposed double precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the double precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the RQ decomposition of the sgerqf() function with the given general double precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the zunmrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the single precision Q from a RQ decomposition with another matrix.
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'C' for ![]() |
m | The number of rows of the matrix C ![]() |
n | The number of columns of the matrix C ![]() |
k | The number of elementary reflectors, whose product defines the matrix Q. |
A | Pointer to the first element of the RQ decomposed single precision column-major matrix. |
lda | The total number of elements between two columns of the matrix A ![]() |
tau | Array for the scalar factors of the elementary reflectors; size >= min( m, n ). |
C | Pointer to the first element of the single precision column-major matrix multiplicator. |
ldc | The total number of elements between two columns of the matrix C ![]() |
work | Auxiliary array; size >= max( 1, lwork ). |
lwork | The dimension of the array work. |
info | Return code of the function call. |
This function multiplies the Q matrix resulting from the RQ decomposition of the sgerqf() function with the given general single precision m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
In case side is specified as 'L'
, the Q matrix is expected to be of size m-by-m, in case side is set to 'R'
, Q is expected to be of size n-by-n.
The info argument provides feedback on the success of the function call:
For more information on the cunmrq() function, see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/
|
inline |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix.
C | The matrix multiplier. |
A | The decomposed matrix. |
side | 'L' to apply ![]() ![]() 'R' to apply from the right. |
trans | 'N' for ![]() 'T' for ![]() |
tau | Array for the scalar factors of the elementary reflectors. |
std::invalid_argument | Invalid size of Q matrix. |
std::invalid_argument | Invalid side argument provided. |
std::invalid_argument | Invalid trans argument provided. |
This function multiplies a square Q matrix resulting from the RQ decomposition of the gerqf() functions with the given general m-by-n matrix C. Depending on the settings of side and trans it overwrites C with
Note that the size of matrix C
is preserved, which means that the function does not work for non-square Q matrices. Therefore in case the number of rows of A is smaller than the number of columns, a std::invalid_argument exception is thrown. Also note that this function can only be used for general, non-adapted matrices with float
or 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 following code example demonstrates the use of the unmrq() function:
The function fails if ...
'L'
nor 'R'
;'N'
nor 'T'
.In all failure cases an exception is thrown.
For more information on the unmrq() functions (i.e. cunmrq() and zunmrq()) see the LAPACK online documentation browser:
http://www.netlib.org/lapack/explore-html/