| 
| 
using  | ConstViewType = VectorView< std::add_const_t< Real >, Device, Index > | 
|   | Compatible constant VectorView type. 
  | 
| using  | DeviceType = Device | 
|   | Device used to run operations on the vector.  
  | 
| 
using  | IndexType = Index | 
|   | Type being used for the vector elements indexing. 
  | 
| 
using  | RealType = Real | 
|   | Type of elements stored in this vector. 
  | 
| 
template<typename _Real, typename _Device = Device, typename _Index = Index>  | 
| using  | Self = VectorView< _Real, _Device, _Index > | 
|   | A template which allows to quickly obtain a VectorView type with changed template parameters. 
  | 
| 
using  | ViewType = VectorView< Real, Device, Index > | 
|   | Compatible VectorView type. 
  | 
| 
using  | ConstViewType | 
|   | Compatible constant ArrayView type. 
  | 
| using  | DeviceType | 
|   | Device used to run operations on the array.  
  | 
| 
using  | IndexType | 
|   | Type being used for the array elements indexing. 
  | 
| 
using  | Self | 
|   | A template which allows to quickly obtain an ArrayView type with changed template parameters. 
  | 
| 
using  | ValueType | 
|   | Type of elements stored in this array. 
  | 
| 
using  | ViewType | 
|   | Compatible ArrayView type. 
  | 
 | 
| __cuda_callable__  | VectorView ()=default | 
|   | Constructs an empty vector view.  
  | 
| 
template<typename Real_>  | 
| __cuda_callable__  | VectorView (const ArrayView< Real_, Device, Index > &view) | 
|   | Constructor for the initialization by a base class object. 
  | 
| __cuda_callable__  | VectorView (const VectorView &view)=default | 
|   | Shallow copy constructor.  
  | 
| __cuda_callable__  | VectorView (RealType *data, IndexType size) | 
|   | Constructs a vector view by binding to the given data pointer and size.  
  | 
| __cuda_callable__  | VectorView (VectorView &&view) noexcept=default | 
|   | Move constructor for initialization from rvalues.  
  | 
| __cuda_callable__ ConstViewType  | getConstView (IndexType begin=0, IndexType end=0) const | 
|   | Returns a non-modifiable view of the vector view.  
  | 
| __cuda_callable__ ViewType  | getView (IndexType begin=0, IndexType end=0) | 
|   | Returns a modifiable view of the vector view.  
  | 
| template<typename VectorExpression>  | 
| VectorView &  | operator%= (const VectorExpression &expression) | 
|   | Modulo assignment operator for vector view and a vector expression.  
  | 
| 
template<typename VectorExpression>  | 
| VectorView< Real, Device, Index > &  | operator%= (const VectorExpression &expression) | 
| template<typename VectorExpression>  | 
| VectorView &  | operator*= (const VectorExpression &expression) | 
|   | Multiplies elements of this vector view and a vector expression and stores the result in this vector view.  
  | 
| 
template<typename VectorExpression>  | 
| VectorView< Real, Device, Index > &  | operator*= (const VectorExpression &expression) | 
| template<typename VectorExpression>  | 
| VectorView &  | operator+= (const VectorExpression &expression) | 
|   | Adds elements of this vector view and a vector expression and stores the result in this vector view.  
  | 
| 
template<typename VectorExpression>  | 
| VectorView< Real, Device, Index > &  | operator+= (const VectorExpression &expression) | 
| template<typename VectorExpression>  | 
| VectorView &  | operator-= (const VectorExpression &expression) | 
|   | Subtracts elements of this vector view and a vector expression and stores the result in this vector view.  
  | 
| 
template<typename VectorExpression>  | 
| VectorView< Real, Device, Index > &  | operator-= (const VectorExpression &expression) | 
| template<typename VectorExpression>  | 
| VectorView &  | operator/= (const VectorExpression &expression) | 
|   | Divides elements of this vector view and a vector expression and stores the result in this vector view.  
  | 
| 
template<typename VectorExpression>  | 
| VectorView< Real, Device, Index > &  | operator/= (const VectorExpression &expression) | 
| template<typename T, typename..., typename = std::enable_if_t< std::is_convertible_v< T, Real > || IsArrayType< T >::value >>  | 
| ArrayView< Real, Device, Index > &  | operator= (const T &data) | 
|   | Assigns a value or an array - same as ArrayView::operator=.  
  | 
| template<typename VectorExpression, typename..., typename = std::enable_if_t< Expressions::HasEnabledExpressionTemplates< VectorExpression >::value                                          && ! IsArrayType< VectorExpression >::value >>  | 
| VectorView &  | operator= (const VectorExpression &expression) | 
|   | Assigns a vector expression to this vector view.  
  | 
| 
template<typename VectorExpression, typename..., typename>  | 
| VectorView< Real, Device, Index > &  | operator= (const VectorExpression &expression) | 
| VectorView &  | operator= (const VectorView &view)=default | 
|   | Deep copy assignment operator - same as ArrayView::operator=.  
  | 
| __cuda_callable__  | ArrayView ()=default | 
|   | Constructs an empty array view.  
  | 
| __cuda_callable__ void  | bind (ValueType *data, IndexType size) | 
|   | Method for rebinding (reinitialization) using a raw pointer and size.  
  | 
| __cuda_callable__ bool  | empty () const | 
|   | Returns true if the current array view size is zero.  
  | 
| void  | forAllElements (Function &&f) | 
|   | Process the lambda function f for each array element.  
  | 
| void  | forElements (IndexType begin, IndexType end, Function &&f) | 
|   | Process the lambda function f for each array element in interval [ begin, end).  
  | 
| __cuda_callable__ const ValueType *  | getArrayData () const | 
|   | Returns a const-qualified raw pointer to the data.  
  | 
| __cuda_callable__ ConstViewType  | getConstView (IndexType begin=0, IndexType end=0) const | 
|   | Returns a non-modifiable view of the array view.  
  | 
| __cuda_callable__ const ValueType *  | getData () const | 
|   | Returns a const-qualified raw pointer to the data.  
  | 
| __cuda_callable__ ValueType  | getElement (IndexType i) const | 
|   | Returns the value of the i-th element.  
  | 
| __cuda_callable__ IndexType  | getSize () const | 
|   | Returns the current size of the array view.  
  | 
| __cuda_callable__ ViewType  | getView (IndexType begin=0, IndexType end=0) | 
|   | Returns a modifiable view of the array view.  
  | 
| void  | load (const std::string &fileName) | 
|   | Method for loading the data from a binary file fileName.  
  | 
| bool  | operator!= (const ArrayT &array) const | 
|   | Compares the array view with another array-like container.  
  | 
| __cuda_callable__ double &  | operator() (IndexType i) | 
|   | Accesses the i-th element of the array.  
  | 
| 
ArrayView< double, Devices::Host, int > &  | operator= (const T &data) | 
| bool  | operator== (const ArrayT &array) const | 
|   | Compares the array view with another array-like container.  
  | 
| __cuda_callable__ double &  | operator[] (IndexType i) | 
|   | Accesses the i-th element of the array view.  
  | 
| 
__cuda_callable__ void  | reset () | 
| void  | save (const std::string &fileName) const | 
|   | Method for saving the data to a binary file fileName.  
  | 
| __cuda_callable__ void  | setElement (IndexType i, ValueType value) | 
|   | Sets the value of the i-th element to v.  
  | 
| void  | setValue (ValueType value, IndexType begin=0, IndexType end=0) | 
|   | Sets elements of the array view to given value.  
  | 
| __cuda_callable__ void  | swap (ArrayView &view) noexcept | 
|   | Swaps this array view with another.  
  | 
template<typename 
Real = double, typename Device = Devices::Host, typename Index = int>
class TNL::Containers::VectorView< Real, Device, Index >
VectorView extends ArrayView with algebraic operations. 
The template parameters have the same meaning as in ArrayView, with Real corresponding to ArrayView's Value parameter.
- Template Parameters
 - 
  
    | Real | An arithmetic type for the vector values, e.g. float or double.  | 
    | Device | The device to be used for the execution of vector operations.  | 
    | Index | The indexing type.  |