Classes | Public Types | Public Member Functions | Static Public Attributes | Private Types | Static Private Attributes | List of all members
blaze::HybridVector< Type, N, TF > Class Template Reference

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

Classes

struct  Rebind
 Rebind mechanism to obtain a HybridVector with different data/element type. More...
 
struct  Resize
 Resize mechanism to obtain a HybridVector with a different fixed number of elements. More...
 

Public Types

using This = HybridVector< Type, N, TF >
 Type of this HybridVector instance.
 
using BaseType = DenseVector< This, TF >
 Base type of this HybridVector instance.
 
using ResultType = This
 Result type for expression template evaluations.
 
using TransposeType = HybridVector< Type, N,!TF >
 Transpose type for expression template evaluations.
 
using ElementType = Type
 Type of the vector elements.
 
using SIMDType = SIMDTrait_t< ElementType >
 SIMD type of the vector elements.
 
using ReturnType = const Type &
 Return type for expression template evaluations.
 
using CompositeType = const HybridVector &
 Data type for composite expression templates.
 
using Reference = Type &
 Reference to a non-constant vector value.
 
using ConstReference = const Type &
 Reference to a constant vector value.
 
using Pointer = Type *
 Pointer to a non-constant vector value.
 
using ConstPointer = const Type *
 Pointer to a constant vector value.
 
using Iterator = DenseIterator< Type, align >
 Iterator over non-constant elements.
 
using ConstIterator = DenseIterator< const Type, align >
 Iterator over constant elements.
 
using VectorType = VT
 Type of the vector.
 

Public Member Functions

template<typename Other , size_t Dim>
HybridVector< Type, N, TF > & operator= (const Other(&array)[Dim])
 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 ( $ \vec{a}+=\vec{b} $). More...
 
template<typename VT >
HybridVector< Type, N, TF > & operator-= (const Vector< VT, TF > &rhs)
 Subtraction assignment operator for the subtraction of a vector ( $ \vec{a}-=\vec{b} $). More...
 
template<typename VT >
HybridVector< Type, N, TF > & operator*= (const Vector< VT, TF > &rhs)
 Multiplication assignment operator for the multiplication of a vector ( $ \vec{a}*=\vec{b} $). More...
 
template<typename VT >
HybridVector< Type, N, TF > & operator/= (const DenseVector< VT, TF > &rhs)
 Division assignment operator for the division of a dense vector ( $ \vec{a}/=\vec{b} $). More...
 
template<typename VT >
HybridVector< Type, N, TF > & operator%= (const Vector< VT, TF > &rhs)
 Cross product assignment operator for the multiplication of a vector ( $ \vec{a}\times=\vec{b} $). More...
 
template<typename Other >
HybridVector< Type, N, TF > & scale (const Other &scalar)
 Scaling of the vector by the scalar value scalar ( $ \vec{a}*=s $). More...
 
BLAZE_ALWAYS_INLINE constexpr VectorTypeoperator~ () noexcept
 Conversion operator for non-constant vectors. More...
 
BLAZE_ALWAYS_INLINE constexpr const VectorTypeoperator~ () const noexcept
 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...
 
 HybridVector (initializer_list< Type > list)
 List initialization of all 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 Dim>
 HybridVector (const Other(&array)[Dim])
 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...
 
Destructor
 ~HybridVector ()=default
 
Data access functions
Reference operator[] (size_t index) noexcept
 Subscript operator for the direct access to the vector elements. More...
 
ConstReference operator[] (size_t index) const noexcept
 Subscript operator for the direct access to the vector elements. More...
 
Reference at (size_t index)
 Checked access to the vector elements. More...
 
ConstReference at (size_t index) const
 Checked access to the vector elements. More...
 
Pointer data () noexcept
 Low-level data access to the vector elements. More...
 
ConstPointer data () const noexcept
 Low-level data access to the vector elements. More...
 
Iterator begin () noexcept
 Returns an iterator to the first element of the hybrid vector. More...
 
ConstIterator begin () const noexcept
 Returns an iterator to the first element of the hybrid vector. More...
 
ConstIterator cbegin () const noexcept
 Returns an iterator to the first element of the hybrid vector. More...
 
Iterator end () noexcept
 Returns an iterator just past the last element of the hybrid vector. More...
 
ConstIterator end () const noexcept
 Returns an iterator just past the last element of the hybrid vector. More...
 
ConstIterator cend () const noexcept
 Returns an iterator just past the last element of the hybrid vector. More...
 
Assignment operators
HybridVectoroperator= (const Type &rhs)
 Homogenous assignment to all vector elements. More...
 
HybridVectoroperator= (initializer_list< Type > list)
 List assignment to all vector elements. More...
 
template<typename Other , size_t Dim>
HybridVectoroperator= (const Other(&array)[Dim])
 
HybridVectoroperator= (const HybridVector &rhs)
 Copy assignment operator for HybridVector. More...
 
template<typename VT >
HybridVectoroperator= (const Vector< VT, TF > &rhs)
 
template<typename VT >
HybridVectoroperator+= (const Vector< VT, TF > &rhs)
 
template<typename VT >
HybridVectoroperator-= (const Vector< VT, TF > &rhs)
 
