viennacl Namespace Reference

Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them. More...

Namespaces
namespace	backend
	Namespace providing routines for handling the different memory domains.
namespace	detail
	Holds implementation details for functionality in the main viennacl-namespace. Not intended for direct use by library users.
namespace	generator
	Provides an OpenCL kernel generator.
namespace	io
	Provides basic input-output functionality.
namespace	linalg
	Provides all linear algebra operations which are not covered by operator overloads.
namespace	ocl
	OpenCL backend. Manages platforms, contexts, buffers, kernels, etc.
namespace	result_of
	Namespace containing many meta-functions.
namespace	tools
	Namespace for various tools used within ViennaCL.
namespace	traits
	Namespace providing traits-information as well as generic wrappers to common routines for vectors and matrices such as size() or clear()
Data Structures
class	circulant_matrix
	A Circulant matrix class. More...
class	compressed_matrix
	A sparse square matrix in compressed sparse rows format. More...
class	coordinate_matrix
	A sparse square matrix, where entries are stored as triplets (i,j, val), where i and j are the row and column indices and val denotes the entry. More...
class	ell_matrix
struct	row_major_tag
struct	column_major_tag
struct	row_major
	A tag for row-major storage of a dense matrix. More...
struct	column_major
struct	is_cpu_scalar
struct	is_scalar
struct	is_flip_sign_scalar
struct	is_any_scalar
struct	is_row_major
struct	is_any_sparse_matrix
struct	is_circulant_matrix
struct	is_hankel_matrix
struct	is_toeplitz_matrix
struct	is_vandermonde_matrix
struct	is_any_dense_structured_matrix
struct	vcl_static_assert< true >
class	value_base
class	value
class	any
class	bad_any_cast
struct	true_pred
class	hankel_matrix
	A Hankel matrix class. More...
class	hyb_matrix
class	identity_matrix
	Represents a vector consisting of 1 at a given index and zeros otherwise. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
class	zero_matrix
	Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
class	scalar_matrix
	Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
class	matrix_expression
struct	row_iteration
	A tag indicating iteration along increasing row index of a matrix. More...
struct	col_iteration
	A tag indicating iteration along increasing columns index of a matrix. More...
class	matrix_iterator
class	matrix_base
	A dense matrix class. More...
class	matrix
	A dense matrix class. More...
class	matrix_range
class	matrix_slice
struct	enable_if
	Simple enable-if variant that uses the SFINAE pattern. More...
struct	enable_if< false, T >
struct	is_addition
	Helper metafunction for checking whether the provided type is viennacl::op_add (for addition) More...
struct	is_subtraction
	Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction) More...
struct	is_product
	Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multiplication) More...
struct	is_division
	Helper metafunction for checking whether the provided type is viennacl::op_div (for division) More...
struct	tag_none
struct	tag_mtl4
struct	tag_eigen
struct	tag_ublas
struct	tag_stl
struct	tag_viennacl
struct	is_mtl4
	Meta function which checks whether a tag is tag_mtl4. More...
struct	is_mtl4< viennacl::tag_mtl4 >
struct	is_eigen
	Meta function which checks whether a tag is tag_eigen. More...
struct	is_eigen< viennacl::tag_eigen >
struct	is_ublas
	Meta function which checks whether a tag is tag_ublas. More...
struct	is_ublas< viennacl::tag_ublas >
struct	is_stl
	Meta function which checks whether a tag is tag_ublas. More...
struct	is_stl< viennacl::tag_stl >
struct	is_viennacl
	Meta function which checks whether a tag is tag_viennacl. More...
struct	is_viennacl< viennacl::tag_viennacl >
struct	cuthill_mckee_tag
class	advanced_cuthill_mckee_tag
	Tag for the advanced Cuthill-McKee algorithm. More...
struct	gibbs_poole_stockmeyer_tag
class	basic_range
	A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded. More...
class	scalar_expression
	A proxy for scalar expressions (e.g. from inner vector products) More...
class	scalar_expression< LHS, RHS, op_inner_prod >
	Specialization of a scalar expression for inner products. Allows for a final reduction on the CPU. More...
class	scalar_expression< LHS, RHS, op_norm_1 >
	Specialization of a scalar expression for norm_1. Allows for a final reduction on the CPU. More...
class	scalar_expression< LHS, RHS, op_norm_2 >
	Specialization of a scalar expression for norm_2. Allows for a final reduction on the CPU. More...
class	scalar_expression< LHS, RHS, op_norm_inf >
	Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU. More...
class	scalar
	This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type like float or double. More...
class	basic_slice
	A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded. More...
class	toeplitz_matrix
	A Toeplitz matrix class. More...
class	entry_proxy
	A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-users of the library. More...
class	const_entry_proxy
	A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-users of the library. More...
class	vandermonde_matrix
	A Vandermonde matrix class. More...
class	unit_vector
	Represents a vector consisting of 1 at a given index and zeros otherwise. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
class	zero_vector
	Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
class	scalar_vector
	Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
class	vector_expression
	An expression template class that represents a binary operation that yields a vector. More...
class	const_vector_iterator
	A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!! More...
class	vector_iterator
	A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! More...
class	vector_base
	Common base class for dense vectors, vector ranges, and vector slices. More...
class	vector
	A vector class representing a linear memory sequence on the GPU. Inspired by boost::numeric::ublas::vector. More...
class	vector_range
class	vector_slice
Typedefs
typedef std::size_t	vcl_size_t
typedef std::ptrdiff_t	vcl_ptrdiff_t
typedef basic_range	range
typedef basic_slice	slice
Enumerations
enum	memory_types { MEMORY_NOT_INITIALIZED, MAIN_MEMORY, OPENCL_MEMORY, CUDA_MEMORY }
Functions
template<typename T >
void	switch_memory_domain (T &obj, viennacl::memory_types new_mem_domain)
	Generic convenience routine for migrating data of an object to a new memory domain.
template<typename T >
viennacl::memory_types	memory_domain (T &obj)
	Returns the currently active memory domain for an object.
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (std::vector< SCALARTYPE > &cpu_vec, circulant_matrix< SCALARTYPE, ALIGNMENT > &gpu_mat)
	Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (circulant_matrix< SCALARTYPE, ALIGNMENT > &gpu_mat, std::vector< SCALARTYPE > &cpu_vec)
	Copies a circulant matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (circulant_matrix< SCALARTYPE, ALIGNMENT > &circ_src, MATRIXTYPE &com_dst)
	Copies a circulant matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (MATRIXTYPE &com_src, circulant_matrix< SCALARTYPE, ALIGNMENT > &circ_dst)
	Copies a the matrix-like object to the circulant matrix from the OpenCL device (either GPU or multi-core CPU)
template<class SCALARTYPE , unsigned int ALIGNMENT>
std::ostream &	operator<< (std::ostream &s, circulant_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas.
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const CPU_MATRIX &cpu_matrix, compressed_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
	Copies a sparse matrix from the host to the OpenCL device (either GPU or multi-core CPU)
template<typename SizeType , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const std::vector< std::map< SizeType, SCALARTYPE > > &cpu_matrix, compressed_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
	Copies a sparse square matrix in the std::vector< std::map < > > format to an OpenCL device. Use viennacl::tools::sparse_matrix_adapter for non-square matrices.
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const compressed_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix, CPU_MATRIX &cpu_matrix)
	Copies a sparse matrix from the OpenCL device (either GPU or multi-core CPU) to the host.
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const compressed_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix, std::vector< std::map< unsigned int, SCALARTYPE > > &cpu_matrix)
	Copies a sparse matrix from an OpenCL device to the host. The host type is the std::vector< std::map < > > format .
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const CPU_MATRIX &cpu_matrix, coordinate_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
	Copies a sparse matrix from the host to the OpenCL device (either GPU or multi-core CPU)
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const std::vector< std::map< unsigned int, SCALARTYPE > > &cpu_matrix, coordinate_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
	Copies a sparse matrix in the std::vector< std::map < > > format to an OpenCL device.
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const coordinate_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix, CPU_MATRIX &cpu_matrix)
	Copies a sparse matrix from the OpenCL device (either GPU or multi-core CPU) to the host.
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const coordinate_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix, std::vector< std::map< unsigned int, SCALARTYPE > > &cpu_matrix)
	Copies a sparse matrix from an OpenCL device to the host. The host type is the std::vector< std::map < > > format .
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const CPU_MATRIX &cpu_matrix, ell_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const ell_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix, CPU_MATRIX &cpu_matrix)
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >
void	copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< SCALARTYPE, ALIGNMENT > gpu_begin)
	STL-like transfer for the entries of a GPU vector to the CPU. The cpu type does not need to lie in a linear piece of memory.
template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
void	copy (const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_begin, const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_end, vector_iterator< SCALARTYPE, ALIGNMENT_DEST > gpu_dest_begin)
	Copy (parts of a) GPU vector to another GPU vector.
template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
void	copy (const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_begin, const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_end, const_vector_iterator< SCALARTYPE, ALIGNMENT_DEST > gpu_dest_begin)
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >
void	fast_copy (const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin)
	STL-like transfer of a GPU vector to the CPU. The cpu type is assumed to reside in a linear piece of memory, such as e.g. for std::vector.
template<typename CPU_ITERATOR , typename SCALARTYPE , unsigned int ALIGNMENT>
void	fast_copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< SCALARTYPE, ALIGNMENT > gpu_begin)
	STL-like transfer of a CPU vector to the GPU. The cpu type is assumed to reside in a linear piece of memory, such as e.g. for std::vector.
template<class T >
T	any_cast (any &a)
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (std::vector< SCALARTYPE > const &cpu_vec, hankel_matrix< SCALARTYPE, ALIGNMENT > &gpu_mat)
	Copies a Hankel matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (hankel_matrix< SCALARTYPE, ALIGNMENT > const &gpu_mat, std::vector< SCALARTYPE > &cpu_vec)
	Copies a Hankel matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (hankel_matrix< SCALARTYPE, ALIGNMENT > const &han_src, MATRIXTYPE &com_dst)
	Copies a Hankel matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (MATRIXTYPE const &com_src, hankel_matrix< SCALARTYPE, ALIGNMENT > &han_dst)
	Copies a the matrix-like object to the Hankel matrix from the OpenCL device (either GPU or multi-core CPU)
