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

Namespaces
	backend
	Namespace providing routines for handling the different memory domains.

	detail
	Holds implementation details for functionality in the main viennacl-namespace. Not intended for direct use by library users.

	device_specific
	Provides an OpenCL kernel generator.

	io
	Provides basic input-output functionality.

	linalg
	Provides all linear algebra operations which are not covered by operator overloads.

	ocl
	OpenCL backend. Manages platforms, contexts, buffers, kernels, etc.

	result_of
	Namespace containing many meta-functions.

	scheduler
	Contains the scheduling functionality which allows for dynamic kernel generation as well as the fusion of multiple statements into a single kernel.

	tools
	Namespace for various tools used within ViennaCL.

	traits
	Namespace providing traits-information as well as generic wrappers to common routines for vectors and matrices such as size() or clear()

Classes
class	advanced_cuthill_mckee_tag
	Tag for the advanced Cuthill-McKee algorithm (i.e. running the 'standard' Cuthill-McKee algorithm for a couple of different seeds). More...

class	basic_range
	A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded. More...

class	basic_slice
	A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded. More...

class	circulant_matrix
	A Circulant matrix class. More...

struct	col_iteration
	A tag indicating iteration along increasing columns index of a matrix. More...

struct	column_major
	A tag for column-major storage of a dense matrix. More...

struct	column_major_tag
	Tag class for indicating column-major layout of a matrix. Not passed to the matrix directly, see row_major type. More...

class	compressed_compressed_matrix
	A sparse square matrix in compressed sparse rows format optimized for the case that only a few rows carry nonzero entries. More...

class	compressed_matrix
	A sparse square matrix in compressed sparse rows format. 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	const_vector_iterator
	A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!! More...

class	context
	Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also suitable for CUDA and OpenMP. 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	cuda_not_available_exception

struct	cuthill_mckee_tag
	A tag class for selecting the Cuthill-McKee algorithm for reducing the bandwidth of a sparse matrix. More...

class	ell_matrix
	Sparse matrix class using the ELLPACK format for storing the nonzeros. More...

struct	enable_if
	Simple enable-if variant that uses the SFINAE pattern. 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...

struct	gibbs_poole_stockmeyer_tag
	Tag class for identifying the Gibbs-Poole-Stockmeyer algorithm for reducing the bandwidth of a sparse matrix. More...

class	hankel_matrix
	A Hankel matrix class. More...

class	hyb_matrix
	Sparse matrix class using a hybrid format composed of the ELL and CSR format for storing the nonzeros. More...

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	implicit_matrix_base
	Base class for representing matrices where the individual entries are not all stored explicitly, e.g. identity_matrix<> More...

class	implicit_vector_base
	Common base class for representing vectors where the entries are not all stored explicitly. More...

struct	is_addition
	Helper metafunction for checking whether the provided type is viennacl::op_add (for addition) More...

struct	is_any_dense_matrix
	Checks for either matrix_base or implicit_matrix_base. More...

struct	is_any_dense_structured_matrix
	Helper class for checking whether the provided type is any of the dense structured matrix types (circulant, Hankel, etc.) More...

struct	is_any_scalar
	Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy) More...

struct	is_any_sparse_matrix
	Helper class for checking whether the provided type is one of the sparse matrix types (compressed_matrix, coordinate_matrix, etc.) More...

struct	is_any_vector
	Checks for a type being either vector_base or implicit_vector_base. More...

struct	is_circulant_matrix
	Helper class for checking whether a matrix is a circulant matrix. More...

struct	is_compressed_matrix
	Helper class for checking whether a matrix is a compressed_matrix (CSR format) More...

struct	is_coordinate_matrix
	Helper class for checking whether a matrix is a coordinate_matrix (COO format) More...

struct	is_cpu_scalar
	Helper struct for checking whether a type is a host scalar type (e.g. float, double) More...

struct	is_division
	Helper metafunction for checking whether the provided type is viennacl::op_div (for division) More...

struct	is_eigen
	Meta function which checks whether a tag is tag_eigen. More...

struct	is_ell_matrix
	Helper class for checking whether a matrix is an ell_matrix (ELL format) More...

struct	is_flip_sign_scalar
	Helper struct for checking whether a type represents a sign flip on a viennacl::scalar<> More...

struct	is_hankel_matrix
	Helper class for checking whether a matrix is a Hankel matrix. More...

struct	is_hyb_matrix
	Helper class for checking whether a matrix is a hyb_matrix (hybrid format: ELL plus CSR) More...

struct	is_mtl4
	Meta function which checks whether a tag is tag_mtl4. More...

struct	is_primitive_type
	Helper class for checking whether a type is a primitive type. More...

struct	is_product
	Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multiplication) More...

struct	is_row_major
	Helper class for checking whether a matrix has a row-major layout. More...

struct	is_scalar
	Helper struct for checking whether a type is a viennacl::scalar<> More...

struct	is_sliced_ell_matrix
	Helper class for checking whether a matrix is a sliced_ell_matrix (SELL-C- $\sigma$ format) More...

struct	is_stl
	Meta function which checks whether a tag is tag_ublas. More...

struct	is_subtraction
	Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction) More...

struct	is_toeplitz_matrix
	Helper class for checking whether a matrix is a Toeplitz matrix. More...

struct	is_ublas
	Meta function which checks whether a tag is tag_ublas. More...

struct	is_vandermonde_matrix
	Helper class for checking whether a matrix is a Vandermonde matrix. More...

struct	is_viennacl
	Meta function which checks whether a tag is tag_viennacl. More...

class	matrix
	A dense matrix class. More...

class	matrix_base

class	matrix_expression
	Expression template class for representing a tree of expressions which ultimately result in a matrix. More...

class	matrix_iterator
	A dense matrix class. More...

class	matrix_range
	Class for representing non-strided submatrices of a bigger matrix A. More...

class	matrix_range< matrix_range< MatrixType > >

class	matrix_slice
	Class for representing strided submatrices of a bigger matrix A. More...

class	matrix_slice< matrix_range< MatrixType > >

class	memory_exception
	Exception class in case of memory errors. More...

struct	one_vector

struct	op_abs
	A tag class representing the modulus function for integers. More...

struct	op_acos
	A tag class representing the acos() function. More...

struct	op_add
	A tag class representing addition. More...

struct	op_argmax
	A tag class for representing the argmax() function. More...

struct	op_argmin
	A tag class for representing the argmin() function. More...

struct	op_asin
	A tag class representing the asin() function. More...

struct	op_assign
	A tag class representing assignment. More...

struct	op_atan
	A tag class representing the atan() function. More...

struct	op_atan2
	A tag class representing the atan2() function. More...

struct	op_ceil
	A tag class representing the ceil() function. More...

struct	op_col_sum
	A tag class representing the summation of all columns of a matrix. More...

struct	op_column
	A tag class representing the extraction of a matrix column to a vector. More...

struct	op_cos
	A tag class representing the cos() function. More...

struct	op_cosh
	A tag class representing the cosh() function. More...

struct	op_div
	A tag class representing division. More...

struct	op_element_binary
	A tag class representing element-wise binary operations (like multiplication) on vectors or matrices. More...

struct	op_element_cast
	A tag class representing element-wise casting operations on vectors and matrices. More...

struct	op_element_unary
	A tag class representing element-wise unary operations (like sin()) on vectors or matrices. More...

struct	op_eq
	A tag class representing equality. More...

struct	op_exp
	A tag class representing the exp() function. More...

struct	op_fabs
	A tag class representing the fabs() function. More...

struct	op_fdim
	A tag class representing the fdim() function. More...

struct	op_flip_sign
	A tag class representing sign flips (for scalars only. Vectors and matrices use the standard multiplication by the scalar -1.0) More...

struct	op_floor
	A tag class representing the floor() function. More...

struct	op_fmax
	A tag class representing the fmax() function. More...

struct	op_fmin
	A tag class representing the fmin() function. More...

struct	op_fmod
	A tag class representing the fmod() function. More...

struct	op_geq
	A tag class representing greater-than-or-equal-to. More...

struct	op_greater
	A tag class representing greater-than. More...

struct	op_inner_prod
	A tag class representing inner products of two vectors. More...

struct	op_inplace_add
	A tag class representing inplace addition. More...

struct	op_inplace_sub
	A tag class representing inplace subtraction. More...

struct	op_leq
	A tag class representing less-than-or-equal-to. More...

struct	op_less
	A tag class representing less-than. More...

struct	op_log
	A tag class representing the log() function. More...

struct	op_log10
	A tag class representing the log10() function. More...

struct	op_mat_mat_prod
	A tag class representing matrix-matrix products. More...

struct	op_matrix_diag
	A tag class representing the (off-)diagonal of a matrix. More...

struct	op_max
	A tag class representing the maximum of a vector. More...

struct	op_min
	A tag class representing the minimum of a vector. More...

struct	op_mult
	A tag class representing multiplication by a scalar. More...

struct	op_neq
	A tag class representing inequality. More...

struct	op_norm_1
	A tag class representing the 1-norm of a vector. More...

struct	op_norm_2
	A tag class representing the 2-norm of a vector. More...

struct	op_norm_frobenius
	A tag class representing the Frobenius-norm of a matrix. More...

struct	op_norm_inf
	A tag class representing the inf-norm of a vector. More...

struct	op_pow
	A tag class representing the power function. More...

struct	op_prod
	A tag class representing matrix-vector products and element-wise multiplications. More...

struct	op_row
	A tag class representing the extraction of a matrix row to a vector. More...

struct	op_row_sum
	A tag class representing the summation of all rows of a matrix. More...

struct	op_sin
	A tag class representing the sin() function. More...

struct	op_sinh
	A tag class representing the sinh() function. More...

struct	op_sqrt
	A tag class representing the sqrt() function. More...

struct	op_sub
	A tag class representing subtraction. More...

struct	op_sum
	A tag class representing the summation of a vector. More...

struct	op_tan
	A tag class representing the tan() function. More...

struct	op_tanh
	A tag class representing the tanh() function. More...

struct	op_trans
	A tag class representing transposed matrices. More...

struct	op_vector_diag
	A tag class representing a matrix given by a vector placed on a certain (off-)diagonal. More...

struct	row_iteration
	A tag indicating iteration along increasing row index of a matrix. More...

struct	row_major
	A tag for row-major storage of a dense matrix. More...

struct	row_major_tag
	Tag class for indicating row-major layout of a matrix. Not passed to the matrix directly, see row_major type. 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	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_max >
	Specialization of a scalar expression for max(). Allows for a final reduction on the CPU. More...

class	scalar_expression< LHS, RHS, op_min >
	Specialization of a scalar expression for norm_inf. 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_frobenius >
	Specialization of a scalar expression for norm_frobenius. 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_expression< LHS, RHS, op_sum >
	Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU. 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...

struct	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	sliced_ell_matrix
	Sparse matrix class using the sliced ELLPACK with parameters C, $\sigma$ . More...

struct	tag_eigen
	A tag class for identifying types from Eigen. More...

struct	tag_mtl4
	A tag class for identifying types from MTL4. More...

struct	tag_none
	A tag class for identifying 'unknown' types. More...

