ViennaCL - The Vienna Computing Library
1.5.1
|
Namespace holding implementation details for linear algebra routines. Usually not of interest for a library user. More...
Namespaces | |
namespace | amg |
Implementation namespace for algebraic multigrid preconditioner. | |
namespace | spai |
Implementation namespace for sparse approximate inverse preconditioner. | |
Data Structures | |
class | ilu_vector_range |
Helper range class for representing a subvector of a larger buffer. More... | |
struct | op_applier |
Worker class for decomposing expression templates. More... | |
struct | op_executor |
Worker class for decomposing expression templates. More... | |
class | FastMatrix |
Internal helper class representing a row-major dense matrix used for the QR method for the purpose of computing eigenvalues. More... | |
Enumerations | |
enum | row_info_types { SPARSE_ROW_NORM_INF = 0, SPARSE_ROW_NORM_1, SPARSE_ROW_NORM_2, SPARSE_ROW_DIAGONAL } |
Functions | |
template<typename T , typename OtherVectorType > | |
void | copy_vec_to_vec (viennacl::vector< T > const &src, OtherVectorType &dest) |
overloaded function for copying vectors | |
template<typename OtherVectorType , typename T > | |
void | copy_vec_to_vec (OtherVectorType const &src, viennacl::vector< T > &dest) |
template<typename VectorType1 , typename VectorType2 > | |
void | copy_vec_to_vec (VectorType1 const &src, VectorType2 &dest) |
template<typename ScalarType > | |
void | extract_block_matrix (viennacl::compressed_matrix< ScalarType > const &A, viennacl::compressed_matrix< ScalarType > &diagonal_block_A, vcl_size_t start_index, vcl_size_t stop_index) |
Extracts a diagonal block from a larger system matrix. | |
template<typename ScalarType , unsigned int ALIGNMENT> | |
void | level_scheduling_setup_impl (viennacl::compressed_matrix< ScalarType, ALIGNMENT > const &LU, vector< ScalarType > const &diagonal_LU, std::list< viennacl::backend::mem_handle > &row_index_arrays, std::list< viennacl::backend::mem_handle > &row_buffers, std::list< viennacl::backend::mem_handle > &col_buffers, std::list< viennacl::backend::mem_handle > &element_buffers, std::list< vcl_size_t > &row_elimination_num_list, bool setup_U) |
template<typename ScalarType , unsigned int ALIGNMENT> | |
void | level_scheduling_setup_L (viennacl::compressed_matrix< ScalarType, ALIGNMENT > const &LU, vector< ScalarType > const &diagonal_LU, std::list< viennacl::backend::mem_handle > &row_index_arrays, std::list< viennacl::backend::mem_handle > &row_buffers, std::list< viennacl::backend::mem_handle > &col_buffers, std::list< viennacl::backend::mem_handle > &element_buffers, std::list< vcl_size_t > &row_elimination_num_list) |
template<typename ScalarType , unsigned int ALIGNMENT> | |
void | level_scheduling_setup_U (viennacl::compressed_matrix< ScalarType, ALIGNMENT > const &LU, vector< ScalarType > const &diagonal_LU, std::list< viennacl::backend::mem_handle > &row_index_arrays, std::list< viennacl::backend::mem_handle > &row_buffers, std::list< viennacl::backend::mem_handle > &col_buffers, std::list< viennacl::backend::mem_handle > &element_buffers, std::list< vcl_size_t > &row_elimination_num_list) |
template<typename ScalarType > | |
void | level_scheduling_substitute (vector< ScalarType > &vec, std::list< viennacl::backend::mem_handle > const &row_index_arrays, std::list< viennacl::backend::mem_handle > const &row_buffers, std::list< viennacl::backend::mem_handle > const &col_buffers, std::list< viennacl::backend::mem_handle > const &element_buffers, std::list< vcl_size_t > const &row_elimination_num_list) |
template<typename T , typename B > | |
bool | op_aliasing (vector_base< T > const &, B const &) |
template<typename T > | |
bool | op_aliasing (vector_base< T > const &lhs, vector_base< T > const &b) |
template<typename T , typename LHS , typename RHS , typename OP > | |
bool | op_aliasing (vector_base< T > const &lhs, vector_expression< const LHS, const RHS, OP > const &rhs) |
template<typename T , typename F , typename B > | |
bool | op_aliasing (matrix_base< T, F > const &, B const &) |
template<typename T , typename F > | |
bool | op_aliasing (matrix_base< T, F > const &lhs, matrix_base< T, F > const &b) |
template<typename T , typename F , typename LHS , typename RHS , typename OP > | |
bool | op_aliasing (matrix_base< T, F > const &lhs, matrix_expression< const LHS, const RHS, OP > const &rhs) |
template<typename SRC_VECTOR , typename DEST_VECTOR > | |
void | gmres_copy_helper (SRC_VECTOR const &src, DEST_VECTOR &dest, vcl_size_t len, vcl_size_t start=0) |
template<typename ScalarType , typename DEST_VECTOR > | |
void | gmres_copy_helper (viennacl::vector< ScalarType > const &src, DEST_VECTOR &dest, vcl_size_t len, vcl_size_t start=0) |
template<typename VectorType , typename ScalarType > | |
void | gmres_setup_householder_vector (VectorType const &input_vec, VectorType &hh_vec, ScalarType &beta, ScalarType &mu, vcl_size_t j) |
Computes the householder vector 'hh_vec' which rotates 'input_vec' such that all entries below the j-th entry of 'v' become zero. | |
template<typename VectorType , typename ScalarType > | |
void | gmres_householder_reflect (VectorType &x, VectorType const &h, ScalarType beta) |
template<typename MatrixT , typename VectorT > | |
std::vector< typename viennacl::result_of::cpu_value_type < typename MatrixT::value_type > ::type > | lanczosPRO (MatrixT const &A, VectorT &r, vcl_size_t size, lanczos_tag const &tag) |
Implementation of the Lanczos PRO algorithm. | |
template<typename MatrixT , typename VectorT > | |
std::vector< typename viennacl::result_of::cpu_value_type < typename MatrixT::value_type > ::type > | lanczos (MatrixT const &A, VectorT &r, vcl_size_t size, lanczos_tag) |
Implementation of the lanczos algorithm without reorthogonalization. | |
template<typename MatrixT , typename VectorT > | |
std::vector< typename viennacl::result_of::cpu_value_type < typename MatrixT::value_type > ::type > | lanczosFRO (MatrixT const &A, VectorT &r, vcl_size_t size, lanczos_tag) |
Implementation of the Lanczos FRO algorithm. | |
template<typename ScalarType > | |
void | level_scheduling_substitute (vector< ScalarType > &vec, viennacl::backend::mem_handle const &row_index_array, viennacl::backend::mem_handle const &row_buffer, viennacl::backend::mem_handle const &col_buffer, viennacl::backend::mem_handle const &element_buffer, vcl_size_t num_rows) |
template<typename SCALARTYPE > | |
SCALARTYPE | pythag (SCALARTYPE a, SCALARTYPE b) |
template<typename SCALARTYPE > | |
SCALARTYPE | sign (SCALARTYPE val) |
template<typename VectorType > | |
VectorType::value_type | norm_lcl (VectorType const &x, vcl_size_t size) |
template<typename VectorType > | |
void | normalize (VectorType &x, vcl_size_t size) |
template<typename VectorType > | |
void | householder_vector (VectorType &v, vcl_size_t start) |
template<typename MatrixType > | |
void | transpose (MatrixType &A) |
template<typename T > | |
void | cdiv (T xr, T xi, T yr, T yi, T &cdivr, T &cdivi) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
void | copy_vec (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &A, viennacl::vector< SCALARTYPE, ALIGNMENT > &V, vcl_size_t row_start, vcl_size_t col_start, bool copy_col) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
void | prepare_householder_vector (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &A, viennacl::vector< SCALARTYPE, ALIGNMENT > &D, vcl_size_t size, vcl_size_t row_start, vcl_size_t col_start, vcl_size_t start, bool is_column) |
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename VectorType > | |
void | bidiag_pack (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &A, VectorType &dh, VectorType &sh) |
template<typename MatrixType , typename VectorType > | |
void | givens_next (MatrixType &matrix, VectorType &tmp1, VectorType &tmp2, int l, int m) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
void | tql2 (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &Q, boost::numeric::ublas::vector< SCALARTYPE > &d, boost::numeric::ublas::vector< SCALARTYPE > &e) |
template<typename SCALARTYPE , typename MatrixT > | |
void | final_iter_update_gpu (MatrixT &A, int n, int last_n, SCALARTYPE q, SCALARTYPE p) |
template<typename SCALARTYPE , typename MatrixT > | |
void | update_float_QR_column_gpu (MatrixT &A, const std::vector< SCALARTYPE > &buf, viennacl::vector< SCALARTYPE > &buf_vcl, int m, int n, int last_n, bool) |
template<typename SCALARTYPE , typename MatrixT > | |
void | final_iter_update (MatrixT &A, int n, int last_n, SCALARTYPE q, SCALARTYPE p) |
template<typename SCALARTYPE , typename MatrixT > | |
void | update_float_QR_column (MatrixT &A, const std::vector< SCALARTYPE > &buf, int m, int n, int last_i, bool is_triangular) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
void | hqr2 (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &vcl_H, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &V, boost::numeric::ublas::vector< SCALARTYPE > &d, boost::numeric::ublas::vector< SCALARTYPE > &e) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
bool | householder_twoside (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &A, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &Q, viennacl::vector< SCALARTYPE, ALIGNMENT > &D, vcl_size_t start) |
template<typename SCALARTYPE , typename F , unsigned int ALIGNMENT> | |
void | tridiagonal_reduction (viennacl::matrix< SCALARTYPE, F, ALIGNMENT > &A, viennacl::matrix< SCALARTYPE, F, ALIGNMENT > &Q) |
template<typename SCALARTYPE , typename F , unsigned int ALIGNMENT> | |
void | qr_method (viennacl::matrix< SCALARTYPE, F, ALIGNMENT > &A, viennacl::matrix< SCALARTYPE, F, ALIGNMENT > &Q, boost::numeric::ublas::vector< SCALARTYPE > &D, boost::numeric::ublas::vector< SCALARTYPE > &E, bool is_symmetric=true) |
template<typename MatrixType , typename VectorType > | |
MatrixType::value_type | setup_householder_vector_ublas (MatrixType const &A, VectorType &v, MatrixType &matrix_1x1, vcl_size_t j) |
template<typename MatrixType , typename VectorType > | |
viennacl::result_of::cpu_value_type < typename MatrixType::value_type >::type | setup_householder_vector_viennacl (MatrixType const &A, VectorType &v, MatrixType &matrix_1x1, vcl_size_t j) |
template<typename MatrixType , typename VectorType , typename ScalarType > | |
void | householder_reflect (MatrixType &A, VectorType &v, ScalarType beta, vcl_size_t j, vcl_size_t k) |
template<typename MatrixType , typename VectorType , typename ScalarType > | |
void | householder_reflect_ublas (MatrixType &A, VectorType &v, MatrixType &matrix_1x1, ScalarType beta, vcl_size_t j, vcl_size_t k) |
template<typename MatrixType , typename VectorType , typename ScalarType > | |
void | householder_reflect_viennacl (MatrixType &A, VectorType &v, MatrixType &matrix_1x1, ScalarType beta, vcl_size_t j, vcl_size_t k) |
template<typename MatrixType , typename VectorType , typename ScalarType > | |
void | householder_reflect (MatrixType &A, VectorType &v, ScalarType beta, vcl_size_t j) |
template<typename MatrixType , typename VectorType > | |
void | write_householder_to_A (MatrixType &A, VectorType const &v, vcl_size_t j) |
template<typename MatrixType , typename VectorType > | |
void | write_householder_to_A_ublas (MatrixType &A, VectorType const &v, vcl_size_t j) |
template<typename MatrixType , typename VectorType > | |
void | write_householder_to_A_viennacl (MatrixType &A, VectorType const &v, vcl_size_t j) |
template<typename MatrixType > | |
std::vector< typename MatrixType::value_type > | inplace_qr_ublas (MatrixType &A, vcl_size_t block_size=32) |
Implementation of inplace-QR factorization for a general Boost.uBLAS compatible matrix A. | |
template<typename MatrixType > | |
std::vector< typename viennacl::result_of::cpu_value_type < typename MatrixType::value_type >::type > | inplace_qr_viennacl (MatrixType &A, vcl_size_t block_size=16) |
Implementation of a OpenCL-only QR factorization for GPUs (or multi-core CPU). DEPRECATED! Use only if you're curious and interested in playing a bit with a GPU-only implementation. | |
template<typename MatrixType > | |
std::vector< typename viennacl::result_of::cpu_value_type < typename MatrixType::value_type >::type > | inplace_qr_hybrid (MatrixType &A, vcl_size_t block_size=16) |
Implementation of a hybrid QR factorization using uBLAS on the CPU and ViennaCL for GPUs (or multi-core CPU) | |
template<typename SparseMatrixType , typename SCALARTYPE , unsigned int VEC_ALIGNMENT> | |
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value > ::type | row_info (SparseMatrixType const &mat, vector< SCALARTYPE, VEC_ALIGNMENT > &vec, row_info_types info_selector) |
template<typename SparseMatrixType , class ScalarType , typename SOLVERTAG > | |
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value > ::type | block_inplace_solve (const matrix_expression< const SparseMatrixType, const SparseMatrixType, op_trans > &mat, viennacl::backend::mem_handle const &block_index_array, vcl_size_t num_blocks, viennacl::vector_base< ScalarType > const &mat_diagonal, viennacl::vector_base< ScalarType > &vec, SOLVERTAG tag) |
template<typename MatrixType , typename VectorType > | |
void | givens_prev (MatrixType &matrix, VectorType &tmp1, VectorType &tmp2, int n, int l, int k) |
template<typename MatrixType , typename VectorType > | |
void | change_signs (MatrixType &matrix, VectorType &signs, int n) |
template<typename MatrixType , typename CPU_VectorType > | |
void | svd_qr_shift (MatrixType &vcl_u, MatrixType &vcl_v, CPU_VectorType &q, CPU_VectorType &e) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
bool | householder_c (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &A, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &Q, viennacl::vector< SCALARTYPE, ALIGNMENT > &D, vcl_size_t row_start, vcl_size_t col_start) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
bool | householder_r (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &A, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &Q, viennacl::vector< SCALARTYPE, ALIGNMENT > &D, vcl_size_t row_start, vcl_size_t col_start) |
template<typename SCALARTYPE , unsigned int ALIGNMENT> | |
void | bidiag (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &Ai, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &QL, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &QR) |
Namespace holding implementation details for linear algebra routines. Usually not of interest for a library user.
enum row_info_types |
void viennacl::linalg::detail::bidiag | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | Ai, |
viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | QL, | ||
viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | QR | ||
) |
void viennacl::linalg::detail::bidiag_pack | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | A, |
VectorType & | dh, | ||
VectorType & | sh | ||
) |
viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value>::type viennacl::linalg::detail::block_inplace_solve | ( | const matrix_expression< const SparseMatrixType, const SparseMatrixType, op_trans > & | mat, |
viennacl::backend::mem_handle const & | block_index_array, | ||
vcl_size_t | num_blocks, | ||
viennacl::vector_base< ScalarType > const & | mat_diagonal, | ||
viennacl::vector_base< ScalarType > & | vec, | ||
SOLVERTAG | tag | ||
) |
void viennacl::linalg::detail::cdiv | ( | T | xr, |
T | xi, | ||
T | yr, | ||
T | yi, | ||
T & | cdivr, | ||
T & | cdivi | ||
) |
void viennacl::linalg::detail::change_signs | ( | MatrixType & | matrix, |
VectorType & | signs, | ||
int | n | ||
) |
void viennacl::linalg::detail::copy_vec | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | A, |
viennacl::vector< SCALARTYPE, ALIGNMENT > & | V, | ||
vcl_size_t | row_start, | ||
vcl_size_t | col_start, | ||
bool | copy_col | ||
) |
void viennacl::linalg::detail::copy_vec_to_vec | ( | viennacl::vector< T > const & | src, |
OtherVectorType & | dest | ||
) |
overloaded function for copying vectors
void viennacl::linalg::detail::copy_vec_to_vec | ( | OtherVectorType const & | src, |
viennacl::vector< T > & | dest | ||
) |
void viennacl::linalg::detail::copy_vec_to_vec | ( | VectorType1 const & | src, |
VectorType2 & | dest | ||
) |
void viennacl::linalg::detail::extract_block_matrix | ( | viennacl::compressed_matrix< ScalarType > const & | A, |
viennacl::compressed_matrix< ScalarType > & | diagonal_block_A, | ||
vcl_size_t | start_index, | ||
vcl_size_t | stop_index | ||
) |
Extracts a diagonal block from a larger system matrix.
A | The full matrix |
diagonal_block_A | The output matrix, to which the extracted block is written to |
start_index | First row- and column-index of the block |
stop_index | First row- and column-index beyond the block |
void viennacl::linalg::detail::final_iter_update | ( | MatrixT & | A, |
int | n, | ||
int | last_n, | ||
SCALARTYPE | q, | ||
SCALARTYPE | p | ||
) |
void viennacl::linalg::detail::final_iter_update_gpu | ( | MatrixT & | A, |
int | n, | ||
int | last_n, | ||
SCALARTYPE | q, | ||
SCALARTYPE | p | ||
) |
void viennacl::linalg::detail::givens_next | ( | MatrixType & | matrix, |
VectorType & | tmp1, | ||
VectorType & | tmp2, | ||
int | l, | ||
int | m | ||
) |
void viennacl::linalg::detail::givens_prev | ( | MatrixType & | matrix, |
VectorType & | tmp1, | ||
VectorType & | tmp2, | ||
int | n, | ||
int | l, | ||
int | k | ||
) |
void viennacl::linalg::detail::gmres_copy_helper | ( | SRC_VECTOR const & | src, |
DEST_VECTOR & | dest, | ||
vcl_size_t | len, | ||
vcl_size_t | start = 0 |
||
) |
void viennacl::linalg::detail::gmres_copy_helper | ( | viennacl::vector< ScalarType > const & | src, |
DEST_VECTOR & | dest, | ||
vcl_size_t | len, | ||
vcl_size_t | start = 0 |
||
) |
void viennacl::linalg::detail::gmres_householder_reflect | ( | VectorType & | x, |
VectorType const & | h, | ||
ScalarType | beta | ||
) |
void viennacl::linalg::detail::gmres_setup_householder_vector | ( | VectorType const & | input_vec, |
VectorType & | hh_vec, | ||
ScalarType & | beta, | ||
ScalarType & | mu, | ||
vcl_size_t | j | ||
) |
Computes the householder vector 'hh_vec' which rotates 'input_vec' such that all entries below the j-th entry of 'v' become zero.
input_vec | The input vector |
hh_vec | The householder vector defining the relection (I - beta * hh_vec * hh_vec^T) |
beta | The coefficient beta in (I - beta * hh_vec * hh_vec^T) |
mu | The norm of the input vector part relevant for the reflection: norm_2(input_vec[j:size]) |
j | Index of the last nonzero index in 'input_vec' after applying the reflection |
bool viennacl::linalg::detail::householder_c | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | A, |
viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | Q, | ||
viennacl::vector< SCALARTYPE, ALIGNMENT > & | D, | ||
vcl_size_t | row_start, | ||
vcl_size_t | col_start | ||
) |
bool viennacl::linalg::detail::householder_r | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | A, |
viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | Q, | ||
viennacl::vector< SCALARTYPE, ALIGNMENT > & | D, | ||
vcl_size_t | row_start, | ||
vcl_size_t | col_start | ||
) |
void viennacl::linalg::detail::householder_reflect | ( | MatrixType & | A, |
VectorType & | v, | ||
ScalarType | beta, | ||
vcl_size_t | j, | ||
vcl_size_t | k | ||
) |
void viennacl::linalg::detail::householder_reflect | ( | MatrixType & | A, |
VectorType & | v, | ||
ScalarType | beta, | ||
vcl_size_t | j | ||
) |
void viennacl::linalg::detail::householder_reflect_ublas | ( | MatrixType & | A, |
VectorType & | v, | ||
MatrixType & | matrix_1x1, | ||
ScalarType | beta, | ||
vcl_size_t | j, | ||
vcl_size_t | k | ||
) |
void viennacl::linalg::detail::householder_reflect_viennacl | ( | MatrixType & | A, |
VectorType & | v, | ||
MatrixType & | matrix_1x1, | ||
ScalarType | beta, | ||
vcl_size_t | j, | ||
vcl_size_t | k | ||
) |
bool viennacl::linalg::detail::householder_twoside | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | A, |
viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | Q, | ||
viennacl::vector< SCALARTYPE, ALIGNMENT > & | D, | ||
vcl_size_t | start | ||
) |
void viennacl::linalg::detail::householder_vector | ( | VectorType & | v, |
vcl_size_t | start | ||
) |
void viennacl::linalg::detail::hqr2 | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | vcl_H, |
viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | V, | ||
boost::numeric::ublas::vector< SCALARTYPE > & | d, | ||
boost::numeric::ublas::vector< SCALARTYPE > & | e | ||
) |
std::vector< typename viennacl::result_of::cpu_value_type< typename MatrixType::value_type >::type > viennacl::linalg::detail::inplace_qr_hybrid | ( | MatrixType & | A, |
vcl_size_t | block_size = 16 |
||
) |
Implementation of a hybrid QR factorization using uBLAS on the CPU and ViennaCL for GPUs (or multi-core CPU)
Prefer the use of the convenience interface inplace_qr()
A | A dense ViennaCL matrix to be factored |
block_size | The block size to be used. The number of columns of A must be a multiple of block_size |
std::vector<typename MatrixType::value_type> viennacl::linalg::detail::inplace_qr_ublas | ( | MatrixType & | A, |
vcl_size_t | block_size = 32 |
||
) |
Implementation of inplace-QR factorization for a general Boost.uBLAS compatible matrix A.
A | A dense compatible to Boost.uBLAS |
block_size | The block size to be used. The number of columns of A must be a multiple of block_size |
std::vector< typename viennacl::result_of::cpu_value_type< typename MatrixType::value_type >::type > viennacl::linalg::detail::inplace_qr_viennacl | ( | MatrixType & | A, |
vcl_size_t | block_size = 16 |
||
) |
Implementation of a OpenCL-only QR factorization for GPUs (or multi-core CPU). DEPRECATED! Use only if you're curious and interested in playing a bit with a GPU-only implementation.
Performance is rather poor at small matrix sizes. Prefer the use of the hybrid version, which is automatically chosen using the interface function inplace_qr()
A | A dense ViennaCL matrix to be factored |
block_size | The block size to be used. The number of columns of A must be a multiple of block_size |
std::vector< typename viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type > viennacl::linalg::detail::lanczos | ( | MatrixT const & | A, |
VectorT & | r, | ||
vcl_size_t | size, | ||
lanczos_tag | |||
) |
Implementation of the lanczos algorithm without reorthogonalization.
A | The system matrix |
r | Random start vector |
size | Size of krylov-space |
std::vector< typename viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type > viennacl::linalg::detail::lanczosFRO | ( | MatrixT const & | A, |
VectorT & | r, | ||
vcl_size_t | size, | ||
lanczos_tag | |||
) |
Implementation of the Lanczos FRO algorithm.
A | The system matrix |
r | Random start vector |
size | Size of krylov-space |
std::vector< typename viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type > viennacl::linalg::detail::lanczosPRO | ( | MatrixT const & | A, |
VectorT & | r, | ||
vcl_size_t | size, | ||
lanczos_tag const & | tag | ||
) |
Implementation of the Lanczos PRO algorithm.
A | The system matrix |
r | Random start vector |
size | Size of krylov-space |
tag | Lanczos_tag with several options for the algorithm |
void viennacl::linalg::detail::level_scheduling_setup_impl | ( | viennacl::compressed_matrix< ScalarType, ALIGNMENT > const & | LU, |
vector< ScalarType > const & | diagonal_LU, | ||
std::list< viennacl::backend::mem_handle > & | row_index_arrays, | ||
std::list< viennacl::backend::mem_handle > & | row_buffers, | ||
std::list< viennacl::backend::mem_handle > & | col_buffers, | ||
std::list< viennacl::backend::mem_handle > & | element_buffers, | ||
std::list< vcl_size_t > & | row_elimination_num_list, | ||
bool | setup_U | ||
) |
void viennacl::linalg::detail::level_scheduling_setup_L | ( | viennacl::compressed_matrix< ScalarType, ALIGNMENT > const & | LU, |
vector< ScalarType > const & | diagonal_LU, | ||
std::list< viennacl::backend::mem_handle > & | row_index_arrays, | ||
std::list< viennacl::backend::mem_handle > & | row_buffers, | ||
std::list< viennacl::backend::mem_handle > & | col_buffers, | ||
std::list< viennacl::backend::mem_handle > & | element_buffers, | ||
std::list< vcl_size_t > & | row_elimination_num_list | ||
) |
void viennacl::linalg::detail::level_scheduling_setup_U | ( | viennacl::compressed_matrix< ScalarType, ALIGNMENT > const & | LU, |
vector< ScalarType > const & | diagonal_LU, | ||
std::list< viennacl::backend::mem_handle > & | row_index_arrays, | ||
std::list< viennacl::backend::mem_handle > & | row_buffers, | ||
std::list< viennacl::backend::mem_handle > & | col_buffers, | ||
std::list< viennacl::backend::mem_handle > & | element_buffers, | ||
std::list< vcl_size_t > & | row_elimination_num_list | ||
) |
void viennacl::linalg::detail::level_scheduling_substitute | ( | vector< ScalarType > & | vec, |
viennacl::backend::mem_handle const & | row_index_array, | ||
viennacl::backend::mem_handle const & | row_buffer, | ||
viennacl::backend::mem_handle const & | col_buffer, | ||
viennacl::backend::mem_handle const & | element_buffer, | ||
vcl_size_t | num_rows | ||
) |
void viennacl::linalg::detail::level_scheduling_substitute | ( | vector< ScalarType > & | vec, |
std::list< viennacl::backend::mem_handle > const & | row_index_arrays, | ||
std::list< viennacl::backend::mem_handle > const & | row_buffers, | ||
std::list< viennacl::backend::mem_handle > const & | col_buffers, | ||
std::list< viennacl::backend::mem_handle > const & | element_buffers, | ||
std::list< vcl_size_t > const & | row_elimination_num_list | ||
) |
VectorType::value_type viennacl::linalg::detail::norm_lcl | ( | VectorType const & | x, |
vcl_size_t | size | ||
) |
void viennacl::linalg::detail::normalize | ( | VectorType & | x, |
vcl_size_t | size | ||
) |
bool viennacl::linalg::detail::op_aliasing | ( | vector_base< T > const & | , |
B const & | |||
) |
bool viennacl::linalg::detail::op_aliasing | ( | vector_base< T > const & | lhs, |
vector_base< T > const & | b | ||
) |
bool viennacl::linalg::detail::op_aliasing | ( | vector_base< T > const & | lhs, |
vector_expression< const LHS, const RHS, OP > const & | rhs | ||
) |
bool viennacl::linalg::detail::op_aliasing | ( | matrix_base< T, F > const & | , |
B const & | |||
) |
bool viennacl::linalg::detail::op_aliasing | ( | matrix_base< T, F > const & | lhs, |
matrix_base< T, F > const & | b | ||
) |
bool viennacl::linalg::detail::op_aliasing | ( | matrix_base< T, F > const & | lhs, |
matrix_expression< const LHS, const RHS, OP > const & | rhs | ||
) |
void viennacl::linalg::detail::prepare_householder_vector | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | A, |
viennacl::vector< SCALARTYPE, ALIGNMENT > & | D, | ||
vcl_size_t | size, | ||
vcl_size_t | row_start, | ||
vcl_size_t | col_start, | ||
vcl_size_t | start, | ||
bool | is_column | ||
) |
SCALARTYPE viennacl::linalg::detail::pythag | ( | SCALARTYPE | a, |
SCALARTYPE | b | ||
) |
void viennacl::linalg::detail::qr_method | ( | viennacl::matrix< SCALARTYPE, F, ALIGNMENT > & | A, |
viennacl::matrix< SCALARTYPE, F, ALIGNMENT > & | Q, | ||
boost::numeric::ublas::vector< SCALARTYPE > & | D, | ||
boost::numeric::ublas::vector< SCALARTYPE > & | E, | ||
bool | is_symmetric = true |
||
) |
viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value >::type viennacl::linalg::detail::row_info | ( | SparseMatrixType const & | mat, |
vector< SCALARTYPE, VEC_ALIGNMENT > & | vec, | ||
row_info_types | info_selector | ||
) |
MatrixType::value_type viennacl::linalg::detail::setup_householder_vector_ublas | ( | MatrixType const & | A, |
VectorType & | v, | ||
MatrixType & | matrix_1x1, | ||
vcl_size_t | j | ||
) |
viennacl::result_of::cpu_value_type< typename MatrixType::value_type >::type viennacl::linalg::detail::setup_householder_vector_viennacl | ( | MatrixType const & | A, |
VectorType & | v, | ||
MatrixType & | matrix_1x1, | ||
vcl_size_t | j | ||
) |
SCALARTYPE viennacl::linalg::detail::sign | ( | SCALARTYPE | val | ) |
void viennacl::linalg::detail::svd_qr_shift | ( | MatrixType & | vcl_u, |
MatrixType & | vcl_v, | ||
CPU_VectorType & | q, | ||
CPU_VectorType & | e | ||
) |
void viennacl::linalg::detail::tql2 | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | Q, |
boost::numeric::ublas::vector< SCALARTYPE > & | d, | ||
boost::numeric::ublas::vector< SCALARTYPE > & | e | ||
) |
void viennacl::linalg::detail::transpose | ( | MatrixType & | A | ) |
void viennacl::linalg::detail::tridiagonal_reduction | ( | viennacl::matrix< SCALARTYPE, F, ALIGNMENT > & | A, |
viennacl::matrix< SCALARTYPE, F, ALIGNMENT > & | Q | ||
) |
void viennacl::linalg::detail::update_float_QR_column | ( | MatrixT & | A, |
const std::vector< SCALARTYPE > & | buf, | ||
int | m, | ||
int | n, | ||
int | last_i, | ||
bool | is_triangular | ||
) |
void viennacl::linalg::detail::update_float_QR_column_gpu | ( | MatrixT & | A, |
const std::vector< SCALARTYPE > & | buf, | ||
viennacl::vector< SCALARTYPE > & | buf_vcl, | ||
int | m, | ||
int | n, | ||
int | last_n, | ||
bool | |||
) |
void viennacl::linalg::detail::write_householder_to_A | ( | MatrixType & | A, |
VectorType const & | v, | ||
vcl_size_t | j | ||
) |
void viennacl::linalg::detail::write_householder_to_A_ublas | ( | MatrixType & | A, |
VectorType const & | v, | ||
vcl_size_t | j | ||
) |
void viennacl::linalg::detail::write_householder_to_A_viennacl | ( | MatrixType & | A, |
VectorType const & | v, | ||
vcl_size_t | j | ||
) |