All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatTDMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTDMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTDMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
61 #include <blaze/util/Assert.h>
64 #include <blaze/util/SelectType.h>
65 #include <blaze/util/Types.h>
66 
67 
68 namespace blaze {
69 
70 //=================================================================================================
71 //
72 // CLASS DMATTDMATSUBEXPR
73 //
74 //=================================================================================================
75 
76 //*************************************************************************************************
83 template< typename MT1 // Type of the left-hand side dense matrix
84  , typename MT2 > // Type of the right-hand side dense matrix
85 class DMatTDMatSubExpr : public DenseMatrix< DMatTDMatSubExpr<MT1,MT2>, false >
86  , private MatMatSubExpr
87  , private Computation
88 {
89  private:
90  //**Type definitions****************************************************************************
91  typedef typename MT1::ResultType RT1;
92  typedef typename MT2::ResultType RT2;
93  typedef typename MT1::ReturnType RN1;
94  typedef typename MT2::ReturnType RN2;
95  typedef typename MT1::CompositeType CT1;
96  typedef typename MT2::CompositeType CT2;
97  //**********************************************************************************************
98 
99  //**Return type evaluation**********************************************************************
101 
106  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
107 
110  //**********************************************************************************************
111 
112  public:
113  //**Type definitions****************************************************************************
119 
122 
124  typedef const ResultType CompositeType;
125 
127  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
128 
130  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
131  //**********************************************************************************************
132 
133  //**Compilation flags***************************************************************************
135  enum { vectorizable = 0 };
136 
138  enum { smpAssignable = MT1::smpAssignable && MT2::smpAssignable };
139  //**********************************************************************************************
140 
141  //**Constructor*********************************************************************************
147  explicit inline DMatTDMatSubExpr( const MT1& lhs, const MT2& rhs )
148  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
149  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
150  {
151  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
152  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
153  }
154  //**********************************************************************************************
155 
156  //**Access operator*****************************************************************************
163  inline ReturnType operator()( size_t i, size_t j ) const {
164  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
165  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
166  return lhs_(i,j) - rhs_(i,j);
167  }
168  //**********************************************************************************************
169 
170  //**Rows function*******************************************************************************
175  inline size_t rows() const {
176  return lhs_.rows();
177  }
178  //**********************************************************************************************
179 
180  //**Columns function****************************************************************************
185  inline size_t columns() const {
186  return lhs_.columns();
187  }
188  //**********************************************************************************************
189 
190  //**Left operand access*************************************************************************
195  inline LeftOperand leftOperand() const {
196  return lhs_;
197  }
198  //**********************************************************************************************
199 
200  //**Right operand access************************************************************************
205  inline RightOperand rightOperand() const {
206  return rhs_;
207  }
208  //**********************************************************************************************
209 
210  //**********************************************************************************************
216  template< typename T >
217  inline bool canAlias( const T* alias ) const {
218  return ( IsExpression<MT1>::value && ( RequiresEvaluation<MT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
219  ( IsExpression<MT2>::value && ( RequiresEvaluation<MT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
220  }
221  //**********************************************************************************************
222 
223  //**********************************************************************************************
229  template< typename T >
230  inline bool isAliased( const T* alias ) const {
231  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
232  }
233  //**********************************************************************************************
234 
235  //**********************************************************************************************
240  inline bool isAligned() const {
241  return lhs_.isAligned() && rhs_.isAligned();
242  }
243  //**********************************************************************************************
244 
245  //**********************************************************************************************
250  inline bool canSMPAssign() const {
251  return lhs_.canSMPAssign() || rhs_.canSMPAssign() ||
253  }
254  //**********************************************************************************************
255 
256  private:
257  //**Member variables****************************************************************************
260  //**********************************************************************************************
261 
262  //**Assignment to dense matrices****************************************************************
274  template< typename MT // Type of the target dense matrix
275  , bool SO2 > // Storage order of the target dense matrix
276  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
277  {
279 
280  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
281  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
282 
283  // In case non of the two dense operands requires an intermediate evaluation, the
284  // addition expression is assigned directly in a cache-efficient manner.
286  {
287  const size_t m( rhs.rows() );
288  const size_t n( rhs.columns() );
289  const size_t block( 16UL );
290 
291  for( size_t ii=0UL; ii<m; ii+=block ) {
292  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
293  for( size_t jj=0UL; jj<n; jj+=block ) {
294  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
295  for( size_t i=ii; i<iend; ++i ) {
296  for( size_t j=jj; j<jend; ++j ) {
297  (~lhs)(i,j) = rhs.lhs_(i,j) - rhs.rhs_(i,j);
298  }
299  }
300  }
301  }
302  }
303 
304  // In case either of the two dense operands requires an intermediate evaluation, the
305  // expression is evaluated in a one- or two-step approach (depending on whether any
306  // of the operands is aliased with the target matrix).
307  else if( !IsExpression<MT1>::value && (~lhs).isAliased( &rhs.lhs_ ) ) {
308  smpSubAssign( ~lhs, rhs.rhs_ );
309  }
310  else {
311  smpAssign ( ~lhs, rhs.lhs_ );
312  smpSubAssign( ~lhs, rhs.rhs_ );
313  }
314  }
316  //**********************************************************************************************
317 
318  //**Assignment to sparse matrices***************************************************************
330  template< typename MT // Type of the target sparse matrix
331  , bool SO2 > // Storage order of the target sparse matrix
332  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
333  {
335 
336  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
337 
344 
345  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
346  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
347 
348  const TmpType tmp( rhs );
349  smpAssign( ~lhs, tmp );
350  }
352  //**********************************************************************************************
353 
354  //**Addition assignment to dense matrices*******************************************************
367  template< typename MT // Type of the target dense matrix
368  , bool SO2 > // Storage order of the target dense matrix
369  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
370  {
372 
373  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
374  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
375 
376  // In case non of the two dense operands requires an intermediate evaluation, the
377  // addition expression is assigned directly in a cache-efficient manner.
378  if( !RequiresEvaluation<MT1>::value && !RequiresEvaluation<MT2>::value )
379  {
380  const size_t m( rhs.rows() );
381  const size_t n( rhs.columns() );
382  const size_t block( 16UL );
383 
384  for( size_t ii=0UL; ii<m; ii+=block ) {
385  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
386  for( size_t jj=0UL; jj<n; jj+=block ) {
387  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
388  for( size_t i=ii; i<iend; ++i ) {
389  for( size_t j=jj; j<jend; ++j ) {
390  (~lhs)(i,j) += rhs.lhs_(i,j) - rhs.rhs_(i,j);
391  }
392  }
393  }
394  }
395  }
396 
397  // In case either of the two dense operands requires an intermediate evaluation, the
398  // expression is evaluated in a two-step approach.
399  else
400  {
401  smpAddAssign( ~lhs, rhs.lhs_ );
402  smpSubAssign( ~lhs, rhs.rhs_ );
403  }
404  }
406  //**********************************************************************************************
407 
408  //**Addition assignment to sparse matrices******************************************************
409  // No special implementation for the addition assignment to sparse matrices.
410  //**********************************************************************************************
411 
412  //**Subtraction assignment to dense matrices****************************************************
425  template< typename MT // Type of the target dense matrix
426  , bool SO2 > // Storage order of the target dense matrix
427  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& 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  // In case non of the two dense operands requires an intermediate evaluation, the
435  // addition expression is assigned directly in a cache-efficient manner.
436  if( !RequiresEvaluation<MT1>::value && !RequiresEvaluation<MT2>::value )
437  {
438  const size_t m( rhs.rows() );
439  const size_t n( rhs.columns() );
440  const size_t block( 16UL );
441 
442  for( size_t ii=0UL; ii<m; ii+=block ) {
443  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
444  for( size_t jj=0UL; jj<n; jj+=block ) {
445  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
446  for( size_t i=ii; i<iend; ++i ) {
447  for( size_t j=jj; j<jend; ++j ) {
448  (~lhs)(i,j) -= rhs.lhs_(i,j) - rhs.rhs_(i,j);
449  }
450  }
451  }
452  }
453  }
454 
455  // In case either of the two dense operands requires an intermediate evaluation, the
456  // expression is evaluated in a two-step approach.
457  else
458  {
459  smpSubAssign( ~lhs, rhs.lhs_ );
460  smpAddAssign( ~lhs, rhs.rhs_ );
461  }
462  }
464  //**********************************************************************************************
465 
466  //**Subtraction assignment to sparse matrices***************************************************
467  // No special implementation for the subtraction assignment to sparse matrices.
468  //**********************************************************************************************
469 
470  //**Multiplication assignment to dense matrices*************************************************
471  // No special implementation for the multiplication assignment to dense matrices.
472  //**********************************************************************************************
473 
474  //**Multiplication assignment to sparse matrices************************************************
475  // No special implementation for the multiplication assignment to sparse matrices.
476  //**********************************************************************************************
477 
478  //**Compile time checks*************************************************************************
484  //**********************************************************************************************
485 };
486 //*************************************************************************************************
487 
488 
489 
490 
491 //=================================================================================================
492 //
493 // GLOBAL BINARY ARITHMETIC OPERATORS
494 //
495 //=================================================================================================
496 
497 //*************************************************************************************************
526 template< typename T1 // Type of the left-hand side dense matrix
527  , typename T2 > // Type of the right-hand side dense matrix
528 inline const DMatTDMatSubExpr<T1,T2>
530 {
532 
533  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
534  throw std::invalid_argument( "Matrix sizes do not match" );
535 
536  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
537 }
538 //*************************************************************************************************
539 
540 
541 //*************************************************************************************************
570 template< typename T1 // Type of the left-hand side dense matrix
571  , typename T2 > // Type of the right-hand side dense matrix
572 inline const DMatTDMatSubExpr<T1,T2>
574 {
576 
577  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
578  throw std::invalid_argument( "Matrix sizes do not match" );
579 
580  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
581 }
582 //*************************************************************************************************
583 
584 
585 
586 
587 //=================================================================================================
588 //
589 // EXPRESSION TRAIT SPECIALIZATIONS
590 //
591 //=================================================================================================
592 
593 //*************************************************************************************************
595 template< typename MT1, typename MT2, bool AF >
596 struct SubmatrixExprTrait< DMatTDMatSubExpr<MT1,MT2>, AF >
597 {
598  public:
599  //**********************************************************************************************
600  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
601  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
602  //**********************************************************************************************
603 };
605 //*************************************************************************************************
606 
607 
608 //*************************************************************************************************
610 template< typename MT1, typename MT2 >
611 struct RowExprTrait< DMatTDMatSubExpr<MT1,MT2> >
612 {
613  public:
614  //**********************************************************************************************
615  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
616  , typename RowExprTrait<const MT2>::Type >::Type Type;
617  //**********************************************************************************************
618 };
620 //*************************************************************************************************
621 
622 
623 //*************************************************************************************************
625 template< typename MT1, typename MT2 >
626 struct ColumnExprTrait< DMatTDMatSubExpr<MT1,MT2> >
627 {
628  public:
629  //**********************************************************************************************
630  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
631  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
632  //**********************************************************************************************
633 };
635 //*************************************************************************************************
636 
637 } // namespace blaze
638 
639 #endif
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:94
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatTDMatSubExpr.h:217
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
Header file for the subtraction trait.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:117
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:151
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
#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
Header file for the ColumnExprTrait class template.
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatTDMatSubExpr.h:109
Header file for the sparse matrix SMP implementation.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:258
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:95
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:93
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:104
Constraint on the data type.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:121
const size_t SMP_DMATTDMATSUB_THRESHOLD
SMP row-major dense matrix/column-major dense matrix subtraction threshold.This threshold represents ...
Definition: Thresholds.h:407
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:92
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:121
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
Expression object for dense matrix-transpose dense matrix subtractions.The DMatTDMatSubExpr class rep...
Definition: DMatTDMatSubExpr.h:85
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTDMatSubExpr.h:124
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the IsTemporary type trait class.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:91
Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a...
Definition: MatMatSubExpr.h:65
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: StorageOrder.h:161
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatTDMatSubExpr.h:230
Header file for the dense matrix SMP implementation.
Header file for the DenseMatrix base class.
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
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatTDMatSubExpr.h:118
Header file for the MatMatSubExpr base class.
DMatTDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatTDMatSubExpr class.
Definition: DMatTDMatSubExpr.h:147
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:259
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:115
#define BLAZE_CONSTRAINT_MUST_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:78
Constraints on the storage order of matrix types.
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:103
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:325
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTDMatSubExpr.h:240
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:96
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:91
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: StorageOrder.h:81
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2383
Header file for run time assertion macros.
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
DMatTDMatSubExpr< MT1, MT2 > This
Type of this DMatTDMatSubExpr instance.
Definition: DMatTDMatSubExpr.h:114
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTDMatSubExpr.h:163
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatTDMatSubExpr.h:175
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:127
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:283
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:130
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
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatTDMatSubExpr.h:195
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2379
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: DMatTDMatSubExpr.h:205
Header file for basic type definitions.
Base template for the SubTrait class.
Definition: SubTrait.h:141
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTDMatSubExpr.h:116
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatTDMatSubExpr.h:250
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatTDMatSubExpr.h:185
Header file for the SubExprTrait class template.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
size_t rows(const Matrix< MT, SO > &m)
Returns the current number of rows of the matrix.
Definition: Matrix.h:138
#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
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:87
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.