Blaze 3.9
SMatTransExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_SMATTRANSEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_SMATTRANSEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
58#include <blaze/util/Assert.h>
59#include <blaze/util/EnableIf.h>
62#include <blaze/util/mpl/If.h>
63#include <blaze/util/Types.h>
65
66
67namespace blaze {
68
69//=================================================================================================
70//
71// CLASS SMATTRANSEXPR
72//
73//=================================================================================================
74
75//*************************************************************************************************
82template< typename MT // Type of the sparse matrix
83 , bool SO > // Storage order
85 : public MatTransExpr< SparseMatrix< SMatTransExpr<MT,SO>, SO > >
86 , private If_t< IsComputation_v<MT>, Computation, Transformation >
87{
88 private:
89 //**Type definitions****************************************************************************
91 BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetConstIterator, ConstIterator, INVALID_TYPE );
92 //**********************************************************************************************
93
94 //**Serial evaluation strategy******************************************************************
96
102 static constexpr bool useAssign = RequiresEvaluation_v<MT>;
103
106 template< typename MT2 >
107 static constexpr bool UseAssign_v = useAssign;
109 //**********************************************************************************************
110
111 //**Parallel evaluation strategy****************************************************************
113
119 template< typename MT2 >
120 static constexpr bool UseSMPAssign_v = ( MT2::smpAssignable && useAssign );
122 //**********************************************************************************************
123
124 public:
125 //**Type definitions****************************************************************************
128
131
137
140
142 using ConstIterator = GetConstIterator_t<MT>;
143
145 using Operand = If_t< IsExpression_v<MT>, const MT, const MT& >;
146 //**********************************************************************************************
147
148 //**Compilation flags***************************************************************************
150 static constexpr bool smpAssignable = MT::smpAssignable;
151 //**********************************************************************************************
152
153 //**Constructor*********************************************************************************
158 explicit inline SMatTransExpr( const MT& sm ) noexcept
159 : sm_( sm )
160 {}
161 //**********************************************************************************************
162
163 //**Access operator*****************************************************************************
170 inline ReturnType operator()( size_t i, size_t j ) const {
171 BLAZE_INTERNAL_ASSERT( i < sm_.columns(), "Invalid row access index" );
172 BLAZE_INTERNAL_ASSERT( j < sm_.rows() , "Invalid column access index" );
173 return sm_(j,i);
174 }
175 //**********************************************************************************************
176
177 //**At function*********************************************************************************
185 inline ReturnType at( size_t i, size_t j ) const {
186 if( i >= sm_.columns() ) {
187 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
188 }
189 if( j >= sm_.rows() ) {
190 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
191 }
192 return (*this)(i,j);
193 }
194 //**********************************************************************************************
195
196 //**Begin function******************************************************************************
202 inline ConstIterator begin( size_t i ) const {
203 return sm_.begin(i);
204 }
205 //**********************************************************************************************
206
207 //**End function********************************************************************************
213 inline ConstIterator end( size_t i ) const {
214 return sm_.end(i);
215 }
216 //**********************************************************************************************
217
218 //**Rows function*******************************************************************************
223 inline size_t rows() const noexcept {
224 return sm_.columns();
225 }
226 //**********************************************************************************************
227
228 //**Columns function****************************************************************************
233 inline size_t columns() const noexcept {
234 return sm_.rows();
235 }
236 //**********************************************************************************************
237
238 //**NonZeros function***************************************************************************
243 inline size_t nonZeros() const {
244 return sm_.nonZeros();
245 }
246 //**********************************************************************************************
247
248 //**NonZeros function***************************************************************************
254 inline size_t nonZeros( size_t i ) const {
255 return sm_.nonZeros( i );
256 }
257 //**********************************************************************************************
258
259 //**Find function*******************************************************************************
266 inline ConstIterator find( size_t i, size_t j ) const {
268 return sm_.find( j, i );
269 }
270 //**********************************************************************************************
271
272 //**LowerBound function*************************************************************************
279 inline ConstIterator lowerBound( size_t i, size_t j ) const {
281 return sm_.lowerBound( j, i );
282 }
283 //**********************************************************************************************
284
285 //**UpperBound function*************************************************************************
292 inline ConstIterator upperBound( size_t i, size_t j ) const {
294 return sm_.upperBound( j, i );
295 }
296 //**********************************************************************************************
297
298 //**Operand access******************************************************************************
303 inline Operand operand() const noexcept {
304 return sm_;
305 }
306 //**********************************************************************************************
307
308 //**********************************************************************************************
314 template< typename T >
315 inline bool canAlias( const T* alias ) const noexcept {
316 return sm_.isAliased( alias );
317 }
318 //**********************************************************************************************
319
320 //**********************************************************************************************
326 template< typename T >
327 inline bool isAliased( const T* alias ) const noexcept {
328 return sm_.isAliased( alias );
329 }
330 //**********************************************************************************************
331
332 //**********************************************************************************************
337 inline bool canSMPAssign() const noexcept {
338 return sm_.canSMPAssign();
339 }
340 //**********************************************************************************************
341
342 private:
343 //**Member variables****************************************************************************
345 //**********************************************************************************************
346
347 //**Assignment to dense matrices****************************************************************
361 template< typename MT2 // Type of the target dense matrix
362 , bool SO2 > // Storage order of the target dense matrix
363 friend inline auto assign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
365 {
367
368 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
369 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
370
371 DMatTransposer<MT2,!SO2> tmp( *lhs );
372 assign( tmp, rhs.sm_ );
373 }
375 //**********************************************************************************************
376
377 //**Assignment to sparse matrices***************************************************************
391 template< typename MT2 // Type of the target sparse matrix
392 , bool SO2 > // Storage order of the target sparse matrix
393 friend inline auto assign( SparseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
395 {
397
398 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
399 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
400
401 SMatTransposer<MT2,!SO2> tmp( *lhs );
402 assign( tmp, rhs.sm_ );
403 }
405 //**********************************************************************************************
406
407 //**Addition assignment to dense matrices*******************************************************
421 template< typename MT2 // Type of the target dense matrix
422 , bool SO2 > // Storage order of the target dense matrix
423 friend inline auto addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
424 -> EnableIf_t< UseAssign_v<MT2> >
425 {
427
428 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
429 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
430
431 DMatTransposer<MT2,!SO2> tmp( *lhs );
432 addAssign( tmp, rhs.sm_ );
433 }
435 //**********************************************************************************************
436
437 //**Addition assignment to sparse matrices******************************************************
438 // No special implementation for the addition assignment to sparse matrices.
439 //**********************************************************************************************
440
441 //**Subtraction assignment to dense matrices****************************************************
455 template< typename MT2 // Type of the target dense matrix
456 , bool SO2 > // Storage order of the target dense matrix
457 friend inline auto subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
458 -> EnableIf_t< UseAssign_v<MT2> >
459 {
461
462 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
463 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
464
465 DMatTransposer<MT2,!SO2> tmp( *lhs );
466 subAssign( tmp, rhs.sm_ );
467 }
469 //**********************************************************************************************
470
471 //**Subtraction assignment to sparse matrices***************************************************
472 // No special implementation for the subtraction assignment to sparse matrices.
473 //**********************************************************************************************
474
475 //**Schur product assignment to dense matrices**************************************************
489 template< typename MT2 // Type of the target dense matrix
490 , bool SO2 > // Storage order of the target dense matrix
491 friend inline auto schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
492 -> EnableIf_t< UseAssign_v<MT2> >
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 DMatTransposer<MT2,!SO2> tmp( *lhs );
500 schurAssign( tmp, rhs.sm_ );
501 }
503 //**********************************************************************************************
504
505 //**Schur product assignment to sparse matrices*************************************************
506 // No special implementation for the Schur product assignment to sparse matrices.
507 //**********************************************************************************************
508
509 //**Multiplication assignment to dense matrices*************************************************
510 // No special implementation for the multiplication assignment to dense matrices.
511 //**********************************************************************************************
512
513 //**Multiplication assignment to sparse matrices************************************************
514 // No special implementation for the multiplication assignment to sparse matrices.
515 //**********************************************************************************************
516
517 //**SMP assignment to dense matrices************************************************************
531 template< typename MT2 // Type of the target dense matrix
532 , bool SO2 > // Storage order of the target dense matrix
533 friend inline auto smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
534 -> EnableIf_t< UseSMPAssign_v<MT2> >
535 {
537
538 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
539 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
540
541 DMatTransposer<MT2,!SO2> tmp( *lhs );
542 smpAssign( tmp, rhs.sm_ );
543 }
545 //**********************************************************************************************
546
547 //**SMP assignment to sparse matrices***********************************************************
561 template< typename MT2 // Type of the target sparse matrix
562 , bool SO2 > // Storage order of the target sparse matrix
563 friend inline auto smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
564 -> EnableIf_t< UseSMPAssign_v<MT2> >
565 {
567
568 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
569 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
570
571 SMatTransposer<MT2,!SO2> tmp( *lhs );
572 smpAssign( tmp, rhs.sm_ );
573 }
575 //**********************************************************************************************
576
577 //**SMP addition assignment to dense matrices***************************************************
591 template< typename MT2 // Type of the target dense matrix
592 , bool SO2 > // Storage order of the target dense matrix
593 friend inline auto smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
594 -> EnableIf_t< UseSMPAssign_v<MT2> >
595 {
597
598 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
599 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
600
601 DMatTransposer<MT2,!SO2> tmp( *lhs );
602 smpAddAssign( tmp, rhs.sm_ );
603 }
605 //**********************************************************************************************
606
607 //**SMP addition assignment to sparse matrices**************************************************
608 // No special implementation for the SMP addition assignment to sparse matrices.
609 //**********************************************************************************************
610
611 //**SMP subtraction assignment to dense matrices************************************************
626 template< typename MT2 // Type of the target dense matrix
627 , bool SO2 > // Storage order of the target dense matrix
628 friend inline auto smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
629 -> EnableIf_t< UseSMPAssign_v<MT2> >
630 {
632
633 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
634 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
635
636 DMatTransposer<MT2,!SO2> tmp( *lhs );
637 smpSubAssign( tmp, rhs.sm_ );
638 }
640 //**********************************************************************************************
641
642 //**SMP subtraction assignment to sparse matrices***********************************************
643 // No special implementation for the SMP subtraction assignment to sparse matrices.
644 //**********************************************************************************************
645
646 //**SMP Schur product assignment to dense matrices**********************************************
661 template< typename MT2 // Type of the target dense matrix
662 , bool SO2 > // Storage order of the target dense matrix
663 friend inline auto smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
664 -> EnableIf_t< UseSMPAssign_v<MT2> >
665 {
667
668 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
669 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
670
671 DMatTransposer<MT2,!SO2> tmp( *lhs );
672 smpSchurAssign( tmp, rhs.sm_ );
673 }
675 //**********************************************************************************************
676
677 //**SMP Schur product assignment to sparse matrices*********************************************
678 // No special implementation for the SMP Schur product assignment to sparse matrices.
679 //**********************************************************************************************
680
681 //**SMP multiplication assignment to dense matrices*********************************************
682 // No special implementation for the SMP multiplication assignment to dense matrices.
683 //**********************************************************************************************
684
685 //**SMP multiplication assignment to sparse matrices********************************************
686 // No special implementation for the SMP multiplication assignment to sparse matrices.
687 //**********************************************************************************************
688
689 //**Compile time checks*************************************************************************
694 //**********************************************************************************************
695};
696//*************************************************************************************************
697
698
699
700
701//=================================================================================================
702//
703// GLOBAL OPERATORS
704//
705//=================================================================================================
706
707//*************************************************************************************************
726template< typename MT // Type of the sparse matrix
727 , bool SO > // Storage order
728inline decltype(auto) trans( const SparseMatrix<MT,SO>& sm )
729{
731
732 using ReturnType = const SMatTransExpr<MT,!SO>;
733 return ReturnType( *sm );
734}
735//*************************************************************************************************
736
737
738//*************************************************************************************************
749template< typename MT // Type of the sparse matrix
750 , bool SO > // Storage order
751inline decltype(auto) transIf( FalseType, const SparseMatrix<MT,SO>& sm )
752{
753 return *sm;
754}
756//*************************************************************************************************
757
758
759//*************************************************************************************************
770template< typename MT // Type of the sparse matrix
771 , bool SO > // Storage order
772inline decltype(auto) transIf( TrueType, const SparseMatrix<MT,SO>& sm )
773{
774 return trans( *sm );
775}
777//*************************************************************************************************
778
779
780//*************************************************************************************************
791template< bool B // Compile time condition
792 , typename MT // Type of the sparse matrix
793 , bool SO > // Storage order
794inline decltype(auto) transIf( const SparseMatrix<MT,SO>& sm )
795{
796 return transIf( BoolConstant<B>(), *sm );
797}
798//*************************************************************************************************
799
800} // namespace blaze
801
802#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 dense matrix transposer.
Header file for the EnableIf class template.
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 sparse matrix transposer.
Expression object for the transposition of a dense matrix.
Definition: DMatTransposer.h:79
Base class for dense matrices.
Definition: DenseMatrix.h:82
Expression object for sparse matrix transpositions.
Definition: SMatTransExpr.h:87
SMatTransExpr(const MT &sm) noexcept
Constructor for the SMatTransExpr class.
Definition: SMatTransExpr.h:158
ElementType_t< MT > ElementType
Resulting element type.
Definition: SMatTransExpr.h:135
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatTransExpr.h:233
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatTransExpr.h:136
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the transposition expression.
Definition: SMatTransExpr.h:102
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTransExpr.h:170
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatTransExpr.h:303
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatTransExpr.h:243
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: SMatTransExpr.h:213
ResultType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition: SMatTransExpr.h:134
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: SMatTransExpr.h:150
GetConstIterator_t< MT > ConstIterator
Iterator over the elements of the sparse matrix.
Definition: SMatTransExpr.h:142
If_t< IsExpression_v< MT >, const MT, const MT & > Operand
Composite data type of the sparse matrix expression.
Definition: SMatTransExpr.h:145
TransposeType_t< MT > ResultType
Result type for expression template evaluations.
Definition: SMatTransExpr.h:132
ConstIterator upperBound(size_t i, size_t j) const
Returns an iterator to the first index greater then the given index.
Definition: SMatTransExpr.h:292
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row/column.
Definition: SMatTransExpr.h:254
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatTransExpr.h:327
Operand sm_
Sparse matrix of the transposition expression.
Definition: SMatTransExpr.h:344
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(GetConstIterator, ConstIterator, INVALID_TYPE)
Definition of the GetConstIterator type trait.
OppositeType_t< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTransExpr.h:133
ConstIterator find(size_t i, size_t j) const
Searches for a specific matrix element.
Definition: SMatTransExpr.h:266
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatTransExpr.h:315
If_t< useAssign, const ResultType, const SMatTransExpr & > CompositeType
Data type for composite expression templates.
Definition: SMatTransExpr.h:139
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatTransExpr.h:185
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatTransExpr.h:337
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: SMatTransExpr.h:202
ConstIterator lowerBound(size_t i, size_t j) const
Returns an iterator to the first index not less then the given index.
Definition: SMatTransExpr.h:279
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatTransExpr.h:223
Expression object for the transposition of a sparse matrix.
Definition: SMatTransposer.h:72
Base class for sparse matrices.
Definition: SparseMatrix.h:77
Constraint on the data type.
Constraint on the data type.
Header file for the Computation base class.
Header file for the MatTransExpr base class.
Header file for the SparseMatrix base class.
Header file for the Transformation base class.
decltype(auto) transIf(const DenseMatrix< MT, SO > &dm)
Conditional calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:832
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:766
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.
Definition: RequiresEvaluation.h:81
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition: SparseMatrix.h:61
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.
Definition: StorageOrder.h:63
#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 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
BoolConstant< true > TrueType
Type traits base class.
Definition: IntegralConstant.h:132
BoolConstant< false > FalseType
Type/value traits base class.
Definition: IntegralConstant.h:121
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition: EnableIf.h:138
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.
Constraints on the storage order of matrix types.
Header file for all forward declarations for expression class templates.
Generic wrapper for a compile time constant integral value.
Definition: IntegralConstant.h:74
Base class for all matrix transposition expression templates.
Definition: MatTransExpr.h:69
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.