35 #ifndef _BLAZE_MATH_DENSE_STATICVECTOR_H_
36 #define _BLAZE_MATH_DENSE_STATICVECTOR_H_
153 template<
typename Type
156 class StaticVector :
public DenseVector< StaticVector<Type,N,TF>, TF >
165 enum { NN = N + ( IT::size - ( N % IT::size ) ) % IT::size };
195 enum { smpAssignable = 0 };
203 template<
typename Other >
explicit inline StaticVector(
size_t n,
const Other* array );
205 template<
typename Other >
206 explicit inline StaticVector(
const Other (&array)[N] );
209 template<
typename Other >
inline StaticVector(
const StaticVector<Other,N,TF>& v );
210 template<
typename VT >
inline StaticVector(
const Vector<VT,TF>& v );
213 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3 );
214 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4 );
215 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3,
216 const Type& v4,
const Type& v5 );
217 inline StaticVector(
const Type& v1,
const Type& v2,
const Type& v3,
218 const Type& v4,
const Type& v5,
const Type& v6 );
231 inline Type*
data ();
232 inline const Type*
data ()
const;
245 template<
typename Other >
246 inline StaticVector& operator=(
const Other (&array)[N] );
250 template<
typename Other >
inline StaticVector& operator= (
const StaticVector<Other,N,TF>& rhs );
251 template<
typename VT >
inline StaticVector& operator= (
const Vector<VT,TF>& rhs );
252 template<
typename VT >
inline StaticVector& operator+=(
const Vector<VT,TF>& rhs );
253 template<
typename VT >
inline StaticVector& operator-=(
const Vector<VT,TF>& rhs );
254 template<
typename VT >
inline StaticVector& operator*=(
const Vector<VT,TF>& rhs );
256 template<
typename Other >
257 inline typename EnableIf< IsNumeric<Other>,
StaticVector >::Type&
258 operator*=( Other rhs );
260 template<
typename Other >
261 inline typename EnableIf< IsNumeric<Other>,
StaticVector >::Type&
262 operator/=( Other rhs );
269 inline size_t size()
const;
273 template<
typename Other >
inline StaticVector& scale( Other scalar );
281 template<
typename VT >
283 struct VectorizedAssign {
284 enum { value = vectorizable && VT::vectorizable &&
285 IsSame<Type,typename VT::ElementType>::value };
292 template<
typename VT >
294 struct VectorizedAddAssign {
295 enum { value = vectorizable && VT::vectorizable &&
296 IsSame<Type,typename VT::ElementType>::value &&
297 IntrinsicTrait<Type>::addition };
304 template<
typename VT >
306 struct VectorizedSubAssign {
307 enum { value = vectorizable && VT::vectorizable &&
308 IsSame<Type,typename VT::ElementType>::value &&
309 IntrinsicTrait<Type>::subtraction };
316 template<
typename VT >
318 struct VectorizedMultAssign {
319 enum { value = vectorizable && VT::vectorizable &&
320 IsSame<Type,typename VT::ElementType>::value &&
321 IntrinsicTrait<Type>::multiplication };
330 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
331 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
339 template<
typename VT >
340 inline typename DisableIf< VectorizedAssign<VT> >::Type
341 assign(
const DenseVector<VT,TF>& rhs );
343 template<
typename VT >
344 inline typename EnableIf< VectorizedAssign<VT> >::Type
345 assign(
const DenseVector<VT,TF>& rhs );
347 template<
typename VT >
inline void assign(
const SparseVector<VT,TF>& rhs );
349 template<
typename VT >
350 inline typename DisableIf< VectorizedAddAssign<VT> >::Type
351 addAssign(
const DenseVector<VT,TF>& rhs );
353 template<
typename VT >
354 inline typename EnableIf< VectorizedAddAssign<VT> >::Type
355 addAssign(
const DenseVector<VT,TF>& rhs );
357 template<
typename VT >
inline void addAssign(
const SparseVector<VT,TF>& rhs );
359 template<
typename VT >
360 inline typename DisableIf< VectorizedSubAssign<VT> >::Type
361 subAssign(
const DenseVector<VT,TF>& rhs );
363 template<
typename VT >
364 inline typename EnableIf< VectorizedSubAssign<VT> >::Type
365 subAssign(
const DenseVector<VT,TF>& rhs );
367 template<
typename VT >
inline void subAssign(
const SparseVector<VT,TF>& rhs );
369 template<
typename VT >
370 inline typename DisableIf< VectorizedMultAssign<VT> >::Type
371 multAssign(
const DenseVector<VT,TF>& rhs );
373 template<
typename VT >
374 inline typename EnableIf< VectorizedMultAssign<VT> >::Type
375 multAssign(
const DenseVector<VT,TF>& rhs );
377 template<
typename VT >
inline void multAssign(
const SparseVector<VT,TF>& rhs );
421 template<
typename Type
427 for(
size_t i=0UL; i<NN; ++i )
439 template<
typename Type
444 for(
size_t i=0UL; i<N; ++i )
448 for(
size_t i=N; i<NN; ++i )
477 template<
typename Type
480 template<
typename Other >
484 throw std::invalid_argument(
"Invalid setup of static vector" );
486 for(
size_t i=0UL; i<n; ++i )
490 for(
size_t i=n; i<NN; ++i )
513 template<
typename Type
516 template<
typename Other >
519 for(
size_t i=0UL; i<N; ++i )
523 for(
size_t i=N; i<NN; ++i )
537 template<
typename Type
542 for(
size_t i=0UL; i<NN; ++i )
553 template<
typename Type
556 template<
typename Other >
559 for(
size_t i=0UL; i<N; ++i )
563 for(
size_t i=N; i<NN; ++i )
580 template<
typename Type
583 template<
typename VT >
588 if( (~v).size() != N )
589 throw std::invalid_argument(
"Invalid setup of static vector" );
613 template<
typename Type
624 for(
size_t i=N; i<NN; ++i )
644 template<
typename Type
656 for(
size_t i=N; i<NN; ++i )
677 template<
typename Type
681 const Type& v3,
const Type& v4 )
691 for(
size_t i=N; i<NN; ++i )
713 template<
typename Type
717 const Type& v4,
const Type& v5 )
728 for(
size_t i=N; i<NN; ++i )
751 template<
typename Type
755 const Type& v4,
const Type& v5,
const Type& v6 )
767 for(
size_t i=N; i<NN; ++i )
790 template<
typename Type
810 template<
typename Type
829 template<
typename Type
846 template<
typename Type
861 template<
typename Type
876 template<
typename Type
891 template<
typename Type
906 template<
typename Type
921 template<
typename Type
936 template<
typename Type
971 template<
typename Type
974 template<
typename Other >
977 for(
size_t i=0UL; i<N; ++i )
990 template<
typename Type
995 for(
size_t i=0UL; i<N; ++i )
1010 template<
typename Type
1021 for(
size_t i=0UL; i<N; ++i )
1034 template<
typename Type
1037 template<
typename Other >
1046 for(
size_t i=0UL; i<N; ++i )
1063 template<
typename Type
1066 template<
typename VT >
1071 if( (~rhs).size() != N )
1072 throw std::invalid_argument(
"Invalid assignment to static vector" );
1074 if( (~rhs).canAlias(
this ) ) {
1099 template<
typename Type
1102 template<
typename VT >
1107 if( (~rhs).size() != N )
1108 throw std::invalid_argument(
"Vector sizes do not match" );
1110 if( (~rhs).canAlias(
this ) ) {
1133 template<
typename Type
1136 template<
typename VT >
1141 if( (~rhs).size() != N )
1142 throw std::invalid_argument(
"Vector sizes do not match" );
1144 if( (~rhs).canAlias(
this ) ) {
1168 template<
typename Type
1171 template<
typename VT >
1176 if( (~rhs).size() != N )
1177 throw std::invalid_argument(
"Vector sizes do not match" );
1181 this->operator=( tmp );
1184 assign( *
this, *
this * (~rhs) );
1199 template<
typename Type
1202 template<
typename Other >
1208 assign( *
this, (*
this) * rhs );
1223 template<
typename Type
1226 template<
typename Other >
1234 assign( *
this, (*
this) / rhs );
1253 template<
typename Type
1268 template<
typename Type
1286 template<
typename Type
1291 size_t nonzeros( 0 );
1293 for(
size_t i=0UL; i<N; ++i ) {
1308 template<
typename Type
1314 for(
size_t i=0UL; i<N; ++i )
1326 template<
typename Type
1329 template<
typename Other >
1332 for(
size_t i=0; i<N; ++i )
1346 template<
typename Type
1353 for(
size_t i=0UL; i<N; ++i )
1354 swap( v_[i], v.v_[i] );
1377 template<
typename Type
1380 template<
typename Other >
1383 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1398 template<
typename Type
1401 template<
typename Other >
1404 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1422 template<
typename Type
1436 return load( &v_[index] );
1454 template<
typename Type
1467 return loadu( &v_[index] );
1486 template<
typename Type
1499 store( &v_[index], value );
1518 template<
typename Type
1530 storeu( &v_[index], value );
1549 template<
typename Type
1562 stream( &v_[index], value );
1578 template<
typename Type
1581 template<
typename VT >
1587 for(
size_t i=0UL; i<N; ++i )
1604 template<
typename Type
1607 template<
typename VT >
1617 for(
size_t i=0UL; i<N; i+=IT::size ) {
1635 template<
typename Type
1638 template<
typename VT >
1643 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
1644 v_[element->index()] = element->value();
1660 template<
typename Type
1663 template<
typename VT >
1669 for(
size_t i=0UL; i<N; ++i )
1686 template<
typename Type
1689 template<
typename VT >
1700 for(
size_t i=0UL; i<N; i+=IT::size ) {
1718 template<
typename Type
1721 template<
typename VT >
1726 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
1727 v_[element->index()] += element->value();
1743 template<
typename Type
1746 template<
typename VT >
1752 for(
size_t i=0UL; i<N; ++i )
1769 template<
typename Type
1772 template<
typename VT >
1783 for(
size_t i=0UL; i<N; i+=IT::size ) {
1801 template<
typename Type
1804 template<
typename VT >
1809 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
1810 v_[element->index()] -= element->value();
1826 template<
typename Type
1829 template<
typename VT >
1835 for(
size_t i=0UL; i<N; ++i )
1852 template<
typename Type
1855 template<
typename VT >
1866 for(
size_t i=0UL; i<N; i+=IT::size ) {
1884 template<
typename Type
1887 template<
typename VT >
1896 for(
typename VT::ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
1897 v_[element->index()] = tmp[element->index()] * element->value();
1922 template<
typename Type
1944 template<
typename Type,
size_t N,
bool TF >
1947 template<
typename Type,
size_t N,
bool TF >
1950 template<
typename Type,
size_t N,
bool TF >
1953 template<
typename Type,
bool TF >
1956 template<
typename Type,
bool TF >
1959 template<
typename Type,
size_t N,
bool TF >
1972 template<
typename Type
1991 template<
typename Type
2019 template<
typename Type
2024 for(
size_t i=0UL; i<N; ++i )
2042 template<
typename Type
2059 template<
typename Type
2063 if( v[0] != Type() || v[1] != Type() )
2080 template<
typename Type
2100 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2101 struct AddTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2103 typedef StaticVector< typename AddTrait<T1,T2>::Type, N, TF > Type;
2119 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2120 struct SubTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2122 typedef StaticVector< typename SubTrait<T1,T2>::Type, N, TF > Type;
2138 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2139 struct MultTrait< StaticVector<T1,N,TF>, T2 >
2141 typedef StaticVector< typename MultTrait<T1,T2>::Type, N, TF > Type;
2145 template<
typename T1,
typename T2,
size_t N,
bool TF >
2146 struct MultTrait< T1, StaticVector<T2,N,TF> >
2148 typedef StaticVector< typename MultTrait<T1,T2>::Type, N, TF > Type;
2152 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2153 struct MultTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2155 typedef StaticVector< typename MultTrait<T1,T2>::Type, N, TF > Type;
2158 template<
typename T1,
size_t M,
typename T2,
size_t N >
2159 struct MultTrait< StaticVector<T1,M,false>, StaticVector<T2,N,true> >
2161 typedef StaticMatrix< typename MultTrait<T1,T2>::Type, M, N,
false > Type;
2164 template<
typename T1,
size_t N,
typename T2 >
2165 struct MultTrait< StaticVector<T1,N,true>, StaticVector<T2,N,false> >
2167 typedef typename MultTrait<T1,T2>::Type Type;
2183 template<
typename T1,
typename T2 >
2184 struct CrossTrait< StaticVector<T1,3UL,false>, StaticVector<T2,3UL,false> >
2187 typedef typename MultTrait<T1,T2>::Type T;
2190 typedef StaticVector< typename SubTrait<T,T>::Type, 3UL,
false > Type;
2206 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2207 struct DivTrait< StaticVector<T1,N,TF>, T2 >
2209 typedef StaticVector< typename DivTrait<T1,T2>::Type, N, TF > Type;
2226 template<
typename T1,
size_t N,
bool TF,
typename T2 >
2227 struct MathTrait< StaticVector<T1,N,TF>, StaticVector<T2,N,TF> >
2229 typedef StaticVector< typename MathTrait<T1,T2>::HighType, N, TF > HighType;
2230 typedef StaticVector< typename MathTrait<T1,T2>::LowType , N, TF > LowType;
2246 template<
typename T1,
size_t N,
bool TF >
2247 struct SubvectorTrait< StaticVector<T1,N,TF> >
2249 typedef HybridVector<T1,N,TF> Type;
Compile time check for vectorizable types.Depending on the available instruction set (SSE...
Definition: IsVectorizable.h:107
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:1426
const bool defaultTransposeFlag
The default transpose flag for all vectors of the Blaze library.This value specifies the default tran...
Definition: TransposeFlag.h:56
Compile time check for numeric types.This type trait tests whether or not the given template paramete...
Definition: IsNumeric.h:98
Constraint on the data type.
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4512
#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 >, Load< T, sizeof(T)> >::Type::Type load(const T *address)
Loads a vector of integral values.
Definition: Load.h:222
Header file for the subtraction trait.
Header file for the SparseVector base class.
Iterator end()
Returns an iterator just past the last element of the static vector.
Definition: StaticVector.h:909
AlignedArray< Type, NN > v_
The statically allocated vector elements.
Definition: StaticVector.h:385
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4555
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 storeu(float *address, const sse_float_t &value)
Unaligned store of a vector of 'float' values.
Definition: Storeu.h:234
Header file for the DenseVector base class.
StaticVector< Type, N,!TF > TransposeType
Transpose type for expression template evaluations.
Definition: StaticVector.h:172
#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
Type & Reference
Reference to a non-constant vector value.
Definition: StaticVector.h:177
size_t nonZeros() const
Returns the number of non-zero elements in the vector.
Definition: StaticVector.h:1289
void clear(DynamicMatrix< Type, SO > &m)
Clearing the given dense matrix.
Definition: DynamicMatrix.h:4528
Constraint on the data type.
Efficient implementation of a fixed-sized vector.The StaticVector class template is the representatio...
Definition: Forward.h:51
void stream(float *address, const sse_float_t &value)
Aligned, non-temporal store of a vector of 'float' values.
Definition: Stream.h:233
Header file for the DisableIf class template.
size_t capacity() const
Returns the maximum capacity of the vector.
Definition: StaticVector.h:1271
bool canAlias(const Other *alias) const
Returns whether the vector can alias with the given address alias.
Definition: StaticVector.h:1381
void swap(StaticVector &v)
Swapping the contents of two static vectors.
Definition: StaticVector.h:1349
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:4541
Header file for all forward declarations of the math module.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2379
#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:179
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:171
void reset()
Reset to the default initial values.
Definition: StaticVector.h:1311
#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:894
Reference operator[](size_t index)
Subscript operator for the direct access to the vector elements.
Definition: StaticVector.h:794
IT::Type IntrinsicType
Intrinsic type of the vector elements.
Definition: StaticVector.h:174
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:2044
void store(size_t index, const IntrinsicType &value)
Aligned store of an intrinsic element of the vector.
Definition: StaticVector.h:1489
Header file for the EnableIf class template.
Header file for the IsVectorizable type trait.
ColumnIterator< const MT > ConstIterator
Iterator over constant elements.
Definition: DenseColumn.h:1972
Header file for the IsNumeric type trait.
DenseIterator< Type > Iterator
Iterator over non-constant elements.
Definition: StaticVector.h:179
Header file for the IsSparseVector type trait.
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:648
StaticVector()
The default constructor for StaticVector.
Definition: StaticVector.h:424
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:4584
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:209
const Type & ReturnType
Return type for expression template evaluations.
Definition: StaticVector.h:175
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:178
#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:864
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:239
#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:2378
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:1402
const StaticVector & CompositeType
Data type for composite expression templates.
Definition: StaticVector.h:176
StaticVector< Type, N, TF > This
Type of this StaticVector instance.
Definition: StaticVector.h:170
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:1552
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:180
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:1256
IntrinsicTrait< Type > IT
Intrinsic trait for the vector element type.
Definition: StaticVector.h:160
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:105
Header file for basic type definitions.
ConstIterator cend() const
Returns an iterator just past the last element of the static vector.
Definition: StaticVector.h:939
SelectType< useConst, ConstIterator, ColumnIterator< MT > >::Type Iterator
Iterator over non-constant elements.
Definition: DenseColumn.h:1980
IntrinsicType loadu(size_t index) const
Unaligned load of an intrinsic element of the vector.
Definition: StaticVector.h:1458
#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 * data()
Low-level data access to the vector elements.
Definition: StaticVector.h:832
Type ElementType
Type of the vector elements.
Definition: StaticVector.h:173
#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 store(float *address, const sse_float_t &value)
Aligned store of a vector of 'float' values.
Definition: Store.h:242
void storeu(size_t index, const IntrinsicType &value)
Unaligned store of an intrinsic element of the vector.
Definition: StaticVector.h:1521