struct	tag_stl
	A tag class for identifying types from the C++ STL. More...

struct	tag_ublas
	A tag class for identifying types from uBLAS. More...

struct	tag_viennacl
	A tag class for identifying types from ViennaCL. More...

class	toeplitz_matrix
	A Toeplitz matrix class. More...

struct	unit_vector
	Represents a vector consisting of 1 at a given index and zeros otherwise. More...

class	unknown_norm_exception

class	vandermonde_matrix
	A Vandermonde matrix class. More...

class	vector

class	vector_base
	Common base class for dense vectors, vector ranges, and vector slices. More...

class	vector_expression
	An expression template class that represents a binary operation that yields a vector. More...

class	vector_iterator
	A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! More...

class	vector_range
	Class for representing non-strided subvectors of a bigger vector x. More...

class	vector_range< vector_range< VectorType > >

class	vector_slice
	Class for representing strided subvectors of a bigger vector x. More...

class	vector_slice< vector_slice< VectorType > >

class	vector_tuple
	Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from viennacl::tie(). 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	zero_on_diagonal_exception

struct	zero_vector

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_context (T &obj, viennacl::context new_ctx)
	Generic convenience routine for migrating data of an object to a new memory domain. More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (std::vector< NumericT > &cpu_vec, circulant_matrix< NumericT, AlignmentV > &gpu_mat)
	Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (circulant_matrix< NumericT, AlignmentV > &gpu_mat, std::vector< NumericT > &cpu_vec)
	Copies a circulant matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (circulant_matrix< NumericT, AlignmentV > &circ_src, MatrixT &com_dst)
	Copies a circulant matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (MatrixT &com_src, circulant_matrix< NumericT, AlignmentV > &circ_dst)
	Copies a the matrix-like object to the circulant matrix from the OpenCL device (either GPU or multi-core CPU) More...

template<class NumericT , unsigned int AlignmentV>
std::ostream &	operator<< (std::ostream &s, circulant_matrix< NumericT, AlignmentV > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas. More...

template<typename CPUMatrixT , typename NumericT >
void	copy (const CPUMatrixT &cpu_matrix, compressed_compressed_matrix< NumericT > &gpu_matrix)
	Copies a sparse matrix from the host to the OpenCL device (either GPU or multi-core CPU) More...

template<typename SizeT , typename NumericT >
void	copy (const std::vector< std::map< SizeT, NumericT > > &cpu_matrix, compressed_compressed_matrix< NumericT > &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. More...

template<typename CPUMatrixT , typename NumericT >
void	copy (const compressed_compressed_matrix< NumericT > &gpu_matrix, CPUMatrixT &cpu_matrix)
	Copies a sparse matrix from the OpenCL device (either GPU or multi-core CPU) to the host. More...

template<typename NumericT >
void	copy (const compressed_compressed_matrix< NumericT > &gpu_matrix, std::vector< std::map< unsigned int, NumericT > > &cpu_matrix)
	Copies a sparse matrix from an OpenCL device to the host. The host type is the std::vector< std::map < > > format . More...

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const CPUMatrixT &cpu_matrix, compressed_matrix< NumericT, AlignmentV > &gpu_matrix)
	Copies a sparse matrix from the host to the OpenCL device (either GPU or multi-core CPU) More...

template<typename SizeT , typename NumericT , unsigned int AlignmentV>
void	copy (const std::vector< std::map< SizeT, NumericT > > &cpu_matrix, compressed_matrix< NumericT, AlignmentV > &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. More...

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const compressed_matrix< NumericT, AlignmentV > &gpu_matrix, CPUMatrixT &cpu_matrix)
	Copies a sparse matrix from the OpenCL device (either GPU or multi-core CPU) to the host. More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (const compressed_matrix< NumericT, AlignmentV > &gpu_matrix, std::vector< std::map< unsigned int, NumericT > > &cpu_matrix)
	Copies a sparse matrix from an OpenCL device to the host. The host type is the std::vector< std::map < > > format . More...

template<typename NumericT , unsigned int AlignmentV>
std::ostream &	operator<< (std::ostream &os, compressed_matrix< NumericT, AlignmentV > const &A)
	Output stream support for compressed_matrix. Output format is same as MATLAB, Octave, or SciPy. More...

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const CPUMatrixT &cpu_matrix, coordinate_matrix< NumericT, AlignmentV > &gpu_matrix)
	Copies a sparse matrix from the host to the OpenCL device (either GPU or multi-core CPU) More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (const std::vector< std::map< unsigned int, NumericT > > &cpu_matrix, coordinate_matrix< NumericT, AlignmentV > &gpu_matrix)
	Copies a sparse matrix in the std::vector< std::map < > > format to an OpenCL device. More...

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const coordinate_matrix< NumericT, AlignmentV > &gpu_matrix, CPUMatrixT &cpu_matrix)
	Copies a sparse matrix from the OpenCL device (either GPU or multi-core CPU) to the host. More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (const coordinate_matrix< NumericT, AlignmentV > &gpu_matrix, std::vector< std::map< unsigned int, NumericT > > &cpu_matrix)
	Copies a sparse matrix from an OpenCL device to the host. The host type is the std::vector< std::map < > > format . More...

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const CPUMatrixT &cpu_matrix, ell_matrix< NumericT, AlignmentV > &gpu_matrix)

template<typename IndexT , typename NumericT , unsigned int AlignmentV>
void	copy (std::vector< std::map< IndexT, NumericT > > const &cpu_matrix, ell_matrix< NumericT, AlignmentV > &gpu_matrix)
	Copies a sparse matrix from the host to the compute device. The host type is the std::vector< std::map < > > format . More...

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const ell_matrix< NumericT, AlignmentV > &gpu_matrix, CPUMatrixT &cpu_matrix)

template<typename NumericT , unsigned int AlignmentV, typename IndexT >
void	copy (const ell_matrix< NumericT, AlignmentV > &gpu_matrix, std::vector< std::map< IndexT, NumericT > > &cpu_matrix)
	Copies a sparse matrix from the compute device to the host. The host type is the std::vector< std::map < > > format . More...

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)

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)

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)

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)

template<typename NumericT , unsigned int AlignmentV>
void	copy (std::vector< NumericT > const &cpu_vec, hankel_matrix< NumericT, AlignmentV > &gpu_mat)
	Copies a Hankel matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (hankel_matrix< NumericT, AlignmentV > const &gpu_mat, std::vector< NumericT > &cpu_vec)
	Copies a Hankel matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (hankel_matrix< NumericT, AlignmentV > const &han_src, MatrixT &com_dst)
	Copies a Hankel matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (MatrixT const &com_src, hankel_matrix< NumericT, AlignmentV > &han_dst)
	Copies a the matrix-like object to the Hankel matrix from the OpenCL device (either GPU or multi-core CPU) More...

template<class NumericT , unsigned int AlignmentV>
std::ostream &	operator<< (std::ostream &s, hankel_matrix< NumericT, AlignmentV > &gpu_matrix)

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const CPUMatrixT &cpu_matrix, hyb_matrix< NumericT, AlignmentV > &gpu_matrix)

template<typename IndexT , typename NumericT , unsigned int AlignmentV>
void	copy (std::vector< std::map< IndexT, NumericT > > const &cpu_matrix, hyb_matrix< NumericT, AlignmentV > &gpu_matrix)
	Copies a sparse matrix from the host to the compute device. The host type is the std::vector< std::map < > > format . More...

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>
void	copy (const hyb_matrix< NumericT, AlignmentV > &gpu_matrix, CPUMatrixT &cpu_matrix)

template<typename NumericT , unsigned int AlignmentV, typename IndexT >
void	copy (const hyb_matrix< NumericT, AlignmentV > &gpu_matrix, std::vector< std::map< IndexT, NumericT > > &cpu_matrix)
	Copies a sparse matrix from the compute device to the host. The host type is the std::vector< std::map < > > format . More...

