All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatEvalExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATEVALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATEVALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <cmath>
63 #include <blaze/util/Assert.h>
65 #include <blaze/util/EnableIf.h>
66 #include <blaze/util/InvalidType.h>
68 #include <blaze/util/SelectType.h>
69 #include <blaze/util/Types.h>
70 
71 
72 namespace blaze {
73 
74 //=================================================================================================
75 //
76 // CLASS SMATEVALEXPR
77 //
78 //=================================================================================================
79 
80 //*************************************************************************************************
87 template< typename MT // Type of the sparse matrix
88  , bool SO > // Storage order
89 class SMatEvalExpr : public SparseMatrix< SMatEvalExpr<MT,SO>, SO >
90  , private MatEvalExpr
91  , private Computation
92 {
93  public:
94  //**Type definitions****************************************************************************
96  typedef typename MT::ResultType ResultType;
97  typedef typename MT::OppositeType OppositeType;
98  typedef typename MT::TransposeType TransposeType;
99  typedef typename MT::ElementType ElementType;
100  typedef typename MT::ReturnType ReturnType;
101 
103  typedef const ResultType CompositeType;
104 
106  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type Operand;
107  //**********************************************************************************************
108 
109  //**Compilation flags***************************************************************************
111  enum { smpAssignable = MT::smpAssignable };
112  //**********************************************************************************************
113 
114  //**Constructor*********************************************************************************
119  explicit inline SMatEvalExpr( const MT& sm )
120  : sm_( sm ) // Sparse matrix of the evaluation expression
121  {}
122  //**********************************************************************************************
123 
124  //**Access operator*****************************************************************************
131  inline ReturnType operator()( size_t i, size_t j ) const {
132  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
133  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
134  return sm_(i,j);
135  }
136  //**********************************************************************************************
137 
138  //**Rows function*******************************************************************************
143  inline size_t rows() const {
144  return sm_.rows();
145  }
146  //**********************************************************************************************
147 
148  //**Columns function****************************************************************************
153  inline size_t columns() const {
154  return sm_.columns();
155  }
156  //**********************************************************************************************
157 
158  //**NonZeros function***************************************************************************
163  inline size_t nonZeros() const {
164  return sm_.nonZeros();
165  }
166  //**********************************************************************************************
167 
168  //**NonZeros function***************************************************************************
174  inline size_t nonZeros( size_t i ) const {
175  return sm_.nonZeros(i);
176  }
177  //**********************************************************************************************
178 
179  //**Operand access******************************************************************************
184  inline Operand operand() const {
185  return sm_;
186  }
187  //**********************************************************************************************
188 
189  //**********************************************************************************************
195  template< typename T >
196  inline bool canAlias( const T* alias ) const {
197  return sm_.canAlias( alias );
198  }
199  //**********************************************************************************************
200 
201  //**********************************************************************************************
207  template< typename T >
208  inline bool isAliased( const T* alias ) const {
209  return sm_.isAliased( alias );
210  }
211  //**********************************************************************************************
212 
213  //**********************************************************************************************
218  inline bool canSMPAssign() const {
219  return sm_.canSMPAssign();
220  }
221  //**********************************************************************************************
222 
223  private:
224  //**Member variables****************************************************************************
226  //**********************************************************************************************
227 
228  //**Assignment to dense matrices****************************************************************
240  template< typename MT2 // Type of the target dense matrix
241  , bool SO2 > // Storage order of the target dense matrix
242  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
243  {
245 
246  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
247  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
248 
249  assign( ~lhs, rhs.sm_ );
250  }
252  //**********************************************************************************************
253 
254  //**Assignment to sparse matrices***************************************************************
266  template< typename MT2 // Type of the target sparse matrix
267  , bool SO2 > // Storage order of the target sparse matrix
268  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
269  {
271 
272  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
273  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
274 
275  assign( ~lhs, rhs.sm_ );
276  }
278  //**********************************************************************************************
279 
280  //**Addition assignment to dense matrices*******************************************************
292  template< typename MT2 // Type of the target dense matrix
293  , bool SO2 > // Storage order of the target dense matrix
294  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
295  {
297 
298  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
299  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
300 
301  addAssign( ~lhs, rhs.sm_ );
302  }
304  //**********************************************************************************************
305 
306  //**Addition assignment to sparse matrices******************************************************
318  template< typename MT2 // Type of the target sparse matrix
319  , bool SO2 > // Storage order of the target sparse matrix
320  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
321  {
323 
324  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
325  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
326 
327  addAssign( ~lhs, rhs.sm_ );
328  }
330  //**********************************************************************************************
331 
332  //**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 SMatEvalExpr& 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.sm_ );
354  }
356  //**********************************************************************************************
357 
358  //**Subtraction assignment to sparse matrices***************************************************
370  template< typename MT2 // Type of the target sparse matrix
371  , bool SO2 > // Storage order of the target sparse matrix
372  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
373  {
375 
376  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
377  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
378 
379  subAssign( ~lhs, rhs.sm_ );
380  }
382  //**********************************************************************************************
383 
384  //**Multiplication assignment to dense matrices*************************************************
396  template< typename MT2 // Type of the target dense matrix
397  , bool SO2 > // Storage order of the target dense matrix
398  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
399  {
401 
402  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
403  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
404 
405  multAssign( ~lhs, rhs.sm_ );
406  }
408  //**********************************************************************************************
409 
410  //**Multiplication assignment to sparse matrices************************************************
422  template< typename MT2 // Type of the target sparse matrix
423  , bool SO2 > // Storage order of the target sparse matrix
424  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
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  multAssign( ~lhs, rhs.sm_ );
432  }
434  //**********************************************************************************************
435 
436  //**SMP assignment to dense matrices************************************************************
448  template< typename MT2 // Type of the target dense matrix
449  , bool SO2 > // Storage order of the target dense matrix
450  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
451  {
453 
454  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
455  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
456 
457  smpAssign( ~lhs, rhs.sm_ );
458  }
460  //**********************************************************************************************
461 
462  //**SMP assignment to sparse matrices***********************************************************
474  template< typename MT2 // Type of the target sparse matrix
475  , bool SO2 > // Storage order of the target sparse matrix
476  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
477  {
479 
480  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
481  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
482 
483  smpAssign( ~lhs, rhs.sm_ );
484  }
486  //**********************************************************************************************
487 
488  //**SMP addition assignment to dense matrices***************************************************
500  template< typename MT2 // Type of the target dense matrix
501  , bool SO2 > // Storage order of the target dense matrix
502  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
503  {
505 
506  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
507  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
508 
509  smpAddAssign( ~lhs, rhs.sm_ );
510  }
512  //**********************************************************************************************
513 
514  //**SMP addition assignment to sparse matrices**************************************************
526  template< typename MT2 // Type of the target sparse matrix
527  , bool SO2 > // Storage order of the target sparse matrix
528  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
529  {
531 
532  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
533  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
534 
535  smpAddAssign( ~lhs, rhs.sm_ );
536  }
538  //**********************************************************************************************
539 
540  //**SMP subtraction assignment to dense matrices************************************************
552  template< typename MT2 // Type of the target dense matrix
553  , bool SO2 > // Storage order of the target dense matrix
554  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
555  {
557 
558  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
559  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
560 
561  smpSubAssign( ~lhs, rhs.sm_ );
562  }
564  //**********************************************************************************************
565 
566  //**SMP subtraction assignment to sparse matrices***********************************************
578  template< typename MT2 // Type of the target sparse matrix
579  , bool SO2 > // Storage order of the target sparse matrix
580  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
581  {
583 
584  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
585  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
586 
587  smpSubAssign( ~lhs, rhs.sm_ );
588  }
590  //**********************************************************************************************
591 
592  //**SMP multiplication assignment to dense matrices*********************************************
605  template< typename MT2 // Type of the target dense matrix
606  , bool SO2 > // Storage order of the target dense matrix
607  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
608  {
610 
611  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
612  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
613 
614  smpMultAssign( ~lhs, rhs.sm_ );
615  }
617  //**********************************************************************************************
618 
619  //**SMP multiplication assignment to sparse matrices********************************************
632  template< typename MT2 // Type of the target sparse matrix
633  , bool SO2 > // Storage order of the target sparse matrix
634  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
635  {
637 
638  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
639  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
640 
641  smpMultAssign( ~lhs, rhs.sm_ );
642  }
644  //**********************************************************************************************
645 
646  //**Compile time checks*************************************************************************
651  //**********************************************************************************************
652 };
653 //*************************************************************************************************
654 
655 
656 
657 
658 //=================================================================================================
659 //
660 // GLOBAL FUNCTIONS
661 //
662 //=================================================================================================
663 
664 //*************************************************************************************************
681 template< typename MT // Type of the sparse matrix
682  , bool SO > // Storage order
684 {
686 
687  return SMatEvalExpr<MT,SO>( ~sm );
688 }
689 //*************************************************************************************************
690 
691 
692 
693 
694 //=================================================================================================
695 //
696 // GLOBAL RESTRUCTURING FUNCTIONS
697 //
698 //=================================================================================================
699 
700 //*************************************************************************************************
711 template< typename MT // Type of the sparse matrix
712  , bool SO > // Storage order
713 inline const SMatEvalExpr<MT,SO> eval( const SMatEvalExpr<MT,SO>& sm )
714 {
715  return sm;
716 }
718 //*************************************************************************************************
719 
720 
721 
722 
723 //=================================================================================================
724 //
725 // EXPRESSION TRAIT SPECIALIZATIONS
726 //
727 //=================================================================================================
728 
729 //*************************************************************************************************
731 template< typename MT >
732 struct SMatEvalExprTrait< SMatEvalExpr<MT,false> >
733 {
734  public:
735  //**********************************************************************************************
736  typedef typename SelectType< IsSparseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
737  , SMatEvalExpr<MT,false>
738  , INVALID_TYPE >::Type Type;
739  //**********************************************************************************************
740 };
742 //*************************************************************************************************
743 
744 
745 //*************************************************************************************************
747 template< typename MT >
748 struct TSMatEvalExprTrait< SMatEvalExpr<MT,true> >
749 {
750  public:
751  //**********************************************************************************************
752  typedef typename SelectType< IsSparseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
753  , SMatEvalExpr<MT,true>
754  , INVALID_TYPE >::Type Type;
755  //**********************************************************************************************
756 };
758 //*************************************************************************************************
759 
760 
761 //*************************************************************************************************
763 template< typename MT, bool SO, bool AF >
764 struct SubmatrixExprTrait< SMatEvalExpr<MT,SO>, AF >
765 {
766  public:
767  //**********************************************************************************************
768  typedef typename EvalExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
769  //**********************************************************************************************
770 };
772 //*************************************************************************************************
773 
774 
775 //*************************************************************************************************
777 template< typename MT, bool SO >
778 struct RowExprTrait< SMatEvalExpr<MT,SO> >
779 {
780  public:
781  //**********************************************************************************************
782  typedef typename EvalExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
783  //**********************************************************************************************
784 };
786 //*************************************************************************************************
787 
788 
789 //*************************************************************************************************
791 template< typename MT, bool SO >
792 struct ColumnExprTrait< SMatEvalExpr<MT,SO> >
793 {
794  public:
795  //**********************************************************************************************
796  typedef typename EvalExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
797  //**********************************************************************************************
798 };
800 //*************************************************************************************************
801 
802 } // namespace blaze
803 
804 #endif
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatEvalExpr.h:97
SMatEvalExpr< MT, SO > This
Type of this SMatEvalExpr instance.
Definition: SMatEvalExpr.h:95
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatEvalExpr.h:153
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
Header file for the IsSparseMatrix type trait.
#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
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:178
Header file for the ColumnExprTrait class template.
Header file for the TSMatEvalExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
Operand operand() const
Returns the sparse matrix operand.
Definition: SMatEvalExpr.h:184
Header file for the sparse matrix SMP implementation.
Header file for the MatEvalExpr base class.
MT::ElementType ElementType
Resulting element type.
Definition: SMatEvalExpr.h:99
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2380
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
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the sparse matrix expression.
Definition: SMatEvalExpr.h:106
Constraint on the data type.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatEvalExpr.h:103
Header file for the SparseMatrix base class.
Constraint on the data type.
Operand sm_
Sparse matrix of the evaluation expression.
Definition: SMatEvalExpr.h:225
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
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatEvalExpr.h:218
Header file for the SMatEvalExprTrait class template.
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 dense matrix SMP implementation.
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
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatEvalExpr.h:174
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2381
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2382
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:269
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: SMatEvalExpr.h:96
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 EnableIf class template.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatEvalExpr.h:208
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatEvalExpr.h:196
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.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2383
SMatEvalExpr(const MT &sm)
Constructor for the SMatEvalExpr class.
Definition: SMatEvalExpr.h:119
Header file for run time assertion macros.
Utility type for generic codes.
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
Header file for the EvalExprTrait class template.
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
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:584
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatEvalExpr.h:163
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatEvalExpr.h:131
Header file for the IsRowMajorMatrix type trait.
#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
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SMatEvalExpr.h:100
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2379
Header file for basic type definitions.
Expression object for the forced evaluation of sparse matrices.The SMatEvalExpr class represents the ...
Definition: Forward.h:90
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatEvalExpr.h:98
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatEvalExpr.h:143
#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
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.