35 #ifndef _BLAZE_MATH_DENSE_STATICVECTOR_H_
36 #define _BLAZE_MATH_DENSE_STATICVECTOR_H_
156 template<
typename Type
159 class StaticVector :
public DenseVector< StaticVector<Type,N,TF>, TF >
168 enum { NN = N + ( IT::size - ( N % IT::size ) ) % IT::size };
200 enum { smpAssignable = 0 };
208 template<
typename Other >
explicit inline StaticVector(
size_t n,
const Other* array );
210 template<
typename Other >
211 explicit inline StaticVector(
const Other (&array)[N] );
214 template<
typename Other >
inline StaticVector(
const StaticVector<Other,N,TF>& v );
215 template<
typename VT >
inline StaticVector(
const Vector<VT,TF>& v );
218 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3 );
219 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4 );
220 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3,
221 const Type& v4,
const Type& v5 );
222 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3,
223 const Type& v4,
const Type& v5,
const Type& v6 );
250 template<
typename Other >
251 inline StaticVector& operator=(
const Other (&array)[N] );
255 template<
typename Other >
inline StaticVector& operator= (
const StaticVector<Other,N,TF>& rhs );
256 template<
typename VT >
inline StaticVector& operator= (
const Vector<VT,TF>& rhs );
257 template<
typename VT >
inline StaticVector& operator+=(
const Vector<VT,TF>& rhs );
258 template<
typename VT >
inline StaticVector& operator-=(
const Vector<VT,TF>& rhs );
259 template<
typename VT >
inline StaticVector& operator*=(
const Vector<VT,TF>& rhs );
261 template<
typename Other >
262 inline typename EnableIf< IsNumeric<Other>,
StaticVector >::Type&
263 operator*=( Other rhs );
265 template<
typename Other >
266 inline typename EnableIf< IsNumeric<Other>,
StaticVector >::Type&
267 operator/=( Other rhs );
274 inline size_t size()
const;
278 template<
typename Other >
inline StaticVector& scale( Other scalar );
286 static inline void*
operator new ( std::size_t
size );
287 static inline void*
operator new[]( std::size_t
size );
288 static inline void*
operator new ( std::size_t
size,
const std::nothrow_t& );
289 static inline void*
operator new[]( std::size_t
size,
const std::nothrow_t& );
291 static inline void operator delete (
void* ptr );
292 static inline void operator delete[](
void* ptr );
293 static inline void operator delete (
void* ptr,
const std::nothrow_t& );
294 static inline void operator delete[](
void* ptr,
const std::nothrow_t& );
301 template<
typename VT >
303 struct VectorizedAssign {
304 enum { value = vectorizable && VT::vectorizable &&
305 IsSame<Type,typename VT::ElementType>::value };
312 template<
typename VT >
314 struct VectorizedAddAssign {
315 enum { value = vectorizable && VT::vectorizable &&
316 IsSame<Type,typename VT::ElementType>::value &&
317 IntrinsicTrait<Type>::addition };
324 template<
typename VT >
326 struct VectorizedSubAssign {
327 enum { value = vectorizable && VT::vectorizable &&
328 IsSame<Type,typename VT::ElementType>::value &&
329 IntrinsicTrait<Type>::subtraction };
336 template<
typename VT >
338 struct VectorizedMultAssign {
339 enum { value = vectorizable && VT::vectorizable &&
340 IsSame<Type,typename VT::ElementType>::value &&
341 IntrinsicTrait<Type>::multiplication };
350 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
351 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
361 template<
typename VT >
362 inline typename DisableIf< VectorizedAssign<VT> >::Type
363 assign(
const DenseVector<VT,TF>& rhs );
365 template<
typename VT >
366 inline typename EnableIf< VectorizedAssign<VT> >::Type
367 assign(
const DenseVector<VT,TF>& rhs );
369 template<
typename VT >
inline void assign(
const SparseVector<VT,TF>& rhs );
371 template<
typename VT >
372 inline typename DisableIf< VectorizedAddAssign<VT> >::Type
373 addAssign(
const DenseVector<VT,TF>& rhs );
375 template<
typename VT >
376 inline typename EnableIf< VectorizedAddAssign<VT> >::Type
377 addAssign(
const DenseVector<VT,TF>& rhs );
379 template<
typename VT >
inline void addAssign(
const SparseVector<VT,TF>& rhs );
381 template<
typename VT >
382 inline typename DisableIf< VectorizedSubAssign<VT> >::Type
383 subAssign(
const DenseVector<VT,TF>& rhs );
385 template<
typename VT >
386 inline typename EnableIf< VectorizedSubAssign<VT> >::Type
387 subAssign(
const DenseVector<VT,TF>& rhs );
389 template<
typename VT >
inline void subAssign(
const SparseVector<VT,TF>& rhs );
391 template<
typename VT >
392 inline typename DisableIf< VectorizedMultAssign<VT> >::Type
393 multAssign(
const DenseVector<VT,TF>& rhs );
395 template<
typename VT >
396 inline typename EnableIf< VectorizedMultAssign<VT> >::Type
397 multAssign(
const DenseVector<VT,TF>& rhs );
399 template<
typename VT >
inline void multAssign(
const SparseVector<VT,TF>& rhs );
443 template<
typename Type
450 for(
size_t i=0UL; i<NN; ++i )
462 template<
typename Type
468 for(
size_t i=0UL; i<N; ++i )
472 for(
size_t i=N; i<NN; ++i )
501 template<
typename Type
504 template<
typename Other >
509 throw std::invalid_argument(
"Invalid setup of static vector" );
511 for(
size_t i=0UL; i<n; ++i )
515 for(
size_t i=n; i<NN; ++i )
538 template<
typename Type
541 template<
typename Other >
545 for(
size_t i=0UL; i<N; ++i )
549 for(
size_t i=N; i<NN; ++i )
563 template<
typename Type
569 for(
size_t i=0UL; i<NN; ++i )
580 template<
typename Type
583 template<
typename Other >
587 for(
size_t i=0UL; i<N; ++i )
591 for(
size_t i=N; i<NN; ++i )
608 template<
typename Type
611 template<
typename VT >
617 if( (~v).
size() != N )
618 throw std::invalid_argument(
"Invalid setup of static vector" );
621 i<( IsVectorizable<Type>::value ? NN : N ); ++i ) {
642 template<
typename Type
654 for(
size_t i=N; i<NN; ++i )
674 template<
typename Type
687 for(
size_t i=N; i<NN; ++i )
708 template<
typename Type
712 const Type& v3,
const Type& v4 )
723 for(
size_t i=N; i<NN; ++i )
745 template<
typename Type
749 const Type& v4,
const Type& v5 )
761 for(
size_t i=N; i<NN; ++i )
784 template<
typename Type
788 const Type& v4,
const Type& v5,
const Type& v6 )
801 for(
size_t i=N; i<NN; ++i )
824 template<
typename Type
844 template<
typename Type
863 template<
typename Type
880 template<
typename Type
895 template<
typename Type
910 template<
typename Type
925 template<
typename Type
940 template<
typename Type
955 template<
typename Type
970 template<
typename Type
1005 template<
typename Type
1008 template<
typename Other >
1011 for(
size_t i=0UL; i<N; ++i )
1024 template<
typename Type
1029 for(
size_t i=0UL; i<N; ++i )
1044 template<
typename Type
1063 template<
typename Type
1066 template<
typename Other >
1087 template<
typename Type
1090 template<
typename VT >
1095 if( (~rhs).size() != N )
1096 throw std::invalid_argument(
"Invalid assignment to static vector" );
1098 if( (~rhs).canAlias(
this ) ) {
1123 template<
typename Type
1126 template<
typename VT >
1131 if( (~rhs).size() != N )
1132 throw std::invalid_argument(
"Vector sizes do not match" );
1134 if( (~rhs).canAlias(
this ) ) {
1157 template<
typename Type
1160 template<
typename VT >
1165 if( (~rhs).size() != N )
1166 throw std::invalid_argument(
"Vector sizes do not match" );
1168 if( (~rhs).canAlias(
this ) ) {
1192 template<
typename Type
1195 template<
typename VT >
1200 if( (~rhs).size() != N )
1201 throw std::invalid_argument(
"Vector sizes do not match" );
1205 this->operator=( tmp );
1223 template<
typename Type
1226 template<
typename Other >
1232 assign( *
this, (*
this) * rhs );
1247 template<
typename Type
1250 template<
typename Other >
1258 assign( *
this, (*
this) / rhs );
1277 template<
typename Type
1292 template<
typename Type
1310 template<
typename Type
1315 size_t nonzeros( 0 );
1317 for(
size_t i=0UL; i<N; ++i ) {
1332 template<
typename Type
1338 for(
size_t i=0UL; i<N; ++i )
1350 template<
typename Type
1353 template<
typename Other >
1356 for(
size_t i=0; i<N; ++i )
1370 template<
typename Type
1377 for(
size_t i=0UL; i<N; ++i )
1378 swap( v_[i], v.v_[i] );
1401 template<
typename Type
1410 return allocate<StaticVector>( 1UL );
1425 template<
typename Type
1433 return allocate<StaticVector>( size/
sizeof(
StaticVector) );
1448 template<
typename Type
1457 return allocate<StaticVector>( 1UL );
1472 template<
typename Type
1480 return allocate<StaticVector>( size/
sizeof(
StaticVector) );
1491 template<
typename Type
1496 deallocate( static_cast<StaticVector*>( ptr ) );
1507 template<
typename Type
1512 deallocate( static_cast<StaticVector*>( ptr ) );
1523 template<
typename Type
1528 deallocate( static_cast<StaticVector*>( ptr ) );
1539 template<
typename Type
1544 deallocate( static_cast<StaticVector*>( ptr ) );
1567 template<
typename Type
1570 template<
typename Other >
1573 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1588 template<
typename Type
1591 template<
typename Other >
1594 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1608 template<
typename Type
1631 template<
typename Type
1645 return load( &v_[index] );
1663 template<
typename Type
1676 return loadu( &v_[index] );
1695 template<
typename Type
1708 store( &v_[index], value );
1727 template<
typename Type
1739 storeu( &v_[index], value );
1758 template<
typename Type
1771 stream( &v_[index], value );
1787 template<
typename Type
1790 template<
typename VT >
1796 for(
size_t i=0UL; i<N; ++i )
1813 template<
typename Type
1816 template<
typename VT >
1826 for(
size_t i=0UL; i<N; i+=IT::size ) {
1844 template<
typename Type
1847 template<
typename VT >
1852 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
1853 v_[element->index()] = element->value();
1869 template<
typename Type
1872 template<
typename VT >
1878 for(
size_t i=0UL; i<N; ++i )
1895 template<
typename Type
1898 template<
typename VT >
1909 for(
size_t i=0UL; i<N; i+=IT::size ) {
1927 template<
typename Type
1930 template<
typename VT >
1935 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
1936 v_[element->index()] += element->value();
1952 template<
typename Type
1955 template<
typename VT >
1961 for(
size_t i=0UL; i<N; ++i )
1978 template<
typename Type
1981 template<
typename VT >
1992 for(
size_t i=0UL; i<N; i+=IT::size ) {
2010 template<
typename Type
2013 template<
typename VT >
2018 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
2019 v_[element->index()] -= element->value();
2035 template<
typename Type
2038 template<
typename VT >
2044 for(
size_t i=0UL; i<N; ++i )
2061 template<
typename Type
2064 template<
typename VT >
2075 for(
size_t i=0UL; i<N; i+=IT::size ) {
2093 template<
typename Type
2096 template<
typename VT >
2105 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
2106 v_[element->index()] = tmp[element->index()] * element->value();
2131 template<
typename Type
2153 template<
typename Type,
size_t N,
bool TF >
2156 template<
typename Type,
size_t N,
bool TF >
2159 template<
typename Type,
size_t N,
bool TF >
2162 template<
typename Type,
bool TF >
2165 template<
typename Type,
bool TF >
2168 template<
typename Type,
size_t N,
bool TF >
2181 template<
typename Type
2200 template<
typename Type
2228 template<
typename Type
2233 for(
size_t i=0UL; i<N; ++i )
2251 template<
typename Type
2268 template<
typename Type
2272 if( v[0] != Type() || v[1] != Type() )
2289 template<
typename Type
2309 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2310 struct AddTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2312 typedef StaticVector< typename AddTrait<T1,T2>::Type, N, TF > Type;
2328 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2329 struct SubTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2331 typedef StaticVector< typename SubTrait<T1,T2>::Type, N, TF > Type;
2347 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2348 struct MultTrait< StaticVector<T1,N,TF>, T2 >
2350 typedef StaticVector< typename MultTrait<T1,T2>::Type, N, TF > Type;
2354 template<
typename T1,
typename T2,
size_t N,
bool TF >
2355 struct MultTrait< T1, StaticVector<T2,N,TF> >
2357 typedef StaticVector< typename MultTrait<T1,T2>::Type, N, TF > Type;
2361 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2362 struct MultTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2364 typedef StaticVector< typename MultTrait<T1,T2>::Type, N, TF > Type;
2367 template<
typename T1,
size_t M,
typename T2,
size_t N >
2368 struct MultTrait< StaticVector<T1,M,false>, StaticVector<T2,N,true> >
2370 typedef StaticMatrix< typename MultTrait<T1,T2>::Type, M, N,
false > Type;
2373 template<
typename T1,
size_t N,
typename T2 >
2374 struct MultTrait< StaticVector<T1,N,true>, StaticVector<T2,N,false> >
2376 typedef typename MultTrait<T1,T2>::Type Type;
2392 template<
typename T1,
typename T2 >
2393 struct CrossTrait< StaticVector<T1,3UL,false>, StaticVector<T2,3UL,false> >
2396 typedef typename MultTrait<T1,T2>::Type T;
2399 typedef StaticVector< typename SubTrait<T,T>::Type, 3UL,
false > Type;
2415 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2416 struct DivTrait< StaticVector<T1,N,TF>, T2 >
2418 typedef StaticVector< typename DivTrait<T1,T2>::Type, N, TF > Type;
2435 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2436 struct MathTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2438 typedef StaticVector< typename MathTrait<T1,T2>::HighType, N, TF > HighType;
2439 typedef StaticVector< typename MathTrait<T1,T2>::LowType , N, TF > LowType;
2455 template<
typename T1,
size_t N,
bool TF >
2456 struct SubvectorTrait< StaticVector<T1,N,TF> >
2458 typedef HybridVector<T1,N,TF> Type;
Compile time check for vectorizable types.Depending on the available instruction set (SSE...
Definition: IsVectorizable.h:108
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:116
IntrinsicType load(size_t index) const
Aligned load of an intrinsic element of the vector.
Definition: StaticVector.h:1635
const bool defaultTransposeFlag
The default transpose flag for all vectors of the Blaze library.This value specifies the default tran...
Definition: TransposeFlag.h:56
Constraint on the data type.
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4599
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
EnableIf< IsIntegral< T > >::Type store(T *address, const typename Store< T, sizeof(T)>::Type &value)
Aligned store of a vector of integral values.
Definition: Store.h:223
EnableIf< IsIntegral< T >, Load< T, sizeof(T)> >::Type::Type load(const T *address)
Loads a vector of integral values.
Definition: Load.h:222
Header file for the UNUSED_PARAMETER function template.
Header file for the subtraction trait.
Header file for the SparseVector base class.
Type * Pointer
Pointer to a non-constant vector value.
Definition: StaticVector.h:182
Iterator end()
Returns an iterator just past the last element of the static vector.
Definition: StaticVector.h:943
AlignedArray< Type, NN > v_
The statically allocated vector elements.
Definition: StaticVector.h:407
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4642
EnableIf< IsIntegral< T >, Loadu< T, sizeof(T)> >::Type::Type loadu(const T *address)
Loads a vector of integral values.
Definition: Loadu.h:219
Header file for the IsSame and IsStrictlySame type traits.
void UNUSED_PARAMETER(const T1 &)
Suppression of unused parameter warnings.
Definition: Unused.h:84
Header file for the DenseVector base class.
StaticVector< Type, N,!TF > TransposeType
Transpose type for expression template evaluations.
Definition: StaticVector.h:175
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:116
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:690
Type & Reference
Reference to a non-constant vector value.
Definition: StaticVector.h:180
size_t nonZeros() const
Returns the number of non-zero elements in the vector.
Definition: StaticVector.h:1313
Header file for memory allocation and deallocation functionality.
void clear(DynamicMatrix< Type, SO > &m)
Clearing the given dense matrix.
Definition: DynamicMatrix.h:4615
Constraint on the data type.
Efficient implementation of a fixed-sized vector.The StaticVector class template is the representatio...
Definition: Forward.h:52
void deallocate(T *address)
Deallocation of memory.
Definition: Memory.h:115
bool isAligned() const
Returns whether the vector is properly aligned in memory.
Definition: StaticVector.h:1611
Header file for the DisableIf class template.
size_t capacity() const
Returns the maximum capacity of the vector.
Definition: StaticVector.h:1295
bool canAlias(const Other *alias) const
Returns whether the vector can alias with the given address alias.
Definition: StaticVector.h:1571
void swap(StaticVector &v)
Swapping the contents of two static vectors.
Definition: StaticVector.h:1373
Header file for the multiplication trait.
Header file for nested template disabiguation.
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b)
Swapping the contents of two sparse matrices.
Definition: CompressedMatrix.h:4605
Header file for all forward declarations of the math module.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2412
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:116
Header file for the DenseIterator class template.
Header file for the subvector trait.
void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:271
Constraint on the data type.
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
Compile time check for sparse vector types.This type trait tests whether or not the given template pa...
Definition: IsSparseVector.h:103
This ResultType
Result type for expression template evaluations.
Definition: StaticVector.h:174
void reset()
Reset to the default initial values.
Definition: StaticVector.h:1335
#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE(T)
Constraint on the data type.In case the given data type T is not a vectorizable data type...
Definition: Vectorizable.h:79
ConstIterator cbegin() const
Returns an iterator to the first element of the static vector.
Definition: StaticVector.h:928
Reference operator[](size_t index)
Subscript operator for the direct access to the vector elements.
Definition: StaticVector.h:828
void multAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the multiplication assignment of a matrix to a matrix.
Definition: Matrix.h:361
IT::Type IntrinsicType
Intrinsic type of the vector elements.
Definition: StaticVector.h:177
const StaticVector< Type, 2UL, TF > perp(const StaticVector< Type, 2UL, TF > &v)
Unary perp dot product operator for the calculation of a perpendicular vector ( ).
Definition: StaticVector.h:2253
void store(size_t index, const IntrinsicType &value)
Aligned store of an intrinsic element of the vector.
Definition: StaticVector.h:1698
Header file for the EnableIf class template.
EnableIf< IsIntegral< T > >::Type storeu(T *address, const typename Storeu< T, sizeof(T)>::Type &value)
Unaligned store of a vector of integral values.
Definition: Storeu.h:216
Header file for the serial shim.
Header file for the IsVectorizable type trait.
Header file for the IsNumeric type trait.
DenseIterator< Type > Iterator
Iterator over non-constant elements.
Definition: StaticVector.h:184
Header file for the IsSparseVector type trait.
EnableIf< IsIntegral< T > >::Type stream(T *address, const typename Stream< T, sizeof(T)>::Type &value)
Aligned, non-temporal store of a vector of integral values.
Definition: Stream.h:218
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:748
StaticVector()
The default constructor for StaticVector.
Definition: StaticVector.h:446
Header file for run time assertion macros.
Header file for the addition trait.
Header file for the cross product trait.
Header file for the division trait.
void swap(DynamicMatrix< Type, SO > &a, DynamicMatrix< Type, SO > &b)
Swapping the contents of two matrices.
Definition: DynamicMatrix.h:4671
void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:301
const Type & ReturnType
Return type for expression template evaluations.
Definition: StaticVector.h:178
Constraint on the data type.
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
const Type & ConstReference
Reference to a constant vector value.
Definition: StaticVector.h:181
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a numeric (integral or floating poin...
Definition: Numeric.h:79
Iterator begin()
Returns an iterator to the first element of the static vector.
Definition: StaticVector.h:898
Header file for the reset shim.
Header file for the AlignedArray implementation.
void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:331
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:116
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2411
Header file for the isDefault shim.
Constraint on the data type.
bool isAliased(const Other *alias) const
Returns whether the vector is aliased with the given address alias.
Definition: StaticVector.h:1592
const StaticVector & CompositeType
Data type for composite expression templates.
Definition: StaticVector.h:179
StaticVector< Type, N, TF > This
Type of this StaticVector instance.
Definition: StaticVector.h:173
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
void stream(size_t index, const IntrinsicType &value)
Aligned, non-temporal store of an intrinsic element of the vector.
Definition: StaticVector.h:1761
Implementation of a generic iterator for dense vectors and matrices.The DenseIterator represents a ge...
Definition: DenseIterator.h:58
Header file for all intrinsic functionality.
Header file for the mathematical trait.
DenseIterator< const Type > ConstIterator
Iterator over constant elements.
Definition: StaticVector.h:185
const Type * ConstPointer
Pointer to a constant vector value.
Definition: StaticVector.h:183
Header file for the default transpose flag for all vectors of the Blaze library.
size_t size() const
Returns the current size/dimension of the vector.
Definition: StaticVector.h:1280
IntrinsicTrait< Type > IT
Intrinsic trait for the vector element type.
Definition: StaticVector.h:163
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:108
Header file for basic type definitions.
ConstIterator cend() const
Returns an iterator just past the last element of the static vector.
Definition: StaticVector.h:973
IntrinsicType loadu(size_t index) const
Unaligned load of an intrinsic element of the vector.
Definition: StaticVector.h:1667
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:143
Type ElementType
Type of the vector elements.
Definition: StaticVector.h:176
Pointer data()
Low-level data access to the vector elements.
Definition: StaticVector.h:866
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
void storeu(size_t index, const IntrinsicType &value)
Unaligned store of an intrinsic element of the vector.
Definition: StaticVector.h:1730