template<typename NumericT >
NumericT *	cuda_arg (scalar< NumericT > &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL scalar. Non-const version. More...

template<typename NumericT >
const NumericT *	cuda_arg (scalar< NumericT > const &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL scalar. Const version. More...

template<typename NumericT >
NumericT *	cuda_arg (vector_base< NumericT > &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base) with implicit return type deduction. Non-const version. More...

template<typename NumericT >
const NumericT *	cuda_arg (vector_base< NumericT > const &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base) with implicit return type deduction. Const version. More...

template<typename ReturnT , typename NumericT >
ReturnT *	cuda_arg (vector_base< NumericT > &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base). Return type needs to be explicitly provided as first template argument. Non-const version. More...

template<typename ReturnT , typename NumericT >
const ReturnT *	cuda_arg (vector_base< NumericT > const &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base). Return type needs to be explicitly provided as first template argument. Const version. More...

template<typename NumericT >
NumericT *	cuda_arg (matrix_base< NumericT > &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL matrix (through the base class matrix_base). Non-const version. More...

template<typename NumericT >
const NumericT *	cuda_arg (matrix_base< NumericT > const &obj)
	Convenience helper function for extracting the CUDA handle from a ViennaCL matrix (through the base class matrix_base). Const version. More...

template<typename ReturnT >
ReturnT *	cuda_arg (viennacl::backend::mem_handle &h)
	Convenience helper function for extracting the CUDA handle from a generic memory handle. Non-const version. More...

template<typename ReturnT >
ReturnT const *	cuda_arg (viennacl::backend::mem_handle const &h)
	Convenience helper function for extracting the CUDA handle from a generic memory handle. Const-version. More...

template<typename NumericT >
vector< NumericT >	operator+= (vector_base< NumericT > &v1, const viennacl::vector_expression< const matrix_base< NumericT >, const vector_base< NumericT >, viennacl::op_prod > &proxy)
	Implementation of the operation v1 += A * v2, where A is a matrix. More...

template<typename NumericT >
vector< NumericT >	operator-= (vector_base< NumericT > &v1, const viennacl::vector_expression< const matrix_base< NumericT >, const vector_base< NumericT >, viennacl::op_prod > &proxy)
	Implementation of the operation v1 -= A * v2, where A is a matrix. More...

template<typename NumericT >
viennacl::vector< NumericT >	operator+ (const vector_base< NumericT > &v1, const vector_expression< const matrix_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 + A * v2', where A is a matrix. More...

template<typename NumericT >
viennacl::vector< NumericT >	operator- (const vector_base< NumericT > &v1, const vector_expression< const matrix_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 - A * v2', where A is a matrix. More...

template<typename NumericT >
vector< NumericT >	operator+= (vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation v1 += A * v2, where A is a matrix. More...

template<typename NumericT >
vector< NumericT >	operator-= (vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation v1 -= A * v2, where A is a matrix. More...

template<typename NumericT >
vector< NumericT >	operator+ (const vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 + A * v2', where A is a matrix. More...

template<typename NumericT >
vector< NumericT >	operator- (const vector_base< NumericT > &v1, const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans >, const vector_base< NumericT >, op_prod > &proxy)
	Implementation of the operation 'result = v1 - A * v2', where A is a matrix. More...

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. More...

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. More...

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. More...

template<typename T , typename LHS , typename RHS , typename OP >
vector_base< T > &	operator+= (vector_base< T > &v1, const vector_expression< const LHS, const RHS, OP > &proxy)

template<typename T , typename LHS , typename RHS , typename OP >
vector_base< T > &	operator-= (vector_base< T > &v1, const vector_expression< const LHS, const RHS, OP > &proxy)

template<class NumericT >
std::ostream &	operator<< (std::ostream &s, const matrix_base< NumericT > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas. More...

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. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT > , op_trans >	trans (const matrix_base< NumericT > &mat)
	Returns an expression template class representing a transposed matrix. More...

template<typename LhsT , typename RhsT , typename OpT >
matrix_expression< const matrix_expression< const LhsT, const RhsT, OpT >, const matrix_expression< const LhsT, const RhsT, OpT >, op_trans >	trans (const matrix_expression< const LhsT, const RhsT, OpT > &proxy)
	Returns an expression template class representing the transposed matrix expression. More...

template<typename NumericT >
vector_expression< const matrix_base< NumericT >, const int, op_matrix_diag >	diag (const matrix_base< NumericT > &A, int k=0)

template<typename NumericT >
matrix_expression< const vector_base< NumericT >, const int, op_vector_diag >	diag (const vector_base< NumericT > &v, int k=0)

template<typename NumericT , typename F >
vector_expression< const matrix_base< NumericT, F > , const unsigned int, op_row >	row (const matrix_base< NumericT, F > &A, unsigned int i)

template<typename NumericT , typename F >
vector_expression< const matrix_base< NumericT, F > , const unsigned int, op_column >	column (const matrix_base< NumericT, F > &A, unsigned int j)

template<typename CPUMatrixT , typename NumericT , typename F , unsigned int AlignmentV>
void	copy (const CPUMatrixT &cpu_matrix, matrix< NumericT, F, AlignmentV > &gpu_matrix)
	Copies a dense matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU) More...

template<typename NumericT , typename A1 , typename A2 , typename F , unsigned int AlignmentV>
void	copy (const std::vector< std::vector< NumericT, A1 >, A2 > &cpu_matrix, matrix< NumericT, F, AlignmentV > &gpu_matrix)
	Copies a dense STL-type matrix from the host (CPU) to the OpenCL device (GPU or multi-core CPU) More...

template<typename NumericT , typename F , unsigned int AlignmentV>
void	fast_copy (NumericT cpu_matrix_begin, NumericT cpu_matrix_end, matrix< NumericT, F, AlignmentV > &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. More...

template<typename CPUMatrixT , typename NumericT , typename F , unsigned int AlignmentV>
void	copy (const matrix< NumericT, F, AlignmentV > &gpu_matrix, CPUMatrixT &cpu_matrix)
	Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU). More...

template<typename NumericT , typename A1 , typename A2 , typename F , unsigned int AlignmentV>
void	copy (const matrix< NumericT, F, AlignmentV > &gpu_matrix, std::vector< std::vector< NumericT, A1 >, A2 > &cpu_matrix)
	Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU). More...

template<typename NumericT , typename F , unsigned int AlignmentV>
void	fast_copy (const matrix< NumericT, F, AlignmentV > &gpu_matrix, NumericT *cpu_matrix_begin)
	Copies a dense matrix from the OpenCL device (GPU or multi-core CPU) to the host (CPU). More...

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
matrix_expression< const matrix_expression< const LHS1, const RHS1, OP1 >, const matrix_expression< const LHS2, const RHS2, OP2 >, op_add >	operator+ (matrix_expression< const LHS1, const RHS1, OP1 > const &proxy1, matrix_expression< const LHS2, const RHS2, OP2 > const &proxy2)
	Generic 'catch-all' overload, which enforces a temporary if the expression tree gets too deep. More...

template<typename LHS1 , typename RHS1 , typename OP1 , typename NumericT >
matrix_expression< const matrix_expression< const LHS1, const RHS1, OP1 >, const matrix_base< NumericT > , op_add >	operator+ (matrix_expression< const LHS1, const RHS1, OP1 > const &proxy1, matrix_base< NumericT > const &proxy2)

template<typename NumericT , typename LHS2 , typename RHS2 , typename OP2 >
matrix_expression< const matrix_base< NumericT >, const matrix_expression< const LHS2, const RHS2, OP2 >, op_add >	operator+ (matrix_base< NumericT > const &proxy1, matrix_expression< const LHS2, const RHS2, OP2 > const &proxy2)

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT > , op_add >	operator+ (const matrix_base< NumericT > &m1, const matrix_base< NumericT > &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. More...

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
matrix_expression< const matrix_expression< const LHS1, const RHS1, OP1 >, const matrix_expression< const LHS2, const RHS2, OP2 >, op_sub >	operator- (matrix_expression< const LHS1, const RHS1, OP1 > const &proxy1, matrix_expression< const LHS2, const RHS2, OP2 > const &proxy2)

template<typename LHS1 , typename RHS1 , typename OP1 , typename NumericT >
matrix_expression< const matrix_expression< const LHS1, const RHS1, OP1 >, const matrix_base< NumericT > , op_sub >	operator- (matrix_expression< const LHS1, const RHS1, OP1 > const &proxy1, matrix_base< NumericT > const &proxy2)

template<typename NumericT , typename LHS2 , typename RHS2 , typename OP2 >
matrix_expression< const matrix_base< NumericT >, const matrix_expression< const LHS2, const RHS2, OP2 >, op_sub >	operator- (matrix_base< NumericT > const &proxy1, matrix_expression< const LHS2, const RHS2, OP2 > const &proxy2)

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT > , op_sub >	operator- (const matrix_base< NumericT > &m1, const matrix_base< NumericT > &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. More...

template<typename S1 , typename NumericT >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_base< NumericT > , const S1, op_mult >>::type	operator* (S1 const &value, matrix_base< NumericT > const &m1)
	Operator overload for the expression alpha * m1, where alpha is a host scalar (float or double) and m1 is a ViennaCL matrix. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (char value, matrix_base< NumericT > const &m1)
	Operator overload for the expression alpha * m1, where alpha is a char (8-bit integer) More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (short value, matrix_base< NumericT > const &m1)
	Operator overload for the expression alpha * m1, where alpha is a short integer. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (int value, matrix_base< NumericT > const &m1)
	Operator overload for the expression alpha * m1, where alpha is an integer. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (long value, matrix_base< NumericT > const &m1)
	Operator overload for the expression alpha * m1, where alpha is a long integer. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (float value, matrix_base< NumericT > const &m1)
	Operator overload for the expression alpha * m1, where alpha is a single precision floating point value. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (double value, matrix_base< NumericT > const &m1)
	Operator overload for the expression alpha * m1, where alpha is a double precision floating point value. More...

template<typename LHS , typename RHS , typename OP , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_expression< LHS, RHS, OP >, const S1, op_mult > >::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. More...

template<typename S1 , typename LHS , typename RHS , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_expression< LHS, RHS, OP >, const S1, op_mult > >::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. More...

template<typename NumericT , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_base< NumericT > , const S1, op_mult > >::type	operator* (matrix_base< NumericT > const &m1, S1 const &s1)
	Scales the matrix by a GPU scalar 'alpha' and returns an expression template. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (matrix_base< NumericT > const &m1, char s1)
	Scales the matrix by a char (8-bit integer) 'alpha' and returns an expression template. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (matrix_base< NumericT > const &m1, short s1)
	Scales the matrix by a short integer 'alpha' and returns an expression template. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (matrix_base< NumericT > const &m1, int s1)
	Scales the matrix by an integer 'alpha' and returns an expression template. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (matrix_base< NumericT > const &m1, long s1)
	Scales the matrix by a long integer 'alpha' and returns an expression template. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (matrix_base< NumericT > const &m1, float s1)
	Scales the matrix by a single precision floating point number 'alpha' and returns an expression template. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_mult >	operator* (matrix_base< NumericT > const &m1, double s1)
	Scales the matrix by a double precision floating point number 'alpha' and returns an expression template. More...

template<typename NumericT , typename S1 >
viennacl::enable_if < viennacl::is_scalar< S1 > ::value, matrix_base< NumericT > & >::type	operator*= (matrix_base< NumericT > &m1, S1 const &gpu_val)
	Scales a matrix by a GPU scalar value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator*= (matrix_base< NumericT > &m1, char gpu_val)
	Scales a matrix by a char (8-bit) value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator*= (matrix_base< NumericT > &m1, short gpu_val)
	Scales a matrix by a short integer value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator*= (matrix_base< NumericT > &m1, int gpu_val)
	Scales a matrix by an integer value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator*= (matrix_base< NumericT > &m1, long gpu_val)
	Scales a matrix by a long integer value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator*= (matrix_base< NumericT > &m1, float gpu_val)
	Scales a matrix by a single precision floating point value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator*= (matrix_base< NumericT > &m1, double gpu_val)
	Scales a matrix by a double precision floating point value. More...

template<typename LHS , typename RHS , typename OP , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_expression < const LHS, const RHS, OP > , const S1, op_div > >::type	operator/ (matrix_expression< const LHS, const 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. More...

template<typename NumericT , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, matrix_expression < const matrix_base< NumericT > , const S1, op_div > >::type	operator/ (matrix_base< NumericT > const &m1, S1 const &s1)
	Returns an expression template for scaling the matrix by a GPU scalar 'alpha'. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_div >	operator/ (matrix_base< NumericT > const &m1, char s1)
	Returns an expression template for scaling the matrix by a char (8-bit integer) 'alpha'. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_div >	operator/ (matrix_base< NumericT > const &m1, short s1)
	Returns an expression template for scaling the matrix by a short integer 'alpha'. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_div >	operator/ (matrix_base< NumericT > const &m1, int s1)
	Returns an expression template for scaling the matrix by an integer 'alpha'. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_div >	operator/ (matrix_base< NumericT > const &m1, long s1)
	Returns an expression template for scaling the matrix by a long integer 'alpha'. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_div >	operator/ (matrix_base< NumericT > const &m1, float s1)
	Returns an expression template for scaling the matrix by a single precision floating point number 'alpha'. More...

template<typename NumericT >
matrix_expression< const matrix_base< NumericT >, const NumericT, op_div >	operator/ (matrix_base< NumericT > const &m1, double s1)
	Returns an expression template for scaling the matrix by a double precision floating point number 'alpha'. More...

template<typename NumericT , typename S1 >
viennacl::enable_if < viennacl::is_scalar< S1 > ::value, matrix_base< NumericT > & >::type	operator/= (matrix_base< NumericT > &m1, S1 const &gpu_val)
	Scales a matrix by a GPU scalar value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator/= (matrix_base< NumericT > &m1, char gpu_val)
	Scales a matrix by a char (8-bit integer) value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator/= (matrix_base< NumericT > &m1, short gpu_val)
	Scales a matrix by a short integer value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator/= (matrix_base< NumericT > &m1, int gpu_val)
	Scales a matrix by an integer value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator/= (matrix_base< NumericT > &m1, long gpu_val)
	Scales a matrix by a long integer value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator/= (matrix_base< NumericT > &m1, float gpu_val)
	Scales a matrix by a single precision floating point value. More...

template<typename NumericT >
matrix_base< NumericT > &	operator/= (matrix_base< NumericT > &m1, double gpu_val)
	Scales a matrix by a double precision floating point value. More...

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_mult > >::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_cpu_scalar< S1 > ::value, viennacl::matrix_expression < const viennacl::matrix_expression < const vector_base< NumericT > , const vector_base< NumericT > , op_prod >, const NumericT, op_mult >>::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_mult > >::type	operator* (const S1 &val, const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy)

template<typename NumericT , typename S1 >
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_mult >>::type	operator* (const S1 &val, const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &proxy)

template<typename CPUMatrixT , typename NumericT >
void	copy (const CPUMatrixT &cpu_matrix, matrix_range< matrix< NumericT, row_major, 1 > > &gpu_matrix_range)

template<typename CPUMatrixT , typename NumericT >
void	copy (const CPUMatrixT &cpu_matrix, matrix_range< matrix< NumericT, column_major, 1 > > &gpu_matrix_range)

template<typename CPUMatrixT , typename NumericT >
void	copy (matrix_range< matrix< NumericT, row_major, 1 > > const &gpu_matrix_range, CPUMatrixT &cpu_matrix)

template<typename CPUMatrixT , typename NumericT >
void	copy (matrix_range< matrix< NumericT, column_major, 1 > > const &gpu_matrix_range, CPUMatrixT &cpu_matrix)

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

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

template<typename CPUMatrixT , typename NumericT >
void	copy (const CPUMatrixT &cpu_matrix, matrix_slice< matrix< NumericT, row_major, 1 > > &gpu_matrix_slice)

template<typename CPUMatrixT , typename NumericT >
void	copy (const CPUMatrixT &cpu_matrix, matrix_slice< matrix< NumericT, column_major, 1 > > &gpu_matrix_slice)

template<typename CPUMatrixT , typename NumericT >
void	copy (matrix_slice< matrix< NumericT, row_major, 1 > > const &gpu_matrix_slice, CPUMatrixT &cpu_matrix)

template<typename CPUMatrixT , typename NumericT >
void	copy (matrix_slice< matrix< NumericT, column_major, 1 > > const &gpu_matrix_slice, CPUMatrixT &cpu_matrix)

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

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

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

template<typename IndexT , typename ValueT >
std::vector< IndexT >	reorder (std::vector< std::map< IndexT, ValueT > > 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. More...

template<typename IndexT , typename ValueT >
std::vector< IndexT >	reorder (std::vector< std::map< IndexT, ValueT > > 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. More...

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. More...

template<class NumericT >
std::ostream &	operator<< (std::ostream &s, const scalar< NumericT > &val)
	Allows to directly print the value of a scalar to an output stream. More...

template<class NumericT >
std::istream &	operator>> (std::istream &s, const scalar< NumericT > &val)
	Allows to directly read a value of a scalar from an input stream. More...

template<typename CPUMatrixT , typename ScalarT , typename IndexT >
void	copy (CPUMatrixT const &cpu_matrix, sliced_ell_matrix< ScalarT, IndexT > &gpu_matrix)

template<typename IndexT , typename NumericT , typename IndexT2 >
void	copy (std::vector< std::map< IndexT, NumericT > > const &cpu_matrix, sliced_ell_matrix< NumericT, IndexT2 > &gpu_matrix)
	Copies a sparse matrix from the host to the compute device. The host type is the std::vector< std::map < > > format . More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (std::vector< NumericT > const &cpu_vec, toeplitz_matrix< NumericT, AlignmentV > &gpu_mat)
	Copies a Toeplitz matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (toeplitz_matrix< NumericT, AlignmentV > const &gpu_mat, std::vector< NumericT > &cpu_vec)
	Copies a Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (toeplitz_matrix< NumericT, AlignmentV > const &tep_src, MatrixT &com_dst)
	Copies a Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (MatrixT const &com_src, toeplitz_matrix< NumericT, AlignmentV > &tep_dst)
	Copies a the matrix-like object to the Toeplitz matrix from the OpenCL device (either GPU or multi-core CPU) More...

template<class NumericT , unsigned int AlignmentV>
std::ostream &	operator<< (std::ostream &s, toeplitz_matrix< NumericT, AlignmentV > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas. More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (std::vector< NumericT > &cpu_vec, vandermonde_matrix< NumericT, AlignmentV > &gpu_mat)
	Copies a Vandermonde matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) More...

template<typename NumericT , unsigned int AlignmentV>
void	copy (vandermonde_matrix< NumericT, AlignmentV > &gpu_mat, std::vector< NumericT > &cpu_vec)
	Copies a Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU) to the std::vector. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (vandermonde_matrix< NumericT, AlignmentV > &vander_src, MatrixT &com_dst)
	Copies a Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU) to the matrix-like object. More...

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >
void	copy (MatrixT &com_src, vandermonde_matrix< NumericT, AlignmentV > &vander_dst)
	Copies a the matrix-like object to the Vandermonde matrix from the OpenCL device (either GPU or multi-core CPU) More...

template<class NumericT , unsigned int AlignmentV>
std::ostream &	operator<< (std::ostream &s, vandermonde_matrix< NumericT, AlignmentV > &gpu_matrix)
	Prints the matrix. Output is compatible to boost::numeric::ublas. More...

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > const &v0, vector_base< ScalarT > const &v1)

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > &v0, vector_base< ScalarT > &v1)

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > const &v0, vector_base< ScalarT > const &v1, vector_base< ScalarT > const &v2)

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > &v0, vector_base< ScalarT > &v1, vector_base< ScalarT > &v2)

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > const &v0, vector_base< ScalarT > const &v1, vector_base< ScalarT > const &v2, vector_base< ScalarT > const &v3)

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > &v0, vector_base< ScalarT > &v1, vector_base< ScalarT > &v2, vector_base< ScalarT > &v3)

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > const &v0, vector_base< ScalarT > const &v1, vector_base< ScalarT > const &v2, vector_base< ScalarT > const &v3, vector_base< ScalarT > const &v4)

template<typename ScalarT >
vector_tuple< ScalarT >	tie (vector_base< ScalarT > &v0, vector_base< ScalarT > &v1, vector_base< ScalarT > &v2, vector_base< ScalarT > &v3, vector_base< ScalarT > &v4)

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >
void	fast_copy (const const_vector_iterator< NumericT, AlignmentV > &gpu_begin, const const_vector_iterator< NumericT, AlignmentV > &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. More...

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());. More...

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >
void	async_copy (const const_vector_iterator< NumericT, AlignmentV > &gpu_begin, const const_vector_iterator< NumericT, AlignmentV > &gpu_end, CPU_ITERATOR cpu_begin)
	Asynchronous version of fast_copy(), copying data from device to host. The host iterator cpu_begin needs to reside in a linear piece of memory, such as e.g. for std::vector. More...

template<typename NumericT , typename CPUVECTOR >
void	async_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());. More...

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >
void	copy (const const_vector_iterator< NumericT, AlignmentV > &gpu_begin, const const_vector_iterator< NumericT, AlignmentV > &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. More...

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >
void	copy (const vector_iterator< NumericT, AlignmentV > &gpu_begin, const vector_iterator< NumericT, AlignmentV > &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. More...

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());. More...

template<typename CPU_ITERATOR , typename NumericT , unsigned int AlignmentV>
void	fast_copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< NumericT, AlignmentV > 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. More...

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());. More...

template<typename CPU_ITERATOR , typename NumericT , unsigned int AlignmentV>
void	async_copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< NumericT, AlignmentV > gpu_begin)
	Asynchronous version of fast_copy(), copying data from host to device. The host iterator cpu_begin needs to reside in a linear piece of memory, such as e.g. for std::vector. More...

template<typename CPUVECTOR , typename NumericT >
void	async_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());. More...

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >
void	copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< NumericT, AlignmentV > 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. More...