template<class SCALARTYPE , unsigned int ALIGNMENT>
std::ostream &	operator<< (std::ostream &s, hankel_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const CPU_MATRIX &cpu_matrix, hyb_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
template<typename CPU_MATRIX , typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (const hyb_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix, CPU_MATRIX &cpu_matrix)
template<typename NumericT , typename F >
vector< NumericT >	operator+= (vector_base< NumericT > &v1, const viennacl::vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, viennacl::op_prod > &proxy)
	Implementation of the operation v1 += A * v2, where A is a matrix.
template<typename NumericT , typename F >
vector< NumericT >	operator-= (vector_base< NumericT > &v1, const viennacl::vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, viennacl::op_prod > &proxy)
	Implementation of the operation v1 -= A * v2, where A is a matrix.
template<typename NumericT , typename F >
viennacl::vector< NumericT >	operator+ (const vector_base< NumericT > &v1, const vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 + A * v2', where A is a matrix.
template<typename NumericT , typename F >
viennacl::vector< NumericT >	operator- (const vector_base< NumericT > &v1, const vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 - A * v2', where A is a matrix.
template<typename NumericT , typename F >
vector< NumericT >	operator+= (vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation v1 += A * v2, where A is a matrix.
template<typename NumericT , typename F >
vector< NumericT >	operator-= (vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation v1 -= A * v2, where A is a matrix.
template<typename NumericT , typename F >
vector< NumericT >	operator+ (const vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 + A * v2', where A is a matrix.
template<typename NumericT , typename F >
vector< NumericT >	operator- (const vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 - A * v2', where A is a matrix.
template<typename M1 >
viennacl::enable_if < viennacl::is_any_sparse_matrix < M1 >::value, matrix_expression< const M1, const M1, op_trans > >::type	trans (const M1 &mat)
	Returns an expression template class representing a transposed matrix.
template<typename SCALARTYPE , typename SparseMatrixType >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value, viennacl::vector_base < SCALARTYPE > & >::type	operator+= (viennacl::vector_base< SCALARTYPE > &result, const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &proxy)
	Implementation of the operation v1 += A * v2, where A is a matrix.
template<typename SCALARTYPE , typename SparseMatrixType >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value, viennacl::vector_base < SCALARTYPE > & >::type	operator-= (viennacl::vector_base< SCALARTYPE > &result, const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &proxy)
	Implementation of the operation v1 -= A * v2, where A is a matrix.
template<typename SCALARTYPE , typename SparseMatrixType >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value, viennacl::vector< SCALARTYPE > >::type	operator+ (viennacl::vector_base< SCALARTYPE > &result, const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &proxy)
	Implementation of the operation 'result = v1 + A * v2', where A is a matrix.
template<typename SCALARTYPE , typename SparseMatrixType >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value, viennacl::vector< SCALARTYPE > >::type	operator- (viennacl::vector_base< SCALARTYPE > &result, const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &proxy)
	Implementation of the operation 'result = v1 - A * v2', where A is a matrix.
template<class SCALARTYPE , typename F , unsigned int ALIGNMENT>
std::ostream &	operator<< (std::ostream &s, const matrix< SCALARTYPE, F, ALIGNMENT > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas.
template<typename LHS , typename RHS , typename OP >
std::ostream &	operator<< (std::ostream &s, const matrix_expression< LHS, RHS, OP > &expr)
	Prints the matrix. Output is compatible to boost::numeric::ublas.
template<typename NumericT , typename F >
matrix_expression< const matrix_base< NumericT, F > , const matrix_base< NumericT, F >, op_trans >	trans (const matrix_base< NumericT, F > &mat)
	Returns an expression template class representing a transposed matrix.
template<typename CPU_MATRIX , typename SCALARTYPE , typename F , unsigned int ALIGNMENT>
void	copy (const CPU_MATRIX &cpu_matrix, matrix< SCALARTYPE, F, ALIGNMENT > &gpu_matrix)
	Copies a dense matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU)
template<typename SCALARTYPE , typename A1 , typename A2 , typename F , unsigned int ALIGNMENT>
void	copy (const std::vector< std::vector< SCALARTYPE, A1 >, A2 > &cpu_matrix, matrix< SCALARTYPE, F, ALIGNMENT > &gpu_matrix)
	Copies a dense STL-type matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU)
template<typename SCALARTYPE , typename F , unsigned int ALIGNMENT>
void	fast_copy (SCALARTYPE *cpu_matrix_begin, SCALARTYPE *cpu_matrix_end, matrix< SCALARTYPE, F, ALIGNMENT > &gpu_matrix)
	Copies a dense matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU) without temporary. Matrix-Layout on CPU must be equal to the matrix-layout on the GPU.
template<typename CPU_MATRIX , typename SCALARTYPE , typename F , unsigned int ALIGNMENT>
void	copy (const matrix< SCALARTYPE, F, ALIGNMENT > &gpu_matrix, CPU_MATRIX &cpu_matrix)
	Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU).
template<typename SCALARTYPE , typename A1 , typename A2 , typename F , unsigned int ALIGNMENT>
void	copy (const matrix< SCALARTYPE, F, ALIGNMENT > &gpu_matrix, std::vector< std::vector< SCALARTYPE, A1 >, A2 > &cpu_matrix)
	Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU).
template<typename SCALARTYPE , typename F , unsigned int ALIGNMENT>
void	fast_copy (const matrix< SCALARTYPE, F, ALIGNMENT > &gpu_matrix, SCALARTYPE *cpu_matrix_begin)
	Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU).
template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
matrix_expression< LHS1, RHS1, OP1 >::matrix_type	operator+ (matrix_expression< LHS1, RHS1, OP1 > const &proxy1, matrix_expression< LHS2, RHS2, OP2 > const &proxy2)
	Generic 'catch-all' overload, which enforces a temporary if the expression tree gets too deep.
template<typename LHS1 , typename RHS1 , typename OP1 , typename NumericT , typename F >
matrix< NumericT, F >	operator+ (matrix_expression< LHS1, RHS1, OP1 > const &proxy1, matrix_base< NumericT, F > const &proxy2)
template<typename NumericT , typename F , typename LHS2 , typename RHS2 , typename OP2 >
matrix< NumericT, F >	operator+ (matrix_base< NumericT, F > const &proxy1, matrix_expression< LHS2, RHS2, OP2 > const &proxy2)
template<typename NumericT , typename F >
matrix_expression< const matrix_base< NumericT, F > , const matrix_base< NumericT, F >, op_add >	operator+ (const matrix_base< NumericT, F > &m1, const matrix_base< NumericT, F > &m2)
	Operator overload for m1 + m2, where m1 and m2 are either dense matrices, matrix ranges, or matrix slices. No mixing of different storage layouts allowed at the moment.
template<typename NumericT , typename F , typename S3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S3 > ::value, matrix_expression < const matrix_base< NumericT, F >, const matrix_expression < const matrix_base< NumericT, F >, const S3, OP >, op_add > >::type	operator+ (const matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP > &proxy)
	Operator overload for the addition of a matrix expression m1 + m2 @ beta, where @ is either product or division, and beta is either a CPU or GPU scalar.
template<typename NumericT , typename F , typename S2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, matrix_expression < const matrix_expression < const matrix_base< NumericT, F >, const S2, OP >, const matrix_base< NumericT, F > , op_add > >::type	operator+ (const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &proxy, const matrix_base< NumericT, F > &m3)
	Operator overload for the addition of a matrix expression m1 @ alpha + m2, where @ is either product or division, and beta is either a CPU or GPU scalar.
template<typename NumericT , typename F , typename S1 , typename OP1 , typename S2 , typename OP2 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value &&viennacl::is_any_scalar< S2 > ::value, matrix_expression < const matrix_expression < const matrix_base< NumericT, F >, const S1, OP1 >, const matrix_expression< const matrix_base< NumericT, F > , const S2, OP2 >, op_add > >::type	operator+ (matrix_expression< const matrix_base< NumericT, F >, const S1, OP1 > const &lhs, matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 > const &rhs)
	Operator overload for the addition of a matrix expression m1 @ alpha + m2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F >
matrix_base< NumericT, F > &	operator+= (matrix_base< NumericT, F > &m1, const matrix_base< NumericT, F > &other)
template<typename NumericT , typename F , typename S2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, matrix_base< NumericT, F > & >::type	operator+= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &proxy)
	Inplace addition of a scaled matrix, i.e. m1 += m2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.
template<typename NumericT , typename F , typename OP >
viennacl::enable_if < viennacl::is_addition< OP > ::value||viennacl::is_subtraction < OP >::value, matrix_base < NumericT, F > & >::type	operator+= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, OP > &proxy)
	Implementation of the operation m1 += m2 +- m3.
template<typename NumericT , typename F , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S3 > ::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), matrix_base < NumericT, F > & >::type	operator+= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation m1 += m2 +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F , typename S2 , typename OP2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), matrix_base < NumericT, F > & >::type	operator+= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_base< NumericT, F >, OP > &proxy)
	Implementation of the operation m1 += m2 @ alpha +- m3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F , typename S2 , typename OP2 , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&viennacl::is_any_scalar < S3 >::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), matrix_base < NumericT, F > & >::type	operator+= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation m1 += m2 @ alpha +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F >
matrix_base< NumericT, F > &	operator+= (matrix_base< NumericT, F > &m1, const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy)
template<typename NumericT , typename F , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_base< NumericT, F > & >::type	operator+= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod >, const S1, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator+= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F3 >, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator+= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator+= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_base< NumericT, F3 >, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator+= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &proxy)
template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
matrix_expression< LHS1, RHS1, OP1 >::matrix_type	operator- (matrix_expression< LHS1, RHS1, OP1 > const &proxy1, matrix_expression< LHS2, RHS2, OP2 > const &proxy2)
	Generic 'catch-all' overload, which enforces a temporary if the expression tree gets too deep.
template<typename LHS1 , typename RHS1 , typename OP1 , typename NumericT , typename F >
matrix< NumericT, F >	operator- (matrix_expression< LHS1, RHS1, OP1 > const &proxy1, matrix_base< NumericT, F > const &proxy2)
template<typename NumericT , typename F , typename LHS2 , typename RHS2 , typename OP2 >
matrix< NumericT, F >	operator- (matrix_base< NumericT, F > const &proxy1, matrix_expression< LHS2, RHS2, OP2 > const &proxy2)
template<typename NumericT , typename F >
matrix_expression< const matrix_base< NumericT, F > , const matrix_base< NumericT, F >, op_sub >	operator- (const matrix_base< NumericT, F > &m1, const matrix_base< NumericT, F > &m2)
	Operator overload for m1 - m2, where m1 and m2 are either dense matrices, matrix ranges, or matrix slices. No mixing of different storage layouts allowed at the moment.
template<typename NumericT , typename F , typename S3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S3 > ::value, matrix_expression < const matrix_base< NumericT, F >, const matrix_expression < const matrix_base< NumericT, F >, const S3, OP >, op_sub > >::type	operator- (const matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP > &proxy)
	Operator overload for the addition of a matrix expression m1 - m2 @ beta, where @ is either product or division, and beta is either a CPU or GPU scalar.
template<typename NumericT , typename F , typename S2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, matrix_expression < const matrix_expression < const matrix_base< NumericT, F >, const S2, OP >, const matrix_base< NumericT, F > , op_sub > >::type	operator- (const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &proxy, const matrix_base< NumericT, F > &m3)
	Operator overload for the addition of a matrix expression m1 @ alpha - m2, where @ is either product or division, and beta is either a CPU or GPU scalar.
template<typename NumericT , typename F , typename S1 , typename OP1 , typename S2 , typename OP2 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value &&viennacl::is_any_scalar< S2 > ::value, matrix_expression < const matrix_expression < const matrix_base< NumericT, F >, const S1, OP1 >, const matrix_expression< const matrix_base< NumericT, F > , const S2, OP2 >, op_sub > >::type	operator- (matrix_expression< const matrix_base< NumericT, F >, const S1, OP1 > const &lhs, matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 > const &rhs)
	Operator overload for the addition of a matrix expression m1 @ alpha - m2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F >
matrix_base< NumericT, F > &	operator-= (matrix_base< NumericT, F > &m1, const matrix_base< NumericT, F > &other)
template<typename NumericT , typename F , typename S2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, matrix_base< NumericT, F > & >::type	operator-= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &proxy)
	Inplace addition of a scaled matrix, i.e. m1 -= m2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.
template<typename NumericT , typename F , typename OP >
viennacl::enable_if < viennacl::is_addition< OP > ::value||viennacl::is_subtraction < OP >::value, matrix_base < NumericT, F > & >::type	operator-= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, OP > &proxy)
	Implementation of the operation m1 -= m2 +- m3.
template<typename NumericT , typename F , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S3 > ::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), matrix_base < NumericT, F > & >::type	operator-= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_base< NumericT, F >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation m1 -= m2 +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F , typename S2 , typename OP2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), matrix_base < NumericT, F > & >::type	operator-= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_base< NumericT, F >, OP > &proxy)
	Implementation of the operation m1 -= m2 @ alpha +- m3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F , typename S2 , typename OP2 , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&viennacl::is_any_scalar < S3 >::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), matrix_base < NumericT, F > & >::type	operator-= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation m1 -= m2 @ alpha +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename NumericT , typename F >
matrix_base< NumericT, F > &	operator-= (matrix_base< NumericT, F > &m1, const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy)
template<typename NumericT , typename F , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_base< NumericT, F > & >::type	operator-= (matrix_base< NumericT, F > &m1, const matrix_expression< const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod >, const S1, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator-= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F3 >, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator-= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator-= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_base< NumericT, F3 >, op_prod > &proxy)
template<typename NumericT , typename F1 , typename F2 , typename F3 >
matrix_base< NumericT, F1 > &	operator-= (matrix_base< NumericT, F1 > &m1, const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &proxy)
template<typename S1 , typename NumericT , typename F >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_base< NumericT, F >, const S1, op_prod > >::type	operator* (S1 const &value, matrix_base< NumericT, F > const &m1)
	Operator overload for the expression alpha * m1, where alpha is a host scalar (float or double) and m1 is a ViennaCL matrix.
template<typename LHS , typename RHS , typename OP , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, typename matrix_expression< LHS, RHS, OP >::matrix_type >::type	operator* (matrix_expression< LHS, RHS, OP > const &proxy, S1 const &val)
	Operator overload for the multiplication of a matrix expression with a scalar from the right, e.g. (beta * m1) * alpha. Here, beta * m1 is wrapped into a matrix_expression and then multiplied with alpha from the right.
template<typename S1 , typename LHS , typename RHS , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, typename matrix_expression< LHS, RHS, OP >::matrix_type >::type	operator* (S1 const &val, matrix_expression< LHS, RHS, OP > const &proxy)
	Operator overload for the multiplication of a matrix expression with a ViennaCL scalar from the left, e.g. alpha * (beta * m1). Here, beta * m1 is wrapped into a matrix_expression and then multiplied with alpha from the left.
template<typename NumericT , typename F , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_base< NumericT, F >, const S1, op_prod > >::type	operator* (matrix_base< NumericT, F > const &m1, S1 const &s1)
	Scales the matrix by a GPU scalar 'alpha' and returns an expression template.
template<typename NumericT , typename F , typename S1 >
viennacl::enable_if < viennacl::is_scalar< S1 > ::value, matrix_base< NumericT, F > & >::type	operator*= (matrix_base< NumericT, F > &m1, S1 const &gpu_val)
	Scales a matrix by a GPU scalar value.
