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>
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 SMATEVALEXPR
74 //
75 //=================================================================================================
76 
77 //*************************************************************************************************
84 template< typename MT // Type of the sparse matrix
85  , bool SO > // Storage order
86 class SMatEvalExpr : public SparseMatrix< SMatEvalExpr<MT,SO>, SO >
87  , private MatEvalExpr
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 { smpAssignable = MT::smpAssignable };
109  //**********************************************************************************************
110 
111  //**Constructor*********************************************************************************
116  explicit inline SMatEvalExpr( const MT& sm )
117  : sm_( sm ) // Sparse matrix of the evaluation expression
118  {}
119  //**********************************************************************************************
120 
121  //**Access operator*****************************************************************************
128  inline ReturnType operator()( size_t i, size_t j ) const {
129  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
130  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
131  return sm_(i,j);
132  }
133  //**********************************************************************************************
134 
135  //**Rows function*******************************************************************************
140  inline size_t rows() const {
141  return sm_.rows();
142  }
143  //**********************************************************************************************
144 
145  //**Columns function****************************************************************************
150  inline size_t columns() const {
151  return sm_.columns();
152  }
153  //**********************************************************************************************
154 
155  //**NonZeros function***************************************************************************
160  inline size_t nonZeros() const {
161  return sm_.nonZeros();
162  }
163  //**********************************************************************************************
164 
165  //**NonZeros function***************************************************************************
171  inline size_t nonZeros( size_t i ) const {
172  return sm_.nonZeros(i);
173  }
174  //**********************************************************************************************
175 
176  //**Operand access******************************************************************************
181  inline Operand operand() const {
182  return sm_;
183  }
184  //**********************************************************************************************
185 
186  //**********************************************************************************************
192  template< typename T >
193  inline bool canAlias( const T* alias ) const {
194  return sm_.canAlias( alias );
195  }
196  //**********************************************************************************************
197 
198  //**********************************************************************************************
204  template< typename T >
205  inline bool isAliased( const T* alias ) const {
206  return sm_.isAliased( alias );
207  }
208  //**********************************************************************************************
209 
210  //**********************************************************************************************
215  inline bool canSMPAssign() const {
216  return sm_.canSMPAssign();
217  }
218  //**********************************************************************************************
219 
220  private:
221  //**Member variables****************************************************************************
223  //**********************************************************************************************
224 
225  //**Assignment to dense matrices****************************************************************
237  template< typename MT2 // Type of the target dense matrix
238  , bool SO2 > // Storage order of the target dense matrix
239  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
240  {
242 
243  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
244  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
245 
246  assign( ~lhs, rhs.sm_ );
247  }
249  //**********************************************************************************************
250 
251  //**Assignment to sparse matrices***************************************************************
263  template< typename MT2 // Type of the target sparse matrix
264  , bool SO2 > // Storage order of the target sparse matrix
265  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
266  {
268 
269  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
270  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
271 
272  assign( ~lhs, rhs.sm_ );
273  }
275  //**********************************************************************************************
276 
277  //**Addition assignment to dense matrices*******************************************************
289  template< typename MT2 // Type of the target dense matrix
290  , bool SO2 > // Storage order of the target dense matrix
291  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
292  {
294 
295  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
296  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
297 
298  addAssign( ~lhs, rhs.sm_ );
299  }
301  //**********************************************************************************************
302 
303  //**Addition assignment to sparse matrices******************************************************
315  template< typename MT2 // Type of the target sparse matrix
316  , bool SO2 > // Storage order of the target sparse matrix
317  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
318  {
320 
321  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
322  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
323 
324  addAssign( ~lhs, rhs.sm_ );
325  }
327  //**********************************************************************************************
328 
329  //**Subtraction assignment to dense matrices****************************************************
341  template< typename MT2 // Type of the target dense matrix
342  , bool SO2 > // Storage order of the target dense matrix
343  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
344  {
346 
347  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
348  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
349 
350  subAssign( ~lhs, rhs.sm_ );
351  }
353  //**********************************************************************************************
354 
355  //**Subtraction assignment to sparse matrices***************************************************
367  template< typename MT2 // Type of the target sparse matrix
368  , bool SO2 > // Storage order of the target sparse matrix
369  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& 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  subAssign( ~lhs, rhs.sm_ );
377  }
379  //**********************************************************************************************
380 
381  //**Multiplication assignment to dense matrices*************************************************
393  template< typename MT2 // Type of the target dense matrix
394  , bool SO2 > // Storage order of the target dense matrix
395  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
396  {
398 
399  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
400  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
401 
402  multAssign( ~lhs, rhs.sm_ );
403  }
405  //**********************************************************************************************
406 
407  //**Multiplication assignment to sparse matrices************************************************
419  template< typename MT2 // Type of the target sparse matrix
420  , bool SO2 > // Storage order of the target sparse matrix
421  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
422  {
424 
425  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
426  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
427 
428  multAssign( ~lhs, rhs.sm_ );
429  }
431  //**********************************************************************************************
432 
433  //**SMP assignment to dense matrices************************************************************
445  template< typename MT2 // Type of the target dense matrix
446  , bool SO2 > // Storage order of the target dense matrix
447  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
448  {
450 
451  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
452  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
453 
454  smpAssign( ~lhs, rhs.sm_ );
455  }
457  //**********************************************************************************************
458 
459  //**SMP assignment to sparse matrices***********************************************************
471  template< typename MT2 // Type of the target sparse matrix
472  , bool SO2 > // Storage order of the target sparse matrix
473  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
474  {
476 
477  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
478  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
479 
480  smpAssign( ~lhs, rhs.sm_ );
481  }
483  //**********************************************************************************************
484 
485  //**SMP addition assignment to dense matrices***************************************************
497  template< typename MT2 // Type of the target dense matrix
498  , bool SO2 > // Storage order of the target dense matrix
499  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
500  {
502 
503  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
504  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
505 
506  smpAddAssign( ~lhs, rhs.sm_ );
507  }
509  //**********************************************************************************************
510 
511  //**SMP addition assignment to sparse matrices**************************************************
523  template< typename MT2 // Type of the target sparse matrix
524  , bool SO2 > // Storage order of the target sparse matrix
525  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
526  {
528 
529  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
530  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
531 
532  smpAddAssign( ~lhs, rhs.sm_ );
533  }
535  //**********************************************************************************************
536 
537  //**SMP subtraction assignment to dense matrices************************************************
549  template< typename MT2 // Type of the target dense matrix
550  , bool SO2 > // Storage order of the target dense matrix
551  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
552  {
554 
555  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
556  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
557 
558  smpSubAssign( ~lhs, rhs.sm_ );
559  }
561  //**********************************************************************************************
562 
563  //**SMP subtraction assignment to sparse matrices***********************************************
575  template< typename MT2 // Type of the target sparse matrix
576  , bool SO2 > // Storage order of the target sparse matrix
577  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
578  {
580 
581  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
582  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
583 
584  smpSubAssign( ~lhs, rhs.sm_ );
585  }
587  //**********************************************************************************************
588 
589  //**SMP multiplication assignment to dense matrices*********************************************
602  template< typename MT2 // Type of the target dense matrix
603  , bool SO2 > // Storage order of the target dense matrix
604  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
605  {
607 
608  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
609  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
610 
611  smpMultAssign( ~lhs, rhs.sm_ );
612  }
614  //**********************************************************************************************
615 
616  //**SMP multiplication assignment to sparse matrices********************************************
629  template< typename MT2 // Type of the target sparse matrix
630  , bool SO2 > // Storage order of the target sparse matrix
631  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
632  {
634 
635  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
636  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
637 
638  smpMultAssign( ~lhs, rhs.sm_ );
639  }
641  //**********************************************************************************************
642 
643  //**Compile time checks*************************************************************************
648  //**********************************************************************************************
649 };
650 //*************************************************************************************************
651 
652 
653 
654 
655 //=================================================================================================
656 //
657 // GLOBAL FUNCTIONS
658 //
659 //=================================================================================================
660 
661 //*************************************************************************************************
678 template< typename MT // Type of the sparse matrix
679  , bool SO > // Storage order
681 {
683 
684  return SMatEvalExpr<MT,SO>( ~sm );
685 }
686 //*************************************************************************************************
687 
688 
689 
690 
691 //=================================================================================================
692 //
693 // GLOBAL RESTRUCTURING FUNCTIONS
694 //
695 //=================================================================================================
696 
697 //*************************************************************************************************
708 template< typename MT // Type of the sparse matrix
709  , bool SO > // Storage order
710 inline const SMatEvalExpr<MT,SO> eval( const SMatEvalExpr<MT,SO>& sm )
711 {
712  return sm;
713 }
715 //*************************************************************************************************
716 
717 
718 
719 
720 //=================================================================================================
721 //
722 // EXPRESSION TRAIT SPECIALIZATIONS
723 //
724 //=================================================================================================
725 
726 //*************************************************************************************************
728 template< typename MT >
729 struct SMatEvalExprTrait< SMatEvalExpr<MT,false> >
730 {
731  public:
732  //**********************************************************************************************
733  typedef typename SelectType< IsSparseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
734  , SMatEvalExpr<MT,false>
735  , INVALID_TYPE >::Type Type;
736  //**********************************************************************************************
737 };
739 //*************************************************************************************************
740 
741 
742 //*************************************************************************************************
744 template< typename MT >
745 struct TSMatEvalExprTrait< SMatEvalExpr<MT,true> >
746 {
747  public:
748  //**********************************************************************************************
749  typedef typename SelectType< IsSparseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
750  , SMatEvalExpr<MT,true>
751  , INVALID_TYPE >::Type Type;
752  //**********************************************************************************************
753 };
755 //*************************************************************************************************
756 
757 
758 //*************************************************************************************************
760 template< typename MT, bool SO, bool AF >
761 struct SubmatrixExprTrait< SMatEvalExpr<MT,SO>, AF >
762 {
763  public:
764  //**********************************************************************************************
765  typedef typename EvalExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
766  //**********************************************************************************************
767 };
769 //*************************************************************************************************
770 
771 
772 //*************************************************************************************************
774 template< typename MT, bool SO >
775 struct RowExprTrait< SMatEvalExpr<MT,SO> >
776 {
777  public:
778  //**********************************************************************************************
779  typedef typename EvalExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
780  //**********************************************************************************************
781 };
783 //*************************************************************************************************
784 
785 
786 //*************************************************************************************************
788 template< typename MT, bool SO >
789 struct ColumnExprTrait< SMatEvalExpr<MT,SO> >
790 {
791  public:
792  //**********************************************************************************************
793  typedef typename EvalExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
794  //**********************************************************************************************
795 };
797 //*************************************************************************************************
798 
799 } // namespace blaze
800 
801 #endif
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatEvalExpr.h:94
SMatEvalExpr< MT, SO > This
Type of this SMatEvalExpr instance.
Definition: SMatEvalExpr.h:92
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatEvalExpr.h:150
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
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:179
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:181
Header file for the MatEvalExpr base class.
MT::ElementType ElementType
Resulting element type.
Definition: SMatEvalExpr.h:96
Header file for the Computation base class.
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
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the sparse matrix expression.
Definition: SMatEvalExpr.h:103
Constraint on the data type.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatEvalExpr.h:100
Header file for the SparseMatrix base class.
Constraint on the data type.
Operand sm_
Sparse matrix of the evaluation expression.
Definition: SMatEvalExpr.h:222
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
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatEvalExpr.h:215
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
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
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatEvalExpr.h:171
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
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: SMatEvalExpr.h:93
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:205
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatEvalExpr.h:193
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
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2407
SMatEvalExpr(const MT &sm)
Constructor for the SMatEvalExpr class.
Definition: SMatEvalExpr.h:116
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:301
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:331
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:672
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatEvalExpr.h:160
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatEvalExpr.h:128
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:97
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2403
Header file for basic type definitions.
Expression object for the forced evaluation of sparse matrices.The SMatEvalExpr class represents the ...
Definition: Forward.h:92
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatEvalExpr.h:95
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatEvalExpr.h:140
#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.