template<typename HostVectorT , typename T >
void	copy (HostVectorT const &cpu_vec, vector_base< T > &gpu_vec)
	Transfer from a host vector object to a ViennaCL vector proxy. Requires the vector proxy to have the necessary size. Convenience wrapper for viennacl::linalg::copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());. More...

template<typename HostVectorT , typename T , unsigned int AlignmentV>
void	copy (HostVectorT const &cpu_vec, vector< T, AlignmentV > &gpu_vec)
	Transfer from a host vector object to a ViennaCL vector. Resizes the ViennaCL vector if it has zero size. Convenience wrapper for viennacl::linalg::copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());. More...

template<typename NumericT , unsigned int AlignmentV_SRC, unsigned int AlignmentV_DEST>
void	copy (const_vector_iterator< NumericT, AlignmentV_SRC > const &gpu_src_begin, const_vector_iterator< NumericT, AlignmentV_SRC > const &gpu_src_end, vector_iterator< NumericT, AlignmentV_DEST > gpu_dest_begin)
	Copy (parts of a) GPU vector to another GPU vector. More...

template<typename NumericT , unsigned int AlignmentV_SRC, unsigned int AlignmentV_DEST>
void	copy (vector_iterator< NumericT, AlignmentV_SRC > const &gpu_src_begin, vector_iterator< NumericT, AlignmentV_SRC > const &gpu_src_end, vector_iterator< NumericT, AlignmentV_DEST > gpu_dest_begin)
	Copy (parts of a) GPU vector to another GPU vector. More...

template<typename NumericT , unsigned int AlignmentV_SRC, unsigned int AlignmentV_DEST>
void	copy (vector< NumericT, AlignmentV_SRC > const &gpu_src_vec, vector< NumericT, AlignmentV_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());. More...

template<typename T >
std::ostream &	operator<< (std::ostream &os, vector_base< T > const &val)
	Output stream. Output format is ublas compatible. More...

template<typename LHS , typename RHS , typename OP >
std::ostream &	operator<< (std::ostream &os, 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. More...

template<typename NumericT , unsigned int AlignmentV>
vector< NumericT, AlignmentV > &	fast_swap (vector< NumericT, AlignmentV > &v1, vector< NumericT, AlignmentV > &v2)
	Swaps the content of two vectors by swapping OpenCL handles only, NO data is copied. More...

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. More...

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. More...

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
vector_expression< const vector_expression< LHS1, RHS1, OP1 >, const vector_expression < LHS2, RHS2, OP2 > , viennacl::op_add >	operator+ (vector_expression< LHS1, RHS1, OP1 > const &proxy1, vector_expression< LHS2, RHS2, OP2 > const &proxy2)
	Operator overload for the addition of two vector expressions. More...

template<typename LHS , typename RHS , typename OP , typename T >
vector_expression< const vector_expression< LHS, RHS, OP >, const vector_base< T > , viennacl::op_add >	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. More...

template<typename T , typename LHS , typename RHS , typename OP >
vector_expression< const vector_base< T >, const vector_expression< LHS, RHS, OP >, viennacl::op_add >	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. More...

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. More...

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
vector_expression< const vector_expression< LHS1, RHS1, OP1 >, const vector_expression < LHS2, RHS2, OP2 > , viennacl::op_sub >	operator- (vector_expression< LHS1, RHS1, OP1 > const &proxy1, vector_expression< LHS2, RHS2, OP2 > const &proxy2)
	Operator overload for the subtraction of two vector expressions. More...

template<typename LHS , typename RHS , typename OP , typename T >
vector_expression< const vector_expression< LHS, RHS, OP >, const vector_base< T > , viennacl::op_sub >	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. More...

template<typename T , typename LHS , typename RHS , typename OP >
vector_expression< const vector_base< T >, const vector_expression< LHS, RHS, OP >, viennacl::op_sub >	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. More...

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. More...

template<typename S1 , typename T >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_expression < const vector_base< T > , const S1, op_mult > >::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. More...

template<typename T >
vector_expression< const vector_base< T >, const T, op_mult >	operator* (char value, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a char. More...

template<typename T >
vector_expression< const vector_base< T >, const T, op_mult >	operator* (short value, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a short. More...

template<typename T >
vector_expression< const vector_base< T >, const T, op_mult >	operator* (int value, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a int. More...

template<typename T >
vector_expression< const vector_base< T >, const T, op_mult >	operator* (long value, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a long. More...

template<typename T >
vector_expression< const vector_base< T >, const T, op_mult >	operator* (float value, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a float. More...

template<typename T >
vector_expression< const vector_base< T >, const T, op_mult >	operator* (double value, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a double. More...

template<typename LHS , typename RHS , typename OP , typename T >
vector_expression< const vector_base< T >, const scalar_expression< LHS, RHS, OP >, op_mult >	operator* (scalar_expression< LHS, RHS, OP > const &expr, vector_base< T > const &vec)
	Operator overload for the expression alpha * v1, where alpha is a scalar expression and v1 is a ViennaCL vector. More...

template<typename T , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, vector_expression < const vector_base< T > , const S1, op_mult > >::type	operator* (vector_base< T > const &vec, S1 const &value)
	Scales the vector by a scalar 'alpha' and returns an expression template. More...

template<typename T >
vector_expression< const vector_base< T >, const T, op_mult >	operator* (vector_base< T > const &vec, T const &value)

template<typename LHS , typename RHS , typename OP , typename S1 >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, viennacl::vector_expression < const vector_expression< LHS, RHS, OP >, const S1, op_mult > >::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. More...

template<typename S1 , typename LHS , typename RHS , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, viennacl::vector_expression < const vector_expression< LHS, RHS, OP >, const S1, op_mult > >::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. More...

template<typename S1 , typename LHS , typename RHS , typename OP >
viennacl::enable_if < viennacl::is_any_scalar< S1 > ::value, viennacl::vector_expression < const vector_expression< LHS, RHS, OP >, const S1, op_div > >::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. More...

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'. More...

template<typename VectorType , typename NumericT >
void	copy (const VectorType &cpu_vector, vector_range< vector< NumericT > > &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());. More...

template<typename NumericT , typename VectorType >
void	copy (vector_range< vector< NumericT > > 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());. More...

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

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

template<typename VectorType , typename NumericT >
void	copy (const VectorType &cpu_vector, vector_slice< vector< NumericT > > &gpu_vector_slice)

template<typename VectorType , typename NumericT >
void	copy (vector_slice< vector< NumericT > > const &gpu_vector_slice, VectorType &cpu_vector)

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

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

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

template<typename VectorType >
vector_slice< VectorType >	project (viennacl::vector_range< VectorType > const &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 viennacl::range

Examples:: least-squares.cpp, matrix-range.cpp, and vector-range.cpp.

Definition at line 424 of file forwards.h.

typedef basic_slice viennacl::slice

Definition at line 429 of file forwards.h.

typedef std::ptrdiff_t viennacl::vcl_ptrdiff_t

Definition at line 76 of file forwards.h.

typedef std::size_t viennacl::vcl_size_t

Definition at line 75 of file forwards.h.

Enumeration Type Documentation

enum viennacl::memory_types

Enumerator
MEMORY_NOT_INITIALIZED
MAIN_MEMORY
OPENCL_MEMORY
CUDA_MEMORY

Definition at line 345 of file forwards.h.

Function Documentation

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >

void viennacl::async_copy	(	const const_vector_iterator< NumericT, AlignmentV > &	gpu_begin,
		const const_vector_iterator< NumericT, AlignmentV > &	gpu_end,
		CPU_ITERATOR	cpu_begin
	)

Asynchronous version of fast_copy(), copying data from device to host. The host iterator cpu_begin needs to reside in a linear piece of memory, such as e.g. for std::vector.

This method allows for overlapping data transfer with host computation and returns immediately if the gpu vector has a unit-stride. In order to wait for the transfer to complete, use viennacl::backend::finish(). Note that data pointed to by cpu_begin must not be modified prior to completion of the transfer.

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!

Definition at line 1284 of file vector.hpp.

template<typename NumericT , typename CPUVECTOR >

void viennacl::async_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 pointing to entries linear in memory can be obtained via member function .begin()

Definition at line 1309 of file vector.hpp.

template<typename CPU_ITERATOR , typename NumericT , unsigned int AlignmentV>

void viennacl::async_copy	(	CPU_ITERATOR const &	cpu_begin,
		CPU_ITERATOR const &	cpu_end,
		vector_iterator< NumericT, AlignmentV >	gpu_begin
	)

Asynchronous version of fast_copy(), copying data from host to device. The host iterator cpu_begin needs to reside in a linear piece of memory, such as e.g. for std::vector.

This method allows for overlapping data transfer with host computation and returns immediately if the gpu vector has a unit-stride. In order to wait for the transfer to complete, use viennacl::backend::finish(). Note that data pointed to by cpu_begin must not be modified prior to completion of the transfer.

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.

Definition at line 1450 of file vector.hpp.

template<typename CPUVECTOR , typename NumericT >

void viennacl::async_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.

Definition at line 1475 of file vector.hpp.

template<typename NumericT , typename F >

vector_expression< const matrix_base<NumericT, F>, const unsigned int, op_column> viennacl::column	(	const matrix_base< NumericT, F > &	A,
		unsigned int	j
	)

Examples:: lanczos.cpp.

Definition at line 918 of file matrix.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const CPUMatrixT &	cpu_matrix,
		coordinate_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

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

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

Parameters

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

Definition at line 47 of file coordinate_matrix.hpp.

template<typename VectorType , typename NumericT >

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

Definition at line 103 of file vector_proxy.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const std::vector< std::map< unsigned int, NumericT > > &	cpu_matrix,
		coordinate_matrix< NumericT, AlignmentV > &	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

Definition at line 110 of file coordinate_matrix.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const CPUMatrixT &	cpu_matrix,
		compressed_matrix< NumericT, AlignmentV > &	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 CPUMatrixT 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

Definition at line 112 of file compressed_matrix.hpp.

template<typename CPUMatrixT , typename NumericT >

void viennacl::copy	(	const CPUMatrixT &	cpu_matrix,
		compressed_compressed_matrix< NumericT > &	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 CPUMatrixT 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_compressed_matrix from ViennaCL

Definition at line 115 of file compressed_compressed_matrix.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const CPUMatrixT &	cpu_matrix,
		ell_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

Definition at line 124 of file ell_matrix.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const coordinate_matrix< NumericT, AlignmentV > &	gpu_matrix,
		CPUMatrixT &	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 CPUMatrixT 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.

Definition at line 134 of file coordinate_matrix.hpp.

template<typename NumericT , typename VectorType >

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

Definition at line 135 of file vector_proxy.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const CPUMatrixT &	cpu_matrix,
		hyb_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

Definition at line 136 of file hyb_matrix.hpp.

template<typename CPUMatrixT , typename ScalarT , typename IndexT >

void viennacl::copy	(	CPUMatrixT const &	cpu_matrix,
		sliced_ell_matrix< ScalarT, IndexT > &	gpu_matrix
	)

Definition at line 141 of file sliced_ell_matrix.hpp.

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 147 of file matrix_proxy.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	std::vector< NumericT > &	cpu_vec,
		vandermonde_matrix< NumericT, AlignmentV > &	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

Definition at line 148 of file vandermonde_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	std::vector< NumericT > const &	cpu_vec,
		hankel_matrix< NumericT, AlignmentV > &	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

Definition at line 148 of file hankel_matrix.hpp.

template<typename SizeT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const std::vector< std::map< SizeT, NumericT > > &	cpu_matrix,
		compressed_matrix< NumericT, AlignmentV > &	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

Definition at line 149 of file compressed_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	std::vector< NumericT > &	cpu_vec,
		circulant_matrix< NumericT, AlignmentV > &	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

Examples:: amg.cpp, armadillo-with-viennacl.cpp, blas1.cpp, blas2.cpp, blas3.cpp, eigen-with-viennacl.cpp, iterative-custom.cpp, iterative.cpp, lanczos.cpp, least-squares.cpp, matrix-range.cpp, mtl4-with-viennacl.cpp, multithreaded_cg.cpp, power-iter.cpp, qr.cpp, spai.cpp, sparse.cpp, structured-matrices.cpp, and vector-range.cpp.

Definition at line 150 of file circulant_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	std::vector< NumericT > const &	cpu_vec,
		toeplitz_matrix< NumericT, AlignmentV > &	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

Definition at line 158 of file toeplitz_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	vandermonde_matrix< NumericT, AlignmentV > &	gpu_mat,
		std::vector< NumericT > &	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.

Definition at line 161 of file vandermonde_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	hankel_matrix< NumericT, AlignmentV > const &	gpu_mat,
		std::vector< NumericT > &	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.

Definition at line 162 of file hankel_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	circulant_matrix< NumericT, AlignmentV > &	gpu_mat,
		std::vector< NumericT > &	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.

Definition at line 163 of file circulant_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const coordinate_matrix< NumericT, AlignmentV > &	gpu_matrix,
		std::vector< std::map< unsigned int, NumericT > > &	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.

Definition at line 164 of file coordinate_matrix.hpp.

template<typename SizeT , typename NumericT >

void viennacl::copy	(	const std::vector< std::map< SizeT, NumericT > > &	cpu_matrix,
		compressed_compressed_matrix< NumericT > &	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_compressed_matrix from ViennaCL

Definition at line 164 of file compressed_compressed_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	vandermonde_matrix< NumericT, AlignmentV > &	vander_src,
		MatrixT &	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

Definition at line 174 of file vandermonde_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	circulant_matrix< NumericT, AlignmentV > &	circ_src,
		MatrixT &	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

Definition at line 176 of file circulant_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	hankel_matrix< NumericT, AlignmentV > const &	han_src,
		MatrixT &	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

Definition at line 176 of file hankel_matrix.hpp.

template<typename IndexT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	std::vector< std::map< IndexT, NumericT > > const &	cpu_matrix,
		ell_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

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

Parameters

cpu_matrix	A sparse matrix on the host composed of an STL vector and an STL map.
gpu_matrix	The sparse ell_matrix from ViennaCL

Definition at line 181 of file ell_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	toeplitz_matrix< NumericT, AlignmentV > const &	gpu_mat,
		std::vector< NumericT > &	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.

Definition at line 182 of file toeplitz_matrix.hpp.

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 189 of file matrix_proxy.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	MatrixT &	com_src,
		vandermonde_matrix< NumericT, AlignmentV > &	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

Definition at line 196 of file vandermonde_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	MatrixT const &	com_src,
		hankel_matrix< NumericT, AlignmentV > &	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

Definition at line 197 of file hankel_matrix.hpp.

template<typename CPUMatrixT , typename NumericT >

void viennacl::copy	(	const compressed_compressed_matrix< NumericT > &	gpu_matrix,
		CPUMatrixT &	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 CPUMatrixT 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_compressed_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host.

Definition at line 199 of file compressed_compressed_matrix.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const ell_matrix< NumericT, AlignmentV > &	gpu_matrix,
		CPUMatrixT &	cpu_matrix
	)

Definition at line 200 of file ell_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	MatrixT &	com_src,
		circulant_matrix< NumericT, AlignmentV > &	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

Definition at line 203 of file circulant_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	toeplitz_matrix< NumericT, AlignmentV > const &	tep_src,
		MatrixT &	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

Definition at line 204 of file toeplitz_matrix.hpp.

template<typename IndexT , typename NumericT , typename IndexT2 >

void viennacl::copy	(	std::vector< std::map< IndexT, NumericT > > const &	cpu_matrix,
		sliced_ell_matrix< NumericT, IndexT2 > &	gpu_matrix
	)

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

Parameters

cpu_matrix	A sparse matrix on the host composed of an STL vector and an STL map.
gpu_matrix	The sparse ell_matrix from ViennaCL

Definition at line 224 of file sliced_ell_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename MatrixT >

void viennacl::copy	(	MatrixT const &	com_src,
		toeplitz_matrix< NumericT, AlignmentV > &	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

Definition at line 225 of file toeplitz_matrix.hpp.

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 238 of file matrix_proxy.hpp.

template<typename NumericT , unsigned int AlignmentV, typename IndexT >

void viennacl::copy	(	const ell_matrix< NumericT, AlignmentV > &	gpu_matrix,
		std::vector< std::map< IndexT, NumericT > > &	cpu_matrix
	)

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

Parameters

gpu_matrix	The sparse ell_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host composed of an STL vector and an STL map.

Definition at line 242 of file ell_matrix.hpp.

template<typename IndexT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	std::vector< std::map< IndexT, NumericT > > const &	cpu_matrix,
		hyb_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

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

Parameters

cpu_matrix	A sparse matrix on the host composed of an STL vector and an STL map.
gpu_matrix	The sparse hyb_matrix from ViennaCL

Definition at line 243 of file hyb_matrix.hpp.

template<typename NumericT >

void viennacl::copy	(	const compressed_compressed_matrix< NumericT > &	gpu_matrix,
		std::vector< std::map< unsigned int, NumericT > > &	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_compressed_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host.

Definition at line 248 of file compressed_compressed_matrix.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const hyb_matrix< NumericT, AlignmentV > &	gpu_matrix,
		CPUMatrixT &	cpu_matrix
	)

Definition at line 260 of file hyb_matrix.hpp.

template<typename VectorType , typename NumericT >

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

Definition at line 261 of file vector_proxy.hpp.

template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >

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

template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>

void viennacl::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
	)

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 280 of file matrix_proxy.hpp.

template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>

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
	)

template<typename VectorType , typename NumericT >

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

Definition at line 285 of file vector_proxy.hpp.

template<typename NumericT , unsigned int AlignmentV, typename IndexT >

void viennacl::copy	(	const hyb_matrix< NumericT, AlignmentV > &	gpu_matrix,
		std::vector< std::map< IndexT, NumericT > > &	cpu_matrix
	)

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

Parameters

gpu_matrix	The sparse hyb_matrix from ViennaCL
cpu_matrix	A sparse matrix on the host composed of an STL vector and an STL map.

Definition at line 324 of file hyb_matrix.hpp.

template<typename CPUMatrixT , typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const compressed_matrix< NumericT, AlignmentV > &	gpu_matrix,
		CPUMatrixT &	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 CPUMatrixT 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.

Definition at line 341 of file compressed_matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::copy	(	const compressed_matrix< NumericT, AlignmentV > &	gpu_matrix,
		std::vector< std::map< unsigned int, NumericT > > &	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.

Definition at line 387 of file compressed_matrix.hpp.

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 439 of file matrix_proxy.hpp.

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 468 of file matrix_proxy.hpp.

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 506 of file matrix_proxy.hpp.

template<typename CPUMatrixT , typename NumericT >

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

Definition at line 536 of file matrix_proxy.hpp.

template<typename CPUMatrixT , typename NumericT , typename F , unsigned int AlignmentV>

void viennacl::copy	(	const CPUMatrixT &	cpu_matrix,
		matrix< NumericT, F, AlignmentV > &	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

Definition at line 934 of file matrix.hpp.

template<typename NumericT , typename A1 , typename A2 , typename F , unsigned int AlignmentV>

void viennacl::copy	(	const std::vector< std::vector< NumericT, A1 >, A2 > &	cpu_matrix,
		matrix< NumericT, F, AlignmentV > &	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

Definition at line 970 of file matrix.hpp.

template<typename CPUMatrixT , typename NumericT , typename F , unsigned int AlignmentV>

void viennacl::copy	(	const matrix< NumericT, F, AlignmentV > &	gpu_matrix,
		CPUMatrixT &	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()

Definition at line 1170 of file matrix.hpp.

template<typename NumericT , typename A1 , typename A2 , typename F , unsigned int AlignmentV>

void viennacl::copy	(	const matrix< NumericT, F, AlignmentV > &	gpu_matrix,
		std::vector< std::vector< NumericT, 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()

Definition at line 1199 of file matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >

void viennacl::copy	(	const const_vector_iterator< NumericT, AlignmentV > &	gpu_begin,
		const const_vector_iterator< NumericT, AlignmentV > &	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!

Definition at line 1322 of file vector.hpp.

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >

void viennacl::copy	(	const vector_iterator< NumericT, AlignmentV > &	gpu_begin,
		const vector_iterator< NumericT, AlignmentV > &	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!

Definition at line 1344 of file vector.hpp.

template<typename NumericT , typename CPUVECTOR >

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()

Definition at line 1360 of file vector.hpp.

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >

void viennacl::copy	(	CPU_ITERATOR const &	cpu_begin,
		CPU_ITERATOR const &	cpu_end,
		vector_iterator< NumericT, AlignmentV >	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!

Definition at line 1488 of file vector.hpp.

template<typename HostVectorT , typename T >

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

Transfer from a host vector object to a ViennaCL vector proxy. Requires the vector proxy to have the necessary size. 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.

Definition at line 1510 of file vector.hpp.

template<typename HostVectorT , typename T , unsigned int AlignmentV>

void viennacl::copy	(	HostVectorT const &	cpu_vec,
		vector< T, AlignmentV > &	gpu_vec
	)

Transfer from a host vector object to a ViennaCL vector. Resizes the ViennaCL vector if it has zero size. Convenience wrapper for viennacl::linalg::copy(cpu_vec.begin(), cpu_vec.end(), gpu_vec.begin());.

Parameters

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

Definition at line 1521 of file vector.hpp.

template<typename NumericT , unsigned int AlignmentV_SRC, unsigned int AlignmentV_DEST>

void viennacl::copy	(	const_vector_iterator< NumericT, AlignmentV_SRC > const &	gpu_src_begin,
		const_vector_iterator< NumericT, AlignmentV_SRC > const &	gpu_src_end,
		vector_iterator< NumericT, AlignmentV_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!

Definition at line 1557 of file vector.hpp.

template<typename NumericT , unsigned int AlignmentV_SRC, unsigned int AlignmentV_DEST>

void viennacl::copy	(	vector_iterator< NumericT, AlignmentV_SRC > const &	gpu_src_begin,
		vector_iterator< NumericT, AlignmentV_SRC > const &	gpu_src_end,
		vector_iterator< NumericT, AlignmentV_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!

Definition at line 1585 of file vector.hpp.

template<typename NumericT , unsigned int AlignmentV_SRC, unsigned int AlignmentV_DEST>

void viennacl::copy	(	vector< NumericT, AlignmentV_SRC > const &	gpu_src_vec,
		vector< NumericT, AlignmentV_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()

Definition at line 1600 of file vector.hpp.

template<typename NumericT >

NumericT* viennacl::cuda_arg ( scalar< NumericT > & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL scalar. Non-const version.

Examples:: examples/tutorial/libviennacl.cpp, and matrix-free.cpp.

Definition at line 39 of file common.hpp.

template<typename NumericT >

const NumericT* viennacl::cuda_arg ( scalar< NumericT > const & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL scalar. Const version.

Definition at line 46 of file common.hpp.

template<typename NumericT >

NumericT* viennacl::cuda_arg ( vector_base< NumericT > & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base) with implicit return type deduction. Non-const version.

Definition at line 56 of file common.hpp.

template<typename NumericT >

const NumericT* viennacl::cuda_arg ( vector_base< NumericT > const & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base) with implicit return type deduction. Const version.

Definition at line 63 of file common.hpp.

template<typename ReturnT , typename NumericT >

ReturnT* viennacl::cuda_arg ( vector_base< NumericT > & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base). Return type needs to be explicitly provided as first template argument. Non-const version.

Definition at line 70 of file common.hpp.

template<typename ReturnT , typename NumericT >

const ReturnT* viennacl::cuda_arg ( vector_base< NumericT > const & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL vector (through the base class vector_base). Return type needs to be explicitly provided as first template argument. Const version.

Definition at line 77 of file common.hpp.

template<typename NumericT >

NumericT* viennacl::cuda_arg ( matrix_base< NumericT > & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL matrix (through the base class matrix_base). Non-const version.

Definition at line 87 of file common.hpp.

template<typename NumericT >

const NumericT* viennacl::cuda_arg ( matrix_base< NumericT > const & obj )

Convenience helper function for extracting the CUDA handle from a ViennaCL matrix (through the base class matrix_base). Const version.

Definition at line 94 of file common.hpp.

template<typename ReturnT >

ReturnT* viennacl::cuda_arg ( viennacl::backend::mem_handle & h )

Convenience helper function for extracting the CUDA handle from a generic memory handle. Non-const version.

Definition at line 106 of file common.hpp.

template<typename ReturnT >

ReturnT const* viennacl::cuda_arg ( viennacl::backend::mem_handle const & h )

Convenience helper function for extracting the CUDA handle from a generic memory handle. Const-version.

Definition at line 113 of file common.hpp.

template<typename NumericT >

vector_expression< const matrix_base<NumericT>, const int, op_matrix_diag> viennacl::diag	(	const matrix_base< NumericT > &	A,
		int	k = `0`
	)

Definition at line 895 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const vector_base<NumericT>, const int, op_vector_diag> viennacl::diag	(	const vector_base< NumericT > &	v,
		int	k = `0`
	)

Definition at line 902 of file matrix.hpp.

template<typename CPUVECTOR , typename VectorType >

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.

Definition at line 124 of file vector_proxy.hpp.

template<typename VectorType , typename CPUVECTOR >

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()

Definition at line 157 of file vector_proxy.hpp.

template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >

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

template<typename CPU_ITERATOR , typename SCALARTYPE , unsigned int ALIGNMENT>

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

template<typename NumericT , typename F , unsigned int AlignmentV>

void viennacl::fast_copy	(	NumericT *	cpu_matrix_begin,
		NumericT *	cpu_matrix_end,
		matrix< NumericT, F, AlignmentV > &	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.

See Dense Matrix Type in the manual for the underlying data layout including padding rows and columns by zero.

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

Definition at line 1010 of file matrix.hpp.

template<typename NumericT , typename F , unsigned int AlignmentV>

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

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

See Dense Matrix Type in the manual for the underlying data layout including padding rows and columns by zero.

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.

Definition at line 1231 of file matrix.hpp.

template<typename NumericT , unsigned int AlignmentV, typename CPU_ITERATOR >

void viennacl::fast_copy	(	const const_vector_iterator< NumericT, AlignmentV > &	gpu_begin,
		const const_vector_iterator< NumericT, AlignmentV > &	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!

Definition at line 1234 of file vector.hpp.

template<typename NumericT , typename CPUVECTOR >

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 pointing to entries linear in memory can be obtained via member function .begin()

Definition at line 1267 of file vector.hpp.

template<typename CPU_ITERATOR , typename NumericT , unsigned int AlignmentV>

void viennacl::fast_copy	(	CPU_ITERATOR const &	cpu_begin,
		CPU_ITERATOR const &	cpu_end,
		vector_iterator< NumericT, AlignmentV >	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.

Definition at line 1400 of file vector.hpp.

template<typename CPUVECTOR , typename NumericT >

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.

Definition at line 1434 of file vector.hpp.

template<typename NumericT , unsigned int AlignmentV>

vector<NumericT, AlignmentV>& viennacl::fast_swap	(	vector< NumericT, AlignmentV > &	v1,
		vector< NumericT, AlignmentV > &	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

Examples:: blas1.cpp.

Definition at line 1659 of file vector.hpp.

template<typename S1 , typename NumericT >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,matrix_expression< const matrix_base<NumericT>, const S1, op_mult>>::type viennacl::operator*	(	S1 const &	value,
		matrix_base< NumericT > 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

Definition at line 1374 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	char	value,
		matrix_base< NumericT > const &	m1
	)

Operator overload for the expression alpha * m1, where alpha is a char (8-bit integer)

Definition at line 1382 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	short	value,
		matrix_base< NumericT > const &	m1
	)

Operator overload for the expression alpha * m1, where alpha is a short integer.

Definition at line 1390 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	int	value,
		matrix_base< NumericT > const &	m1
	)

Operator overload for the expression alpha * m1, where alpha is an integer.

Definition at line 1398 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	long	value,
		matrix_base< NumericT > const &	m1
	)

Operator overload for the expression alpha * m1, where alpha is a long integer.

Definition at line 1406 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	float	value,
		matrix_base< NumericT > const &	m1
	)

Operator overload for the expression alpha * m1, where alpha is a single precision floating point value.

Definition at line 1414 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	double	value,
		matrix_base< NumericT > const &	m1
	)

Operator overload for the expression alpha * m1, where alpha is a double precision floating point value.

Definition at line 1422 of file matrix.hpp.

template<typename LHS , typename RHS , typename OP , typename S1 >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,matrix_expression< const matrix_expression< LHS, RHS, OP>, const S1, op_mult> >::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

Definition at line 1437 of file matrix.hpp.

template<typename S1 , typename LHS , typename RHS , typename OP >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,matrix_expression< const matrix_expression< LHS, RHS, OP>, const S1, op_mult> >::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

Definition at line 1452 of file matrix.hpp.

template<typename NumericT , typename S1 >

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

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

Definition at line 1463 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	matrix_base< NumericT > const &	m1,
		char	s1
	)

Scales the matrix by a char (8-bit integer) 'alpha' and returns an expression template.

Definition at line 1471 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	matrix_base< NumericT > const &	m1,
		short	s1
	)

Scales the matrix by a short integer 'alpha' and returns an expression template.

Definition at line 1479 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	matrix_base< NumericT > const &	m1,
		int	s1
	)

Scales the matrix by an integer 'alpha' and returns an expression template.

Definition at line 1487 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	matrix_base< NumericT > const &	m1,
		long	s1
	)

Scales the matrix by a long integer 'alpha' and returns an expression template.

Definition at line 1495 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	matrix_base< NumericT > const &	m1,
		float	s1
	)

Scales the matrix by a single precision floating point number 'alpha' and returns an expression template.

Definition at line 1503 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_mult> viennacl::operator*	(	matrix_base< NumericT > const &	m1,
		double	s1
	)

Scales the matrix by a double precision floating point number 'alpha' and returns an expression template.

Definition at line 1511 of file matrix.hpp.

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_mult>>::type viennacl::operator*	(	const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy,
		const S1 &	val
	)

Definition at line 1752 of file matrix.hpp.

template<typename NumericT , typename S1 >

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_mult>>::type viennacl::operator*	(	const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy,
		const S1 &	val
	)

Definition at line 1766 of file matrix.hpp.

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_mult>>::type viennacl::operator*	(	const S1 &	val,
		const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy
	)

Definition at line 1781 of file matrix.hpp.

template<typename NumericT , typename S1 >

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_mult>>::type viennacl::operator*	(	const S1 &	val,
		const viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > &	proxy
	)

Definition at line 1795 of file matrix.hpp.

template<typename S1 , typename T >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,vector_expression< const vector_base<T>, const S1, op_mult> >::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

Definition at line 1871 of file vector.hpp.

template<typename T >

vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator*	(	char	value,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a char.

Parameters

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

Definition at line 1883 of file vector.hpp.

template<typename T >

vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator*	(	short	value,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a short.

Parameters

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

Definition at line 1895 of file vector.hpp.

template<typename T >

vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator*	(	int	value,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a int.

Parameters

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

Definition at line 1907 of file vector.hpp.

template<typename T >

vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator*	(	long	value,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a long.

Parameters

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

Definition at line 1919 of file vector.hpp.

template<typename T >

vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator*	(	float	value,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a float.

Parameters

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

Definition at line 1931 of file vector.hpp.

template<typename T >

vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator*	(	double	value,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a double.

Parameters

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

Definition at line 1943 of file vector.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

vector_expression< const vector_base<T>, const scalar_expression<LHS, RHS, OP>, op_mult> viennacl::operator*	(	scalar_expression< LHS, RHS, OP > const &	expr,
		vector_base< T > const &	vec
	)

Operator overload for the expression alpha * v1, where alpha is a scalar expression and v1 is a ViennaCL vector.

Parameters

expr	The scalar expression
vec	A ViennaCL vector

Definition at line 1957 of file vector.hpp.

template<typename T , typename S1 >

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

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

Definition at line 1967 of file vector.hpp.

template<typename T >

vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator*	(	vector_base< T > const &	vec,
		T const &	value
	)

Definition at line 1974 of file vector.hpp.

template<typename LHS , typename RHS , typename OP , typename S1 >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,viennacl::vector_expression<const vector_expression<LHS, RHS, OP>, const S1, op_mult> >::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

Definition at line 1987 of file vector.hpp.

template<typename S1 , typename LHS , typename RHS , typename OP >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,viennacl::vector_expression<const vector_expression<LHS, RHS, OP>, const S1, op_mult> >::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

Definition at line 2001 of file vector.hpp.

template<typename NumericT , typename S1 >

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

Scales a matrix by a GPU scalar value.

Definition at line 1522 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator*=	(	matrix_base< NumericT > &	m1,
		char	gpu_val
	)

Scales a matrix by a char (8-bit) value.

Definition at line 1533 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator*=	(	matrix_base< NumericT > &	m1,
		short	gpu_val
	)

Scales a matrix by a short integer value.

Definition at line 1543 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator*=	(	matrix_base< NumericT > &	m1,
		int	gpu_val
	)

Scales a matrix by an integer value.

Definition at line 1553 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator*=	(	matrix_base< NumericT > &	m1,
		long	gpu_val
	)

Scales a matrix by a long integer value.

Definition at line 1563 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator*=	(	matrix_base< NumericT > &	m1,
		float	gpu_val
	)

Scales a matrix by a single precision floating point value.

Definition at line 1573 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator*=	(	matrix_base< NumericT > &	m1,
		double	gpu_val
	)

Scales a matrix by a double precision floating point value.

Definition at line 1583 of file matrix.hpp.

template<typename T , typename S1 >

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.

Definition at line 1686 of file vector.hpp.

template<typename SCALARTYPE , typename SparseMatrixType >

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.

Definition at line 390 of file sparse_matrix_operations.hpp.

template<typename NumericT >

viennacl::vector<NumericT> viennacl::operator+	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_base< NumericT >, 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.

Definition at line 1182 of file matrix_operations.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >

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

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

Definition at line 1249 of file matrix.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename NumericT >

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

Definition at line 1265 of file matrix.hpp.

template<typename NumericT >

vector<NumericT> viennacl::operator+	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, 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.

Definition at line 1266 of file matrix_operations.hpp.

template<typename NumericT , typename LHS2 , typename RHS2 , typename OP2 >

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

Definition at line 1281 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_add > viennacl::operator+	(	const matrix_base< NumericT > &	m1,
		const matrix_base< NumericT > &	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.

Definition at line 1295 of file matrix.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >

vector_expression< const vector_expression< LHS1, RHS1, OP1>,const vector_expression< LHS2, RHS2, OP2>,viennacl::op_add> 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

Definition at line 1732 of file vector.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

vector_expression< const vector_expression<LHS, RHS, OP>,const vector_base<T>,viennacl::op_add> 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)

Definition at line 1750 of file vector.hpp.

template<typename T , typename LHS , typename RHS , typename OP >

vector_expression< const vector_base<T>,const vector_expression<LHS, RHS, OP>,viennacl::op_add> 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)

Definition at line 1768 of file vector.hpp.

template<typename T >

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.

Definition at line 1781 of file vector.hpp.

template<typename NumericT >

vector<NumericT> viennacl::operator+=	(	vector_base< NumericT > &	v1,
		const viennacl::vector_expression< const matrix_base< NumericT >, 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.

Definition at line 1141 of file matrix_operations.hpp.

template<typename NumericT >

vector<NumericT> viennacl::operator+=	(	vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, 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.

Definition at line 1223 of file matrix_operations.hpp.

template<typename T , typename LHS , typename RHS , typename OP >

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

Definition at line 1280 of file vector_operations.hpp.

template<typename SCALARTYPE , typename SparseMatrixType >

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.

Definition at line 408 of file sparse_matrix_operations.hpp.

template<typename NumericT >

viennacl::vector<NumericT> viennacl::operator-	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_base< NumericT >, 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.

Definition at line 1200 of file matrix_operations.hpp.

template<typename NumericT >

vector<NumericT> viennacl::operator-	(	const vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, 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.

Definition at line 1286 of file matrix_operations.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >

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

Definition at line 1309 of file matrix.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename NumericT >

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

Definition at line 1325 of file matrix.hpp.

template<typename NumericT , typename LHS2 , typename RHS2 , typename OP2 >

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

Definition at line 1341 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_sub > viennacl::operator-	(	const matrix_base< NumericT > &	m1,
		const matrix_base< NumericT > &	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.

Definition at line 1355 of file matrix.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >

vector_expression< const vector_expression< LHS1, RHS1, OP1>,const vector_expression< LHS2, RHS2, OP2>,viennacl::op_sub> 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

Definition at line 1802 of file vector.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

vector_expression< const vector_expression<LHS, RHS, OP>,const vector_base<T>,viennacl::op_sub> 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)

Definition at line 1821 of file vector.hpp.

template<typename T , typename LHS , typename RHS , typename OP >

vector_expression< const vector_base<T>,const vector_expression<LHS, RHS, OP>,viennacl::op_sub> 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)

Definition at line 1839 of file vector.hpp.

template<typename T >

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.

Definition at line 1852 of file vector.hpp.

template<typename NumericT >

vector<NumericT> viennacl::operator-=	(	vector_base< NumericT > &	v1,
		const viennacl::vector_expression< const matrix_base< NumericT >, 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.

Definition at line 1159 of file matrix_operations.hpp.

template<typename NumericT >

vector<NumericT> viennacl::operator-=	(	vector_base< NumericT > &	v1,
		const vector_expression< const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, 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.

Definition at line 1244 of file matrix_operations.hpp.

template<typename T , typename LHS , typename RHS , typename OP >

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

Definition at line 1291 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S1 >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,matrix_expression< const matrix_expression<const LHS, const RHS, OP>, const S1, op_div> >::type viennacl::operator/	(	matrix_expression< const LHS, const 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

Definition at line 1603 of file matrix.hpp.

template<typename NumericT , typename S1 >

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

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

Definition at line 1614 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_div> viennacl::operator/	(	matrix_base< NumericT > const &	m1,
		char	s1
	)

Returns an expression template for scaling the matrix by a char (8-bit integer) 'alpha'.

Definition at line 1622 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_div> viennacl::operator/	(	matrix_base< NumericT > const &	m1,
		short	s1
	)

Returns an expression template for scaling the matrix by a short integer 'alpha'.

Definition at line 1630 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_div> viennacl::operator/	(	matrix_base< NumericT > const &	m1,
		int	s1
	)

Returns an expression template for scaling the matrix by an integer 'alpha'.

Definition at line 1638 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_div> viennacl::operator/	(	matrix_base< NumericT > const &	m1,
		long	s1
	)

Returns an expression template for scaling the matrix by a long integer 'alpha'.

Definition at line 1646 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_div> viennacl::operator/	(	matrix_base< NumericT > const &	m1,
		float	s1
	)

Returns an expression template for scaling the matrix by a single precision floating point number 'alpha'.

Definition at line 1654 of file matrix.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const NumericT, op_div> viennacl::operator/	(	matrix_base< NumericT > const &	m1,
		double	s1
	)

Returns an expression template for scaling the matrix by a double precision floating point number 'alpha'.

Definition at line 1662 of file matrix.hpp.

template<typename S1 , typename LHS , typename RHS , typename OP >

viennacl::enable_if< viennacl::is_any_scalar<S1>::value,viennacl::vector_expression<const vector_expression<LHS, RHS, OP>, const S1, op_div> >::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

Definition at line 2019 of file vector.hpp.

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 viennacl::operator/	(	vector_base< T > const &	v1,
		S1 const &	s1
	)

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

Definition at line 2031 of file vector.hpp.

template<typename NumericT , typename S1 >

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

Scales a matrix by a GPU scalar value.

Definition at line 1674 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator/=	(	matrix_base< NumericT > &	m1,
		char	gpu_val
	)

Scales a matrix by a char (8-bit integer) value.

Definition at line 1684 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator/=	(	matrix_base< NumericT > &	m1,
		short	gpu_val
	)

Scales a matrix by a short integer value.

Definition at line 1694 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator/=	(	matrix_base< NumericT > &	m1,
		int	gpu_val
	)

Scales a matrix by an integer value.

Definition at line 1704 of file matrix.hpp.

template<typename T , typename S1 >

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.

Definition at line 1707 of file vector.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator/=	(	matrix_base< NumericT > &	m1,
		long	gpu_val
	)

Scales a matrix by a long integer value.

Definition at line 1714 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator/=	(	matrix_base< NumericT > &	m1,
		float	gpu_val
	)

Scales a matrix by a single precision floating point value.

Definition at line 1724 of file matrix.hpp.

template<typename NumericT >

matrix_base<NumericT>& viennacl::operator/=	(	matrix_base< NumericT > &	m1,
		double	gpu_val
	)

Scales a matrix by a double precision floating point value.

Definition at line 1734 of file matrix.hpp.

template<class NumericT , unsigned int AlignmentV>

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		vandermonde_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

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

Parameters

s	STL output stream
gpu_matrix	A ViennaCL Vandermonde matrix

Definition at line 225 of file vandermonde_matrix.hpp.

template<class NumericT , unsigned int AlignmentV>

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		hankel_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

Definition at line 226 of file hankel_matrix.hpp.

template<class NumericT , unsigned int AlignmentV>

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		circulant_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

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

Parameters

s	STL output stream
gpu_matrix	A ViennaCL circulant matrix

Definition at line 241 of file circulant_matrix.hpp.

template<class NumericT , unsigned int AlignmentV>

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		toeplitz_matrix< NumericT, AlignmentV > &	gpu_matrix
	)

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

Parameters

s	STL output stream
gpu_matrix	A ViennaCL Toeplitz matrix

Definition at line 267 of file toeplitz_matrix.hpp.

template<class NumericT >

std::ostream& viennacl::operator<<	(	std::ostream &	s,
		const matrix_base< NumericT > &	gpu_matrix
	)

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

Parameters

s	STL output stream
gpu_matrix	A dense ViennaCL matrix

Definition at line 828 of file matrix.hpp.

template<class NumericT >

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

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

Definition at line 855 of file scalar.hpp.

template<typename LHS , typename RHS , typename OP >

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

Definition at line 865 of file matrix.hpp.

template<typename NumericT , unsigned int AlignmentV>

std::ostream& viennacl::operator<<	(	std::ostream &	os,
		compressed_matrix< NumericT, AlignmentV > const &	A
	)

Output stream support for compressed_matrix. Output format is same as MATLAB, Octave, or SciPy.

Parameters

os	STL output stream
A	The compressed matrix to be printed.

Definition at line 1059 of file compressed_matrix.hpp.

template<typename T >

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

Output stream. Output format is ublas compatible.

Parameters

os	STL output stream
val	The vector that should be printed

Definition at line 1617 of file vector.hpp.

template<typename LHS , typename RHS , typename OP >

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

Definition at line 1633 of file vector.hpp.

template<class NumericT >

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

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

Definition at line 864 of file scalar.hpp.

template<typename VectorType >

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

Definition at line 169 of file vector_proxy.hpp.

template<typename VectorType >

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

Definition at line 175 of file vector_proxy.hpp.

template<typename VectorType >

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

Definition at line 308 of file vector_proxy.hpp.

template<typename VectorType >

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

Definition at line 315 of file vector_proxy.hpp.

template<typename VectorType >

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

Definition at line 324 of file vector_proxy.hpp.

template<typename MatrixType >

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

Definition at line 326 of file matrix_proxy.hpp.

template<typename VectorType >

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

Definition at line 331 of file vector_proxy.hpp.

template<typename MatrixType >

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

Definition at line 335 of file matrix_proxy.hpp.

template<typename MatrixType >

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

Definition at line 568 of file matrix_proxy.hpp.

template<typename MatrixType >

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

Definition at line 576 of file matrix_proxy.hpp.

template<typename MatrixType >

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

Definition at line 584 of file matrix_proxy.hpp.

template<typename MatrixType >

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.

Definition at line 150 of file gibbs_poole_stockmeyer.hpp.

template<typename IndexT , typename ValueT >

std::vector<IndexT> viennacl::reorder	(	std::vector< std::map< IndexT, ValueT > > 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.

Examples:: bandwidth-reduction.cpp.

Definition at line 367 of file cuthill_mckee.hpp.

template<typename IndexT , typename ValueT >

std::vector<IndexT> viennacl::reorder	(	std::vector< std::map< IndexT, ValueT > > 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

Definition at line 474 of file cuthill_mckee.hpp.

template<typename NumericT , typename F >

vector_expression< const matrix_base<NumericT, F>, const unsigned int, op_row> viennacl::row	(	const matrix_base< NumericT, F > &	A,
		unsigned int	i
	)

Definition at line 910 of file matrix.hpp.

template<typename T >

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

Examples:: blas1.cpp.

Definition at line 1648 of file vector.hpp.

template<typename T >

void viennacl::switch_memory_context	(	T &	obj,
		viennacl::context	new_ctx
	)

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

Definition at line 622 of file memory.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > const &	v0,
		vector_base< ScalarT > const &	v1
	)

Definition at line 1155 of file vector.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > &	v0,
		vector_base< ScalarT > &	v1
	)

Definition at line 1158 of file vector.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > const &	v0,
		vector_base< ScalarT > const &	v1,
		vector_base< ScalarT > const &	v2
	)

Definition at line 1162 of file vector.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > &	v0,
		vector_base< ScalarT > &	v1,
		vector_base< ScalarT > &	v2
	)

Definition at line 1165 of file vector.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > const &	v0,
		vector_base< ScalarT > const &	v1,
		vector_base< ScalarT > const &	v2,
		vector_base< ScalarT > const &	v3
	)

Definition at line 1169 of file vector.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > &	v0,
		vector_base< ScalarT > &	v1,
		vector_base< ScalarT > &	v2,
		vector_base< ScalarT > &	v3
	)

Definition at line 1175 of file vector.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > const &	v0,
		vector_base< ScalarT > const &	v1,
		vector_base< ScalarT > const &	v2,
		vector_base< ScalarT > const &	v3,
		vector_base< ScalarT > const &	v4
	)

Definition at line 1182 of file vector.hpp.

template<typename ScalarT >

vector_tuple<ScalarT> viennacl::tie	(	vector_base< ScalarT > &	v0,
		vector_base< ScalarT > &	v1,
		vector_base< ScalarT > &	v2,
		vector_base< ScalarT > &	v3,
		vector_base< ScalarT > &	v4
	)

Definition at line 1199 of file vector.hpp.

template<typename M1 >

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.

Definition at line 376 of file sparse_matrix_operations.hpp.

template<typename NumericT >

matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> viennacl::trans ( const matrix_base< NumericT > & mat )

Returns an expression template class representing a transposed matrix.

Definition at line 877 of file matrix.hpp.

template<typename LhsT , typename RhsT , typename OpT >

matrix_expression< const matrix_expression<const LhsT, const RhsT, OpT>, const matrix_expression<const LhsT, const RhsT, OpT>, op_trans> viennacl::trans ( const matrix_expression< const LhsT, const RhsT, OpT > & proxy )

Returns an expression template class representing the transposed matrix expression.

Definition at line 885 of file matrix.hpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation