All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatSerialExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <cmath>
60 #include <blaze/util/Assert.h>
62 #include <blaze/util/EnableIf.h>
63 #include <blaze/util/InvalidType.h>
65 #include <blaze/util/SelectType.h>
66 #include <blaze/util/Types.h>
67 
68 
69 namespace blaze {
70 
71 //=================================================================================================
72 //
73 // CLASS DMATSERIALEXPR
74 //
75 //=================================================================================================
76 
77 //*************************************************************************************************
84 template< typename MT // Type of the dense matrix
85  , bool SO > // Storage order
86 class DMatSerialExpr : public DenseMatrix< DMatSerialExpr<MT,SO>, SO >
87  , private MatSerialExpr
88  , private Computation
89 {
90  public:
91  //**Type definitions****************************************************************************
93  typedef typename MT::ResultType ResultType;
94  typedef typename MT::OppositeType OppositeType;
95  typedef typename MT::TransposeType TransposeType;
96  typedef typename MT::ElementType ElementType;
97  typedef typename MT::ReturnType ReturnType;
98 
100  typedef const ResultType CompositeType;
101 
103  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type Operand;
104  //**********************************************************************************************
105 
106  //**Compilation flags***************************************************************************
108  enum { vectorizable = 0 };
109 
111  enum { smpAssignable = MT::smpAssignable };
112  //**********************************************************************************************
113 
114  //**Constructor*********************************************************************************
119  explicit inline DMatSerialExpr( const MT& dm )
120  : dm_( dm ) // Dense matrix of the serial evaluation expression
121  {}
122  //**********************************************************************************************
123 
124  //**Access operator*****************************************************************************
131  inline ReturnType operator()( size_t i, size_t j ) const {
132  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
133  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
134  return dm_(i,j);
135  }
136  //**********************************************************************************************
137 
138  //**Rows function*******************************************************************************
143  inline size_t rows() const {
144  return dm_.rows();
145  }
146  //**********************************************************************************************
147 
148  //**Columns function****************************************************************************
153  inline size_t columns() const {
154  return dm_.columns();
155  }
156  //**********************************************************************************************
157 
158  //**Operand access******************************************************************************
163  inline Operand operand() const {
164  return dm_;
165  }
166  //**********************************************************************************************
167 
168  //**Conversion operator*************************************************************************
173  inline operator Operand() const {
174  return dm_;
175  }
176  //**********************************************************************************************
177 
178  //**********************************************************************************************
184  template< typename T >
185  inline bool canAlias( const T* alias ) const {
186  return dm_.canAlias( alias );
187  }
188  //**********************************************************************************************
189 
190  //**********************************************************************************************
196  template< typename T >
197  inline bool isAliased( const T* alias ) const {
198  return dm_.isAliased( alias );
199  }
200  //**********************************************************************************************
201 
202  //**********************************************************************************************
207  inline bool isAligned() const {
208  return dm_.isAligned();
209  }
210  //**********************************************************************************************
211 
212  //**********************************************************************************************
217  inline bool canSMPAssign() const {
218  return dm_.canSMPAssign();
219  }
220  //**********************************************************************************************
221 
222  private:
223  //**Member variables****************************************************************************
225  //**********************************************************************************************
226 
227  //**Assignment to dense matrices****************************************************************
239  template< typename MT2 // Type of the target dense matrix
240  , bool SO2 > // Storage order of the target dense matrix
241  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
242  {
244 
245  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
246  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
247 
248  assign( ~lhs, rhs.dm_ );
249  }
251  //**********************************************************************************************
252 
253  //**Assignment to sparse matrices***************************************************************
265  template< typename MT2 // Type of the target sparse matrix
266  , bool SO2 > // Storage order of the target dense matrix
267  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
268  {
270 
271  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
272  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
273 
274  assign( ~lhs, rhs.dm_ );
275  }
277  //**********************************************************************************************
278 
279  //**Addition assignment to dense matrices*******************************************************
291  template< typename MT2 // Type of the target dense matrix
292  , bool SO2 > // Storage order of the target dense matrix
293  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
294  {
296 
297  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
298  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
299 
300  addAssign( ~lhs, rhs.dm_ );
301  }
303  //**********************************************************************************************
304 
305  //**Addition assignment to sparse matrices******************************************************
317  template< typename MT2 // Type of the target sparse matrix
318  , bool SO2 > // Storage order of the target dense matrix
319  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
320  {
322 
323  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
324  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
325 
326  addAssign( ~lhs, rhs.dm_ );
327  }
329  //**********************************************************************************************
330 
331  //**Subtraction assignment to dense matrices****************************************************
344  template< typename MT2 // Type of the target dense matrix
345  , bool SO2 > // Storage order of the target dense matrix
346  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
347  {
349 
350  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
351  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
352 
353  subAssign( ~lhs, rhs.dm_ );
354  }
356  //**********************************************************************************************
357 
358  //**Subtraction assignment to sparse matrices***************************************************
371  template< typename MT2 // Type of the target sparse matrix
372  , bool SO2 > // Storage order of the target dense matrix
373  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
374  {
376 
377  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
378  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
379 
380  subAssign( ~lhs, rhs.dm_ );
381  }
383  //**********************************************************************************************
384 
385  //**Multiplication assignment to dense matrices*************************************************
398  template< typename MT2 // Type of the target dense matrix
399  , bool SO2 > // Storage order of the target dense matrix
400  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
401  {
403 
404  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
405  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
406 
407  multAssign( ~lhs, rhs.sm_ );
408  }
410  //**********************************************************************************************
411 
412  //**Multiplication assignment to sparse matrices************************************************
425  template< typename MT2 // Type of the target sparse matrix
426  , bool SO2 > // Storage order of the target sparse matrix
427  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
428  {
430 
431  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
432  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
433 
434  multAssign( ~lhs, rhs.sm_ );
435  }
437  //**********************************************************************************************
438 
439  //**SMP assignment to dense matrices************************************************************
451  template< typename MT2 // Type of the target dense matrix
452  , bool SO2 > // Storage order of the target dense matrix
453  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
454  {
456 
457  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
458  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
459 
460  assign( ~lhs, rhs.dm_ );
461  }
463  //**********************************************************************************************
464 
465  //**SMP assignment to sparse matrices***********************************************************
477  template< typename MT2 // Type of the target sparse matrix
478  , bool SO2 > // Storage order of the target dense matrix
479  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
480  {
482 
483  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
484  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
485 
486  assign( ~lhs, rhs.dm_ );
487  }
489  //**********************************************************************************************
490 
491  //**SMP addition assignment to dense matrices***************************************************
504  template< typename MT2 // Type of the target dense matrix
505  , bool SO2 > // Storage order of the target dense matrix
506  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
507  {
509 
510  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
511  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
512 
513  addAssign( ~lhs, rhs.dm_ );
514  }
516  //**********************************************************************************************
517 
518  //**SMP addition assignment to sparse matrices**************************************************
531  template< typename MT2 // Type of the target sparse matrix
532  , bool SO2 > // Storage order of the target dense matrix
533  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
534  {
536 
537  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
538  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
539 
540  addAssign( ~lhs, rhs.dm_ );
541  }
543  //**********************************************************************************************
544 
545  //**SMP subtraction assignment to dense matrices************************************************
558  template< typename MT2 // Type of the target dense matrix
559  , bool SO2 > // Storage order of the target dense matrix
560  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
561  {
563 
564  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
565  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
566 
567  subAssign( ~lhs, rhs.dm_ );
568  }
570  //**********************************************************************************************
571 
572  //**SMP subtraction assignment to sparse matrices***********************************************
585  template< typename MT2 // Type of the target sparse matrix
586  , bool SO2 > // Storage order of the target dense matrix
587  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
588  {
590 
591  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
592  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
593 
594  subAssign( ~lhs, rhs.dm_ );
595  }
597  //**********************************************************************************************
598 
599  //**SMP multiplication assignment to dense matrices*********************************************
612  template< typename MT2 // Type of the target dense matrix
613  , bool SO2 > // Storage order of the target dense matrix
614  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
615  {
617 
618  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
619  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
620 
621  multAssign( ~lhs, rhs.sm_ );
622  }
624  //**********************************************************************************************
625 
626  //**SMP multiplication assignment to sparse matrices********************************************
639  template< typename MT2 // Type of the target sparse matrix
640  , bool SO2 > // Storage order of the target sparse matrix
641  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
642  {
644 
645  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
646  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
647 
648  multAssign( ~lhs, rhs.sm_ );
649  }
651  //**********************************************************************************************
652 
653  //**Compile time checks*************************************************************************
658  //**********************************************************************************************
659 };
660 //*************************************************************************************************
661 
662 
663 
664 
665 //=================================================================================================
666 //
667 // GLOBAL FUNCTIONS
668 //
669 //=================================================================================================
670 
671 //*************************************************************************************************
688 template< typename MT // Type of the dense matrix
689  , bool SO > // Storage order
691 {
693 
694  return DMatSerialExpr<MT,SO>( ~dm );
695 }
696 //*************************************************************************************************
697 
698 
699 
700 
701 //=================================================================================================
702 //
703 // GLOBAL RESTRUCTURING FUNCTIONS
704 //
705 //=================================================================================================
706 
707 //*************************************************************************************************
718 template< typename MT // Type of the dense matrix
719  , bool SO > // Storage order
720 inline const DMatSerialExpr<MT,SO> serial( const DMatSerialExpr<MT,SO>& dm )
721 {
722  return dm;
723 }
725 //*************************************************************************************************
726 
727 
728 
729 
730 //=================================================================================================
731 //
732 // EXPRESSION TRAIT SPECIALIZATIONS
733 //
734 //=================================================================================================
735 
736 //*************************************************************************************************
738 template< typename MT >
739 struct DMatSerialExprTrait< DMatSerialExpr<MT,false> >
740 {
741  public:
742  //**********************************************************************************************
743  typedef typename SelectType< IsDenseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
744  , DMatSerialExpr<MT,false>
745  , INVALID_TYPE >::Type Type;
746  //**********************************************************************************************
747 };
749 //*************************************************************************************************
750 
751 
752 //*************************************************************************************************
754 template< typename MT >
755 struct TDMatSerialExprTrait< DMatSerialExpr<MT,true> >
756 {
757  public:
758  //**********************************************************************************************
759  typedef typename SelectType< IsDenseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
760  , DMatSerialExpr<MT,true>
761  , INVALID_TYPE >::Type Type;
762  //**********************************************************************************************
763 };
765 //*************************************************************************************************
766 
767 
768 //*************************************************************************************************
770 template< typename MT, bool SO, bool AF >
771 struct SubmatrixExprTrait< DMatSerialExpr<MT,SO>, AF >
772 {
773  public:
774  //**********************************************************************************************
775  typedef typename SerialExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
776  //**********************************************************************************************
777 };
779 //*************************************************************************************************
780 
781 
782 //*************************************************************************************************
784 template< typename MT, bool SO >
785 struct RowExprTrait< DMatSerialExpr<MT,SO> >
786 {
787  public:
788  //**********************************************************************************************
789  typedef typename SerialExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
790  //**********************************************************************************************
791 };
793 //*************************************************************************************************
794 
795 
796 //*************************************************************************************************
798 template< typename MT, bool SO >
799 struct ColumnExprTrait< DMatSerialExpr<MT,SO> >
800 {
801  public:
802  //**********************************************************************************************
803  typedef typename SerialExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
804  //**********************************************************************************************
805 };
807 //*************************************************************************************************
808 
809 } // namespace blaze
810 
811 #endif
Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a ...
Definition: MatSerialExpr.h:65
void smpSubAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:152
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatSerialExpr.h:95
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatSerialExpr.h:153
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:242
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
void smpMultAssign(DenseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:179
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
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
Header file for the Computation base class.
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: DMatSerialExpr.h:93
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSerialExpr.h:131
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatSerialExpr.h:207
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2404
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSerialExpr.h:100
Constraint on the data type.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatSerialExpr.h:143
Constraint on the data type.
void smpAddAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:122
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
DMatSerialExpr< MT, SO > This
Type of this DMatSerialExpr instance.
Definition: DMatSerialExpr.h:92
Expression object for the forced serial evaluation of dense matrices.The DMatSerialExpr class represe...
Definition: DMatSerialExpr.h:86
Header file for the DMatSerialExprTrait class template.
MT::ElementType ElementType
Resulting element type.
Definition: DMatSerialExpr.h:96
Header file for the DenseMatrix base class.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatSerialExpr.h:185
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
DMatSerialExpr(const MT &dm)
Constructor for the DMatSerialExpr class.
Definition: DMatSerialExpr.h:119
Header file for the SerialExprTrait class template.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2405
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2406
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
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the IsDenseMatrix type trait.
Header file for the MatSerialExpr base class.
Header file for the EnableIf class template.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatSerialExpr.h:217
Header file for the TDMatSerialExprTrait class template.
void smpAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:92
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatSerialExpr.h:197
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2407
Header file for run time assertion macros.
Utility type for generic codes.
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSerialExpr.h:94
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
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DMatSerialExpr.h:97
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
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the dense matrix expression.
Definition: DMatSerialExpr.h:103
Header file for the IsRowMajorMatrix type trait.
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2403
Header file for basic type definitions.
Operand operand() const
Returns the dense matrix operand.
Definition: DMatSerialExpr.h:163
Operand dm_
Dense matrix of the serial evaluation expression.
Definition: DMatSerialExpr.h:224
#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
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.