template<typename VT >
HybridVectoroperator*= (const Vector< VT, TF > &rhs)
 
template<typename VT >
HybridVectoroperator/= (const DenseVector< VT, TF > &rhs)
 
template<typename VT >
HybridVectoroperator%= (const Vector< VT, TF > &rhs)
 
Numeric functions
template<typename Other >
HybridVectorscale (const Other &scalar)
 
Debugging functions
bool isIntact () const noexcept
 Returns whether the invariants of the hybrid vector are intact. More...
 

Static Public Member Functions

Memory functions
static void * operator new (std::size_t size)
 Class specific implementation of operator new. More...
 
static void * operator new[] (std::size_t size)
 Class specific implementation of operator new[]. More...
 
static void * operator new (std::size_t size, const std::nothrow_t &)
 Class specific implementation of the no-throw operator new. More...
 
static void * operator new[] (std::size_t size, const std::nothrow_t &)
 Class specific implementation of the no-throw operator new[]. More...
 
static void operator delete (void *ptr)
 Class specific implementation of operator delete. More...
 
static void operator delete[] (void *ptr)
 Class specific implementation of operator delete[]. More...
 
static void operator delete (void *ptr, const std::nothrow_t &)
 Class specific implementation of no-throw operator delete. More...
 
static void operator delete[] (void *ptr, const std::nothrow_t &)
 Class specific implementation of no-throw operator delete[]. More...
 

Static Public Attributes

static constexpr bool simdEnabled = IsVectorizable_v<Type>
 Compilation flag for SIMD optimization. More...
 
static constexpr bool smpAssignable = false
 Compilation flag for SMP assignments. More...
 
static constexpr bool transposeFlag = TF
 Transpose flag of the vector.
 

Private Types

using AlignedStorage = AlignedArray< Type, NN, Alignment >
 Type of the aligned storage.
 

Private Attributes

Member variables
AlignedStorage v_
 The statically allocated vector elements. More...
 
size_t size_
 The current size/dimension of the vector.
 

Static Private Attributes

static constexpr size_t SIMDSIZE = SIMDTrait<Type>::size
 The number of elements packed within a single SIMD vector.
 
static constexpr size_t NN = ( usePadding ? nextMultiple( N, SIMDSIZE ) : N )
 Alignment adjustment.
 
static constexpr bool align = ( NN >= SIMDSIZE )
 Compilation switch for the choice of alignment.
 
static constexpr size_t Alignment
 Alignment of the data elements. More...
 

Utility functions

size_t size () const noexcept
 Returns the current size/dimension 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...
 
void swap (HybridVector &v) noexcept
 Swapping the contents of two hybrid vectors. More...
 
static constexpr size_t spacing () noexcept
 Returns the minimum capacity of the vector. More...
 
static constexpr size_t capacity () noexcept
 Returns the maximum capacity of the vector. More...
 

Expression template evaluation functions

template<typename Other >
bool canAlias (const Other *alias) const noexcept
 Returns whether the vector can alias with the given address alias. More...
 
template<typename Other >
bool isAliased (const Other *alias) const noexcept
 Returns whether the vector is aliased with the given address alias. More...
 
BLAZE_ALWAYS_INLINE SIMDType load (size_t index) const noexcept
 Load of a SIMD element of the vector. More...
 
BLAZE_ALWAYS_INLINE SIMDType loada (size_t index) const noexcept
 Aligned load of a SIMD element of the vector. More...
 
BLAZE_ALWAYS_INLINE SIMDType loadu (size_t index) const noexcept
 Unaligned load of a SIMD element of the vector. More...
 
BLAZE_ALWAYS_INLINE void store (size_t index, const SIMDType &value) noexcept
 Store of a SIMD element of the vector. More...
 
BLAZE_ALWAYS_INLINE void storea (size_t index, const SIMDType &value) noexcept
 Aligned store of a SIMD element of the vector. More...
 
BLAZE_ALWAYS_INLINE void storeu (size_t index, const SIMDType &value) noexcept
 Unaligned store of a SIMD element of the vector. More...
 
BLAZE_ALWAYS_INLINE void stream (size_t index, const SIMDType &value) noexcept
 Aligned, non-temporal store of a SIMD element of the vector. More...
 
template<typename VT >
auto assign (const DenseVector< VT, TF > &rhs) -> DisableIf_t< VectorizedAssign_v< VT > >
 Default implementation of the assignment of a dense vector. More...
 
template<typename VT >
auto assign (const DenseVector< VT, TF > &rhs) -> EnableIf_t< VectorizedAssign_v< VT > >
 
template<typename VT >
void assign (const SparseVector< VT, TF > &rhs)
 Default implementation of the assignment of a sparse vector. More...
 
template<typename VT >
auto addAssign (const DenseVector< VT, TF > &rhs) -> DisableIf_t< VectorizedAddAssign_v< VT > >
 Default implementation of the addition assignment of a dense vector. More...
 
template<typename VT >
auto addAssign (const DenseVector< VT, TF > &rhs) -> EnableIf_t< VectorizedAddAssign_v< VT > >
 
