All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatSerialExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATSERIALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATSERIALEXPR_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 SMATSERIALEXPR
74 //
75 //=================================================================================================
76 
77 //*************************************************************************************************
84 template< typename MT // Type of the sparse matrix
85  , bool SO > // Storage order
86 class SMatSerialExpr : public SparseMatrix< SMatSerialExpr<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 { smpAssignable = MT::smpAssignable };
109  //**********************************************************************************************
110 
111  //**Constructor*********************************************************************************
116  explicit inline SMatSerialExpr( const MT& sm )
117  : sm_( sm ) // Sparse matrix of the serial 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  //**Conversion operator*************************************************************************
191  inline operator Operand() const {
192  return sm_;
193  }
194  //**********************************************************************************************
195 
196  //**********************************************************************************************
202  template< typename T >
203  inline bool canAlias( const T* alias ) const {
204  return sm_.canAlias( alias );
205  }
206  //**********************************************************************************************
207 
208  //**********************************************************************************************
214  template< typename T >
215  inline bool isAliased( const T* alias ) const {
216  return sm_.isAliased( alias );
217  }
218  //**********************************************************************************************
219 
220  //**********************************************************************************************
225  inline bool canSMPAssign() const {
226  return sm_.canSMPAssign();
227  }
228  //**********************************************************************************************
229 
230  private:
231  //**Member variables****************************************************************************
233  //**********************************************************************************************
234 
235  //**Assignment to dense matrices****************************************************************
247  template< typename MT2 // Type of the target dense matrix
248  , bool SO2 > // Storage order of the target dense matrix
249  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
250  {
252 
253  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
254  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
255 
256  assign( ~lhs, rhs.sm_ );
257  }
259  //**********************************************************************************************
260 
261  //**Assignment to sparse matrices***************************************************************
273  template< typename MT2 // Type of the target sparse matrix
274  , bool SO2 > // Storage order of the target sparse matrix
275  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
276  {
278 
279  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
280  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
281 
282  assign( ~lhs, rhs.sm_ );
283  }
285  //**********************************************************************************************
286 
287  //**Addition assignment to dense matrices*******************************************************
299  template< typename MT2 // Type of the target dense matrix
300  , bool SO2 > // Storage order of the target dense matrix
301  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
302  {
304 
305  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
306  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
307 
308  addAssign( ~lhs, rhs.sm_ );
309  }
311  //**********************************************************************************************
312 
313  //**Addition assignment to sparse matrices******************************************************
325  template< typename MT2 // Type of the target sparse matrix
326  , bool SO2 > // Storage order of the target sparse matrix
327  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
328  {
330 
331  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
332  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
333 
334  addAssign( ~lhs, rhs.sm_ );
335  }
337  //**********************************************************************************************
338 
339  //**Subtraction assignment to dense matrices****************************************************
352  template< typename MT2 // Type of the target dense matrix
353  , bool SO2 > // Storage order of the target dense matrix
354  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
355  {
357 
358  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
359  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
360 
361  subAssign( ~lhs, rhs.sm_ );
362  }
364  //**********************************************************************************************
365 
366  //**Subtraction assignment to sparse matrices***************************************************
379  template< typename MT2 // Type of the target sparse matrix
380  , bool SO2 > // Storage order of the target sparse matrix
381  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
382  {
384 
385  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
386  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
387 
388  subAssign( ~lhs, rhs.sm_ );
389  }
391  //**********************************************************************************************
392 
393  //**Multiplication assignment to dense matrices*************************************************
406  template< typename MT2 // Type of the target dense matrix
407  , bool SO2 > // Storage order of the target dense matrix
408  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
409  {
411 
412  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
413  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
414 
415  multAssign( ~lhs, rhs.sm_ );
416  }
418  //**********************************************************************************************
419 
420  //**Multiplication assignment to sparse matrices************************************************
433  template< typename MT2 // Type of the target sparse matrix
434  , bool SO2 > // Storage order of the target sparse matrix
435  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
436  {
438 
439  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
440  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
441 
442  multAssign( ~lhs, rhs.sm_ );
443  }
445  //**********************************************************************************************
446 
447  //**SMP assignment to dense matrices************************************************************
459  template< typename MT2 // Type of the target dense matrix
460  , bool SO2 > // Storage order of the target dense matrix
461  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
462  {
464 
465  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
466  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
467 
468  assign( ~lhs, rhs.sm_ );
469  }
471  //**********************************************************************************************
472 
473  //**SMP assignment to sparse matrices***********************************************************
485  template< typename MT2 // Type of the target sparse matrix
486  , bool SO2 > // Storage order of the target sparse matrix
487  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
488  {
490 
491  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
492  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
493 
494  assign( ~lhs, rhs.sm_ );
495  }
497  //**********************************************************************************************
498 
499  //**SMP addition assignment to dense matrices***************************************************
512  template< typename MT2 // Type of the target dense matrix
513  , bool SO2 > // Storage order of the target dense matrix
514  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
515  {
517 
518  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
519  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
520 
521  addAssign( ~lhs, rhs.sm_ );
522  }
524  //**********************************************************************************************
525 
526  //**SMP addition assignment to sparse matrices**************************************************
539  template< typename MT2 // Type of the target sparse matrix
540  , bool SO2 > // Storage order of the target sparse matrix
541  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
542  {
544 
545  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
546  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
547 
548  addAssign( ~lhs, rhs.sm_ );
549  }
551  //**********************************************************************************************
552 
553  //**SMP subtraction assignment to dense matrices************************************************
566  template< typename MT2 // Type of the target dense matrix
567  , bool SO2 > // Storage order of the target dense matrix
568  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
569  {
571 
572  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
573  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
574 
575  subAssign( ~lhs, rhs.sm_ );
576  }
578  //**********************************************************************************************
579 
580  //**SMP subtraction assignment to sparse matrices***********************************************
593  template< typename MT2 // Type of the target sparse matrix
594  , bool SO2 > // Storage order of the target sparse matrix
595  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
596  {
598 
599  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
600  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
601 
602  subAssign( ~lhs, rhs.sm_ );
603  }
605  //**********************************************************************************************
606 
607  //**SMP multiplication assignment to dense matrices*********************************************
620  template< typename MT2 // Type of the target dense matrix
621  , bool SO2 > // Storage order of the target dense matrix
622  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
623  {
625 
626  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
627  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
628 
629  multAssign( ~lhs, rhs.sm_ );
630  }
632  //**********************************************************************************************
633 
634  //**SMP multiplication assignment to sparse matrices********************************************
647  template< typename MT2 // Type of the target sparse matrix
648  , bool SO2 > // Storage order of the target sparse matrix
649  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatSerialExpr& rhs )
650  {
652 
653  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
654  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
655 
656  multAssign( ~lhs, rhs.sm_ );
657  }
659  //**********************************************************************************************
660 
661  //**Compile time checks*************************************************************************
666  //**********************************************************************************************
667 };
668 //*************************************************************************************************
669 
670 
671 
672 
673 //=================================================================================================
674 //
675 // GLOBAL FUNCTIONS
676 //
677 //=================================================================================================
678 
679 //*************************************************************************************************
696 template< typename MT // Type of the sparse matrix
697  , bool SO > // Storage order
699 {
701 
702  return SMatSerialExpr<MT,SO>( ~sm );
703 }
704 //*************************************************************************************************
705 
706 
707 
708 
709 //=================================================================================================
710 //
711 // GLOBAL RESTRUCTURING FUNCTIONS
712 //
713 //=================================================================================================
714 
715 //*************************************************************************************************
726 template< typename MT // Type of the sparse matrix
727  , bool SO > // Storage order
728 inline const SMatSerialExpr<MT,SO> serial( const SMatSerialExpr<MT,SO>& sm )
729 {
730  return sm;
731 }
733 //*************************************************************************************************
734 
735 
736 
737 
738 //=================================================================================================
739 //
740 // EXPRESSION TRAIT SPECIALIZATIONS
741 //
742 //=================================================================================================
743 
744 //*************************************************************************************************
746 template< typename MT >
747 struct SMatSerialExprTrait< SMatSerialExpr<MT,false> >
748 {
749  public:
750  //**********************************************************************************************
751  typedef typename SelectType< IsSparseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
752  , SMatSerialExpr<MT,false>
753  , INVALID_TYPE >::Type Type;
754  //**********************************************************************************************
755 };
757 //*************************************************************************************************
758 
759 
760 //*************************************************************************************************
762 template< typename MT >
763 struct TSMatSerialExprTrait< SMatSerialExpr<MT,true> >
764 {
765  public:
766  //**********************************************************************************************
767  typedef typename SelectType< IsSparseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
768  , SMatSerialExpr<MT,true>
769  , INVALID_TYPE >::Type Type;
770  //**********************************************************************************************
771 };
773 //*************************************************************************************************
774 
775 
776 //*************************************************************************************************
778 template< typename MT, bool SO, bool AF >
779 struct SubmatrixExprTrait< SMatSerialExpr<MT,SO>, AF >
780 {
781  public:
782  //**********************************************************************************************
783  typedef typename SerialExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
784  //**********************************************************************************************
785 };
787 //*************************************************************************************************
788 
789 
790 //*************************************************************************************************
792 template< typename MT, bool SO >
793 struct RowExprTrait< SMatSerialExpr<MT,SO> >
794 {
795  public:
796  //**********************************************************************************************
797  typedef typename SerialExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
798  //**********************************************************************************************
799 };
801 //*************************************************************************************************
802 
803 
804 //*************************************************************************************************
806 template< typename MT, bool SO >
807 struct ColumnExprTrait< SMatSerialExpr<MT,SO> >
808 {
809  public:
810  //**********************************************************************************************
811  typedef typename SerialExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
812  //**********************************************************************************************
813 };
815 //*************************************************************************************************
816 
817 } // namespace blaze
818 
819 #endif
Header file for the SMatSerialExprTrait class template.
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
SMatSerialExpr(const MT &sm)
Constructor for the SMatSerialExpr class.
Definition: SMatSerialExpr.h:116
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.
SMatSerialExpr< MT, SO > This
Type of this SMatSerialExpr instance.
Definition: SMatSerialExpr.h:92
Header file for the IsColumnMajorMatrix type trait.
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatSerialExpr.h:95
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatSerialExpr.h:150
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::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SMatSerialExpr.h:97
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
Constraint on the data type.
Header file for the TSMatSerialExprTrait class template.
Header file for the SparseMatrix base class.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatSerialExpr.h:225
Constraint on the data type.
Operand operand() const
Returns the sparse matrix operand.
Definition: SMatSerialExpr.h:181
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatSerialExpr.h:203
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatSerialExpr.h:94
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatSerialExpr.h:100
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatSerialExpr.h:160
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatSerialExpr.h:140
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: SMatSerialExpr.h:93
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
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 MatSerialExpr base class.
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: SMatSerialExpr.h:215
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the sparse matrix expression.
Definition: SMatSerialExpr.h:103
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
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
MT::ElementType ElementType
Resulting element type.
Definition: SMatSerialExpr.h:96
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
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatSerialExpr.h:128
Operand sm_
Sparse matrix of the serial evaluation expression.
Definition: SMatSerialExpr.h:232
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2403
Header file for basic type definitions.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatSerialExpr.h:171
Expression object for the forced serial evaluation of sparse matrices.The SMatSerialExpr class repres...
Definition: Forward.h:95
#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.