template<typename S1 , typename LHS , typename RHS , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, typename matrix_expression< LHS, RHS, OP >::matrix_type >::type	operator/ (matrix_expression< LHS, RHS, OP > const &proxy, S1 const &val)
	Operator overload for the division of a matrix expression by a scalar from the right, e.g. (beta * m1) / alpha. Here, beta * m1 is wrapped into a matrix_expression and then divided by alpha.
template<typename NumericT , typename F , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_base< NumericT, F >, const S1, op_div > >::type	operator/ (matrix_base< NumericT, F > const &m1, S1 const &s1)
	Returns an expression template for scaling the matrix by a GPU scalar 'alpha'.
template<typename NumericT , typename F , typename S1 >
viennacl::enable_if < viennacl::is_scalar< S1 > ::value, matrix_base< NumericT, F > & >::type	operator/= (matrix_base< NumericT, F > &m1, S1 const &gpu_val)
	Scales a matrix by a GPU scalar value.
template<typename NumericT , typename S1 >
viennacl::enable_if < viennacl::is_scalar< S1 > ::value, viennacl::matrix_expression < const viennacl::matrix_expression < const vector_base< NumericT > , const vector_base< NumericT > , op_prod >, const S1, op_prod > >::type	operator* (const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy, const S1 &val)
template<typename NumericT , typename S1 >
viennacl::enable_if < viennacl::is_scalar< S1 > ::value, viennacl::matrix_expression < const viennacl::matrix_expression < const vector_base< NumericT > , const vector_base< NumericT > , op_prod >, const S1, op_prod > >::type	operator* (const S1 &val, const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (const CPU_MATRIX &cpu_matrix, matrix_range< matrix< SCALARTYPE, row_major, 1 > > &gpu_matrix_range)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (const CPU_MATRIX &cpu_matrix, matrix_range< matrix< SCALARTYPE, column_major, 1 > > &gpu_matrix_range)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (matrix_range< matrix< SCALARTYPE, row_major, 1 > > const &gpu_matrix_range, CPU_MATRIX &cpu_matrix)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (matrix_range< matrix< SCALARTYPE, column_major, 1 > > const &gpu_matrix_range, CPU_MATRIX &cpu_matrix)
template<typename MatrixType >
std::ostream &	operator<< (std::ostream &s, matrix_range< MatrixType > const &proxy)
template<typename MatrixType >
std::ostream &	operator<< (std::ostream &s, matrix_range< const MatrixType > const &proxy)
template<typename MatrixType >
matrix_range< MatrixType >	project (MatrixType &A, viennacl::range const &r1, viennacl::range const &r2)
template<typename MatrixType >
matrix_range< MatrixType >	project (matrix_range< MatrixType > &A, viennacl::range const &r1, viennacl::range const &r2)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (const CPU_MATRIX &cpu_matrix, matrix_slice< matrix< SCALARTYPE, row_major, 1 > > &gpu_matrix_slice)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (const CPU_MATRIX &cpu_matrix, matrix_slice< matrix< SCALARTYPE, column_major, 1 > > &gpu_matrix_slice)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (matrix_slice< matrix< SCALARTYPE, row_major, 1 > > const &gpu_matrix_slice, CPU_MATRIX &cpu_matrix)
template<typename CPU_MATRIX , typename SCALARTYPE >
void	copy (matrix_slice< matrix< SCALARTYPE, column_major, 1 > > const &gpu_matrix_slice, CPU_MATRIX &cpu_matrix)
template<typename MatrixType >
matrix_slice< MatrixType >	project (MatrixType &A, viennacl::slice const &r1, viennacl::slice const &r2)
template<typename MatrixType >
matrix_slice< MatrixType >	project (matrix_range< MatrixType > &A, viennacl::slice const &r1, viennacl::slice const &r2)
template<typename MatrixType >
matrix_slice< MatrixType >	project (matrix_slice< MatrixType > &A, viennacl::slice const &r1, viennacl::slice const &r2)
template<typename MatrixType >
std::vector< int >	reorder (MatrixType const &matrix, cuthill_mckee_tag)
	Function for the calculation of a node number permutation to reduce the bandwidth of an incidence matrix by the Cuthill-McKee algorithm.
template<typename MatrixType >
std::vector< int >	reorder (MatrixType const &matrix, advanced_cuthill_mckee_tag const &tag)
	Function for the calculation of a node number permutation to reduce the bandwidth of an incidence matrix by the advanced Cuthill-McKee algorithm.
template<typename MatrixType >
std::vector< int >	reorder (MatrixType const &matrix, gibbs_poole_stockmeyer_tag)
	Function for the calculation of a node numbering permutation vector to reduce the bandwidth of a incidence matrix by the Gibbs-Poole-Stockmeyer algorithm.
template<class SCALARTYPE >
std::ostream &	operator<< (std::ostream &s, const scalar< SCALARTYPE > &val)
	Allows to directly print the value of a scalar to an output stream.
template<class SCALARTYPE >
std::istream &	operator>> (std::istream &s, const scalar< SCALARTYPE > &val)
	Allows to directly read a value of a scalar from an input stream.
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (std::vector< SCALARTYPE > const &cpu_vec, toeplitz_matrix< SCALARTYPE, ALIGNMENT > &gpu_mat)
	Copies a Toeplitz matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (toeplitz_matrix< SCALARTYPE, ALIGNMENT > const &gpu_mat, std::vector< SCALARTYPE > &cpu_vec)
	Copies a Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (toeplitz_matrix< SCALARTYPE, ALIGNMENT > const &tep_src, MATRIXTYPE &com_dst)
	Copies a Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (MATRIXTYPE const &com_src, toeplitz_matrix< SCALARTYPE, ALIGNMENT > &tep_dst)
	Copies a the matrix-like object to the Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU)
template<class SCALARTYPE , unsigned int ALIGNMENT>
std::ostream &	operator<< (std::ostream &s, toeplitz_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas.
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (std::vector< SCALARTYPE > &cpu_vec, vandermonde_matrix< SCALARTYPE, ALIGNMENT > &gpu_mat)
	Copies a Vandermonde matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void	copy (vandermonde_matrix< SCALARTYPE, ALIGNMENT > &gpu_mat, std::vector< SCALARTYPE > &cpu_vec)
	Copies a Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (vandermonde_matrix< SCALARTYPE, ALIGNMENT > &vander_src, MATRIXTYPE &com_dst)
	Copies a Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename MATRIXTYPE >
void	copy (MATRIXTYPE &com_src, vandermonde_matrix< SCALARTYPE, ALIGNMENT > &vander_dst)
	Copies a the matrix-like object to the Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU)
template<class SCALARTYPE , unsigned int ALIGNMENT>
std::ostream &	operator<< (std::ostream &s, vandermonde_matrix< SCALARTYPE, ALIGNMENT > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas.
template<typename NumericT , typename CPUVECTOR >
void	fast_copy (vector_base< NumericT > const &gpu_vec, CPUVECTOR &cpu_vec)
	Transfer from a gpu vector to a cpu vector. Convenience wrapper for viennacl::linalg::fast_copy(gpu_vec.begin(), gpu_vec.end(), cpu_vec.begin());.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >
void	copy (const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin)
	STL-like transfer for the entries of a GPU vector to the CPU. The cpu type does not need to lie in a linear piece of memory.
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >
void	copy (const vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin)
	STL-like transfer for the entries of a GPU vector to the CPU. The cpu type does not need to lie in a linear piece of memory.
template<typename NumericT , typename CPUVECTOR >
void	copy (vector_base< NumericT > const &gpu_vec, CPUVECTOR &cpu_vec)
	Transfer from a gpu vector to a cpu vector. Convenience wrapper for viennacl::linalg::copy(gpu_vec.begin(), gpu_vec.end(), cpu_vec.begin());.
template<typename CPUVECTOR , typename NumericT >
void	fast_copy (const CPUVECTOR &cpu_vec, vector_base< NumericT > &gpu_vec)
	Transfer from a cpu vector to a gpu vector. Convenience wrapper for viennacl::linalg::fast_copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());.
template<typename CPUVECTOR , typename T >
void	copy (const CPUVECTOR &cpu_vec, vector_base< T > &gpu_vec)
	Transfer from a cpu vector to a gpu vector. Convenience wrapper for viennacl::linalg::copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());.
template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
void	copy (vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_begin, vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_end, vector_iterator< SCALARTYPE, ALIGNMENT_DEST > gpu_dest_begin)
	Copy (parts of a) GPU vector to another GPU vector.
template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
void	copy (vector< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_vec, vector< SCALARTYPE, ALIGNMENT_DEST > &gpu_dest_vec)
	Transfer from a ViennaCL vector to another ViennaCL vector. Convenience wrapper for viennacl::linalg::copy(gpu_src_vec.begin(), gpu_src_vec.end(), gpu_dest_vec.begin());.
template<typename T >
std::ostream &	operator<< (std::ostream &s, vector_base< T > const &val)
	Output stream. Output format is ublas compatible.
template<typename LHS , typename RHS , typename OP >
std::ostream &	operator<< (std::ostream &s, vector_expression< LHS, RHS, OP > const &proxy)
template<typename T >
void	swap (vector_base< T > &vec1, vector_base< T > &vec2)
	Swaps the contents of two vectors, data is copied.
template<typename SCALARTYPE , unsigned int ALIGNMENT>
vector< SCALARTYPE, ALIGNMENT > &	fast_swap (vector< SCALARTYPE, ALIGNMENT > &v1, vector< SCALARTYPE, ALIGNMENT > &v2)
	Swaps the content of two vectors by swapping OpenCL handles only, NO data is copied.
template<typename T >
vector_base< T > &	operator+= (vector_base< T > &v1, const vector_base< T > &v2)
	Inplace addition of a vector.
template<typename T , typename S2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, vector_base< T > & >::type	operator+= (vector_base< T > &v1, const vector_expression< const vector_base< T >, const S2, OP > &proxy)
	Inplace addition of a scaled vector, i.e. v1 += v2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.
