Blaze 3.9
SVecExpandExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_SVECEXPANDEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_SVECEXPANDEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
60#include <blaze/system/Inline.h>
61#include <blaze/util/Assert.h>
62#include <blaze/util/EnableIf.h>
66#include <blaze/util/mpl/If.h>
67#include <blaze/util/Types.h>
69
70
71namespace blaze {
72
73//=================================================================================================
74//
75// CLASS SVECEXPANDEXPR
76//
77//=================================================================================================
78
79//*************************************************************************************************
86template< typename VT // Type of the dense vector
87 , bool TF // Transpose flag
88 , size_t... CEAs > // Compile time expansion arguments
90 : public VecExpandExpr< SparseMatrix< SVecExpandExpr<VT,TF,CEAs...>, !TF >, CEAs... >
91 , private If_t< IsComputation_v<VT>, Computation, Transformation >
92 , private ExpandExprData<CEAs...>
93{
94 private:
95 //**Type definitions****************************************************************************
97
98 using DataType = ExpandExprData<CEAs...>;
99
101 BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetConstIterator, ConstIterator, INVALID_TYPE );
102 //**********************************************************************************************
103
104 //**Serial evaluation strategy******************************************************************
106
112 static constexpr bool useAssign = IsComputation_v<VT> || RequiresEvaluation_v<VT>;
113
116 template< typename MT >
117 static constexpr bool UseAssign_v = useAssign;
119 //**********************************************************************************************
120
121 //**Parallel evaluation strategy****************************************************************
123
129 template< typename MT >
130 static constexpr bool UseSMPAssign_v = ( MT::smpAssignable && useAssign );
132 //**********************************************************************************************
133
134 public:
135 //**Type definitions****************************************************************************
137 using This = SVecExpandExpr<VT,TF,CEAs...>;
138
141
142 using ResultType = ExpandTrait_t<VT,CEAs...>;
147
150
152 using ConstIterator = GetConstIterator_t<VT>;
153
155 using Operand = If_t< IsExpression_v<VT>, const VT, const VT& >;
156 //**********************************************************************************************
157
158 //**Compilation flags***************************************************************************
160 static constexpr bool smpAssignable = VT::smpAssignable;
161 //**********************************************************************************************
162
163 //**Constructor*********************************************************************************
169 template< typename... REAs > // Runtime expansion arguments
170 explicit inline SVecExpandExpr( const VT& sv, REAs... args ) noexcept
171 : DataType( args... ) // Base class initialization
172 , sv_ ( sv ) // Sparse vector of the expansion expression
173 {}
174 //**********************************************************************************************
175
176 //**Access operator*****************************************************************************
183 inline ReturnType operator()( size_t i, size_t j ) const {
184 if( TF ) {
185 BLAZE_INTERNAL_ASSERT( i < expansion(), "Invalid row access index" );
186 BLAZE_INTERNAL_ASSERT( j < sv_.size() , "Invalid column access index" );
187 return sv_[j];
188 }
189 else {
190 BLAZE_INTERNAL_ASSERT( i < sv_.size() , "Invalid row access index" );
191 BLAZE_INTERNAL_ASSERT( j < expansion(), "Invalid column access index" );
192 return sv_[i];
193 }
194 }
195 //**********************************************************************************************
196
197 //**At function*********************************************************************************
205 inline ReturnType at( size_t i, size_t j ) const {
206 if( i >= ( TF ? expansion() : sv_.size() ) ) {
207 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
208 }
209 if( j >= ( TF ? sv_.size() : expansion() ) ) {
210 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
211 }
212 return (*this)(i,j);
213 }
214 //**********************************************************************************************
215
216 //**Begin function******************************************************************************
222 inline ConstIterator begin( size_t i ) const {
223 MAYBE_UNUSED( i );
224 return sv_.begin();
225 }
226 //**********************************************************************************************
227
228 //**End function********************************************************************************
234 inline ConstIterator end( size_t i ) const {
235 MAYBE_UNUSED( i );
236 return sv_.end();
237 }
238 //**********************************************************************************************
239
240 //**Rows function*******************************************************************************
245 inline size_t rows() const noexcept {
246 return ( TF ? expansion() : sv_.size() );
247 }
248 //**********************************************************************************************
249
250 //**Columns function****************************************************************************
255 inline size_t columns() const noexcept {
256 return ( TF ? sv_.size() : expansion() );
257 }
258 //**********************************************************************************************
259
260 //**NonZeros function***************************************************************************
265 inline size_t nonZeros() const {
266 return sv_.nonZeros() * expansion();
267 }
268 //**********************************************************************************************
269
270 //**NonZeros function***************************************************************************
276 inline size_t nonZeros( size_t i ) const {
277 MAYBE_UNUSED( i );
278 return sv_.nonZeros();
279 }
280 //**********************************************************************************************
281
282 //**Find function*******************************************************************************
289 inline ConstIterator find( size_t i, size_t j ) const {
291 return sv_.find( TF ? j : i );
292 }
293 //**********************************************************************************************
294
295 //**LowerBound function*************************************************************************
302 inline ConstIterator lowerBound( size_t i, size_t j ) const {
304 return sv_.lowerBound( TF ? j : i );
305 }
306 //**********************************************************************************************
307
308 //**UpperBound function*************************************************************************
315 inline ConstIterator upperBound( size_t i, size_t j ) const {
317 return sv_.upperBound( TF ? j : i );
318 }
319 //**********************************************************************************************
320
321 //**Operand access******************************************************************************
326 inline Operand operand() const noexcept {
327 return sv_;
328 }
329 //**********************************************************************************************
330
331 //**********************************************************************************************
332 using DataType::expansion;
333 //**********************************************************************************************
334
335 //**********************************************************************************************
341 template< typename T >
342 inline bool canAlias( const T* alias ) const noexcept {
343 return sv_.isAliased( alias );
344 }
345 //**********************************************************************************************
346
347 //**********************************************************************************************
353 template< typename T >
354 inline bool isAliased( const T* alias ) const noexcept {
355 return sv_.isAliased( alias );
356 }
357 //**********************************************************************************************
358
359 //**********************************************************************************************
364 inline bool canSMPAssign() const noexcept {
365 return sv_.canSMPAssign();
366 }
367 //**********************************************************************************************
368
369 private:
370 //**Member variables****************************************************************************
372 //**********************************************************************************************
373
374 //**Assignment to matrices**********************************************************************
388 template< typename MT // Type of the target dense matrix
389 , bool SO > // Storage order of the target dense matrix
390 friend inline auto assign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
392 {
393 using blaze::expand;
394
396
397 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
398 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
399
400 const RT tmp( serial( *rhs.sv_ ) );
401
402 assign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
403 }
405 //**********************************************************************************************
406
407 //**Addition assignment to matrices*************************************************************
421 template< typename MT // Type of the target dense matrix
422 , bool SO > // Storage order of the target dense matrix
423 friend inline auto addAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
425 {
426 using blaze::expand;
427
429
430 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
431 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
432
433 const RT tmp( serial( *rhs.sv_ ) );
434
435 addAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
436 }
438 //**********************************************************************************************
439
440 //**Subtraction assignment to matrices**********************************************************
454 template< typename MT // Type of the target dense matrix
455 , bool SO > // Storage order of the target dense matrix
456 friend inline auto subAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
457 -> EnableIf_t< UseAssign_v<MT> >
458 {
459 using blaze::expand;
460
462
463 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
464 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
465
466 const RT tmp( serial( *rhs.sv_ ) );
467
468 subAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
469 }
471 //**********************************************************************************************
472
473 //**Schur product assignment to matrices********************************************************
487 template< typename MT // Type of the target dense matrix
488 , bool SO > // Storage order of the target dense matrix
489 friend inline auto schurAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
490 -> EnableIf_t< UseAssign_v<MT> >
491 {
492 using blaze::expand;
493
495
496 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
497 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
498
499 const RT tmp( serial( *rhs.sv_ ) );
500
501 schurAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
502 }
504 //**********************************************************************************************
505
506 //**Multiplication assignment to matrices*******************************************************
520 template< typename MT // Type of the target dense matrix
521 , bool SO > // Storage order of the target dense matrix
522 friend inline auto multAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
523 -> EnableIf_t< UseAssign_v<MT> >
524 {
525 using blaze::expand;
526
528
529 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
530 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
531
532 const RT tmp( serial( *rhs.sv_ ) );
533
534 multAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
535 }
537 //**********************************************************************************************
538
539 //**SMP assignment to matrices******************************************************************
553 template< typename MT // Type of the target matrix
554 , bool SO > // Storage order of the target matrix
555 friend inline auto smpAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
556 -> EnableIf_t< UseSMPAssign_v<MT> >
557 {
558 using blaze::expand;
559
561
562 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
563 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
564
565 const RT tmp( *rhs.sv_ );
566
567 smpAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
568 }
570 //**********************************************************************************************
571
572 //**SMP addition assignment to matrices*********************************************************
586 template< typename MT // Type of the target matrix
587 , bool SO > // Storage order of the target matrix
588 friend inline auto smpAddAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
589 -> EnableIf_t< UseSMPAssign_v<MT> >
590 {
591 using blaze::expand;
592
594
595 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
596 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
597
598 const RT tmp( *rhs.sv_ );
599
600 smpAddAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
601 }
603 //**********************************************************************************************
604
605 //**SMP subtraction assignment to matrices******************************************************
619 template< typename MT // Type of the target matrix
620 , bool SO > // Storage order of the target matrix
621 friend inline auto smpSubAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
622 -> EnableIf_t< UseSMPAssign_v<MT> >
623 {
624 using blaze::expand;
625
627
628 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
629 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
630
631 const RT tmp( *rhs.sv_ );
632
633 smpSubAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
634 }
636 //**********************************************************************************************
637
638 //**SMP Schur product assignment to matrices****************************************************
652 template< typename MT // Type of the target matrix
653 , bool SO > // Storage order of the target matrix
654 friend inline auto smpSchurAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
655 -> EnableIf_t< UseSMPAssign_v<MT> >
656 {
657 using blaze::expand;
658
660
661 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
662 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
663
664 const RT tmp( *rhs.sv_ );
665
666 smpSchurAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
667 }
669 //**********************************************************************************************
670
671 //**SMP multiplication assignment to matrices***************************************************
685 template< typename MT // Type of the target matrix
686 , bool SO > // Storage order of the target matrix
687 friend inline auto smpMultAssign( Matrix<MT,SO>& lhs, const SVecExpandExpr& rhs )
688 -> EnableIf_t< UseSMPAssign_v<MT> >
689 {
690 using blaze::expand;
691
693
694 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
695 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
696
697 const RT tmp( *rhs.sv_ );
698
699 smpMultAssign( *lhs, expand<CEAs...>( tmp, rhs.expansion() ) );
700 }
702 //**********************************************************************************************
703
704 //**Compile time checks*************************************************************************
709 //**********************************************************************************************
710};
711//*************************************************************************************************
712
713
714
715
716//=================================================================================================
717//
718// GLOBAL OPERATORS
719//
720//=================================================================================================
721
722//*************************************************************************************************
763template< typename VT // Type of the sparse vector
764 , bool TF > // Transpose flag
765inline decltype(auto) expand( const SparseVector<VT,TF>& sv, size_t expansion )
766{
768
769 using ReturnType = const SVecExpandExpr<VT,TF>;
770 return ReturnType( *sv, expansion );
771}
772//*************************************************************************************************
773
774
775//*************************************************************************************************
815template< size_t E // Compile time expansion argument
816 , typename VT // Type of the sparse vector
817 , bool TF > // Transpose flag
818inline decltype(auto) expand( const SparseVector<VT,TF>& sv )
819{
821
822 using ReturnType = const SVecExpandExpr<VT,TF,E>;
823 return ReturnType( *sv );
824}
825//*************************************************************************************************
826
827
828//*************************************************************************************************
840template< size_t E // Compile time expansion argument
841 , typename VT // Type of the sparse vector
842 , bool TF > // Transpose flag
843inline decltype(auto) expand( const SparseVector<VT,TF>& sv, size_t expansion )
844{
845 MAYBE_UNUSED( expansion );
846
848
849 using ReturnType = const SVecExpandExpr<VT,TF,E>;
850 return ReturnType( *sv );
851}
853//*************************************************************************************************
854
855} // namespace blaze
856
857#endif
Header file for auxiliary alias declarations.
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.
Definition: Aliases.h:470
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.
Definition: Aliases.h:450
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition: Aliases.h:190
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.
Definition: Aliases.h:310
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.
Definition: Aliases.h:550
Header file for run time assertion macros.
Header file for the EnableIf class template.
Header file for the implementation of the ExpandExprData class template.
Header file for the expand trait.
Header file for the function trace functionality.
Header file for the GetMemberType type trait.
Header file for the If class template.
Utility type for generic codes.
Header file for the IsComputation type trait class.
Header file for the IsExpression type trait class.
Header file for the MAYBE_UNUSED function template.
Auxiliary class template for the data members of expansion expression classes.
Definition: ExpandExprData.h:64
Base class for matrices.
Definition: Matrix.h:85
Expression object for sparse vector expansion.
Definition: SVecExpandExpr.h:93
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: SVecExpandExpr.h:160
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SVecExpandExpr.h:342
TransposeType_t< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: SVecExpandExpr.h:144
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: SVecExpandExpr.h:222
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SVecExpandExpr.h:255
ResultType_t< VT > RT
Result type of the sparse vector expression.
Definition: SVecExpandExpr.h:96
ConstIterator find(size_t i, size_t j) const
Searches for a specific matrix element.
Definition: SVecExpandExpr.h:289
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the expansion expression.
Definition: SVecExpandExpr.h:112
Operand operand() const noexcept
Returns the sparse vector operand.
Definition: SVecExpandExpr.h:326
OppositeType_t< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SVecExpandExpr.h:143
SVecExpandExpr(const VT &sv, REAs... args) noexcept
Constructor for the SVecExpandExpr class.
Definition: SVecExpandExpr.h:170
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SVecExpandExpr.h:183
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: SVecExpandExpr.h:234
Operand sv_
Sparse vector of the expansion expression.
Definition: SVecExpandExpr.h:371
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SVecExpandExpr.h:354
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SVecExpandExpr.h:364
If_t< IsExpression_v< VT >, const VT, const VT & > Operand
Composite data type of the sparse matrix expression.
Definition: SVecExpandExpr.h:155
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SVecExpandExpr.h:245
ExpandExprData< CEAs... > DataType
The type of the ExpandExprData base class.
Definition: SVecExpandExpr.h:98
If_t< useAssign, const ResultType, const SVecExpandExpr & > CompositeType
Data type for composite expression templates.
Definition: SVecExpandExpr.h:149
ReturnType_t< VT > ReturnType
Return type for expression template evaluations.
Definition: SVecExpandExpr.h:146
ExpandTrait_t< VT, CEAs... > ResultType
Result type for expression template evaluations.
Definition: SVecExpandExpr.h:142
ConstIterator upperBound(size_t i, size_t j) const
Returns an iterator to the first index greater then the given index.
Definition: SVecExpandExpr.h:315
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SVecExpandExpr.h:265
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(GetConstIterator, ConstIterator, INVALID_TYPE)
Definition of the GetConstIterator type trait.
ElementType_t< VT > ElementType
Resulting element type.
Definition: SVecExpandExpr.h:145
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SVecExpandExpr.h:205
GetConstIterator_t< VT > ConstIterator
Iterator over the elements of the sparse matrix.
Definition: SVecExpandExpr.h:152
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row/column.
Definition: SVecExpandExpr.h:276
ConstIterator lowerBound(size_t i, size_t j) const
Returns an iterator to the first index not less then the given index.
Definition: SVecExpandExpr.h:302
Base class for sparse vectors.
Definition: SparseVector.h:72
Constraint on the data type.
Constraint on the data type.
Header file for the Computation base class.
Header file for the SparseMatrix base class.
Header file for the SparseVector base class.
Header file for the Transformation base class.
Header file for the VecExpandExpr base class.
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:812
decltype(auto) expand(const DenseVector< VT, TF > &dv, size_t expansion)
Expansion of the given dense vector.
Definition: DVecExpandExpr.h:746
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.
Definition: RequiresEvaluation.h:81
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
Constraint on the data type.
Definition: TransposeFlag.h:63
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.
Definition: SparseVector.h:61
typename ExpandTrait< T, CEAs... >::Type ExpandTrait_t
Auxiliary alias declaration for the ExpandTrait type trait.
Definition: ExpandTrait.h:145
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
auto smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP multiplication assignment of a vector to a dense vector.
Definition: DenseVector.h:192
auto smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:194
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition: EnableIf.h:138
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
typename If< Condition >::template Type< T1, T2 > If_t
Auxiliary alias template for the If class template.
Definition: If.h:108
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.
Definition: Exception.h:331
#define BLAZE_FUNCTION_TRACE
Function trace macro.
Definition: FunctionTrace.h:94
Header file for the exception macros of the math module.
Constraint on the data type.
Header file for all forward declarations for expression class templates.
Header file for the serial shim.
Base class for all vector expansion expression templates.
Definition: VecExpandExpr.h:69
System settings for the inline keywords.
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.