A vector class representing a linear memory sequence on the GPU. Inspired by boost::numeric::ublas::vector.
More...
|
| vector () |
| Default constructor in order to be compatible with various containers. More...
|
|
| vector (size_type vec_size) |
| An explicit constructor for the vector, allocating the given amount of memory (plus a padding specified by 'ALIGNMENT') More...
|
|
| vector (size_type vec_size, viennacl::context ctx) |
|
| vector (SCALARTYPE *ptr_to_mem, viennacl::memory_types mem_type, size_type vec_size, size_type start=0, difference_type stride=1) |
|
template<typename LHS , typename RHS , typename OP > |
| vector (vector_expression< const LHS, const RHS, OP > const &proxy) |
|
| vector (const base_type &v) |
|
| vector (const self_type &v) |
|
| vector (unit_vector< SCALARTYPE > const &v) |
| Creates the vector from the supplied unit vector. More...
|
|
| vector (zero_vector< SCALARTYPE > const &v) |
| Creates the vector from the supplied zero vector. More...
|
|
| vector (scalar_vector< SCALARTYPE > const &v) |
| Creates the vector from the supplied scalar vector. More...
|
|
template<typename T > |
self_type & | operator= (T const &other) |
|
void | resize (size_type new_size, bool preserve=true) |
| Resizes the allocated memory for the vector. Pads the memory to be a multiple of 'ALIGNMENT'. More...
|
|
void | resize (size_type new_size, viennacl::context ctx, bool preserve=true) |
|
self_type & | fast_swap (self_type &other) |
| Swaps the handles of two vectors by swapping the OpenCL handles only, no data copy. More...
|
|
void | switch_memory_context (viennacl::context new_ctx) |
|
| vector_base () |
| Default constructor in order to be compatible with various containers. More...
|
|
| vector_base (viennacl::backend::mem_handle &h, size_type vec_size, size_type vec_start, difference_type vec_stride) |
| An explicit constructor for wrapping an existing vector into a vector_range or vector_slice. More...
|
|
| vector_base (size_type vec_size, viennacl::context ctx=viennacl::context()) |
| Creates a vector and allocates the necessary memory. More...
|
|
| vector_base (SCALARTYPE *ptr_to_mem, viennacl::memory_types mem_type, size_type vec_size, vcl_size_t start=0, difference_type stride=1) |
|
| vector_base (vector_expression< const LHS, const RHS, OP > const &proxy) |
| Creates the vector from the supplied random vector. More...
|
|
self_type & | operator= (const self_type &vec) |
| Assignment operator. Other vector needs to be of the same size, or this vector is not yet initialized. More...
|
|
self_type & | operator= (const vector_expression< const LHS, const RHS, OP > &proxy) |
| Implementation of the operation v1 = v2 @ alpha, where @ denotes either multiplication or division, and alpha is either a CPU or a GPU scalar. More...
|
|
self_type & | operator= (const vector_base< T > &v1) |
|
self_type & | operator= (unit_vector< SCALARTYPE > const &v) |
| Creates the vector from the supplied unit vector. More...
|
|
self_type & | operator= (zero_vector< SCALARTYPE > const &v) |
| Creates the vector from the supplied zero vector. More...
|
|
self_type & | operator= (scalar_vector< SCALARTYPE > const &v) |
| Creates the vector from the supplied scalar vector. More...
|
|
self_type & | operator= (const viennacl::vector_expression< const matrix_base< SCALARTYPE, F >, const vector_base< SCALARTYPE >, viennacl::op_prod > &proxy) |
| Operator overload for v1 = A * v2, where v1, v2 are vectors and A is a dense matrix. More...
|
|
self_type & | operator= (const vector_expression< const matrix_expression< const matrix_base< SCALARTYPE, F >, const matrix_base< SCALARTYPE, F >, op_trans >, const vector_base< SCALARTYPE >, op_prod > &proxy) |
| Operator overload for v1 = trans(A) * v2, where v1, v2 are vectors and A is a dense matrix. More...
|
|
entry_proxy< SCALARTYPE > | operator() (size_type index) |
| Read-write access to a single element of the vector. More...
|
|
const_entry_proxy< SCALARTYPE > | operator() (size_type index) const |
| Read access to a single element of the vector. More...
|
|
entry_proxy< SCALARTYPE > | operator[] (size_type index) |
| Read-write access to a single element of the vector. More...
|
|
const_entry_proxy< SCALARTYPE > | operator[] (size_type index) const |
| Read access to a single element of the vector. More...
|
|
self_type & | operator+= (const self_type &vec) |
|
self_type & | operator-= (const self_type &vec) |
|
self_type & | operator*= (SCALARTYPE val) |
| Scales a vector (or proxy) by a CPU scalar value. More...
|
|
self_type & | operator/= (SCALARTYPE val) |
| Scales this vector by a CPU scalar value. More...
|
|
vector_expression< const
self_type, const SCALARTYPE,
op_mult > | operator* (SCALARTYPE value) const |
| Scales the vector by a CPU scalar 'alpha' and returns an expression template. More...
|
|
vector_expression< const
self_type, const SCALARTYPE,
op_div > | operator/ (SCALARTYPE value) const |
| Scales the vector by a CPU scalar 'alpha' and returns an expression template. More...
|
|
vector_expression< const
self_type, const SCALARTYPE,
op_mult > | operator- () const |
| Sign flip for the vector. Emulated to be equivalent to -1.0 * vector. More...
|
|
iterator | begin () |
| Returns an iterator pointing to the beginning of the vector (STL like) More...
|
|
const_iterator | begin () const |
| Returns a const-iterator pointing to the beginning of the vector (STL like) More...
|
|
iterator | end () |
| Returns an iterator pointing to the end of the vector (STL like) More...
|
|
const_iterator | end () const |
| Returns a const-iterator pointing to the end of the vector (STL like) More...
|
|
self_type & | swap (self_type &other) |
| Swaps the entries of the two vectors. More...
|
|
size_type | size () const |
| Returns the length of the vector (cf. std::vector) More...
|
|
size_type | internal_size () const |
| Returns the internal length of the vector, which is given by size() plus the extra memory due to padding the memory with zeros up to a multiple of 'ALIGNMENT'. More...
|
|
size_type | start () const |
| Returns the offset within the buffer. More...
|
|
size_type | stride () const |
| Returns the stride within the buffer (in multiples of sizeof(SCALARTYPE)) More...
|
|
bool | empty () const |
| Returns true is the size is zero. More...
|
|
const handle_type & | handle () const |
| Returns the memory handle. More...
|
|
handle_type & | handle () |
| Returns the memory handle. More...
|
|
void | clear () |
| Resets all entries to zero. Does not change the size of the vector. More...
|
|
viennacl::memory_types | memory_domain () const |
|
template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
class viennacl::vector< SCALARTYPE, ALIGNMENT >
A vector class representing a linear memory sequence on the GPU. Inspired by boost::numeric::ublas::vector.
This is the basic vector type of ViennaCL. It is similar to std::vector and boost::numeric::ublas::vector and supports various linear algebra operations. By default, the internal length of the vector is padded to a multiple of 'ALIGNMENT' in order to speed up several GPU viennacl::ocl::kernels.
- Template Parameters
-
SCALARTYPE | The floating point type, either 'float' or 'double' |
ALIGNMENT | The internal memory size is given by (size()/ALIGNMENT + 1) * ALIGNMENT. ALIGNMENT must be a power of two. Best values or usually 4, 8 or 16, higher values are usually a waste of memory. |