![]() |
Efficient implementation of a dynamically sized vector with static memory.The HybridVector class template combines the flexibility of a dynamically sized vector with the efficiency and performance of a fixed-size vector. It is implemented as a crossing between the blaze::StaticVector and the blaze::DynamicVector class templates: Similar to the static vector it uses static stack memory instead of dynamically allocated memory and similar to the dynamic vector it can be resized (within the extend of the static memory). The type of the elements, the maximum number of elements and the transpose flag of the vector can be specified via the three template parameters: More...
#include <HybridVector.h>
Inherits blaze::DenseVector< HybridVector< Type, N, TF >, TF >.
Public Types | |
enum | { vectorizable = IsVectorizable<Type>::value } |
Compilation flag for intrinsic optimization. More... | |
enum | { smpAssignable = 0 } |
Compilation flag for SMP assignments. More... | |
typedef HybridVector< Type, N, TF > | This |
Type of this HybridVector instance. | |
typedef This | ResultType |
Result type for expression template evaluations. | |
typedef HybridVector< Type, N,!TF > | TransposeType |
Transpose type for expression template evaluations. | |
typedef Type | ElementType |
Type of the vector elements. | |
typedef IT::Type | IntrinsicType |
Intrinsic type of the vector elements. | |
typedef const Type & | ReturnType |
Return type for expression template evaluations. | |
typedef const HybridVector & | CompositeType |
Data type for composite expression templates. | |
typedef Type & | Reference |
Reference to a non-constant vector value. | |
typedef const Type & | ConstReference |
Reference to a constant vector value. | |
typedef DenseIterator< Type > | Iterator |
Iterator over non-constant elements. | |
typedef DenseIterator< const Type > | ConstIterator |
Iterator over constant elements. | |
typedef VT | VectorType |
Type of the vector. | |
Public Member Functions | |
template<typename Other , size_t M> | |
HybridVector< Type, N, TF > & | operator= (const Other(&array)[M]) |
Array assignment to all vector elements. More... | |
template<typename VT > | |
HybridVector< Type, N, TF > & | operator= (const Vector< VT, TF > &rhs) |
Assignment operator for different vectors. More... | |
template<typename VT > | |
HybridVector< Type, N, TF > & | operator+= (const Vector< VT, TF > &rhs) |
Addition assignment operator for the addition of a vector ( ![]() | |
template<typename VT > | |
HybridVector< Type, N, TF > & | operator-= (const Vector< VT, TF > &rhs) |
Subtraction assignment operator for the subtraction of a vector ( ![]() | |
template<typename VT > | |
HybridVector< Type, N, TF > & | operator*= (const Vector< VT, TF > &rhs) |
Multiplication assignment operator for the multiplication of a vector ( ![]() | |
template<typename Other > | |
EnableIf< IsNumeric< Other > , HybridVector< Type, N, TF > >::Type & | operator*= (Other rhs) |
Multiplication assignment operator for the multiplication between a vector and a scalar value ( ![]() | |
template<typename Other > | |
EnableIf< IsNumeric< Other > , HybridVector< Type, N, TF > >::Type & | operator/= (Other rhs) |
Division assignment operator for the division of a vector by a scalar value ( ![]() | |
template<typename Other > | |
HybridVector< Type, N, TF > & | scale (Other scalar) |
Scaling of the vector by the scalar value scalar ( ![]() | |
template<typename VT > | |
DisableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedAssign< VT > >::Type | assign (const DenseVector< VT, TF > &rhs) |
Default implementation of the assignment of a dense vector. More... | |
template<typename VT > | |
EnableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedAssign< VT > >::Type | assign (const DenseVector< VT, TF > &rhs) |
Intrinsic optimized implementation of the assignment of a dense vector. More... | |
template<typename VT > | |
DisableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedAddAssign< VT > >::Type | addAssign (const DenseVector< VT, TF > &rhs) |
Default implementation of the addition assignment of a dense vector. More... | |
template<typename VT > | |
EnableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedAddAssign< VT > >::Type | addAssign (const DenseVector< VT, TF > &rhs) |
Intrinsic optimized implementation of the addition assignment of a dense vector. More... | |
template<typename VT > | |
DisableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedSubAssign< VT > >::Type | subAssign (const DenseVector< VT, TF > &rhs) |
Default implementation of the subtraction assignment of a dense vector. More... | |
template<typename VT > | |
EnableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedSubAssign< VT > >::Type | subAssign (const DenseVector< VT, TF > &rhs) |
Intrinsic optimized implementation of the subtraction assignment of a dense vector. More... | |
template<typename VT > | |
DisableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedMultAssign< VT > >::Type | multAssign (const DenseVector< VT, TF > &rhs) |
Default implementation of the multiplication assignment of a dense vector. More... | |
template<typename VT > | |
EnableIf< typename HybridVector< Type, N, TF > ::BLAZE_TEMPLATE VectorizedMultAssign< VT > >::Type | multAssign (const DenseVector< VT, TF > &rhs) |
Intrinsic optimized implementation of the multiplication assignment of a dense vector. More... | |
VectorType & | operator~ () |
Conversion operator for non-constant vectors. More... | |
const VectorType & | operator~ () const |
Conversion operator for constant vectors. More... | |
Constructors | |
HybridVector () | |
The default constructor for HybridVector. More... | |
HybridVector (size_t n) | |
Constructor for a vector of size n. More... | |
HybridVector (size_t n, const Type &init) | |
Constructor for a homogeneous initialization of all n vector elements. More... | |
template<typename Other > | |
HybridVector (size_t n, const Other *array) | |
Array initialization of all vector elements. More... | |
template<typename Other , size_t M> | |
HybridVector (const Other(&array)[M]) | |
Array initialization of all vector elements. More... | |
HybridVector (const HybridVector &v) | |
The copy constructor for HybridVector. More... | |
template<typename VT > | |
HybridVector (const Vector< VT, TF > &v) | |
Conversion constructor from different vectors. More... | |
Data access functions | |
Reference | operator[] (size_t index) |
Subscript operator for the direct access to the vector elements. More... | |
ConstReference | operator[] (size_t index) const |
Subscript operator for the direct access to the vector elements. More... | |
Type * | data () |
Low-level data access to the vector elements. More... | |
const Type * | data () const |
Low-level data access to the vector elements. More... | |
Iterator | begin () |
Returns an iterator to the first element of the hybrid vector. More... | |
ConstIterator | begin () const |
Returns an iterator to the first element of the hybrid vector. More... | |
ConstIterator | cbegin () const |
Returns an iterator to the first element of the hybrid vector. More... | |
Iterator | end () |
Returns an iterator just past the last element of the hybrid vector. More... | |
ConstIterator | end () const |
Returns an iterator just past the last element of the hybrid vector. More... | |
ConstIterator | cend () const |
Returns an iterator just past the last element of the hybrid vector. More... | |
Assignment operators | |
template<typename Other , size_t M> | |
HybridVector & | operator= (const Other(&array)[M]) |
HybridVector & | operator= (const Type &rhs) |
Homogenous assignment to all vector elements. More... | |
HybridVector & | operator= (const HybridVector &rhs) |
Copy assignment operator for HybridVector. More... | |
template<typename VT > | |
HybridVector & | operator= (const Vector< VT, TF > &rhs) |
template<typename VT > | |
HybridVector & | operator+= (const Vector< VT, TF > &rhs) |
template<typename VT > | |
HybridVector & | operator-= (const Vector< VT, TF > &rhs) |
template<typename VT > | |
HybridVector & | operator*= (const Vector< VT, TF > &rhs) |
template<typename Other > | |
EnableIf< IsNumeric< Other > , HybridVector >::Type & | operator*= (Other rhs) |
template<typename Other > | |
EnableIf< IsNumeric< Other > , HybridVector >::Type & | operator/= (Other rhs) |
Utility functions | |
size_t | size () const |
Returns the current size/dimension of the vector. More... | |
size_t | capacity () const |
Returns the maximum capacity of the vector. More... | |
size_t | nonZeros () const |
Returns the number of non-zero elements in the vector. More... | |
void | reset () |
Reset to the default initial values. More... | |
void | clear () |
Clearing the vector. More... | |
void | resize (size_t n, bool preserve=true) |
Changing the size of the vector. More... | |
void | extend (size_t n, bool preserve=true) |
Extending the size of the vector. More... | |
template<typename Other > | |
HybridVector & | scale (Other scalar) |
void | swap (HybridVector &v) |
Swapping the contents of two hybrid vectors. More... | |
Expression template evaluation functions | |
template<typename Other > | |
bool | canAlias (const Other *alias) const |
Returns whether the vector can alias with the given address alias. More... | |
template<typename Other > | |
bool | isAliased (const Other *alias) const |
Returns whether the vector is aliased with the given address alias. More... | |
IntrinsicType | load (size_t index) const |
Aligned load of an intrinsic element of the vector. More... | |
IntrinsicType | loadu (size_t index) const |
Unaligned load of an intrinsic element of the vector. More... | |
void | store (size_t index, const IntrinsicType &value) |
Aligned store of an intrinsic element of the vector. More... | |
void | storeu (size_t index, const IntrinsicType &value) |
Unaligned store of an intrinsic element of the vector. More... | |
void | stream (size_t index, const IntrinsicType &value) |
Aligned, non-temporal store of an intrinsic element of the vector. More... | |
template<typename VT > | |
DisableIf< VectorizedAssign < VT > >::Type | assign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
EnableIf< VectorizedAssign< VT > >::Type | assign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
void | assign (const SparseVector< VT, TF > &rhs) |
Default implementation of the assignment of a sparse vector. More... | |
template<typename VT > | |
DisableIf< VectorizedAddAssign < VT > >::Type | addAssign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
EnableIf< VectorizedAddAssign < VT > >::Type | addAssign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
void | addAssign (const SparseVector< VT, TF > &rhs) |
Default implementation of the addition assignment of a sparse vector. More... | |
template<typename VT > | |
DisableIf< VectorizedSubAssign < VT > >::Type | subAssign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
EnableIf< VectorizedSubAssign < VT > >::Type | subAssign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
void | subAssign (const SparseVector< VT, TF > &rhs) |
Default implementation of the subtraction assignment of a sparse vector. More... | |
template<typename VT > | |
DisableIf < VectorizedMultAssign< VT > >::Type | multAssign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
EnableIf< VectorizedMultAssign < VT > >::Type | multAssign (const DenseVector< VT, TF > &rhs) |
template<typename VT > | |
void | multAssign (const SparseVector< VT, TF > &rhs) |
Default implementation of the multiplication assignment of a sparse vector. More... | |
Private Types | |
enum | { NN = N + ( IT::size - ( N % IT::size ) ) % IT::size } |
Alignment adjustment. | |
typedef IntrinsicTrait< Type > | IT |
Intrinsic trait for the vector element type. | |
Private Attributes | |
Member variables | |
AlignedArray< Type, NN > | v_ |
The statically allocated vector elements. More... | |
size_t | size_ |
The current size/dimension of the vector. | |
Efficient implementation of a dynamically sized vector with static memory.
The HybridVector class template combines the flexibility of a dynamically sized vector with the efficiency and performance of a fixed-size vector. It is implemented as a crossing between the blaze::StaticVector and the blaze::DynamicVector class templates: Similar to the static vector it uses static stack memory instead of dynamically allocated memory and similar to the dynamic vector it can be resized (within the extend of the static memory). The type of the elements, the maximum number of elements and the transpose flag of the vector can be specified via the three template parameters:
These contiguously stored elements can be directly accessed with the subscript operator. The numbering of the vector elements is
The use of HybridVector is very natural and intuitive. All operations (addition, subtraction, multiplication, scaling, ...) can be performed on all possible combinations of dense and sparse vectors with fitting element types. The following example gives an impression of the use of a 2-dimensional HybridVector:
anonymous enum |
Compilation flag for intrinsic optimization.
The vectorizable compilation flag indicates whether expressions the vector is involved in can be optimized via intrinsics. In case the element type of the vector is a vectorizable data type, the vectorizable compilation flag is set to true, otherwise it is set to false.
anonymous enum |
Compilation flag for SMP assignments.
The smpAssignable compilation flag indicates whether the vector can be used in SMP (shared memory parallel) assignments (both on the left-hand and right-hand side of the assignment).
|
inlineexplicit |
The default constructor for HybridVector.
The size of a default constructed HybridVector is initially set to 0.
|
inlineexplicit |
Constructor for a vector of size n.
n | The size of the vector. |
std::invalid_argument | Invalid size for hybrid vector. |
This constructor creates a hybrid vector of size n and initializes all vector elements to the default value (for instance 0 for integral types). In case n is larger than the maximum allowed number of elements (i.e. n > N) a std::invalid_argument exception is thrown.
|
inlineexplicit |
Constructor for a homogeneous initialization of all n vector elements.
n | The size of the vector. |
init | The initial value of the vector elements. |
std::invalid_argument | Invalid size for hybrid vector. |
This constructor creates a hybrid vector of size n and initializes all vector elements with the specified value. In case n is larger than the maximum allowed number of elements (i.e. n > N) a std::invalid_argument exception is thrown.
|
inlineexplicit |
Array initialization of all vector elements.
n | The size of the vector. |
array | Dynamic array for the initialization. |
This assignment operator offers the option to directly initialize the elements of the vector with a dynamic array:
The vector is sized according to the size of the array and initialized with the values from the given array. In case the size of the given array exceeds the maximum size of the hybrid vector (i.e. is larger than N), a std::invalid_argument exception is thrown.
Note that it is expected that the given array has at least n elements. Providing an array with less elements results in undefined behavior!
|
inlineexplicit |
Array initialization of all vector elements.
array | M-dimensional array for the initialization. |
This assignment operator offers the option to directly initialize the elements of the vector with a static array:
The vector is sized according to the size of the array and initialized with the values from the given array. This constructor only works for arrays with a size smaller-or-equal than the maximum number of elements of the hybrid vector (i.e. M <= N). The attempt to use a larger array will result in a compile time error.
|
inline |
The copy constructor for HybridVector.
v | Vector to be copied. |
The copy constructor is explicitly defined in order to enable/facilitate NRV optimization.
|
inline |
Conversion constructor from different vectors.
v | Vector to be copied. |
std::invalid_argument | Invalid setup of hybrid vector. |
This constructor initializes the hybrid vector from the given vector. In case the size of the given vector exceeds the maximum size of the hybrid vector (i.e. is larger than N), a std::invalid_argument exception is thrown.
|
inline |
Default implementation of the addition assignment of a sparse vector.
rhs | The right-hand side sparse vector to be added. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Default implementation of the addition assignment of a dense vector.
rhs | The right-hand side dense vector to be added. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Intrinsic optimized implementation of the addition assignment of a dense vector.
rhs | The right-hand side dense vector to be added. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Default implementation of the assignment of a sparse vector.
rhs | The right-hand side sparse vector to be assigned. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Default implementation of the assignment of a dense vector.
rhs | The right-hand side dense vector to be assigned. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Intrinsic optimized implementation of the assignment of a dense vector.
rhs | The right-hand side dense vector to be assigned. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Returns an iterator to the first element of the hybrid vector.
|
inline |
Returns an iterator to the first element of the hybrid vector.
|
inline |
Returns whether the vector can alias with the given address alias.
alias | The alias to be checked. |
This function returns whether the given address can alias with the vector. In contrast to the isAliased() function this function is allowed to use compile time expressions to optimize the evaluation.
|
inline |
Returns the maximum capacity of the vector.
|
inline |
Returns an iterator to the first element of the hybrid vector.
|
inline |
Returns an iterator just past the last element of the hybrid vector.
|
inline |
|
inline |
Low-level data access to the vector elements.
This function returns a pointer to the internal storage of the hybrid vector.
|
inline |
Low-level data access to the vector elements.
This function returns a pointer to the internal storage of the hybrid vector.
|
inline |
Returns an iterator just past the last element of the hybrid vector.
|
inline |
Returns an iterator just past the last element of the hybrid vector.
|
inline |
Extending the size of the vector.
n | Number of additional vector elements. |
preserve | true if the old values of the vector should be preserved, false if not. |
This function increases the vector size by n elements. In case the resulting size of the vector is larger than the maximum number of vector elements (i.e. if n > N) a std::invalid_argument exception is thrown. During this operation, all vector elements are potentially changed. In order to preserve the old vector values, the preserve flag can be set to true.
Note that new vector elements are not initialized!
|
inline |
Returns whether the vector is aliased with the given address alias.
alias | The alias to be checked. |
This function returns whether the given address is aliased with the vector. In contrast to the conAlias() function this function is not allowed to use compile time expressions to optimize the evaluation.
|
inline |
Aligned load of an intrinsic element of the vector.
index | Access index. The index must be smaller than the number of vector elements. |
This function performs an aligned load of a specific intrinsic element of the dense vector. The index must be smaller than the number of vector elements and it must be a multiple of the number of values inside the intrinsic element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
|
inline |
Unaligned load of an intrinsic element of the vector.
index | Access index. The index must be smaller than the number of vector elements. |
This function performs an unaligned load of a specific intrinsic element of the dense vector. The index must be smaller than the number of vector elements and it must be a multiple of the number of values inside the intrinsic element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
|
inline |
Default implementation of the multiplication assignment of a sparse vector.
rhs | The right-hand side sparse vector to be multiplied. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Default implementation of the multiplication assignment of a dense vector.
rhs | The right-hand side dense vector to be multiplied. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Intrinsic optimized implementation of the multiplication assignment of a dense vector.
rhs | The right-hand side dense vector to be multiplied. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Returns the number of non-zero elements in the vector.
Note that the number of non-zero elements is always less than or equal to the current size of the vector.
|
inline |
Multiplication assignment operator for the multiplication of a vector ( ).
rhs | The right-hand side vector to be multiplied with the vector. |
std::invalid_argument | Vector sizes do not match. |
In case the current sizes of the two vectors don't match, a std::invalid_argument exception is thrown.
|
inline |
Multiplication assignment operator for the multiplication between a vector and a scalar value ( ).
rhs | The right-hand side scalar value for the multiplication. |
|
inline |
Addition assignment operator for the addition of a vector ( ).
rhs | The right-hand side vector to be added to the vector. |
std::invalid_argument | Vector sizes do not match. |
In case the current sizes of the two vectors don't match, a std::invalid_argument exception is thrown.
|
inline |
Subtraction assignment operator for the subtraction of a vector ( ).
rhs | The right-hand side vector to be subtracted from the vector. |
std::invalid_argument | Vector sizes do not match. |
In case the current sizes of the two vectors don't match, a std::invalid_argument exception is thrown.
|
inline |
Division assignment operator for the division of a vector by a scalar value ( ).
rhs | The right-hand side scalar value for the division. |
Note: A division by zero is only checked by an user assert.
|
inline |
Homogenous assignment to all vector elements.
rhs | Scalar value to be assigned to all vector elements. |
|
inline |
Copy assignment operator for HybridVector.
rhs | Vector to be copied. |
Explicit definition of a copy assignment operator for performance reasons.
|
inline |
Array assignment to all vector elements.
array | M-dimensional array for the assignment. |
This assignment operator offers the option to directly set all elements of the vector:
The vector is sized according to the size of the array and assigned the values of the given array. This assignment operator only works for arrays with a size smaller-or-equal than the maximum number of elements of the hybrid vector. (i.e. M<= N). The attempt to use a larger array will result in a compile time error.
|
inline |
Assignment operator for different vectors.
rhs | Vector to be copied. |
std::invalid_argument | Invalid assignment to hybrid vector. |
This constructor initializes the vector as a copy of the given vector. In case the size of the given vector is larger than N, a std::invalid_argument exception is thrown.
|
inline |
Subscript operator for the direct access to the vector elements.
index | Access index. The index has to be in the range ![]() |
In case BLAZE_USER_ASSERT() is active, this operator performs an index check.
|
inline |
Subscript operator for the direct access to the vector elements.
index | Access index. The index has to be in the range ![]() |
In case BLAZE_USER_ASSERT() is active, this operator performs an index check.
|
inlineinherited |
Conversion operator for non-constant vectors.
|
inlineinherited |
Conversion operator for constant vectors.
|
inline |
Reset to the default initial values.
|
inline |
Changing the size of the vector.
n | The new size of the vector. |
preserve | true if the old values of the vector should be preserved, false if not. |
std::invalid_argument | Invalid size for hybrid vector. |
This function resizes the vector to the given size n. In case the given size n is larger than the maximum number of vector elements (i.e. if n > N) a std::invalid_argument exception is thrown. During this operation, all vector elements are potentially changed. In order to preserve the old vector values, the preserve flag can be set to true.
Note that in case the size of the vector is increased new vector elements are not initialized! This is illustrated by the following example, which demonstrates the resizing of a vector of size 2 to a vector of size 4. The new, uninitialized elements are marked with x:
|
inline |
Scaling of the vector by the scalar value scalar ( ).
scalar | The scalar value for the vector scaling. |
|
inline |
Returns the current size/dimension of the vector.
|
inline |
Aligned store of an intrinsic element of the vector.
index | Access index. The index must be smaller than the number of vector elements. |
value | The intrinsic element to be stored. |
This function performs an aligned store of a specific intrinsic element of the dense vector. The index must be smaller than the number of vector elements and it must be a multiple of the number of values inside the intrinsic element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
|
inline |
Unaligned store of an intrinsic element of the vector.
index | Access index. The index must be smaller than the number of vector elements. |
value | The intrinsic element to be stored. |
This function performs an unaligned store of a specific intrinsic element of the dense vector. The index must be smaller than the number of vector elements and it must be a multiple of the number of values inside the intrinsic element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
|
inline |
Aligned, non-temporal store of an intrinsic element of the vector.
index | Access index. The index must be smaller than the number of vector elements. |
value | The intrinsic element to be stored. |
This function performs an aligned, non-temporal store of a specific intrinsic element of the dense vector. The index must be smaller than the number of vector elements and it must be a multiple of the number of values inside the intrinsic element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
|
inline |
Default implementation of the subtraction assignment of a sparse vector.
rhs | The right-hand side sparse vector to be subtracted. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Default implementation of the subtraction assignment of a dense vector.
rhs | The right-hand side dense vector to be subtracted. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Intrinsic optimized implementation of the subtraction assignment of a dense vector.
rhs | The right-hand side dense vector to be subtracted. |
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.
|
inline |
Swapping the contents of two hybrid vectors.
v | The vector to be swapped. |
no-throw | guarantee. |
|
private |
The statically allocated vector elements.
Access to the vector values is gained via the subscript operator. The order of the elements is