ViennaCL - The Vienna Computing Library  1.5.1
Namespaces | Data Structures | Enumerations | Functions
viennacl::linalg::detail Namespace Reference

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)

Detailed Description

Namespace holding implementation details for linear algebra routines. Usually not of interest for a library user.


Enumeration Type Documentation

Enumerator:
SPARSE_ROW_NORM_INF 
SPARSE_ROW_NORM_1 
SPARSE_ROW_NORM_2 
SPARSE_ROW_DIAGONAL 

Function Documentation

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 ( xr,
xi,
yr,
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.

Parameters:
AThe full matrix
diagonal_block_AThe output matrix, to which the extracted block is written to
start_indexFirst row- and column-index of the block
stop_indexFirst 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.

Parameters:
input_vecThe input vector
hh_vecThe householder vector defining the relection (I - beta * hh_vec * hh_vec^T)
betaThe coefficient beta in (I - beta * hh_vec * hh_vec^T)
muThe norm of the input vector part relevant for the reflection: norm_2(input_vec[j:size])
jIndex 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()

Parameters:
AA dense ViennaCL matrix to be factored
block_sizeThe 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.

Parameters:
AA dense compatible to Boost.uBLAS
block_sizeThe 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()

Parameters:
AA dense ViennaCL matrix to be factored
block_sizeThe 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.

Parameters:
AThe system matrix
rRandom start vector
sizeSize of krylov-space
Returns:
Returns the eigenvalues (number of eigenvalues equals 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.

Parameters:
AThe system matrix
rRandom start vector
sizeSize of krylov-space
Returns:
Returns the eigenvalues (number of eigenvalues equals 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.

Parameters:
AThe system matrix
rRandom start vector
sizeSize of krylov-space
tagLanczos_tag with several options for the algorithm
Returns:
Returns the eigenvalues (number of eigenvalues equals size of krylov-space)
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 
)