template<typename VT >
void addAssign (const SparseVector< VT, TF > &rhs)
 Default implementation of the addition assignment of a sparse vector. More...
 
template<typename VT >
auto subAssign (const DenseVector< VT, TF > &rhs) -> DisableIf_t< VectorizedSubAssign_v< VT > >
 Default implementation of the subtraction assignment of a dense vector. More...
 
template<typename VT >
auto subAssign (const DenseVector< VT, TF > &rhs) -> EnableIf_t< VectorizedSubAssign_v< VT > >
 
template<typename VT >
void subAssign (const SparseVector< VT, TF > &rhs)
 Default implementation of the subtraction assignment of a sparse vector. More...
 
template<typename VT >
auto multAssign (const DenseVector< VT, TF > &rhs) -> DisableIf_t< VectorizedMultAssign_v< VT > >
 Default implementation of the multiplication assignment of a dense vector. More...
 
template<typename VT >
auto multAssign (const DenseVector< VT, TF > &rhs) -> EnableIf_t< VectorizedMultAssign_v< VT > >
 
template<typename VT >
void multAssign (const SparseVector< VT, TF > &rhs)
 Default implementation of the multiplication assignment of a sparse vector. More...
 
template<typename VT >
auto divAssign (const DenseVector< VT, TF > &rhs) -> DisableIf_t< VectorizedDivAssign_v< VT > >
 Default implementation of the division assignment of a dense vector. More...
 
template<typename VT >
auto divAssign (const DenseVector< VT, TF > &rhs) -> EnableIf_t< VectorizedDivAssign_v< VT > >
 
static constexpr bool isAligned () noexcept
 Returns whether the vector is properly aligned in memory. More...
 

Detailed Description

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
class blaze::HybridVector< Type, N, TF >

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:

template< typename Type, size_t N, bool TF >

These contiguously stored elements can be directly accessed with the subscript operator. The numbering of the vector elements is

\[\left(\begin{array}{*{4}{c}} 0 & 1 & \cdots & N-1 \\ \end{array}\right)\]

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:

HybridVector<double,2UL> a( 2 ); // Non-initialized 2D vector of size 2
a[0] = 1.0; // Initialization of the first element
a[1] = 2.0; // Initialization of the second element
HybridVector<double,2UL> b( 2, 2.0 ); // Directly, homogeneously initialized 2D vector
CompressedVector<float> c( 2 ); // Empty sparse single precision vector
HybridVector<double,2UL> d; // Default constructed hybrid vector
StaticMatrix<double,2UL,2UL> A; // Default constructed static row-major matrix
d = a + b; // Vector addition between vectors of equal element type
d = a - c; // Vector subtraction between a dense and sparse vector with different element types
d = a * b; // Component-wise vector multiplication
a *= 2.0; // In-place scaling of vector
d = a * 2.0; // Scaling of vector a
d = 2.0 * a; // Scaling of vector a
d += a - b; // Addition assignment
d -= a + c; // Subtraction assignment
d *= a * b; // Multiplication assignment
double scalar = trans( a ) * b; // Scalar/dot/inner product between two vectors
A = a * trans( b ); // Outer product between two vectors

Constructor & Destructor Documentation

◆ HybridVector() [1/8]

template<typename Type , size_t N, bool TF>
blaze::HybridVector< Type, N, TF >::HybridVector ( )
inlineexplicit

The default constructor for HybridVector.

The size of a default constructed HybridVector is initially set to 0.

◆ HybridVector() [2/8]

template<typename Type , size_t N, bool TF>
blaze::HybridVector< Type, N, TF >::HybridVector ( size_t  n)
inlineexplicit

Constructor for a vector of size n.

Parameters
nThe size of the vector.
Exceptions
std::invalid_argumentInvalid 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.

◆ HybridVector() [3/8]

template<typename Type , size_t N, bool TF>
blaze::HybridVector< Type, N, TF >::HybridVector ( size_t  n,
const Type &  init 
)
inlineexplicit

Constructor for a homogeneous initialization of all n vector elements.

Parameters
nThe size of the vector.
initThe initial value of the vector elements.
Exceptions
std::invalid_argumentInvalid 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.

◆ HybridVector() [4/8]

template<typename Type , size_t N, bool TF>
blaze::HybridVector< Type, N, TF >::HybridVector ( initializer_list< Type >  list)
inlineexplicit

List initialization of all vector elements.

Parameters
listThe initializer list.
Exceptions
std::invalid_argumentInvalid setup of hybrid vector.

This constructor provides the option to explicitly initialize the elements of the vector by means of an initializer list:

blaze::HybridVector<double,6UL> v1{ 4.2, 6.3, -1.2 };

The vector is sized according to the size of the initializer list and all its elements are (copy) assigned the values of the given initializer list. In case the size of the given list exceeds the maximum size of the hybrid vector (i.e. is larger than N), a std::invalid_argument exception is thrown.

◆ HybridVector() [5/8]

template<typename Type , size_t N, bool TF>
template<typename Other >
blaze::HybridVector< Type, N, TF >::HybridVector ( size_t  n,
const Other *  array 
)
inlineexplicit

Array initialization of all vector elements.

