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- ![]() | |
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_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_reduce_columns |
struct | op_reduce_rows |
struct | op_reduce_vector |
struct | op_row |
A tag class representing the extraction of a matrix row to a vector. 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_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_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, ![]() | |
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 | 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... | |
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 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 > | |
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 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) |
Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them.
typedef basic_range viennacl::range |
Definition at line 423 of file forwards.h.
typedef basic_slice viennacl::slice |
Definition at line 428 of file forwards.h.
typedef std::ptrdiff_t viennacl::vcl_ptrdiff_t |
Definition at line 75 of file forwards.h.
typedef std::size_t viennacl::vcl_size_t |
Definition at line 74 of file forwards.h.
Enumerator | |
---|---|
MEMORY_NOT_INITIALIZED | |
MAIN_MEMORY | |
OPENCL_MEMORY | |
CUDA_MEMORY |
Definition at line 344 of file forwards.h.
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.
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 1270 of file vector.hpp.
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());.
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 1295 of file vector.hpp.
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.
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 1436 of file vector.hpp.
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());.
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 1461 of file vector.hpp.
vector_expression< const matrix_base<NumericT, F>, const unsigned int, op_column> viennacl::column | ( | const matrix_base< NumericT, F > & | A, |
unsigned int | j | ||
) |
Definition at line 861 of file matrix.hpp.
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<>)
cpu_matrix | A sparse matrix on the host. |
gpu_matrix | A compressed_matrix from ViennaCL |
Definition at line 47 of file coordinate_matrix.hpp.
void viennacl::copy | ( | const VectorType & | cpu_vector, |
vector_range< vector< NumericT > > & | gpu_vector_range | ||
) |
Definition at line 93 of file vector_proxy.hpp.
void viennacl::copy | ( | const CPUMatrixT & | cpu_matrix, |
matrix_range< matrix< NumericT, row_major, 1 > > & | gpu_matrix_range | ||
) |
Definition at line 105 of file matrix_proxy.hpp.
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.
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.
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):
cpu_matrix | A sparse matrix on the host. |
gpu_matrix | A compressed_matrix from ViennaCL |
Definition at line 112 of file compressed_matrix.hpp.
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):
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.
void viennacl::copy | ( | const CPUMatrixT & | cpu_matrix, |
ell_matrix< NumericT, AlignmentV > & | gpu_matrix | ||
) |
Definition at line 124 of file ell_matrix.hpp.
void viennacl::copy | ( | vector_range< vector< NumericT > > const & | gpu_vector_range, |
VectorType & | cpu_vector | ||
) |
Definition at line 125 of file vector_proxy.hpp.
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):
gpu_matrix | A coordinate_matrix from ViennaCL |
cpu_matrix | A sparse matrix on the host. |
Definition at line 127 of file coordinate_matrix.hpp.
void viennacl::copy | ( | const CPUMatrixT & | cpu_matrix, |
hyb_matrix< NumericT, AlignmentV > & | gpu_matrix | ||
) |
Definition at line 136 of file hyb_matrix.hpp.
void viennacl::copy | ( | CPUMatrixT const & | cpu_matrix, |
sliced_ell_matrix< ScalarT, IndexT > & | gpu_matrix | ||
) |
Definition at line 137 of file sliced_ell_matrix.hpp.
void viennacl::copy | ( | const CPUMatrixT & | cpu_matrix, |
matrix_range< matrix< NumericT, column_major, 1 > > & | gpu_matrix_range | ||
) |
Definition at line 147 of file matrix_proxy.hpp.
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)
cpu_vec | A std::vector on the host. |
gpu_mat | A vandermonde_matrix from ViennaCL |
Definition at line 148 of file vandermonde_matrix.hpp.
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)
cpu_vec | A std::vector on the host. |
gpu_mat | A hankel_matrix from ViennaCL |
Definition at line 148 of file hankel_matrix.hpp.
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.
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.
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)
cpu_vec | A std::vector on the host. |
gpu_mat | A circulant_matrix from ViennaCL |
Definition at line 150 of file circulant_matrix.hpp.
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 .
gpu_matrix | A coordinate_matrix from ViennaCL |
cpu_matrix | A sparse matrix on the host. |
Definition at line 157 of file coordinate_matrix.hpp.
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)
cpu_vec | A std::vector on the host. |
gpu_mat | A toeplitz_matrix from ViennaCL |
Definition at line 158 of file toeplitz_matrix.hpp.
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.
gpu_mat | A vandermonde_matrix from ViennaCL |
cpu_vec | A std::vector on the host. |
Definition at line 161 of file vandermonde_matrix.hpp.
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.
gpu_mat | A hankel_matrix from ViennaCL |
cpu_vec | A std::vector on the host. |
Definition at line 162 of file hankel_matrix.hpp.
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.
gpu_mat | A circulant_matrix from ViennaCL |
cpu_vec | A std::vector on the host. |
Definition at line 163 of file circulant_matrix.hpp.
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.
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.
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.
vander_src | A vandermonde_matrix from ViennaCL |
com_dst | A matrix-like object |
Definition at line 174 of file vandermonde_matrix.hpp.
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.
circ_src | A circulant_matrix from ViennaCL |
com_dst | A matrix-like object |
Definition at line 176 of file circulant_matrix.hpp.
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.
han_src | A hankel_matrix from ViennaCL |
com_dst | A matrix-like object |
Definition at line 176 of file hankel_matrix.hpp.
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 .
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.
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.
gpu_mat | A toeplitz_matrix from ViennaCL |
cpu_vec | A std::vector on the host. |
Definition at line 182 of file toeplitz_matrix.hpp.
void viennacl::copy | ( | const ell_matrix< NumericT, AlignmentV > & | gpu_matrix, |
CPUMatrixT & | cpu_matrix | ||
) |
Definition at line 194 of file ell_matrix.hpp.
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)
com_src | A std::vector on the host |
vander_dst | A vandermonde_matrix from ViennaCL |
Definition at line 196 of file vandermonde_matrix.hpp.
void viennacl::copy | ( | matrix_range< matrix< NumericT, row_major, 1 > > const & | gpu_matrix_range, |
CPUMatrixT & | cpu_matrix | ||
) |
Definition at line 196 of file matrix_proxy.hpp.
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)
com_src | A std::vector on the host |
han_dst | A hankel_matrix from ViennaCL |
Definition at line 197 of file hankel_matrix.hpp.
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):
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.
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)
com_src | A std::vector on the host |
circ_dst | A circulant_matrix from ViennaCL |
Definition at line 203 of file circulant_matrix.hpp.
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.
tep_src | A toeplitz_matrix from ViennaCL |
com_dst | A matrix-like object |
Definition at line 204 of file toeplitz_matrix.hpp.
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)
com_src | A std::vector on the host |
tep_dst | A toeplitz_matrix from ViennaCL |
Definition at line 225 of file toeplitz_matrix.hpp.
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 .
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 234 of file sliced_ell_matrix.hpp.
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 .
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 236 of file ell_matrix.hpp.
void viennacl::copy | ( | matrix_range< matrix< NumericT, column_major, 1 > > const & | gpu_matrix_range, |
CPUMatrixT & | cpu_matrix | ||
) |
Definition at line 238 of file matrix_proxy.hpp.
void viennacl::copy | ( | const VectorType & | cpu_vector, |
vector_slice< vector< NumericT > > & | gpu_vector_slice | ||
) |
Definition at line 242 of file vector_proxy.hpp.
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 .
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.
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 .
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.
void viennacl::copy | ( | const hyb_matrix< NumericT, AlignmentV > & | gpu_matrix, |
CPUMatrixT & | cpu_matrix | ||
) |
Definition at line 254 of file hyb_matrix.hpp.
void viennacl::copy | ( | vector_slice< vector< NumericT > > const & | gpu_vector_slice, |
VectorType & | cpu_vector | ||
) |
Definition at line 266 of file vector_proxy.hpp.
void viennacl::copy | ( | CPU_ITERATOR const & | cpu_begin, |
CPU_ITERATOR const & | cpu_end, | ||
vector_iterator< SCALARTYPE, ALIGNMENT > | gpu_begin | ||
) |
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 | ||
) |
void viennacl::copy | ( | const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const & | gpu_src_begin, |
const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const & | gpu_src_end, | ||
const_vector_iterator< SCALARTYPE, ALIGNMENT_DEST > | gpu_dest_begin | ||
) |
void viennacl::copy | ( | const 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):
gpu_matrix | A compressed_matrix from ViennaCL |
cpu_matrix | A sparse matrix on the host. |
Definition at line 283 of file compressed_matrix.hpp.
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 .
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 318 of file hyb_matrix.hpp.
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 .
gpu_matrix | A compressed_matrix from ViennaCL |
cpu_matrix | A sparse matrix on the host. |
Definition at line 329 of file compressed_matrix.hpp.
void viennacl::copy | ( | const CPUMatrixT & | cpu_matrix, |
matrix_slice< matrix< NumericT, row_major, 1 > > & | gpu_matrix_slice | ||
) |
Definition at line 388 of file matrix_proxy.hpp.
void viennacl::copy | ( | const CPUMatrixT & | cpu_matrix, |
matrix_slice< matrix< NumericT, column_major, 1 > > & | gpu_matrix_slice | ||
) |
Definition at line 417 of file matrix_proxy.hpp.
void viennacl::copy | ( | matrix_slice< matrix< NumericT, row_major, 1 > > const & | gpu_matrix_slice, |
CPUMatrixT & | cpu_matrix | ||
) |
Definition at line 455 of file matrix_proxy.hpp.
void viennacl::copy | ( | matrix_slice< matrix< NumericT, column_major, 1 > > const & | gpu_matrix_slice, |
CPUMatrixT & | cpu_matrix | ||
) |
Definition at line 485 of file matrix_proxy.hpp.
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)
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 877 of file matrix.hpp.
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)
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 913 of file matrix.hpp.
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).
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 1091 of file matrix.hpp.
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).
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 1120 of file matrix.hpp.
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.
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 1308 of file vector.hpp.
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.
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 1330 of file vector.hpp.
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());.
gpu_vec | A gpu vector |
cpu_vec | The cpu vector. Type requirements: Output iterator can be obtained via member function .begin() |
Definition at line 1346 of file vector.hpp.
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.
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 1474 of file vector.hpp.
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());.
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 1496 of file vector.hpp.
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());.
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 1507 of file vector.hpp.
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.
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 1549 of file vector.hpp.
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.
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 1577 of file vector.hpp.
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());.
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 1592 of file vector.hpp.
vector_expression< const matrix_base<NumericT>, const int, op_matrix_diag> viennacl::diag | ( | const matrix_base< NumericT > & | A, |
int | k = 0 |
||
) |
Definition at line 838 of file matrix.hpp.
matrix_expression< const vector_base<NumericT>, const int, op_vector_diag> viennacl::diag | ( | const vector_base< NumericT > & | v, |
int | k = 0 |
||
) |
Definition at line 845 of file matrix.hpp.
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());.
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 114 of file vector_proxy.hpp.
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());.
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 147 of file vector_proxy.hpp.
void viennacl::fast_copy | ( | const const_vector_iterator< SCALARTYPE, ALIGNMENT > & | gpu_begin, |
const const_vector_iterator< SCALARTYPE, ALIGNMENT > & | gpu_end, | ||
CPU_ITERATOR | cpu_begin | ||
) |
void viennacl::fast_copy | ( | CPU_ITERATOR const & | cpu_begin, |
CPU_ITERATOR const & | cpu_end, | ||
vector_iterator< SCALARTYPE, ALIGNMENT > | gpu_begin | ||
) |
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.
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 953 of file matrix.hpp.
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.
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 1152 of file matrix.hpp.
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.
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 1220 of file vector.hpp.
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());.
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 1253 of file vector.hpp.
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.
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 1386 of file vector.hpp.
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());.
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 1420 of file vector.hpp.
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.
v1 | The first vector |
v2 | The second vector |
Definition at line 1651 of file vector.hpp.
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.
value | The host scalar (float or double) |
m1 | A ViennaCL matrix |
Definition at line 1295 of file matrix.hpp.
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 1303 of file matrix.hpp.
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 1311 of file matrix.hpp.
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 1319 of file matrix.hpp.
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 1327 of file matrix.hpp.
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 1335 of file matrix.hpp.
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 1343 of file matrix.hpp.
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.
proxy | Left hand side matrix expression |
val | Right hand side scalar |
Definition at line 1358 of file matrix.hpp.
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.
val | Right hand side scalar |
proxy | Left hand side matrix expression |
Definition at line 1373 of file matrix.hpp.
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 1384 of file matrix.hpp.
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 1392 of file matrix.hpp.
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 1400 of file matrix.hpp.
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 1408 of file matrix.hpp.
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 1416 of file matrix.hpp.
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 1424 of file matrix.hpp.
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 1432 of file matrix.hpp.
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 1673 of file matrix.hpp.
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 1687 of file matrix.hpp.
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 1702 of file matrix.hpp.
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 1716 of file matrix.hpp.
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.
value | The host scalar (float or double) |
vec | A ViennaCL vector |
Definition at line 1863 of file vector.hpp.
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.
value | The host scalar (float or double) |
vec | A ViennaCL vector |
Definition at line 1875 of file vector.hpp.
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.
value | The host scalar (float or double) |
vec | A ViennaCL vector |
Definition at line 1887 of file vector.hpp.
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.
value | The host scalar (float or double) |
vec | A ViennaCL vector |
Definition at line 1899 of file vector.hpp.
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.
value | The host scalar (float or double) |
vec | A ViennaCL vector |
Definition at line 1911 of file vector.hpp.
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.
value | The host scalar (float or double) |
vec | A ViennaCL vector |
Definition at line 1923 of file vector.hpp.
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.
value | The host scalar (float or double) |
vec | A ViennaCL vector |
Definition at line 1935 of file vector.hpp.
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.
expr | The scalar expression |
vec | A ViennaCL vector |
Definition at line 1949 of file vector.hpp.
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 1959 of file vector.hpp.
vector_expression< const vector_base<T>, const T, op_mult> viennacl::operator* | ( | vector_base< T > const & | vec, |
T const & | value | ||
) |
Definition at line 1966 of file vector.hpp.
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.
proxy | Left hand side vector expression |
val | Right hand side scalar |
Definition at line 1979 of file vector.hpp.
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.
val | Right hand side scalar |
proxy | Left hand side vector expression |
Definition at line 1993 of file vector.hpp.
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 1443 of file matrix.hpp.
matrix_base<NumericT>& viennacl::operator*= | ( | matrix_base< NumericT > & | m1, |
char | gpu_val | ||
) |
Scales a matrix by a char (8-bit) value.
Definition at line 1454 of file matrix.hpp.
matrix_base<NumericT>& viennacl::operator*= | ( | matrix_base< NumericT > & | m1, |
short | gpu_val | ||
) |
Scales a matrix by a short integer value.
Definition at line 1464 of file matrix.hpp.
matrix_base<NumericT>& viennacl::operator*= | ( | matrix_base< NumericT > & | m1, |
int | gpu_val | ||
) |
Scales a matrix by an integer value.
Definition at line 1474 of file matrix.hpp.
matrix_base<NumericT>& viennacl::operator*= | ( | matrix_base< NumericT > & | m1, |
long | gpu_val | ||
) |
Scales a matrix by a long integer value.
Definition at line 1484 of file matrix.hpp.
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 1494 of file matrix.hpp.
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 1504 of file matrix.hpp.
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 1678 of file vector.hpp.
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.
result | The vector the result is written to. |
proxy | An expression template proxy class holding v1, A, and v2. |
Definition at line 344 of file sparse_matrix_operations.hpp.
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 1170 of file matrix.hpp.
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 1186 of file matrix.hpp.
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 1202 of file matrix.hpp.
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.
v1 | The addend vector. |
proxy | An expression template proxy class. |
Definition at line 1211 of file matrix_operations.hpp.
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 1216 of file matrix.hpp.
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.
v1 | The addend vector. |
proxy | An expression template proxy class. |
Definition at line 1295 of file matrix_operations.hpp.
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.
proxy1 | Left hand side vector expression |
proxy2 | Right hand side vector expression |
Definition at line 1724 of file vector.hpp.
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.
proxy | Left hand side vector expression |
vec | Right hand side vector (also -range and -slice is allowed) |
Definition at line 1742 of file vector.hpp.
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.
proxy | Left hand side vector expression |
vec | Right hand side vector (also -range and -slice is allowed) |
Definition at line 1760 of file vector.hpp.
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 1773 of file vector.hpp.
vector_base<T>& viennacl::operator+= | ( | vector_base< T > & | v1, |
const vector_expression< const LHS, const RHS, OP > & | proxy | ||
) |
Definition at line 1062 of file vector_operations.hpp.
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.
v1 | The result vector v1 where A * v2 is added to |
proxy | An expression template proxy class. |
Definition at line 1170 of file matrix_operations.hpp.
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.
v1 | The addend vector where the result is written to. |
proxy | An expression template proxy class. |
Definition at line 1252 of file matrix_operations.hpp.
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.
result | The vector the result is written to. |
proxy | An expression template proxy class. |
Definition at line 362 of file sparse_matrix_operations.hpp.
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.
v1 | The addend vector. |
proxy | An expression template proxy class. |
Definition at line 1229 of file matrix_operations.hpp.
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 1230 of file matrix.hpp.
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 1246 of file matrix.hpp.
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 1262 of file matrix.hpp.
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 1276 of file matrix.hpp.
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.
v1 | The addend vector. |
proxy | An expression template proxy class. |
Definition at line 1315 of file matrix_operations.hpp.
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.
proxy1 | Left hand side vector expression |
proxy2 | Right hand side vector expression |
Definition at line 1794 of file vector.hpp.
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.
proxy | Left hand side vector expression |
vec | Right hand side vector (also -range and -slice is allowed) |
Definition at line 1813 of file vector.hpp.
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.
proxy | Left hand side vector expression |
vec | Right hand side vector (also -range and -slice is allowed) |
Definition at line 1831 of file vector.hpp.
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 1844 of file vector.hpp.
vector_base<T>& viennacl::operator-= | ( | vector_base< T > & | v1, |
const vector_expression< const LHS, const RHS, OP > & | proxy | ||
) |
Definition at line 1073 of file vector_operations.hpp.
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.
v1 | The result vector v1 where A * v2 is subtracted from |
proxy | An expression template proxy class. |
Definition at line 1188 of file matrix_operations.hpp.
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.
v1 | The addend vector where the result is written to. |
proxy | An expression template proxy class. |
Definition at line 1273 of file matrix_operations.hpp.
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.
proxy | Left hand side matrix expression |
val | Right hand side scalar |
Definition at line 1524 of file matrix.hpp.
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 1535 of file matrix.hpp.
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 1543 of file matrix.hpp.
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 1551 of file matrix.hpp.
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 1559 of file matrix.hpp.
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 1567 of file matrix.hpp.
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 1575 of file matrix.hpp.
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 1583 of file matrix.hpp.
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.
proxy | Left hand side vector expression |
val | Right hand side scalar |
Definition at line 2011 of file vector.hpp.
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 2023 of file vector.hpp.
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 1595 of file matrix.hpp.
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 1605 of file matrix.hpp.
matrix_base<NumericT>& viennacl::operator/= | ( | matrix_base< NumericT > & | m1, |
short | gpu_val | ||
) |
Scales a matrix by a short integer value.
Definition at line 1615 of file matrix.hpp.
matrix_base<NumericT>& viennacl::operator/= | ( | matrix_base< NumericT > & | m1, |
int | gpu_val | ||
) |
Scales a matrix by an integer value.
Definition at line 1625 of file matrix.hpp.
matrix_base<NumericT>& viennacl::operator/= | ( | matrix_base< NumericT > & | m1, |
long | gpu_val | ||
) |
Scales a matrix by a long integer value.
Definition at line 1635 of file matrix.hpp.
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 1645 of file matrix.hpp.
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 1655 of file matrix.hpp.
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 1699 of file vector.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | s, |
vandermonde_matrix< NumericT, AlignmentV > & | gpu_matrix | ||
) |
Prints the matrix. Output is compatible to boost::numeric::ublas.
s | STL output stream |
gpu_matrix | A ViennaCL Vandermonde matrix |
Definition at line 225 of file vandermonde_matrix.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | s, |
hankel_matrix< NumericT, AlignmentV > & | gpu_matrix | ||
) |
Definition at line 226 of file hankel_matrix.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | s, |
circulant_matrix< NumericT, AlignmentV > & | gpu_matrix | ||
) |
Prints the matrix. Output is compatible to boost::numeric::ublas.
s | STL output stream |
gpu_matrix | A ViennaCL circulant matrix |
Definition at line 241 of file circulant_matrix.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | s, |
toeplitz_matrix< NumericT, AlignmentV > & | gpu_matrix | ||
) |
Prints the matrix. Output is compatible to boost::numeric::ublas.
s | STL output stream |
gpu_matrix | A ViennaCL Toeplitz matrix |
Definition at line 267 of file toeplitz_matrix.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | s, |
const matrix_base< NumericT > & | gpu_matrix | ||
) |
Prints the matrix. Output is compatible to boost::numeric::ublas.
s | STL output stream |
gpu_matrix | A dense ViennaCL matrix |
Definition at line 781 of file matrix.hpp.
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 814 of file scalar.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | s, |
const matrix_expression< LHS, RHS, OP > & | expr | ||
) |
Prints the matrix. Output is compatible to boost::numeric::ublas.
s | STL output stream |
expr | A matrix expression |
Definition at line 818 of file matrix.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | os, |
vector_base< T > const & | val | ||
) |
Output stream. Output format is ublas compatible.
os | STL output stream |
val | The vector that should be printed |
Definition at line 1609 of file vector.hpp.
std::ostream& viennacl::operator<< | ( | std::ostream & | os, |
vector_expression< LHS, RHS, OP > const & | proxy | ||
) |
Definition at line 1625 of file vector.hpp.
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 823 of file scalar.hpp.
vector_range<VectorType> viennacl::project | ( | VectorType const & | vec, |
viennacl::range const & | r1 | ||
) |
Definition at line 159 of file vector_proxy.hpp.
vector_range<VectorType> viennacl::project | ( | viennacl::vector_range< VectorType > const & | vec, |
viennacl::range const & | r1 | ||
) |
Definition at line 165 of file vector_proxy.hpp.
matrix_range<MatrixType> viennacl::project | ( | MatrixType const & | A, |
viennacl::range const & | r1, | ||
viennacl::range const & | r2 | ||
) |
Definition at line 284 of file matrix_proxy.hpp.
vector_slice<VectorType> viennacl::project | ( | VectorType const & | vec, |
viennacl::slice const & | s1 | ||
) |
Definition at line 289 of file vector_proxy.hpp.
matrix_range<MatrixType> viennacl::project | ( | matrix_range< MatrixType > const & | A, |
viennacl::range const & | r1, | ||
viennacl::range const & | r2 | ||
) |
Definition at line 293 of file matrix_proxy.hpp.
vector_slice<VectorType> viennacl::project | ( | viennacl::vector_slice< VectorType > const & | vec, |
viennacl::slice const & | s1 | ||
) |
Definition at line 296 of file vector_proxy.hpp.
vector_slice<VectorType> viennacl::project | ( | viennacl::vector_slice< VectorType > const & | vec, |
viennacl::range const & | r1 | ||
) |
Definition at line 305 of file vector_proxy.hpp.
vector_slice<VectorType> viennacl::project | ( | viennacl::vector_range< VectorType > const & | vec, |
viennacl::slice const & | s1 | ||
) |
Definition at line 312 of file vector_proxy.hpp.
matrix_slice<MatrixType> viennacl::project | ( | MatrixType const & | A, |
viennacl::slice const & | r1, | ||
viennacl::slice const & | r2 | ||
) |
Definition at line 517 of file matrix_proxy.hpp.
matrix_slice<MatrixType> viennacl::project | ( | matrix_range< MatrixType > const & | A, |
viennacl::slice const & | r1, | ||
viennacl::slice const & | r2 | ||
) |
Definition at line 525 of file matrix_proxy.hpp.
matrix_slice<MatrixType> viennacl::project | ( | matrix_slice< MatrixType > const & | A, |
viennacl::slice const & | r1, | ||
viennacl::slice const & | r2 | ||
) |
Definition at line 533 of file matrix_proxy.hpp.
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)
matrix | vector of n matrix rows, where each row is a map<int, double> containing only the nonzero elements |
Definition at line 150 of file gibbs_poole_stockmeyer.hpp.
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)
matrix | vector of n matrix rows, where each row is a map<int, double> containing only the nonzero elements |
Definition at line 367 of file cuthill_mckee.hpp.
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.
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 853 of file matrix.hpp.
void viennacl::swap | ( | vector_base< T > & | vec1, |
vector_base< T > & | vec2 | ||
) |
Swaps the contents of two vectors, data is copied.
vec1 | The first vector |
vec2 | The second vector |
Definition at line 1640 of file vector.hpp.
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.
vector_tuple<ScalarT> viennacl::tie | ( | vector_base< ScalarT > const & | v0, |
vector_base< ScalarT > const & | v1 | ||
) |
Definition at line 1141 of file vector.hpp.
vector_tuple<ScalarT> viennacl::tie | ( | vector_base< ScalarT > & | v0, |
vector_base< ScalarT > & | v1 | ||
) |
Definition at line 1144 of file vector.hpp.
vector_tuple<ScalarT> viennacl::tie | ( | vector_base< ScalarT > const & | v0, |
vector_base< ScalarT > const & | v1, | ||
vector_base< ScalarT > const & | v2 | ||
) |
Definition at line 1148 of file vector.hpp.
vector_tuple<ScalarT> viennacl::tie | ( | vector_base< ScalarT > & | v0, |
vector_base< ScalarT > & | v1, | ||
vector_base< ScalarT > & | v2 | ||
) |
Definition at line 1151 of file vector.hpp.
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 1155 of file vector.hpp.
vector_tuple<ScalarT> viennacl::tie | ( | vector_base< ScalarT > & | v0, |
vector_base< ScalarT > & | v1, | ||
vector_base< ScalarT > & | v2, | ||
vector_base< ScalarT > & | v3 | ||
) |
Definition at line 1161 of file vector.hpp.
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 1168 of file vector.hpp.
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 1185 of file vector.hpp.
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 330 of file sparse_matrix_operations.hpp.
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 830 of file matrix.hpp.