template<typename T , typename OP >
viennacl::enable_if < (viennacl::is_addition< OP > ::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator+= (vector_base< T > &v1, const vector_expression< const vector_base< T >, const vector_base< T >, OP > &proxy)
	Implementation of the operation v1 += v2 +- v3.
template<typename T , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S3 > ::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator+= (vector_base< T > &v1, const vector_expression< const vector_base< T >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation v1 += v2 +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T , typename S2 , typename OP2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator+= (vector_base< T > &v1, const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_base< T >, OP > &proxy)
	Implementation of the operation v1 += v2 @ alpha +- v3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T , typename S2 , typename OP2 , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&viennacl::is_any_scalar < S3 >::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator+= (vector_base< T > &v1, const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation v1 += v2 @ alpha +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T >
vector_base< T > &	operator-= (vector_base< T > &v1, const vector_base< T > &vec)
	Inplace subtraction of a vector.
template<typename T , typename S2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, vector_base< T > & >::type	operator-= (vector_base< T > &v1, const vector_expression< const vector_base< T >, const S2, OP > &proxy)
	Inplace subtraction of a scaled vector, i.e. v1 -= v2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.
template<typename T , typename OP >
viennacl::enable_if < (viennacl::is_addition< OP > ::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator-= (vector_base< T > &v1, const vector_expression< const vector_base< T >, const vector_base< T >, OP > &proxy)
	Implementation of the operation v1 -= v2 +- v3.
template<typename T , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S3 > ::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator-= (vector_base< T > &v1, const vector_expression< const vector_base< T >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation v1 -= v2 +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T , typename S2 , typename OP2 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator-= (vector_base< T > &v1, const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_base< T >, OP > &proxy)
	Implementation of the operation v1 -= v2 @ alpha +- v3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T , typename S2 , typename OP2 , typename S3 , typename OP3 , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value &&(viennacl::is_product< OP2 > ::value||viennacl::is_division < OP2 >::value)&&viennacl::is_any_scalar < S3 >::value &&(viennacl::is_product< OP3 > ::value||viennacl::is_division < OP3 >::value)&&(viennacl::is_addition < OP >::value||viennacl::is_subtraction < OP >::value), vector_base< T > & >::type	operator-= (vector_base< T > &v1, const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &proxy)
	Implementation of the operation v1 -= v2 @ alpha +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_base< T > & >::type	operator*= (vector_base< T > &v1, S1 const &gpu_val)
	Scales this vector by a GPU scalar value.
template<typename T , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_base< T > & >::type	operator/= (vector_base< T > &v1, S1 const &gpu_val)
	Scales this vector by a GPU scalar value.
template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
vector_expression< LHS1, RHS1, OP1 >::VectorType	operator+ (vector_expression< LHS1, RHS1, OP1 > const &proxy1, vector_expression< LHS2, RHS2, OP2 > const &proxy2)
	Operator overload for the addition of two vector expressions.
template<typename LHS , typename RHS , typename OP , typename T >
viennacl::vector< T >	operator+ (vector_expression< LHS, RHS, OP > const &proxy, vector_base< T > const &vec)
	Operator overload for the addition of a vector expression with a vector or another vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.
template<typename T , typename LHS , typename RHS , typename OP >
viennacl::vector< T >	operator+ (vector_base< T > const &vec, vector_expression< LHS, RHS, OP > const &proxy)
	Operator overload for the addition of a vector with a vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.
template<typename T , typename S1 , typename OP1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_expression < const vector_expression < const vector_base< T > , const S1, OP1 >, const vector_base< T >, op_add > >::type	operator+ (vector_expression< const vector_base< T >, const S1, OP1 > const &proxy, vector_base< T > const &vec)
	Operator overload for the addition of a vector expression v1 @ alpha + v2, where @ denotes either product or division, and alpha is either a CPU or a GPU scalar.
template<typename T , typename S1 , typename OP1 , typename S2 , typename OP2 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value &&viennacl::is_any_scalar< S2 > ::value, vector_expression < const vector_expression < const vector_base< T > , const S1, OP1 >, const vector_expression< const vector_base< T >, const S2, OP2 >, op_add > >::type	operator+ (vector_expression< const vector_base< T >, const S1, OP1 > const &lhs, vector_expression< const vector_base< T >, const S2, OP2 > const &rhs)
	Operator overload for the addition of a vector expression v1 @ alpha + v2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T >
vector_expression< const vector_base< T >, const vector_base< T >, op_add >	operator+ (const vector_base< T > &v1, const vector_base< T > &v2)
	Returns an expression template object for adding up two vectors, i.e. v1 + v2.
template<typename T , typename S2 , typename OP2 >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, vector_expression < const vector_base< T > , const vector_expression < const vector_base< T > , const S2, OP2 >, op_add > >::type	operator+ (const vector_base< T > &v1, const vector_expression< const vector_base< T >, const S2, OP2 > &proxy)
	Returns an expression template object for adding up two vectors, one being scaled, i.e. v1 + v2 * alpha, where alpha is a CPU or a GPU scalar.
template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
vector_expression< LHS1, RHS1, OP1 >::VectorType	operator- (vector_expression< LHS1, RHS1, OP1 > const &proxy1, vector_expression< LHS2, RHS2, OP2 > const &proxy2)
	Operator overload for the subtraction of two vector expressions.
template<typename LHS , typename RHS , typename OP , typename T >
viennacl::vector< T >	operator- (vector_expression< LHS, RHS, OP > const &proxy, vector_base< T > const &vec)
	Operator overload for the subtraction of a vector expression with a vector or another vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.
template<typename T , typename LHS , typename RHS , typename OP >
viennacl::vector< T >	operator- (vector_base< T > const &vec, vector_expression< LHS, RHS, OP > const &proxy)
	Operator overload for the subtraction of a vector expression with a vector or another vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.
template<typename T , typename S1 , typename OP1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_expression < const vector_expression < const vector_base< T > , const S1, OP1 >, const vector_base< T >, op_sub > >::type	operator- (vector_expression< const vector_base< T >, const S1, OP1 > const &proxy, vector_base< T > const &vec)
	Operator overload for the addition of a vector expression v1 @ alpha - v2, where @ denotes either product or division, and alpha is either a CPU or a GPU scalar.
template<typename T , typename S1 , typename OP1 , typename S2 , typename OP2 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value &&viennacl::is_any_scalar< S2 > ::value, vector_expression < const vector_expression < const vector_base< T > , const S1, OP1 >, const vector_expression< const vector_base< T >, const S2, OP2 >, op_sub > >::type	operator- (vector_expression< const vector_base< T >, const S1, OP1 > const &lhs, vector_expression< const vector_base< T >, const S2, OP2 > const &rhs)
	Operator overload for the addition of a vector expression v1 @ alpha - v2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.
template<typename T >
vector_expression< const vector_base< T >, const vector_base< T >, op_sub >	operator- (const vector_base< T > &v1, const vector_base< T > &v2)
	Returns an expression template object for subtracting two vectors, i.e. v1 - v2.
template<typename T , typename S2 , typename OP2 >
viennacl::enable_if < viennacl::is_any_scalar< S2 > ::value, vector_expression < const vector_base< T > , const vector_expression < const vector_base< T > , const S2, OP2 >, op_sub > >::type	operator- (const vector_base< T > &v1, const vector_expression< const vector_base< T >, const S2, OP2 > &proxy)
	Returns an expression template object for subtracting two vectors, one being scaled, i.e. v1 - v2 * alpha, where alpha is a CPU or a GPU scalar.
template<typename S1 , typename T >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_expression < const vector_base< T > , const S1, op_prod > >::type	operator* (S1 const &value, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a host scalar (float or double) and v1 is a ViennaCL vector.
template<typename LHS , typename RHS , typename OP , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, viennacl::vector < typename viennacl::result_of::cpu_value_type < RHS >::type > >::type	operator* (vector_expression< LHS, RHS, OP > const &proxy, S1 const &val)
	Operator overload for the multiplication of a vector expression with a scalar from the right, e.g. (beta * vec1) * alpha. Here, beta * vec1 is wrapped into a vector_expression and then multiplied with alpha from the right.
template<typename S1 , typename LHS , typename RHS , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, viennacl::vector < typename viennacl::result_of::cpu_value_type < RHS >::type > >::type	operator* (S1 const &val, vector_expression< LHS, RHS, OP > const &proxy)
	Operator overload for the multiplication of a vector expression with a ViennaCL scalar from the left, e.g. alpha * (beta * vec1). Here, beta * vec1 is wrapped into a vector_expression and then multiplied with alpha from the left.
template<typename T , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_expression < const vector_base< T > , const S1, op_prod > >::type	operator* (vector_base< T > const &v1, S1 const &s1)
	Scales the vector by a GPU scalar 'alpha' and returns an expression template.
template<typename S1 , typename LHS , typename RHS , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, viennacl::vector < typename viennacl::result_of::cpu_value_type < RHS >::type > >::type	operator/ (vector_expression< LHS, RHS, OP > const &proxy, S1 const &val)
	Operator overload for the division of a vector expression by a scalar from the right, e.g. (beta * vec1) / alpha. Here, beta * vec1 is wrapped into a vector_expression and then divided by alpha.
template<typename T , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_expression < const vector_base< T > , const S1, op_div > >::type	operator/ (vector_base< T > const &v1, S1 const &s1)
	Returns an expression template for scaling the vector by a GPU scalar 'alpha'.
template<typename VectorType , typename SCALARTYPE >
void	copy (const VectorType &cpu_vector, vector_range< vector< SCALARTYPE > > &gpu_vector_range)
template<typename CPUVECTOR , typename VectorType >
void	fast_copy (const CPUVECTOR &cpu_vec, vector_range< VectorType > &gpu_vec)
	Transfer from a cpu vector to a gpu vector. Convenience wrapper for viennacl::linalg::fast_copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());.
template<typename SCALARTYPE , typename VectorType >
void	copy (vector_range< vector< SCALARTYPE > > const &gpu_vector_range, VectorType &cpu_vector)
template<typename VectorType , typename CPUVECTOR >
void	fast_copy (vector_range< VectorType > const &gpu_vec, CPUVECTOR &cpu_vec)
	Transfer from a GPU vector range to a CPU vector. Convenience wrapper for viennacl::linalg::fast_copy(gpu_vec.begin(), gpu_vec.end(), cpu_vec.begin());.
template<typename VectorType >
vector_range< VectorType >	project (VectorType &vec, viennacl::range const &r1)
template<typename VectorType >
vector_range< VectorType >	project (viennacl::vector_range< VectorType > &vec, viennacl::range const &r1)
template<typename VectorType , typename SCALARTYPE >
void	copy (const VectorType &cpu_vector, vector_slice< vector< SCALARTYPE > > &gpu_vector_slice)
template<typename VectorType , typename SCALARTYPE >
void	copy (vector_slice< vector< SCALARTYPE > > const &gpu_vector_slice, VectorType &cpu_vector)
template<typename VectorType >
vector_slice< VectorType >	project (VectorType &vec, viennacl::slice const &s1)
template<typename VectorType >
vector_slice< VectorType >	project (viennacl::vector_slice< VectorType > &vec, viennacl::slice const &s1)
template<typename VectorType >
vector_slice< VectorType >	project (viennacl::vector_slice< VectorType > &vec, viennacl::range const &r1)
template<typename VectorType >
vector_slice< VectorType >	project (viennacl::vector_range< VectorType > &vec, viennacl::slice const &s1)

---

Detailed Description

Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them.

---

Typedef Documentation

typedef basic_range range

typedef basic_slice slice

typedef std::ptrdiff_t vcl_ptrdiff_t

typedef std::size_t vcl_size_t

---

Enumeration Type Documentation

enum memory_types

Enumerator:

MEMORY_NOT_INITIALIZED
MAIN_MEMORY
OPENCL_MEMORY
CUDA_MEMORY

---

Function Documentation

T any_cast

(

any &

a

)

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		coordinate_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

Copies a sparse matrix from the host to the OpenCL device (either GPU or multi-core CPU)

For the requirements on the CPU_MATRIX type, see the documentation of the function copy(CPU_MATRIX, compressed_matrix<>)

Parameters:

cpu_matrix	A sparse matrix on the host.
gpu_matrix	A compressed_matrix from ViennaCL

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		matrix_range< matrix< SCALARTYPE, row_major, 1 > > &	gpu_matrix_range
	)

void viennacl::copy	(	const VectorType &	cpu_vector,
		vector_range< vector< SCALARTYPE > > &	gpu_vector_range
	)

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		ell_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		hyb_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		compressed_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

Copies a sparse matrix from the host to the OpenCL device (either GPU or multi-core CPU)

There are some type requirements on the CPU_MATRIX type (fulfilled by e.g. boost::numeric::ublas):

• .size1() returns the number of rows
• .size2() returns the number of columns
• const_iterator1 is a type definition for an iterator along increasing row indices
• const_iterator2 is a type definition for an iterator along increasing columns indices
• The const_iterator1 type provides an iterator of type const_iterator2 via members .begin() and .end() that iterates along column indices in the current row.
• The types const_iterator1 and const_iterator2 provide members functions .index1() and .index2() that return the current row and column indices respectively.
• Dereferenciation of an object of type const_iterator2 returns the entry.

Parameters:

cpu_matrix	A sparse matrix on the host.
gpu_matrix	A compressed_matrix from ViennaCL

void viennacl::copy	(	vector_range< vector< SCALARTYPE > > const &	gpu_vector_range,
		VectorType &	cpu_vector
	)

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		matrix_range< matrix< SCALARTYPE, column_major, 1 > > &	gpu_matrix_range
	)

void copy	(	CPU_ITERATOR const &	cpu_begin,
		CPU_ITERATOR const &	cpu_end,
		vector_iterator< SCALARTYPE, ALIGNMENT >	gpu_begin
	)

STL-like transfer for the entries of a GPU vector to the CPU. The cpu type does not need to lie in a linear piece of memory.

Parameters:

cpu_begin	CPU iterator pointing to the beginning of the gpu vector (STL-like)
cpu_end	CPU iterator pointing to the end of the vector (STL-like)
gpu_begin	Output iterator for the gpu vector. The gpu vector must be at least as long as the cpu vector!

void viennacl::copy	(	const std::vector< std::map< unsigned int, SCALARTYPE > > &	cpu_matrix,
		coordinate_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

Copies a sparse matrix in the std::vector< std::map < > > format to an OpenCL device.

Parameters:

cpu_matrix	A sparse square matrix on the host.
gpu_matrix	A coordinate_matrix from ViennaCL

void copy	(	const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &	gpu_src_begin,
		const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &	gpu_src_end,
		vector_iterator< SCALARTYPE, ALIGNMENT_DEST >	gpu_dest_begin
	)

Copy (parts of a) GPU vector to another GPU vector.

Parameters:

gpu_src_begin	GPU iterator pointing to the beginning of the gpu vector (STL-like)
gpu_src_end	GPU iterator pointing to the end of the vector (STL-like)
gpu_dest_begin	Output iterator for the gpu vector. The gpu_dest vector must be at least as long as the gpu_src vector!

void viennacl::copy	(	const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &	gpu_src_begin,
		const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &	gpu_src_end,
		const_vector_iterator< SCALARTYPE, ALIGNMENT_DEST >	gpu_dest_begin
	)

void viennacl::copy	(	const coordinate_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix,
		CPU_MATRIX &	cpu_matrix
	)

Copies a sparse matrix from the OpenCL device (either GPU or multi-core CPU) to the host.

There are two type requirements on the CPU_MATRIX type (fulfilled by e.g. boost::numeric::ublas):

• resize(rows, cols) A resize function to bring the matrix into the correct size
• operator(i,j) Write new entries via the parenthesis operator

Parameters:

gpu_matrix	A coordinate_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host.

void viennacl::copy	(	const ell_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix,
		CPU_MATRIX &	cpu_matrix
	)

void viennacl::copy	(	const std::vector< std::map< SizeType, SCALARTYPE > > &	cpu_matrix,
		compressed_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

Copies a sparse square matrix in the std::vector< std::map < > > format to an OpenCL device. Use viennacl::tools::sparse_matrix_adapter for non-square matrices.

Parameters:

cpu_matrix	A sparse square matrix on the host using STL types
gpu_matrix	A compressed_matrix from ViennaCL

void viennacl::copy	(	std::vector< SCALARTYPE > &	cpu_vec,
		vandermonde_matrix< SCALARTYPE, ALIGNMENT > &	gpu_mat
	)

Copies a Vandermonde matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)

Parameters:

cpu_vec	A std::vector on the host.
gpu_mat	A vandermonde_matrix from ViennaCL

void viennacl::copy	(	std::vector< SCALARTYPE > const &	cpu_vec,
		hankel_matrix< SCALARTYPE, ALIGNMENT > &	gpu_mat
	)

Copies a Hankel matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)

Parameters:

cpu_vec	A std::vector on the host.
gpu_mat	A hankel_matrix from ViennaCL

void viennacl::copy	(	std::vector< SCALARTYPE > &	cpu_vec,
		circulant_matrix< SCALARTYPE, ALIGNMENT > &	gpu_mat
	)

Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)

Parameters:

cpu_vec	A std::vector on the host.
gpu_mat	A circulant_matrix from ViennaCL

void viennacl::copy	(	matrix_range< matrix< SCALARTYPE, row_major, 1 > > const &	gpu_matrix_range,
		CPU_MATRIX &	cpu_matrix
	)

void viennacl::copy	(	std::vector< SCALARTYPE > const &	cpu_vec,
		toeplitz_matrix< SCALARTYPE, ALIGNMENT > &	gpu_mat
	)

Copies a Toeplitz matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU)

Parameters:

cpu_vec	A std::vector on the host.
gpu_mat	A toeplitz_matrix from ViennaCL

void viennacl::copy	(	vandermonde_matrix< SCALARTYPE, ALIGNMENT > &	gpu_mat,
		std::vector< SCALARTYPE > &	cpu_vec
	)

Copies a Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.

Parameters:

gpu_mat	A vandermonde_matrix from ViennaCL
cpu_vec	A std::vector on the host.

void viennacl::copy	(	hankel_matrix< SCALARTYPE, ALIGNMENT > const &	gpu_mat,
		std::vector< SCALARTYPE > &	cpu_vec
	)

Copies a Hankel matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.

Parameters:

gpu_mat	A hankel_matrix from ViennaCL
cpu_vec	A std::vector on the host.

void viennacl::copy	(	const coordinate_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix,
		std::vector< std::map< unsigned int, SCALARTYPE > > &	cpu_matrix
	)

Copies a sparse matrix from an OpenCL device to the host. The host type is the std::vector< std::map < > > format .

Parameters:

gpu_matrix	A coordinate_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host.

void viennacl::copy	(	circulant_matrix< SCALARTYPE, ALIGNMENT > &	gpu_mat,
		std::vector< SCALARTYPE > &	cpu_vec
	)

Copies a circulant matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.

Parameters:

gpu_mat	A circulant_matrix from ViennaCL
cpu_vec	A std::vector on the host.

void viennacl::copy	(	vandermonde_matrix< SCALARTYPE, ALIGNMENT > &	vander_src,
		MATRIXTYPE &	com_dst
	)

Copies a Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.

Parameters:

vander_src	A vandermonde_matrix from ViennaCL
com_dst	A matrix-like object

void viennacl::copy	(	hankel_matrix< SCALARTYPE, ALIGNMENT > const &	han_src,
		MATRIXTYPE &	com_dst
	)

Copies a Hankel matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.

Parameters:

han_src	A hankel_matrix from ViennaCL
com_dst	A matrix-like object

void viennacl::copy	(	circulant_matrix< SCALARTYPE, ALIGNMENT > &	circ_src,
		MATRIXTYPE &	com_dst
	)

Copies a circulant matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.

Parameters:

circ_src	A circulant_matrix from ViennaCL
com_dst	A matrix-like object

void viennacl::copy	(	toeplitz_matrix< SCALARTYPE, ALIGNMENT > const &	gpu_mat,
		std::vector< SCALARTYPE > &	cpu_vec
	)

Copies a Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector.

Parameters:

gpu_mat	A toeplitz_matrix from ViennaCL
cpu_vec	A std::vector on the host.

void viennacl::copy	(	const VectorType &	cpu_vector,
		vector_slice< vector< SCALARTYPE > > &	gpu_vector_slice
	)

void viennacl::copy	(	const hyb_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix,
		CPU_MATRIX &	cpu_matrix
	)

void viennacl::copy	(	MATRIXTYPE &	com_src,
		vandermonde_matrix< SCALARTYPE, ALIGNMENT > &	vander_dst
	)

Copies a the matrix-like object to the Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU)

Parameters:

com_src	A std::vector on the host
vander_dst	A vandermonde_matrix from ViennaCL

void viennacl::copy	(	MATRIXTYPE const &	com_src,
		hankel_matrix< SCALARTYPE, ALIGNMENT > &	han_dst
	)

Copies a the matrix-like object to the Hankel matrix from the OpenCL device (either GPU or multi-core CPU)

Parameters:

com_src	A std::vector on the host
han_dst	A hankel_matrix from ViennaCL

void viennacl::copy	(	toeplitz_matrix< SCALARTYPE, ALIGNMENT > const &	tep_src,
		MATRIXTYPE &	com_dst
	)

Copies a Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object.

Parameters:

tep_src	A toeplitz_matrix from ViennaCL
com_dst	A matrix-like object

void viennacl::copy	(	matrix_range< matrix< SCALARTYPE, column_major, 1 > > const &	gpu_matrix_range,
		CPU_MATRIX &	cpu_matrix
	)

void viennacl::copy	(	MATRIXTYPE &	com_src,
		circulant_matrix< SCALARTYPE, ALIGNMENT > &	circ_dst
	)

Copies a the matrix-like object to the circulant matrix from the OpenCL device (either GPU or multi-core CPU)

Parameters:

com_src	A std::vector on the host
circ_dst	A circulant_matrix from ViennaCL

void viennacl::copy	(	vector_slice< vector< SCALARTYPE > > const &	gpu_vector_slice,
		VectorType &	cpu_vector
	)

void viennacl::copy	(	MATRIXTYPE const &	com_src,
		toeplitz_matrix< SCALARTYPE, ALIGNMENT > &	tep_dst
	)

Copies a the matrix-like object to the Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU)

Parameters:

com_src	A std::vector on the host
tep_dst	A toeplitz_matrix from ViennaCL

void viennacl::copy	(	const compressed_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix,
		CPU_MATRIX &	cpu_matrix
	)

Copies a sparse matrix from the OpenCL device (either GPU or multi-core CPU) to the host.

There are two type requirements on the CPU_MATRIX type (fulfilled by e.g. boost::numeric::ublas):

• resize(rows, cols) A resize function to bring the matrix into the correct size
• operator(i,j) Write new entries via the parenthesis operator

Parameters:

gpu_matrix	A compressed_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host.

void viennacl::copy	(	const compressed_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix,
		std::vector< std::map< unsigned int, SCALARTYPE > > &	cpu_matrix
	)

Copies a sparse matrix from an OpenCL device to the host. The host type is the std::vector< std::map < > > format .

Parameters:

gpu_matrix	A compressed_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host.

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		matrix_slice< matrix< SCALARTYPE, row_major, 1 > > &	gpu_matrix_slice
	)

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		matrix_slice< matrix< SCALARTYPE, column_major, 1 > > &	gpu_matrix_slice
	)

void viennacl::copy	(	matrix_slice< matrix< SCALARTYPE, row_major, 1 > > const &	gpu_matrix_slice,
		CPU_MATRIX &	cpu_matrix
	)

void viennacl::copy	(	matrix_slice< matrix< SCALARTYPE, column_major, 1 > > const &	gpu_matrix_slice,
		CPU_MATRIX &	cpu_matrix
	)

void viennacl::copy	(	const CPU_MATRIX &	cpu_matrix,
		matrix< SCALARTYPE, F, ALIGNMENT > &	gpu_matrix
	)

Copies a dense matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU)

Parameters:

cpu_matrix	A dense matrix on the host. Type requirements: .size1() returns number of rows, .size2() returns number of columns. Access to entries via operator()
gpu_matrix	A dense ViennaCL matrix

void viennacl::copy	(	const std::vector< std::vector< SCALARTYPE, A1 >, A2 > &	cpu_matrix,
		matrix< SCALARTYPE, F, ALIGNMENT > &	gpu_matrix
	)

Copies a dense STL-type matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU)

Parameters:

cpu_matrix	A dense matrix on the host of type std::vector< std::vector<> >. cpu_matrix[i][j] returns the element in the i-th row and j-th columns (both starting with zero)
gpu_matrix	A dense ViennaCL matrix

void viennacl::copy	(	const matrix< SCALARTYPE, F, ALIGNMENT > &	gpu_matrix,
		CPU_MATRIX &	cpu_matrix
	)

Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU).

Parameters:

gpu_matrix	A dense ViennaCL matrix
cpu_matrix	A dense memory on the host. Must have at least as many rows and columns as the gpu_matrix! Type requirement: Access to entries via operator()

void viennacl::copy	(	const matrix< SCALARTYPE, F, ALIGNMENT > &	gpu_matrix,
		std::vector< std::vector< SCALARTYPE, A1 >, A2 > &	cpu_matrix
	)

Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU).

Parameters:

gpu_matrix	A dense ViennaCL matrix
cpu_matrix	A dense memory on the host using STL types, typically std::vector< std::vector<> > Must have at least as many rows and columns as the gpu_matrix! Type requirement: Access to entries via operator()

void viennacl::copy	(	const const_vector_iterator< SCALARTYPE, ALIGNMENT > &	gpu_begin,
		const const_vector_iterator< SCALARTYPE, ALIGNMENT > &	gpu_end,
		CPU_ITERATOR	cpu_begin
	)

STL-like transfer for the entries of a GPU vector to the CPU. The cpu type does not need to lie in a linear piece of memory.

Parameters:

gpu_begin	GPU constant iterator pointing to the beginning of the gpu vector (STL-like)
gpu_end	GPU constant iterator pointing to the end of the vector (STL-like)
cpu_begin	Output iterator for the cpu vector. The cpu vector must be at least as long as the gpu vector!

void viennacl::copy	(	const vector_iterator< SCALARTYPE, ALIGNMENT > &	gpu_begin,
		const vector_iterator< SCALARTYPE, ALIGNMENT > &	gpu_end,
		CPU_ITERATOR	cpu_begin
	)

STL-like transfer for the entries of a GPU vector to the CPU. The cpu type does not need to lie in a linear piece of memory.

Parameters:

gpu_begin	GPU iterator pointing to the beginning of the gpu vector (STL-like)
gpu_end	GPU iterator pointing to the end of the vector (STL-like)
cpu_begin	Output iterator for the cpu vector. The cpu vector must be at least as long as the gpu vector!

void viennacl::copy	(	vector_base< NumericT > const &	gpu_vec,
		CPUVECTOR &	cpu_vec
	)

Transfer from a gpu vector to a cpu vector. Convenience wrapper for viennacl::linalg::copy(gpu_vec.begin(), gpu_vec.end(), cpu_vec.begin());.

Parameters:

gpu_vec	A gpu vector
cpu_vec	The cpu vector. Type requirements: Output iterator can be obtained via member function .begin()

void viennacl::copy	(	const CPUVECTOR &	cpu_vec,
		vector_base< T > &	gpu_vec
	)

Transfer from a cpu vector to a gpu vector. Convenience wrapper for viennacl::linalg::copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());.

Parameters:

cpu_vec	A cpu vector. Type requirements: Iterator can be obtained via member function .begin() and .end()
gpu_vec	The gpu vector.

void viennacl::copy	(	vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &	gpu_src_begin,
		vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &	gpu_src_end,
		vector_iterator< SCALARTYPE, ALIGNMENT_DEST >	gpu_dest_begin
	)

Copy (parts of a) GPU vector to another GPU vector.

Parameters:

gpu_src_begin	GPU iterator pointing to the beginning of the gpu vector (STL-like)
gpu_src_end	GPU iterator pointing to the end of the vector (STL-like)
gpu_dest_begin	Output iterator for the gpu vector. The gpu vector must be at least as long as the cpu vector!

void viennacl::copy	(	vector< SCALARTYPE, ALIGNMENT_SRC > const &	gpu_src_vec,
		vector< SCALARTYPE, ALIGNMENT_DEST > &	gpu_dest_vec
	)

Transfer from a ViennaCL vector to another ViennaCL vector. Convenience wrapper for viennacl::linalg::copy(gpu_src_vec.begin(), gpu_src_vec.end(), gpu_dest_vec.begin());.

Parameters:

gpu_src_vec	A gpu vector
gpu_dest_vec	The cpu vector. Type requirements: Output iterator can be obtained via member function .begin()

void viennacl::fast_copy	(	const CPUVECTOR &	cpu_vec,
		vector_range< VectorType > &	gpu_vec
	)

Transfer from a cpu vector to a gpu vector. Convenience wrapper for viennacl::linalg::fast_copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());.

Parameters:

cpu_vec	A cpu vector. Type requirements: Iterator can be obtained via member function .begin() and .end()
gpu_vec	The gpu vector.

void viennacl::fast_copy	(	vector_range< VectorType > const &	gpu_vec,
		CPUVECTOR &	cpu_vec
	)

Transfer from a GPU vector range to a CPU vector. Convenience wrapper for viennacl::linalg::fast_copy(gpu_vec.begin(), gpu_vec.end(), cpu_vec.begin());.

Parameters:

gpu_vec	A gpu vector range.
cpu_vec	The cpu vector. Type requirements: Output iterator can be obtained via member function .begin()

void fast_copy	(	const const_vector_iterator< SCALARTYPE, ALIGNMENT > &	gpu_begin,
		const const_vector_iterator< SCALARTYPE, ALIGNMENT > &	gpu_end,
		CPU_ITERATOR	cpu_begin
	)

STL-like transfer of a GPU vector to the CPU. The cpu type is assumed to reside in a linear piece of memory, such as e.g. for std::vector.

This method is faster than the plain copy() function, because entries are directly written to the cpu vector, starting with &(*cpu.begin()) However, keep in mind that the cpu type MUST represent a linear piece of memory, otherwise you will run into undefined behavior.

Parameters:

gpu_begin	GPU iterator pointing to the beginning of the gpu vector (STL-like)
gpu_end	GPU iterator pointing to the end of the vector (STL-like)
cpu_begin	Output iterator for the cpu vector. The cpu vector must be at least as long as the gpu vector!

void fast_copy	(	CPU_ITERATOR const &	cpu_begin,
		CPU_ITERATOR const &	cpu_end,
		vector_iterator< SCALARTYPE, ALIGNMENT >	gpu_begin
	)

STL-like transfer of a CPU vector to the GPU. The cpu type is assumed to reside in a linear piece of memory, such as e.g. for std::vector.

This method is faster than the plain copy() function, because entries are directly read from the cpu vector, starting with &(*cpu.begin()). However, keep in mind that the cpu type MUST represent a linear piece of memory, otherwise you will run into undefined behavior.

Parameters:

cpu_begin	CPU iterator pointing to the beginning of the cpu vector (STL-like)
cpu_end	CPU iterator pointing to the end of the vector (STL-like)
gpu_begin	Output iterator for the gpu vector. The gpu iterator must be incrementable (cpu_end - cpu_begin) times, otherwise the result is undefined.

void viennacl::fast_copy	(	SCALARTYPE *	cpu_matrix_begin,
		SCALARTYPE *	cpu_matrix_end,
		matrix< SCALARTYPE, F, ALIGNMENT > &	gpu_matrix
	)

Copies a dense matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU) without temporary. Matrix-Layout on CPU must be equal to the matrix-layout on the GPU.

Parameters:

cpu_matrix_begin	Pointer to the first matrix entry. Cf. iterator concept in STL
cpu_matrix_end	Pointer past the last matrix entry. Cf. iterator concept in STL
gpu_matrix	A dense ViennaCL matrix

void viennacl::fast_copy	(	const matrix< SCALARTYPE, F, ALIGNMENT > &	gpu_matrix,
		SCALARTYPE *	cpu_matrix_begin
	)

Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU).

Parameters:

gpu_matrix	A dense ViennaCL matrix
cpu_matrix_begin	Pointer to the output memory on the CPU. User must ensure that provided memory is large enough.

void viennacl::fast_copy	(	vector_base< NumericT > const &	gpu_vec,
		CPUVECTOR &	cpu_vec
	)

Transfer from a gpu vector to a cpu vector. Convenience wrapper for viennacl::linalg::fast_copy(gpu_vec.begin(), gpu_vec.end(), cpu_vec.begin());.

Parameters:

gpu_vec	A gpu vector.
cpu_vec	The cpu vector. Type requirements: Output iterator can be obtained via member function .begin()

void viennacl::fast_copy	(	const CPUVECTOR &	cpu_vec,
		vector_base< NumericT > &	gpu_vec
	)

Transfer from a cpu vector to a gpu vector. Convenience wrapper for viennacl::linalg::fast_copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());.

Parameters:

cpu_vec	A cpu vector. Type requirements: Iterator can be obtained via member function .begin() and .end()
gpu_vec	The gpu vector.

vector<SCALARTYPE, ALIGNMENT>& viennacl::fast_swap	(	vector< SCALARTYPE, ALIGNMENT > &	v1,
		vector< SCALARTYPE, ALIGNMENT > &	v2
	)

Swaps the content of two vectors by swapping OpenCL handles only, NO data is copied.

Parameters:

v1	The first vector
v2	The second vector

viennacl::memory_types viennacl::memory_domain

(

T &

obj

)

Returns the currently active memory domain for an object.

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, matrix_expression< const matrix_base<NumericT, F>, const S1, op_prod> >::type viennacl::operator*	(	S1 const &	value,
		matrix_base< NumericT, F > const &	m1
	)

Operator overload for the expression alpha * m1, where alpha is a host scalar (float or double) and m1 is a ViennaCL matrix.

Parameters:

value	The host scalar (float or double)
m1	A ViennaCL matrix

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, typename matrix_expression< LHS, RHS, OP>::matrix_type >::type viennacl::operator*	(	matrix_expression< LHS, RHS, OP > const &	proxy,
		S1 const &	val
	)

Operator overload for the multiplication of a matrix expression with a scalar from the right, e.g. (beta * m1) * alpha. Here, beta * m1 is wrapped into a matrix_expression and then multiplied with alpha from the right.

Parameters:

proxy	Left hand side matrix expression
val	Right hand side scalar

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, typename matrix_expression< LHS, RHS, OP>::matrix_type >::type viennacl::operator*	(	S1 const &	val,
		matrix_expression< LHS, RHS, OP > const &	proxy
	)

Operator overload for the multiplication of a matrix expression with a ViennaCL scalar from the left, e.g. alpha * (beta * m1). Here, beta * m1 is wrapped into a matrix_expression and then multiplied with alpha from the left.

Parameters:

val	Right hand side scalar
proxy	Left hand side matrix expression

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, matrix_expression< const matrix_base<NumericT, F>, const S1, op_prod> >::type viennacl::operator*	(	matrix_base< NumericT, F > const &	m1,
		S1 const &	s1
	)

Scales the matrix by a GPU scalar 'alpha' and returns an expression template.

viennacl::enable_if< viennacl::is_cpu_scalar< S1 >::value, viennacl::matrix_expression< const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod >, const NumericT, op_prod > >::type operator*	(	const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy,
		const S1 &	val
	)

viennacl::enable_if< viennacl::is_cpu_scalar< S1 >::value, viennacl::matrix_expression< const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod >, const NumericT, op_prod > >::type operator*	(	const S1 &	val,
		const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy
	)

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, vector_expression< const vector_base<T>, const S1, op_prod> >::type viennacl::operator*	(	S1 const &	value,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a host scalar (float or double) and v1 is a ViennaCL vector.

Parameters:

value	The host scalar (float or double)
vec	A ViennaCL vector

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, viennacl::vector<typename viennacl::result_of::cpu_value_type<RHS>::type> >::type viennacl::operator*	(	vector_expression< LHS, RHS, OP > const &	proxy,
		S1 const &	val
	)

Operator overload for the multiplication of a vector expression with a scalar from the right, e.g. (beta * vec1) * alpha. Here, beta * vec1 is wrapped into a vector_expression and then multiplied with alpha from the right.

Parameters:

proxy	Left hand side vector expression
val	Right hand side scalar

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, viennacl::vector<typename viennacl::result_of::cpu_value_type<RHS>::type> >::type viennacl::operator*	(	S1 const &	val,
		vector_expression< LHS, RHS, OP > const &	proxy
	)

Operator overload for the multiplication of a vector expression with a ViennaCL scalar from the left, e.g. alpha * (beta * vec1). Here, beta * vec1 is wrapped into a vector_expression and then multiplied with alpha from the left.

Parameters:

val	Right hand side scalar
proxy	Left hand side vector expression

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, vector_expression< const vector_base<T>, const S1, op_prod> >::type viennacl::operator*	(	vector_base< T > const &	v1,
		S1 const &	s1
	)

Scales the vector by a GPU scalar 'alpha' and returns an expression template.

viennacl::enable_if< viennacl::is_scalar<S1>::value, matrix_base<NumericT, F> & >::type viennacl::operator*=	(	matrix_base< NumericT, F > &	m1,
		S1 const &	gpu_val
	)

Scales a matrix by a GPU scalar value.

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, vector_base<T> & >::type viennacl::operator*=	(	vector_base< T > &	v1,
		S1 const &	gpu_val
	)

Scales this vector by a GPU scalar value.

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value, viennacl::vector<SCALARTYPE> >::type viennacl::operator+	(	viennacl::vector_base< SCALARTYPE > &	result,
		const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &	proxy
	)

Implementation of the operation 'result = v1 + A * v2', where A is a matrix.

Parameters:

result	The vector the result is written to.
proxy	An expression template proxy class holding v1, A, and v2.

viennacl::vector<NumericT> viennacl::operator+	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, op_prod > &	proxy
	)

Implementation of the operation 'result = v1 + A * v2', where A is a matrix.

Parameters:

v1	The addend vector.
proxy	An expression template proxy class.

vector<NumericT> viennacl::operator+	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &	proxy
	)

Implementation of the operation 'result = v1 + A * v2', where A is a matrix.

Parameters:

v1	The addend vector.
proxy	An expression template proxy class.

matrix_expression< LHS1, RHS1, OP1>::matrix_type viennacl::operator+	(	matrix_expression< LHS1, RHS1, OP1 > const &	proxy1,
		matrix_expression< LHS2, RHS2, OP2 > const &	proxy2
	)

Generic 'catch-all' overload, which enforces a temporary if the expression tree gets too deep.

matrix<NumericT, F> viennacl::operator+	(	matrix_expression< LHS1, RHS1, OP1 > const &	proxy1,
		matrix_base< NumericT, F > const &	proxy2
	)

matrix<NumericT, F> viennacl::operator+	(	matrix_base< NumericT, F > const &	proxy1,
		matrix_expression< LHS2, RHS2, OP2 > const &	proxy2
	)

matrix_expression< const matrix_base<NumericT, F>, const matrix_base<NumericT, F>, op_add > viennacl::operator+	(	const matrix_base< NumericT, F > &	m1,
		const matrix_base< NumericT, F > &	m2
	)

Operator overload for m1 + m2, where m1 and m2 are either dense matrices, matrix ranges, or matrix slices. No mixing of different storage layouts allowed at the moment.

viennacl::enable_if< viennacl::is_any_scalar<S3>::value, matrix_expression< const matrix_base<NumericT, F>, const matrix_expression<const matrix_base<NumericT, F>, const S3, OP>, op_add > >::type viennacl::operator+	(	const matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const S3, OP > &	proxy
	)

Operator overload for the addition of a matrix expression m1 + m2 @ beta, where @ is either product or division, and beta is either a CPU or GPU scalar.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, matrix_expression< const matrix_expression<const matrix_base<NumericT, F>, const S2, OP>, const matrix_base<NumericT, F>, op_add > >::type viennacl::operator+	(	const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &	proxy,
		const matrix_base< NumericT, F > &	m3
	)

Operator overload for the addition of a matrix expression m1 @ alpha + m2, where @ is either product or division, and beta is either a CPU or GPU scalar.

viennacl::enable_if< viennacl::is_any_scalar<S1>::value && viennacl::is_any_scalar<S2>::value, matrix_expression<const matrix_expression<const matrix_base<NumericT, F>, const S1, OP1>, const matrix_expression<const matrix_base<NumericT, F>, const S2, OP2>, op_add> >::type viennacl::operator+	(	matrix_expression< const matrix_base< NumericT, F >, const S1, OP1 > const &	lhs,
		matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 > const &	rhs
	)

Operator overload for the addition of a matrix expression m1 @ alpha + m2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

lhs	Left hand side vector expression
rhs	Right hand side vector (also -range and -slice is allowed)

vector_expression< LHS1, RHS1, OP1>::VectorType viennacl::operator+	(	vector_expression< LHS1, RHS1, OP1 > const &	proxy1,
		vector_expression< LHS2, RHS2, OP2 > const &	proxy2
	)

Operator overload for the addition of two vector expressions.