Parameters
nThe size of the vector.
arrayDynamic array for the initialization.
Exceptions
std::invalid_argumentInvalid size for hybrid vector.

This assignment operator offers the option to directly initialize the elements of the vector with a dynamic array:

double* array = new double[6];
// ... Initialization of the dynamic array
delete[] 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!

◆ HybridVector() [6/8]

template<typename Type , size_t N, bool TF>
template<typename Other , size_t Dim>
blaze::HybridVector< Type, N, TF >::HybridVector ( const Other(&)  array[Dim])
inlineexplicit

Array initialization of all vector elements.

Parameters
arrayM-dimensional array for the initialization.

This assignment operator offers the option to directly initialize the elements of the vector with a static array:

const double init[2] = { 1.0, 2.0 };

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.

◆ HybridVector() [7/8]

template<typename Type , size_t N, bool TF>
blaze::HybridVector< Type, N, TF >::HybridVector ( const HybridVector< Type, N, TF > &  v)
inline

The copy constructor for HybridVector.

Parameters
vVector to be copied.

The copy constructor is explicitly defined in order to enable/facilitate NRV optimization.

◆ HybridVector() [8/8]

template<typename Type , size_t N, bool TF>
template<typename VT >
blaze::HybridVector< Type, N, TF >::HybridVector ( const Vector< VT, TF > &  v)
inline

Conversion constructor from different vectors.

Parameters
vVector to be copied.
Exceptions
std::invalid_argumentInvalid 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.

Member Function Documentation