Parameters:

proxy1	Left hand side vector expression
proxy2	Right hand side vector expression

viennacl::vector<T> viennacl::operator+	(	vector_expression< LHS, RHS, OP > const &	proxy,
		vector_base< T > const &	vec
	)

Operator overload for the addition of a vector expression with a vector or another vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.

Parameters:

proxy	Left hand side vector expression
vec	Right hand side vector (also -range and -slice is allowed)

viennacl::vector<T> viennacl::operator+	(	vector_base< T > const &	vec,
		vector_expression< LHS, RHS, OP > const &	proxy
	)

Operator overload for the addition of a vector with a vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.

Parameters:

proxy	Left hand side vector expression
vec	Right hand side vector (also -range and -slice is allowed)

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, vector_expression<const vector_expression<const vector_base<T>, const S1, OP1>, const vector_base<T>, op_add> >::type viennacl::operator+	(	vector_expression< const vector_base< T >, const S1, OP1 > const &	proxy,
		vector_base< T > const &	vec
	)

Operator overload for the addition of a vector expression v1 @ alpha + v2, where @ denotes either product or division, and alpha is either a CPU or a GPU scalar.

Parameters:

proxy	Left hand side vector expression
vec	Right hand side vector (also -range and -slice is allowed)

viennacl::enable_if< viennacl::is_any_scalar<S1>::value && viennacl::is_any_scalar<S2>::value, vector_expression<const vector_expression<const vector_base<T>, const S1, OP1>, const vector_expression<const vector_base<T>, const S2, OP2>, op_add> >::type viennacl::operator+	(	vector_expression< const vector_base< T >, const S1, OP1 > const &	lhs,
		vector_expression< const vector_base< T >, const S2, OP2 > const &	rhs
	)

Operator overload for the addition of a vector expression v1 @ alpha + v2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

lhs	Left hand side addend v1 @ alpha
rhs	Right hand side addend v2 @ beta

vector_expression< const vector_base<T>, const vector_base<T>, op_add> viennacl::operator+	(	const vector_base< T > &	v1,
		const vector_base< T > &	v2
	)

Returns an expression template object for adding up two vectors, i.e. v1 + v2.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, vector_expression< const vector_base<T>, const vector_expression< const vector_base<T>, const S2, OP2>, op_add> >::type viennacl::operator+	(	const vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const S2, OP2 > &	proxy
	)

Returns an expression template object for adding up two vectors, one being scaled, i.e. v1 + v2 * alpha, where alpha is a CPU or a GPU scalar.

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value, viennacl::vector_base<SCALARTYPE> & >::type viennacl::operator+=	(	viennacl::vector_base< SCALARTYPE > &	result,
		const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &	proxy
	)

Implementation of the operation v1 += A * v2, where A is a matrix.

Parameters:

result	The result vector v1
proxy	An expression template proxy class.

vector<NumericT> viennacl::operator+=	(	vector_base< NumericT > &	v1,
		const viennacl::vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, viennacl::op_prod > &	proxy
	)

Implementation of the operation v1 += A * v2, where A is a matrix.

Parameters:

v1	The result vector v1 where A * v2 is added to
proxy	An expression template proxy class.

vector<NumericT> viennacl::operator+=	(	vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &	proxy
	)

Implementation of the operation v1 += A * v2, where A is a matrix.

Parameters:

v1	The addend vector where the result is written to.
proxy	An expression template proxy class.

matrix_base<NumericT, F>& viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_base< NumericT, F > &	other
	)

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, matrix_base<NumericT, F> &>::type viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &	proxy
	)

Inplace addition of a scaled matrix, i.e. m1 += m2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.

viennacl::enable_if< viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value, matrix_base<NumericT, F> &>::type viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, OP > &	proxy
	)

Implementation of the operation m1 += m2 +- m3.

Parameters:

m1	The result matrix where m2 +- m3 is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), matrix_base<NumericT, F> &>::type viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation m1 += m2 +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

m1	The result matrix where m2 +- m3 @ beta is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), matrix_base<NumericT, F> &>::type viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_base< NumericT, F >, OP > &	proxy
	)

Implementation of the operation m1 += m2 @ alpha +- m3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

m1	The result matrix where m2 @ alpha +- m3 is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), matrix_base<NumericT, F> &>::type viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation m1 += m2 @ alpha +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

m1	The result matrix where m2 @ alpha +- m3 @ beta is added to
proxy	An expression template proxy class.

matrix_base<NumericT, F>& viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy
	)

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, matrix_base<NumericT, F> & >::type viennacl::operator+=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod >, const S1, op_prod > &	proxy
	)

matrix_base<NumericT, F1>& viennacl::operator+=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F3 >, op_prod > &	proxy
	)

matrix_base<NumericT, F1>& viennacl::operator+=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &	proxy
	)

matrix_base<NumericT, F1>& viennacl::operator+=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_base< NumericT, F3 >, op_prod > &	proxy
	)

matrix_base<NumericT, F1>& viennacl::operator+=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &	proxy
	)

vector_base<T>& viennacl::operator+=	(	vector_base< T > &	v1,
		const vector_base< T > &	v2
	)

Inplace addition of a vector.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, vector_base<T> &>::type viennacl::operator+=	(	vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const S2, OP > &	proxy
	)

Inplace addition of a scaled vector, i.e. v1 += v2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.

viennacl::enable_if< (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator+=	(	vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const vector_base< T >, OP > &	proxy
	)

Implementation of the operation v1 += v2 +- v3.

Parameters:

v1	The result vector where v2 +- v3 is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator+=	(	vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation v1 += v2 +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

v1	The result vector where v2 +- v3 @ beta is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator+=	(	vector_base< T > &	v1,
		const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_base< T >, OP > &	proxy
	)

Implementation of the operation v1 += v2 @ alpha +- v3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

v1	The result vector where v2 @ alpha +- v3 is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator+=	(	vector_base< T > &	v1,
		const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation v1 += v2 @ alpha +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

v1	The result vector where v2 @ alpha +- v3 @ beta is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value, viennacl::vector<SCALARTYPE> >::type viennacl::operator-	(	viennacl::vector_base< SCALARTYPE > &	result,
		const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &	proxy
	)

Implementation of the operation 'result = v1 - A * v2', where A is a matrix.

Parameters:

result	The vector the result is written to.
proxy	An expression template proxy class.

viennacl::vector<NumericT> viennacl::operator-	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, op_prod > &	proxy
	)

Implementation of the operation 'result = v1 - A * v2', where A is a matrix.

Parameters:

v1	The addend vector.
proxy	An expression template proxy class.

vector<NumericT> viennacl::operator-	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &	proxy
	)

Implementation of the operation 'result = v1 - A * v2', where A is a matrix.

Parameters:

v1	The addend vector.
proxy	An expression template proxy class.

matrix_expression< LHS1, RHS1, OP1>::matrix_type viennacl::operator-	(	matrix_expression< LHS1, RHS1, OP1 > const &	proxy1,
		matrix_expression< LHS2, RHS2, OP2 > const &	proxy2
	)

Generic 'catch-all' overload, which enforces a temporary if the expression tree gets too deep.

matrix<NumericT, F> viennacl::operator-	(	matrix_expression< LHS1, RHS1, OP1 > const &	proxy1,
		matrix_base< NumericT, F > const &	proxy2
	)

matrix<NumericT, F> viennacl::operator-	(	matrix_base< NumericT, F > const &	proxy1,
		matrix_expression< LHS2, RHS2, OP2 > const &	proxy2
	)

matrix_expression< const matrix_base<NumericT, F>, const matrix_base<NumericT, F>, op_sub > viennacl::operator-	(	const matrix_base< NumericT, F > &	m1,
		const matrix_base< NumericT, F > &	m2
	)

Operator overload for m1 - m2, where m1 and m2 are either dense matrices, matrix ranges, or matrix slices. No mixing of different storage layouts allowed at the moment.

viennacl::enable_if< viennacl::is_any_scalar<S3>::value, matrix_expression< const matrix_base<NumericT, F>, const matrix_expression<const matrix_base<NumericT, F>, const S3, OP>, op_sub > >::type viennacl::operator-	(	const matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const S3, OP > &	proxy
	)

Operator overload for the addition of a matrix expression m1 - m2 @ beta, where @ is either product or division, and beta is either a CPU or GPU scalar.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, matrix_expression< const matrix_expression<const matrix_base<NumericT, F>, const S2, OP>, const matrix_base<NumericT, F>, op_sub > >::type viennacl::operator-	(	const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &	proxy,
		const matrix_base< NumericT, F > &	m3
	)

Operator overload for the addition of a matrix expression m1 @ alpha - m2, where @ is either product or division, and beta is either a CPU or GPU scalar.

viennacl::enable_if< viennacl::is_any_scalar<S1>::value && viennacl::is_any_scalar<S2>::value, matrix_expression<const matrix_expression<const matrix_base<NumericT, F>, const S1, OP1>, const matrix_expression<const matrix_base<NumericT, F>, const S2, OP2>, op_sub> >::type viennacl::operator-	(	matrix_expression< const matrix_base< NumericT, F >, const S1, OP1 > const &	lhs,
		matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 > const &	rhs
	)

Operator overload for the addition of a matrix expression m1 @ alpha - m2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

lhs	Left hand side vector expression
rhs	Right hand side vector (also -range and -slice is allowed)

vector_expression< LHS1, RHS1, OP1>::VectorType viennacl::operator-	(	vector_expression< LHS1, RHS1, OP1 > const &	proxy1,
		vector_expression< LHS2, RHS2, OP2 > const &	proxy2
	)

Operator overload for the subtraction of two vector expressions.

Parameters:

proxy1	Left hand side vector expression
proxy2	Right hand side vector expression

viennacl::vector<T> viennacl::operator-	(	vector_expression< LHS, RHS, OP > const &	proxy,
		vector_base< T > const &	vec
	)

Operator overload for the subtraction of a vector expression with a vector or another vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.

Parameters:

proxy	Left hand side vector expression
vec	Right hand side vector (also -range and -slice is allowed)

viennacl::vector<T> viennacl::operator-	(	vector_base< T > const &	vec,
		vector_expression< LHS, RHS, OP > const &	proxy
	)

Operator overload for the subtraction of a vector expression with a vector or another vector expression. This is the default implementation for all cases that are too complex in order to be covered within a single kernel, hence a temporary vector is created.

Parameters:

proxy	Left hand side vector expression
vec	Right hand side vector (also -range and -slice is allowed)

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, vector_expression<const vector_expression<const vector_base<T>, const S1, OP1>, const vector_base<T>, op_sub> >::type viennacl::operator-	(	vector_expression< const vector_base< T >, const S1, OP1 > const &	proxy,
		vector_base< T > const &	vec
	)

Operator overload for the addition of a vector expression v1 @ alpha - v2, where @ denotes either product or division, and alpha is either a CPU or a GPU scalar.

Parameters:

proxy	Left hand side vector expression
vec	Right hand side vector (also -range and -slice is allowed)

viennacl::enable_if< viennacl::is_any_scalar<S1>::value && viennacl::is_any_scalar<S2>::value, vector_expression<const vector_expression<const vector_base<T>, const S1, OP1>, const vector_expression<const vector_base<T>, const S2, OP2>, op_sub> >::type viennacl::operator-	(	vector_expression< const vector_base< T >, const S1, OP1 > const &	lhs,
		vector_expression< const vector_base< T >, const S2, OP2 > const &	rhs
	)

Operator overload for the addition of a vector expression v1 @ alpha - v2 @ beta, where @ denotes either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

lhs	Left hand side addend v1 @ alpha
rhs	Right hand side addend v2 @ beta

vector_expression< const vector_base<T>, const vector_base<T>, op_sub> viennacl::operator-	(	const vector_base< T > &	v1,
		const vector_base< T > &	v2
	)

Returns an expression template object for subtracting two vectors, i.e. v1 - v2.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, vector_expression< const vector_base<T>, const vector_expression< const vector_base<T>, const S2, OP2>, op_sub> >::type viennacl::operator-	(	const vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const S2, OP2 > &	proxy
	)

Returns an expression template object for subtracting two vectors, one being scaled, i.e. v1 - v2 * alpha, where alpha is a CPU or a GPU scalar.

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value, viennacl::vector_base<SCALARTYPE> & >::type viennacl::operator-=	(	viennacl::vector_base< SCALARTYPE > &	result,
		const viennacl::vector_expression< const SparseMatrixType, const viennacl::vector_base< SCALARTYPE >, viennacl::op_prod > &	proxy
	)

Implementation of the operation v1 -= A * v2, where A is a matrix.

Parameters:

result	The result vector v1
proxy	An expression template proxy class.

vector<NumericT> viennacl::operator-=	(	vector_base< NumericT > &	v1,
		const viennacl::vector_expression< const matrix_base< NumericT, F >, const vector_base< NumericT >, viennacl::op_prod > &	proxy
	)

Implementation of the operation v1 -= A * v2, where A is a matrix.

Parameters:

v1	The result vector v1 where A * v2 is subtracted from
proxy	An expression template proxy class.

vector<NumericT> viennacl::operator-=	(	vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans >, const vector_base< NumericT >, op_prod > &	proxy
	)

Implementation of the operation v1 -= A * v2, where A is a matrix.

Parameters:

v1	The addend vector where the result is written to.
proxy	An expression template proxy class.

matrix_base<NumericT, F>& viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_base< NumericT, F > &	other
	)

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, matrix_base<NumericT, F> &>::type viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const S2, OP > &	proxy
	)

Inplace addition of a scaled matrix, i.e. m1 -= m2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.

viennacl::enable_if< viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value, matrix_base<NumericT, F> &>::type viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, OP > &	proxy
	)

Implementation of the operation m1 -= m2 +- m3.

Parameters:

m1	The result matrix where m2 +- m3 is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), matrix_base<NumericT, F> &>::type viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_base< NumericT, F >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation m1 -= m2 +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

m1	The result matrix where m2 +- m3 @ beta is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), matrix_base<NumericT, F> &>::type viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_base< NumericT, F >, OP > &	proxy
	)

Implementation of the operation m1 -= m2 @ alpha +- m3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

m1	The result matrix where m2 @ alpha +- m3 is added to
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), matrix_base<NumericT, F> &>::type viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F >, const S2, OP2 >, const matrix_expression< const matrix_base< NumericT, F >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation m1 -= m2 @ alpha +- m3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

m1	The result matrix where m2 @ alpha +- m3 @ beta is added to
proxy	An expression template proxy class.

matrix_base<NumericT, F>& viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy
	)

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, matrix_base<NumericT, F> & >::type viennacl::operator-=	(	matrix_base< NumericT, F > &	m1,
		const matrix_expression< const matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod >, const S1, op_prod > &	proxy
	)

matrix_base<NumericT, F1>& viennacl::operator-=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F3 >, op_prod > &	proxy
	)

vector_base<T>& viennacl::operator-=	(	vector_base< T > &	v1,
		const vector_base< T > &	vec
	)

Inplace subtraction of a vector.

matrix_base<NumericT, F1>& viennacl::operator-=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &	proxy
	)

viennacl::enable_if< viennacl::is_any_scalar<S2>::value, vector_base<T> &>::type viennacl::operator-=	(	vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const S2, OP > &	proxy
	)

Inplace subtraction of a scaled vector, i.e. v1 -= v2 @ alpha, where @ is either product or division and alpha is either a CPU or a GPU scalar.

matrix_base<NumericT, F1>& viennacl::operator-=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_base< NumericT, F3 >, op_prod > &	proxy
	)

viennacl::enable_if< (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator-=	(	vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const vector_base< T >, OP > &	proxy
	)

Implementation of the operation v1 -= v2 +- v3.

Parameters:

v1	The result vector where v2 +- v3 is subtracted from
proxy	An expression template proxy class.

matrix_base<NumericT, F1>& viennacl::operator-=	(	matrix_base< NumericT, F1 > &	m1,
		const matrix_expression< const matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >, const matrix_expression< const matrix_base< NumericT, F3 >, const matrix_base< NumericT, F3 >, op_trans >, op_prod > &	proxy
	)

viennacl::enable_if< viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator-=	(	vector_base< T > &	v1,
		const vector_expression< const vector_base< T >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation v1 -= v2 +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

v1	The result vector where v2 +- v3 @ beta is subtracted from
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator-=	(	vector_base< T > &	v1,
		const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_base< T >, OP > &	proxy
	)

Implementation of the operation v1 -= v2 @ alpha +- v3, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

v1	The result vector where v2 @ alpha +- v3 is subtracted from
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S2>::value && (viennacl::is_product<OP2>::value || viennacl::is_division<OP2>::value) && viennacl::is_any_scalar<S3>::value && (viennacl::is_product<OP3>::value || viennacl::is_division<OP3>::value) && (viennacl::is_addition<OP>::value || viennacl::is_subtraction<OP>::value), vector_base<T> &>::type viennacl::operator-=	(	vector_base< T > &	v1,
		const vector_expression< const vector_expression< const vector_base< T >, const S2, OP2 >, const vector_expression< const vector_base< T >, const S3, OP3 >, OP > &	proxy
	)

Implementation of the operation v1 -= v2 @ alpha +- v3 @ beta, where @ is either product or division, and alpha, beta are either CPU or GPU scalars.

Parameters:

v1	The result vector where v2 @ alpha +- v3 @ beta is subtracted from
proxy	An expression template proxy class.

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, typename matrix_expression< LHS, RHS, OP>::matrix_type >::type viennacl::operator/	(	matrix_expression< LHS, RHS, OP > const &	proxy,
		S1 const &	val
	)

Operator overload for the division of a matrix expression by a scalar from the right, e.g. (beta * m1) / alpha. Here, beta * m1 is wrapped into a matrix_expression and then divided by alpha.

Parameters:

proxy	Left hand side matrix expression
val	Right hand side scalar

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, matrix_expression< const matrix_base<NumericT, F>, const S1, op_div> >::type viennacl::operator/	(	matrix_base< NumericT, F > const &	m1,
		S1 const &	s1
	)

Returns an expression template for scaling the matrix by a GPU scalar 'alpha'.

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, viennacl::vector<typename viennacl::result_of::cpu_value_type<RHS>::type> >::type viennacl::operator/	(	vector_expression< LHS, RHS, OP > const &	proxy,
		S1 const &	val
	)

Operator overload for the division of a vector expression by a scalar from the right, e.g. (beta * vec1) / alpha. Here, beta * vec1 is wrapped into a vector_expression and then divided by alpha.

Parameters:

proxy	Left hand side vector expression
val	Right hand side scalar

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, vector_expression< const vector_base<T>, const S1, op_div> >::type viennacl::operator/	(	vector_base< T > const &	v1,
		S1 const &	s1
	)

Returns an expression template for scaling the vector by a GPU scalar 'alpha'.

viennacl::enable_if< viennacl::is_any_scalar<S1>::value, vector_base<T> & >::type viennacl::operator/=	(	vector_base< T > &	v1,
		S1 const &	gpu_val
	)

Scales this vector by a GPU scalar value.

viennacl::enable_if< viennacl::is_scalar<S1>::value, matrix_base<NumericT, F> & >::type viennacl::operator/=	(	matrix_base< NumericT, F > &	m1,
		S1 const &	gpu_val
	)

Scales a matrix by a GPU scalar value.

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		vandermonde_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

Prints the matrix. Output is compatible to boost::numeric::ublas.

Parameters:

s	STL output stream
gpu_matrix	A ViennaCL Vandermonde matrix

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		hankel_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		circulant_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

Prints the matrix. Output is compatible to boost::numeric::ublas.

Parameters:

s	STL output stream
gpu_matrix	A ViennaCL circulant matrix

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		matrix_range< MatrixType > const &	proxy
	)

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		matrix_range< const MatrixType > const &	proxy
	)

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		toeplitz_matrix< SCALARTYPE, ALIGNMENT > &	gpu_matrix
	)

Prints the matrix. Output is compatible to boost::numeric::ublas.

Parameters:

s	STL output stream
gpu_matrix	A ViennaCL Toeplitz matrix

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		const scalar< SCALARTYPE > &	val
	)

Allows to directly print the value of a scalar to an output stream.

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		const matrix< SCALARTYPE, F, ALIGNMENT > &	gpu_matrix
	)

Prints the matrix. Output is compatible to boost::numeric::ublas.

Parameters:

s	STL output stream
gpu_matrix	A dense ViennaCL matrix

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		const matrix_expression< LHS, RHS, OP > &	expr
	)

Prints the matrix. Output is compatible to boost::numeric::ublas.

Parameters:

s	STL output stream
expr	A matrix expression

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		vector_base< T > const &	val
	)

Output stream. Output format is ublas compatible.

Parameters:

s	STL output stream
val	The vector that should be printed

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		vector_expression< LHS, RHS, OP > const &	proxy
	)

std::istream& viennacl::operator>>	(	std::istream &	s,
		const scalar< SCALARTYPE > &	val
	)

Allows to directly read a value of a scalar from an input stream.

vector_range<VectorType> viennacl::project	(	VectorType &	vec,
		viennacl::range const &	r1
	)

vector_range<VectorType> viennacl::project	(	viennacl::vector_range< VectorType > &	vec,
		viennacl::range const &	r1
	)

vector_slice<VectorType> viennacl::project	(	VectorType &	vec,
		viennacl::slice const &	s1
	)

vector_slice<VectorType> viennacl::project	(	viennacl::vector_slice< VectorType > &	vec,
		viennacl::slice const &	s1
	)

vector_slice<VectorType> viennacl::project	(	viennacl::vector_slice< VectorType > &	vec,
		viennacl::range const &	r1
	)

vector_slice<VectorType> viennacl::project	(	viennacl::vector_range< VectorType > &	vec,
		viennacl::slice const &	s1
	)

matrix_range<MatrixType> viennacl::project	(	MatrixType &	A,
		viennacl::range const &	r1,
		viennacl::range const &	r2
	)

matrix_range<MatrixType> viennacl::project	(	matrix_range< MatrixType > &	A,
		viennacl::range const &	r1,
		viennacl::range const &	r2
	)

matrix_slice<MatrixType> viennacl::project	(	MatrixType &	A,
		viennacl::slice const &	r1,
		viennacl::slice const &	r2
	)

matrix_slice<MatrixType> viennacl::project	(	matrix_range< MatrixType > &	A,
		viennacl::slice const &	r1,
		viennacl::slice const &	r2
	)

matrix_slice<MatrixType> viennacl::project	(	matrix_slice< MatrixType > &	A,
		viennacl::slice const &	r1,
		viennacl::slice const &	r2
	)

std::vector<int> viennacl::reorder	(	MatrixType const &	matrix,
		gibbs_poole_stockmeyer_tag
	)

Function for the calculation of a node numbering permutation vector to reduce the bandwidth of a incidence matrix by the Gibbs-Poole-Stockmeyer algorithm.

references: Werner Neudorf: "Bandbreitenreduktion - Teil 3. Algorithmus von Gibbs-Poole-Stockmeyer. Testbeispiele mit CM und GPS", Preprint No. M 08/02, September 2002. Technische Universität Ilmenau, Fakultät für Mathematik und Naturwissenschaften, Institut für Mathematik. http://www.db-thueringen.de/servlets/DerivateServlet/Derivate-8673/IfM_Preprint_M_02_08.pdf (URL taken on June 14, 2011)

Parameters:

matrix

vector of n matrix rows, where each row is a map<int, double> containing only the nonzero elements

Returns:

permutation vector r. r[l] = i means that the new label of node i will be l.

std::vector<int> viennacl::reorder	(	MatrixType const &	matrix,
		cuthill_mckee_tag
	)

Function for the calculation of a node number permutation to reduce the bandwidth of an incidence matrix by the Cuthill-McKee algorithm.

references: Algorithm was implemented similary as described in "Tutorial: Bandwidth Reduction - The CutHill- McKee Algorithm" posted by Ciprian Zavoianu as weblog at http://ciprian-zavoianu.blogspot.com/2009/01/project-bandwidth-reduction.html on January 15, 2009 (URL taken on June 14, 2011)

Parameters:

matrix

vector of n matrix rows, where each row is a map<int, double> containing only the nonzero elements

Returns:

permutation vector r. r[l] = i means that the new label of node i will be l.

std::vector<int> viennacl::reorder	(	MatrixType const &	matrix,
		advanced_cuthill_mckee_tag const &	tag
	)

Function for the calculation of a node number permutation to reduce the bandwidth of an incidence matrix by the advanced Cuthill-McKee algorithm.

references: see description of original Cuthill McKee implementation, and E. Cuthill and J. McKee: "Reducing the Bandwidth of sparse symmetric Matrices". Naval Ship Research and Development Center, Washington, D. C., 20007

void viennacl::swap	(	vector_base< T > &	vec1,
		vector_base< T > &	vec2
	)

Swaps the contents of two vectors, data is copied.

Parameters:

vec1	The first vector
vec2	The second vector

void viennacl::switch_memory_domain	(	T &	obj,
		viennacl::memory_types	new_mem_domain
	)

Generic convenience routine for migrating data of an object to a new memory domain.

viennacl::enable_if<viennacl::is_any_sparse_matrix<M1>::value, matrix_expression< const M1, const M1, op_trans> >::type viennacl::trans

(

const M1 &

mat

)

Returns an expression template class representing a transposed matrix.

matrix_expression< const matrix_base<NumericT, F>, const matrix_base<NumericT, F>, op_trans> viennacl::trans

(

const matrix_base< NumericT, F > &

mat

)

Returns an expression template class representing a transposed matrix.