◆ addAssign() [1/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
auto blaze::HybridVector< Type, N, TF >::addAssign ( const DenseVector< VT, TF > &  rhs) -> DisableIf_t< VectorizedAddAssign_v<VT> >
inline

Default implementation of the addition assignment of a dense vector.

SIMD optimized implementation of the addition assignment of a dense vector.

Parameters
rhsThe right-hand side dense vector to be added.
Returns
void

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.

◆ addAssign() [2/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
void blaze::HybridVector< Type, N, TF >::addAssign ( const SparseVector< VT, TF > &  rhs)
inline

Default implementation of the addition assignment of a sparse vector.

Parameters
rhsThe right-hand side sparse vector to be added.
Returns
void

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.

◆ assign() [1/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
auto blaze::HybridVector< Type, N, TF >::assign ( const DenseVector< VT, TF > &  rhs) -> DisableIf_t< VectorizedAssign_v<VT> >
inline

Default implementation of the assignment of a dense vector.

SIMD optimized implementation of the assignment of a dense vector.

Parameters
rhsThe right-hand side dense vector to be assigned.
Returns
void

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.

◆ assign() [2/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
void blaze::HybridVector< Type, N, TF >::assign ( const SparseVector< VT, TF > &  rhs)
inline

Default implementation of the assignment of a sparse vector.

Parameters
rhsThe right-hand side sparse vector to be assigned.
Returns
void

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.

◆ at() [1/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::Reference blaze::HybridVector< Type, N, TF >::at ( size_t  index)
inline

Checked access to the vector elements.

Parameters
indexAccess index. The index has to be in the range $[0..N-1]$.
Returns
Reference to the accessed value.
Exceptions
std::out_of_rangeInvalid vector access index.

In contrast to the subscript operator this function always performs a check of the given access index.

◆ at() [2/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::ConstReference blaze::HybridVector< Type, N, TF >::at ( size_t  index) const
inline

Checked access to the vector elements.

Parameters
indexAccess index. The index has to be in the range $[0..N-1]$.
Returns
Reference to the accessed value.
Exceptions
std::out_of_rangeInvalid vector access index.

In contrast to the subscript operator this function always performs a check of the given access index.

◆ begin() [1/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::Iterator blaze::HybridVector< Type, N, TF >::begin ( )
inlinenoexcept

Returns an iterator to the first element of the hybrid vector.

Returns
Iterator to the first element of the hybrid vector.

◆ begin() [2/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::ConstIterator blaze::HybridVector< Type, N, TF >::begin ( ) const
inlinenoexcept

Returns an iterator to the first element of the hybrid vector.

Returns
Iterator to the first element of the hybrid vector.

◆ canAlias()

template<typename Type , size_t N, bool TF>
template<typename Other >
bool blaze::HybridVector< Type, N, TF >::canAlias ( const Other *  alias) const
inlinenoexcept

Returns whether the vector can alias with the given address alias.

Parameters
aliasThe alias to be checked.
Returns
true in case the alias corresponds to this vector, false if not.

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.

◆ capacity()

template<typename Type , size_t N, bool TF>
constexpr size_t blaze::HybridVector< Type, N, TF >::capacity ( )
inlinestaticnoexcept

Returns the maximum capacity of the vector.

Returns
The maximum capacity of the vector.

◆ cbegin()

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::ConstIterator blaze::HybridVector< Type, N, TF >::cbegin ( ) const
inlinenoexcept

Returns an iterator to the first element of the hybrid vector.

Returns
Iterator to the first element of the hybrid vector.

◆ cend()

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::ConstIterator blaze::HybridVector< Type, N, TF >::cend ( ) const
inlinenoexcept

Returns an iterator just past the last element of the hybrid vector.

Returns
Iterator just past the last element of the hybrid vector.

◆ clear()

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::clear ( )
inline

Clearing the vector.

Returns
void

After the clear() function, the size of the vector is 0.

◆ data() [1/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::Pointer blaze::HybridVector< Type, N, TF >::data ( )
inlinenoexcept

Low-level data access to the vector elements.

Returns
Pointer to the internal element storage.

This function returns a pointer to the internal storage of the hybrid vector.

◆ data() [2/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::ConstPointer blaze::HybridVector< Type, N, TF >::data ( ) const
inlinenoexcept

Low-level data access to the vector elements.

Returns
Pointer to the internal element storage.

This function returns a pointer to the internal storage of the hybrid vector.

◆ divAssign()

template<typename Type , size_t N, bool TF>
template<typename VT >
auto blaze::HybridVector< Type, N, TF >::divAssign ( const DenseVector< VT, TF > &  rhs) -> DisableIf_t< VectorizedDivAssign_v<VT> >
inline

Default implementation of the division assignment of a dense vector.

SIMD optimized implementation of the division assignment of a dense vector.

Parameters
rhsThe right-hand side dense vector divisor.
Returns
void

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.

◆ end() [1/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::Iterator blaze::HybridVector< Type, N, TF >::end ( )
inlinenoexcept

Returns an iterator just past the last element of the hybrid vector.

Returns
Iterator just past the last element of the hybrid vector.

◆ end() [2/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::ConstIterator blaze::HybridVector< Type, N, TF >::end ( ) const
inlinenoexcept

Returns an iterator just past the last element of the hybrid vector.

Returns
Iterator just past the last element of the hybrid vector.

◆ extend()

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::extend ( size_t  n,
bool  preserve = true 
)
inline

Extending the size of the vector.

Parameters
nNumber of additional vector elements.
preservetrue if the old values of the vector should be preserved, false if not.
Returns
void

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!

◆ isAliased()

template<typename Type , size_t N, bool TF>
template<typename Other >
bool blaze::HybridVector< Type, N, TF >::isAliased ( const Other *  alias) const
inlinenoexcept

Returns whether the vector is aliased with the given address alias.

Parameters
aliasThe alias to be checked.
Returns
true in case the alias corresponds to this vector, false if not.

This function returns whether the given address is aliased with the vector. In contrast to the canAlias() function this function is not allowed to use compile time expressions to optimize the evaluation.

◆ isAligned()

template<typename Type , size_t N, bool TF>
constexpr bool blaze::HybridVector< Type, N, TF >::isAligned ( )
inlinestaticnoexcept

Returns whether the vector is properly aligned in memory.

Returns
true in case the vector is aligned, false if not.

This function returns whether the vector is guaranteed to be properly aligned in memory, i.e. whether the beginning and the end of the vector are guaranteed to conform to the alignment restrictions of the element type Type.

◆ isIntact()

template<typename Type , size_t N, bool TF>
bool blaze::HybridVector< Type, N, TF >::isIntact ( ) const
inlinenoexcept

Returns whether the invariants of the hybrid vector are intact.

Returns
true in case the hybrid vector's invariants are intact, false otherwise.

This function checks whether the invariants of the hybrid vector are intact, i.e. if its state is valid. In case the invariants are intact, the function returns true, else it will return false.

◆ load()

template<typename Type , size_t N, bool TF>
BLAZE_ALWAYS_INLINE HybridVector< Type, N, TF >::SIMDType blaze::HybridVector< Type, N, TF >::load ( size_t  index) const
noexcept

Load of a SIMD element of the vector.

Parameters
indexAccess index. The index must be smaller than the number of vector elements.
Returns
The loaded SIMD element.

This function performs a load of a specific SIMD 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 SIMD 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.

◆ loada()

template<typename Type , size_t N, bool TF>
BLAZE_ALWAYS_INLINE HybridVector< Type, N, TF >::SIMDType blaze::HybridVector< Type, N, TF >::loada ( size_t  index) const
noexcept

Aligned load of a SIMD element of the vector.

Parameters
indexAccess index. The index must be smaller than the number of vector elements.
Returns
The loaded SIMD element.

This function performs an aligned load of a specific SIMD 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 SIMD 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.

◆ loadu()

template<typename Type , size_t N, bool TF>
BLAZE_ALWAYS_INLINE HybridVector< Type, N, TF >::SIMDType blaze::HybridVector< Type, N, TF >::loadu ( size_t  index) const
noexcept

Unaligned load of a SIMD element of the vector.

Parameters
indexAccess index. The index must be smaller than the number of vector elements.
Returns
The loaded SIMD element.

This function performs an unaligned load of a specific SIMD 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 SIMD 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.

◆ multAssign() [1/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
auto blaze::HybridVector< Type, N, TF >::multAssign ( const DenseVector< VT, TF > &  rhs) -> DisableIf_t< VectorizedMultAssign_v<VT> >
inline

Default implementation of the multiplication assignment of a dense vector.

SIMD optimized implementation of the multiplication assignment of a dense vector.

Parameters
rhsThe right-hand side dense vector to be multiplied.
Returns
void

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.

◆ multAssign() [2/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
void blaze::HybridVector< Type, N, TF >::multAssign ( const SparseVector< VT, TF > &  rhs)
inline

Default implementation of the multiplication assignment of a sparse vector.

Parameters
rhsThe right-hand side sparse vector to be multiplied.
Returns
void

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.

◆ nonZeros()

template<typename Type , size_t N, bool TF>
size_t blaze::HybridVector< Type, N, TF >::nonZeros ( ) const
inline

Returns the number of non-zero elements in the vector.

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.

◆ operator delete() [1/2]

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::operator delete ( void *  ptr)
inlinestatic

Class specific implementation of operator delete.

Parameters
ptrThe memory to be deallocated.
Returns
void

◆ operator delete() [2/2]

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::operator delete ( void *  ptr,
const std::nothrow_t &   
)
inlinestatic

Class specific implementation of no-throw operator delete.

Parameters
ptrThe memory to be deallocated.
Returns
void

◆ operator delete[]() [1/2]

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::operator delete[] ( void *  ptr)
inlinestatic

Class specific implementation of operator delete[].

Parameters
ptrThe memory to be deallocated.
Returns
void

◆ operator delete[]() [2/2]

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::operator delete[] ( void *  ptr,
const std::nothrow_t &   
)
inlinestatic

Class specific implementation of no-throw operator delete[].

Parameters
ptrThe memory to be deallocated.
Returns
void

◆ operator new() [1/2]

template<typename Type , size_t N, bool TF>
void * blaze::HybridVector< Type, N, TF >::operator new ( std::size_t  size)
inlinestatic

Class specific implementation of operator new.

Parameters
sizeThe total number of bytes to be allocated.
Returns
Pointer to the newly allocated memory.
Exceptions
std::bad_allocAllocation failed.

This class-specific implementation of operator new provides the functionality to allocate dynamic memory based on the alignment restrictions of the StaticVector class template.

◆ operator new() [2/2]

template<typename Type , size_t N, bool TF>
void * blaze::HybridVector< Type, N, TF >::operator new ( std::size_t  size,
const std::nothrow_t &   
)
inlinestatic

Class specific implementation of the no-throw operator new.

Parameters
sizeThe total number of bytes to be allocated.
Returns
Pointer to the newly allocated memory.
Exceptions
std::bad_allocAllocation failed.

This class-specific implementation of operator new provides the functionality to allocate dynamic memory based on the alignment restrictions of the HybridVector class template.

◆ operator new[]() [1/2]

template<typename Type , size_t N, bool TF>
void * blaze::HybridVector< Type, N, TF >::operator new[] ( std::size_t  size)
inlinestatic

Class specific implementation of operator new[].

Parameters
sizeThe total number of bytes to be allocated.
Returns
Pointer to the newly allocated memory.
Exceptions
std::bad_allocAllocation failed.

This class-specific implementation of operator new provides the functionality to allocate dynamic memory based on the alignment restrictions of the HybridVector class template.

◆ operator new[]() [2/2]

template<typename Type , size_t N, bool TF>
void * blaze::HybridVector< Type, N, TF >::operator new[] ( std::size_t  size,
const std::nothrow_t &   
)
inlinestatic

Class specific implementation of the no-throw operator new[].

Parameters
sizeThe total number of bytes to be allocated.
Returns
Pointer to the newly allocated memory.
Exceptions
std::bad_allocAllocation failed.

This class-specific implementation of operator new provides the functionality to allocate dynamic memory based on the alignment restrictions of the HybridVector class template.

◆ operator%=()

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename VT >
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::operator%= ( const Vector< VT, TF > &  rhs)
inline

Cross product assignment operator for the multiplication of a vector ( $ \vec{a}\times=\vec{b} $).

Parameters
rhsThe right-hand side vector for the cross product.
Returns
Reference to the vector.
Exceptions
std::invalid_argumentInvalid vector size for cross product.

In case the current size of any of the two vectors is not equal to 3, a std::invalid_argument exception is thrown.

◆ operator*=()

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename VT >
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::operator*= ( const Vector< VT, TF > &  rhs)
inline

Multiplication assignment operator for the multiplication of a vector ( $ \vec{a}*=\vec{b} $).

Parameters
rhsThe right-hand side vector to be multiplied with the vector.
Returns
Reference to the vector.
Exceptions
std::invalid_argumentVector sizes do not match.

In case the current sizes of the two vectors don't match, a std::invalid_argument exception is thrown.

◆ operator+=()

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename VT >
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::operator+= ( const Vector< VT, TF > &  rhs)
inline

Addition assignment operator for the addition of a vector ( $ \vec{a}+=\vec{b} $).

Parameters
rhsThe right-hand side vector to be added to the vector.
Returns
Reference to the vector.
Exceptions
std::invalid_argumentVector sizes do not match.

In case the current sizes of the two vectors don't match, a std::invalid_argument exception is thrown.

◆ operator-=()

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename VT >
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::operator-= ( const Vector< VT, TF > &  rhs)
inline

Subtraction assignment operator for the subtraction of a vector ( $ \vec{a}-=\vec{b} $).

Parameters
rhsThe right-hand side vector to be subtracted from the vector.
Returns
Reference to the vector.
Exceptions
std::invalid_argumentVector sizes do not match.

In case the current sizes of the two vectors don't match, a std::invalid_argument exception is thrown.

◆ operator/=()

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename VT >
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::operator/= ( const DenseVector< VT, TF > &  rhs)
inline

Division assignment operator for the division of a dense vector ( $ \vec{a}/=\vec{b} $).

Parameters
rhsThe right-hand side dense vector divisor.
Returns
Reference to the vector.
Exceptions
std::invalid_argumentVector sizes do not match.

In case the current sizes of the two vectors don't match, a std::invalid_argument exception is thrown.

◆ operator=() [1/5]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF > & blaze::HybridVector< Type, N, TF >::operator= ( const Type &  rhs)
inline

Homogenous assignment to all vector elements.

Parameters
rhsScalar value to be assigned to all vector elements.
Returns
Reference to the assigned vector.

◆ operator=() [2/5]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF > & blaze::HybridVector< Type, N, TF >::operator= ( initializer_list< Type >  list)
inline

List assignment to all vector elements.

Parameters
listThe initializer list.
Exceptions
Invalidassignment to hybrid vector.

This assignment operator offers the option to directly assign to all elements of the vector by means of an initializer list:

v = { 4.2, 6.3, -1.2 };

The vector is resized according to the size of the initializer list and all its elements are (copy) assigned the values from the given initializer list. In case the size of the given list exceeds the maximum size of the hybrid vector (i.e. is larger than N), a std::invalid_argument exception is thrown.

◆ operator=() [3/5]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF > & blaze::HybridVector< Type, N, TF >::operator= ( const HybridVector< Type, N, TF > &  rhs)
inline

Copy assignment operator for HybridVector.

Parameters
rhsVector to be copied.
Returns
Reference to the assigned vector.

Explicit definition of a copy assignment operator for performance reasons.

◆ operator=() [4/5]

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename Other , size_t Dim>
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::operator= ( const Other(&)  array[Dim])
inline

Array assignment to all vector elements.

Parameters
arrayM-dimensional array for the assignment.
Returns
Reference to the assigned vector.

This assignment operator offers the option to directly set all elements of the vector:

const double init[2] = { 1.0, 2.0 };
v = init;

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.

◆ operator=() [5/5]

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename VT >
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::operator= ( const Vector< VT, TF > &  rhs)
inline

Assignment operator for different vectors.

Parameters
rhsVector to be copied.
Returns
Reference to the assigned vector.
Exceptions
std::invalid_argumentInvalid 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.

◆ operator[]() [1/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::Reference blaze::HybridVector< Type, N, TF >::operator[] ( size_t  index)
inlinenoexcept

Subscript operator for the direct access to the vector elements.

Parameters
indexAccess index. The index has to be in the range $[0..N-1]$.
Returns
Reference to the accessed value.

This function only performs an index check in case BLAZE_USER_ASSERT() is active. In contrast, the at() function is guaranteed to perform a check of the given access index.

◆ operator[]() [2/2]

template<typename Type , size_t N, bool TF>
HybridVector< Type, N, TF >::ConstReference blaze::HybridVector< Type, N, TF >::operator[] ( size_t  index) const
inlinenoexcept

Subscript operator for the direct access to the vector elements.

Parameters
indexAccess index. The index has to be in the range $[0..N-1]$.
Returns
Reference-to-const to the accessed value.

This function only performs an index check in case BLAZE_USER_ASSERT() is active. In contrast, the at() function is guaranteed to perform a check of the given access index.

◆ operator~() [1/2]

template<typename VT, bool TF>
BLAZE_ALWAYS_INLINE constexpr VectorType& blaze::Vector< VT, TF >::operator~ ( )
inlinenoexceptinherited

Conversion operator for non-constant vectors.

Returns
Reference of the actual type of the vector.

◆ operator~() [2/2]

template<typename VT, bool TF>
BLAZE_ALWAYS_INLINE constexpr const VectorType& blaze::Vector< VT, TF >::operator~ ( ) const
inlinenoexceptinherited

Conversion operator for constant vectors.

Returns
Const reference of the actual type of the vector.

◆ reset()

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::reset ( )
inline

Reset to the default initial values.

Returns
void

◆ resize()

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::resize ( size_t  n,
bool  preserve = true 
)
inline

Changing the size of the vector.

Parameters
nThe new size of the vector.
preservetrue if the old values of the vector should be preserved, false if not.
Returns
void
Exceptions
std::invalid_argumentInvalid 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. Note that this function may invalidate all existing views (subvectors, ...) on the vector if it used to shrink the vector. Additionally, 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:

\[ \left(\begin{array}{*{2}{c}} 1 & 2 \\ \end{array}\right) \Longrightarrow \left(\begin{array}{*{4}{c}} 1 & 2 & x & x \\ \end{array}\right) \]

◆ scale()

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
template<typename Other >
HybridVector<Type,N,TF>& blaze::HybridVector< Type, N, TF >::scale ( const Other &  scalar)
inline

Scaling of the vector by the scalar value scalar ( $ \vec{a}*=s $).

Parameters
scalarThe scalar value for the vector scaling.
Returns
Reference to the vector.

This function scales the vector by applying the given scalar value scalar to each element of the vector. For built-in and complex data types it has the same effect as using the multiplication assignment operator:

// ... Resizing and initialization
a *= 4; // Scaling of the vector
a.scale( 4 ); // Same effect as above

◆ size()

template<typename Type , size_t N, bool TF>
size_t blaze::HybridVector< Type, N, TF >::size ( ) const
inlinenoexcept

Returns the current size/dimension of the vector.

Returns
The size of the vector.

◆ spacing()

template<typename Type , size_t N, bool TF>
constexpr size_t blaze::HybridVector< Type, N, TF >::spacing ( )
inlinestaticnoexcept

Returns the minimum capacity of the vector.

Returns
The minimum capacity of the vector.

This function returns the minimum capacity of the vector, which corresponds to the current size plus padding.

◆ store()

template<typename Type , size_t N, bool TF>
BLAZE_ALWAYS_INLINE void blaze::HybridVector< Type, N, TF >::store ( size_t  index,
const SIMDType value 
)
noexcept

Store of a SIMD element of the vector.

Parameters
indexAccess index. The index must be smaller than the number of vector elements.
valueThe SIMD element to be stored.
Returns
void

This function performs a store of a specific SIMD 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 SIMD 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.

◆ storea()

template<typename Type , size_t N, bool TF>
BLAZE_ALWAYS_INLINE void blaze::HybridVector< Type, N, TF >::storea ( size_t  index,
const SIMDType value 
)
noexcept

Aligned store of a SIMD element of the vector.

Parameters
indexAccess index. The index must be smaller than the number of vector elements.
valueThe SIMD element to be stored.
Returns
void

This function performs an aligned store of a specific SIMD 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 SIMD 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.

◆ storeu()

template<typename Type , size_t N, bool TF>
BLAZE_ALWAYS_INLINE void blaze::HybridVector< Type, N, TF >::storeu ( size_t  index,
const SIMDType value 
)
noexcept

Unaligned store of a SIMD element of the vector.

Parameters
indexAccess index. The index must be smaller than the number of vector elements.
valueThe SIMD element to be stored.
Returns
void

This function performs an unaligned store of a specific SIMD 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 SIMD 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.

◆ stream()

template<typename Type , size_t N, bool TF>
BLAZE_ALWAYS_INLINE void blaze::HybridVector< Type, N, TF >::stream ( size_t  index,
const SIMDType value 
)
noexcept

Aligned, non-temporal store of a SIMD element of the vector.

Parameters
indexAccess index. The index must be smaller than the number of vector elements.
valueThe SIMD element to be stored.
Returns
void

This function performs an aligned, non-temporal store of a specific SIMD 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 SIMD 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.

◆ subAssign() [1/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
auto blaze::HybridVector< Type, N, TF >::subAssign ( const DenseVector< VT, TF > &  rhs) -> DisableIf_t< VectorizedSubAssign_v<VT> >
inline

Default implementation of the subtraction assignment of a dense vector.

SIMD optimized implementation of the subtraction assignment of a dense vector.

Parameters
rhsThe right-hand side dense vector to be subtracted.
Returns
void

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.

◆ subAssign() [2/2]

template<typename Type , size_t N, bool TF>
template<typename VT >
void blaze::HybridVector< Type, N, TF >::subAssign ( const SparseVector< VT, TF > &  rhs)
inline

Default implementation of the subtraction assignment of a sparse vector.

Parameters
rhsThe right-hand side sparse vector to be subtracted.
Returns
void

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.

◆ swap()

template<typename Type , size_t N, bool TF>
void blaze::HybridVector< Type, N, TF >::swap ( HybridVector< Type, N, TF > &  v)
inlinenoexcept

Swapping the contents of two hybrid vectors.

Parameters
vThe vector to be swapped.
Returns
void

Member Data Documentation

◆ Alignment

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
constexpr size_t blaze::HybridVector< Type, N, TF >::Alignment
staticprivate
Initial value:
=
( NN >= SIMDSIZE ? AlignmentOf_v<Type> : std::alignment_of<Type>::value )

Alignment of the data elements.

◆ simdEnabled

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
constexpr bool blaze::HybridVector< Type, N, TF >::simdEnabled = IsVectorizable_v<Type>
static

Compilation flag for SIMD optimization.

The simdEnabled compilation flag indicates whether expressions the vector is involved in can be optimized via SIMD operations. In case the element type of the vector is a vectorizable data type, the simdEnabled compilation flag is set to true, otherwise it is set to false.

◆ smpAssignable

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
constexpr bool blaze::HybridVector< Type, N, TF >::smpAssignable = false
static

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

◆ v_

template<typename Type, size_t N, bool TF = defaultTransposeFlag>
AlignedStorage blaze::HybridVector< Type, N, TF >::v_
private

The statically allocated vector elements.

Access to the vector values is gained via the subscript operator. The order of the elements is

\[\left(\begin{array}{*{4}{c}} 0 & 1 & \cdots & N-1 \\ \end{array}\right)\]


The documentation for this class was generated from the following files: