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>
69 #include <blaze/util/Assert.h>
71 #include <blaze/util/InvalidType.h>
73 #include <blaze/util/SelectType.h>
74 #include <blaze/util/Types.h>
76 
77 
78 namespace blaze {
79 
80 //=================================================================================================
81 //
82 // CLASS SMATEVALEXPR
83 //
84 //=================================================================================================
85 
86 //*************************************************************************************************
93 template< typename MT // Type of the sparse matrix
94  , bool SO > // Storage order
95 class SMatEvalExpr : public SparseMatrix< SMatEvalExpr<MT,SO>, SO >
96  , private MatEvalExpr
97  , private Computation
98 {
99  public:
100  //**Type definitions****************************************************************************
102  typedef typename MT::ResultType ResultType;
103  typedef typename MT::OppositeType OppositeType;
104  typedef typename MT::TransposeType TransposeType;
105  typedef typename MT::ElementType ElementType;
106  typedef typename MT::ReturnType ReturnType;
107 
109  typedef const ResultType CompositeType;
110 
112  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type Operand;
113  //**********************************************************************************************
114 
115  //**Compilation flags***************************************************************************
117  enum { smpAssignable = MT::smpAssignable };
118  //**********************************************************************************************
119 
120  //**Constructor*********************************************************************************
125  explicit inline SMatEvalExpr( const MT& sm )
126  : sm_( sm ) // Sparse matrix of the evaluation expression
127  {}
128  //**********************************************************************************************
129 
130  //**Access operator*****************************************************************************
137  inline ReturnType operator()( size_t i, size_t j ) const {
138  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
139  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
140  return sm_(i,j);
141  }
142  //**********************************************************************************************
143 
144  //**Rows function*******************************************************************************
149  inline size_t rows() const {
150  return sm_.rows();
151  }
152  //**********************************************************************************************
153 
154  //**Columns function****************************************************************************
159  inline size_t columns() const {
160  return sm_.columns();
161  }
162  //**********************************************************************************************
163 
164  //**NonZeros function***************************************************************************
169  inline size_t nonZeros() const {
170  return sm_.nonZeros();
171  }
172  //**********************************************************************************************
173 
174  //**NonZeros function***************************************************************************
180  inline size_t nonZeros( size_t i ) const {
181  return sm_.nonZeros(i);
182  }
183  //**********************************************************************************************
184 
185  //**Operand access******************************************************************************
190  inline Operand operand() const {
191  return sm_;
192  }
193  //**********************************************************************************************
194 
195  //**********************************************************************************************
201  template< typename T >
202  inline bool canAlias( const T* alias ) const {
203  return sm_.canAlias( alias );
204  }
205  //**********************************************************************************************
206 
207  //**********************************************************************************************
213  template< typename T >
214  inline bool isAliased( const T* alias ) const {
215  return sm_.isAliased( alias );
216  }
217  //**********************************************************************************************
218 
219  //**********************************************************************************************
224  inline bool canSMPAssign() const {
225  return sm_.canSMPAssign();
226  }
227  //**********************************************************************************************
228 
229  private:
230  //**Member variables****************************************************************************
231  Operand sm_;
232  //**********************************************************************************************
233 
234  //**Assignment to dense matrices****************************************************************
246  template< typename MT2 // Type of the target dense matrix
247  , bool SO2 > // Storage order of the target dense matrix
248  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
249  {
251 
252  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
253  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
254 
255  assign( ~lhs, rhs.sm_ );
256  }
258  //**********************************************************************************************
259 
260  //**Assignment to sparse matrices***************************************************************
272  template< typename MT2 // Type of the target sparse matrix
273  , bool SO2 > // Storage order of the target sparse matrix
274  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
275  {
277 
278  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
279  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
280 
281  assign( ~lhs, rhs.sm_ );
282  }
284  //**********************************************************************************************
285 
286  //**Addition assignment to dense matrices*******************************************************
298  template< typename MT2 // Type of the target dense matrix
299  , bool SO2 > // Storage order of the target dense matrix
300  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
301  {
303 
304  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
305  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
306 
307  addAssign( ~lhs, rhs.sm_ );
308  }
310  //**********************************************************************************************
311 
312  //**Addition assignment to sparse matrices******************************************************
324  template< typename MT2 // Type of the target sparse matrix
325  , bool SO2 > // Storage order of the target sparse matrix
326  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
327  {
329 
330  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
331  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
332 
333  addAssign( ~lhs, rhs.sm_ );
334  }
336  //**********************************************************************************************
337 
338  //**Subtraction assignment to dense matrices****************************************************
350  template< typename MT2 // Type of the target dense matrix
351  , bool SO2 > // Storage order of the target dense matrix
352  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
353  {
355 
356  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
357  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
358 
359  subAssign( ~lhs, rhs.sm_ );
360  }
362  //**********************************************************************************************
363 
364  //**Subtraction assignment to sparse matrices***************************************************
376  template< typename MT2 // Type of the target sparse matrix
377  , bool SO2 > // Storage order of the target sparse matrix
378  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
379  {
381 
382  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
383  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
384 
385  subAssign( ~lhs, rhs.sm_ );
386  }
388  //**********************************************************************************************
389 
390  //**Multiplication assignment to dense matrices*************************************************
402  template< typename MT2 // Type of the target dense matrix
403  , bool SO2 > // Storage order of the target dense matrix
404  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
405  {
407 
408  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
409  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
410 
411  multAssign( ~lhs, rhs.sm_ );
412  }
414  //**********************************************************************************************
415 
416  //**Multiplication assignment to sparse matrices************************************************
428  template< typename MT2 // Type of the target sparse matrix
429  , bool SO2 > // Storage order of the target sparse matrix
430  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
431  {
433 
434  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
435  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
436 
437  multAssign( ~lhs, rhs.sm_ );
438  }
440  //**********************************************************************************************
441 
442  //**SMP assignment to dense matrices************************************************************
454  template< typename MT2 // Type of the target dense matrix
455  , bool SO2 > // Storage order of the target dense matrix
456  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
457  {
459 
460  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
461  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
462 
463  smpAssign( ~lhs, rhs.sm_ );
464  }
466  //**********************************************************************************************
467 
468  //**SMP assignment to sparse matrices***********************************************************
480  template< typename MT2 // Type of the target sparse matrix
481  , bool SO2 > // Storage order of the target sparse matrix
482  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
483  {
485 
486  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
487  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
488 
489  smpAssign( ~lhs, rhs.sm_ );
490  }
492  //**********************************************************************************************
493 
494  //**SMP addition assignment to dense matrices***************************************************
506  template< typename MT2 // Type of the target dense matrix
507  , bool SO2 > // Storage order of the target dense matrix
508  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
509  {
511 
512  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
513  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
514 
515  smpAddAssign( ~lhs, rhs.sm_ );
516  }
518  //**********************************************************************************************
519 
520  //**SMP addition assignment to sparse matrices**************************************************
532  template< typename MT2 // Type of the target sparse matrix
533  , bool SO2 > // Storage order of the target sparse matrix
534  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
535  {
537 
538  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
539  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
540 
541  smpAddAssign( ~lhs, rhs.sm_ );
542  }
544  //**********************************************************************************************
545 
546  //**SMP subtraction assignment to dense matrices************************************************
558  template< typename MT2 // Type of the target dense matrix
559  , bool SO2 > // Storage order of the target dense matrix
560  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
561  {
563 
564  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
565  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
566 
567  smpSubAssign( ~lhs, rhs.sm_ );
568  }
570  //**********************************************************************************************
571 
572  //**SMP subtraction assignment to sparse matrices***********************************************
584  template< typename MT2 // Type of the target sparse matrix
585  , bool SO2 > // Storage order of the target sparse matrix
586  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
587  {
589 
590  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
591  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
592 
593  smpSubAssign( ~lhs, rhs.sm_ );
594  }
596  //**********************************************************************************************
597 
598  //**SMP multiplication assignment to dense matrices*********************************************
611  template< typename MT2 // Type of the target dense matrix
612  , bool SO2 > // Storage order of the target dense matrix
613  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
614  {
616 
617  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
618  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
619 
620  smpMultAssign( ~lhs, rhs.sm_ );
621  }
623  //**********************************************************************************************
624 
625  //**SMP multiplication assignment to sparse matrices********************************************
638  template< typename MT2 // Type of the target sparse matrix
639  , bool SO2 > // Storage order of the target sparse matrix
640  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
641  {
643 
644  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
645  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
646 
647  smpMultAssign( ~lhs, rhs.sm_ );
648  }
650  //**********************************************************************************************
651 
652  //**Compile time checks*************************************************************************
657  //**********************************************************************************************
658 };
659 //*************************************************************************************************
660 
661 
662 
663 
664 //=================================================================================================
665 //
666 // GLOBAL FUNCTIONS
667 //
668 //=================================================================================================
669 
670 //*************************************************************************************************
687 template< typename MT // Type of the sparse matrix
688  , bool SO > // Storage order
690 {
692 
693  return SMatEvalExpr<MT,SO>( ~sm );
694 }
695 //*************************************************************************************************
696 
697 
698 
699 
700 //=================================================================================================
701 //
702 // GLOBAL RESTRUCTURING FUNCTIONS
703 //
704 //=================================================================================================
705 
706 //*************************************************************************************************
717 template< typename MT // Type of the sparse matrix
718  , bool SO > // Storage order
719 inline const SMatEvalExpr<MT,SO> eval( const SMatEvalExpr<MT,SO>& sm )
720 {
721  return sm;
722 }
724 //*************************************************************************************************
725 
726 
727 
728 
729 //=================================================================================================
730 //
731 // ROWS SPECIALIZATIONS
732 //
733 //=================================================================================================
734 
735 //*************************************************************************************************
737 template< typename MT, bool SO >
738 struct Rows< SMatEvalExpr<MT,SO> > : public Rows<MT>
739 {};
741 //*************************************************************************************************
742 
743 
744 
745 
746 //=================================================================================================
747 //
748 // COLUMNS SPECIALIZATIONS
749 //
750 //=================================================================================================
751 
752 //*************************************************************************************************
754 template< typename MT, bool SO >
755 struct Columns< SMatEvalExpr<MT,SO> > : public Columns<MT>
756 {};
758 //*************************************************************************************************
759 
760 
761 
762 
763 //=================================================================================================
764 //
765 // ISSYMMETRIC SPECIALIZATIONS
766 //
767 //=================================================================================================
768 
769 //*************************************************************************************************
771 template< typename MT, bool SO >
772 struct IsSymmetric< SMatEvalExpr<MT,SO> > : public IsTrue< IsSymmetric<MT>::value >
773 {};
775 //*************************************************************************************************
776 
777 
778 
779 
780 //=================================================================================================
781 //
782 // ISLOWER SPECIALIZATIONS
783 //
784 //=================================================================================================
785 
786 //*************************************************************************************************
788 template< typename MT, bool SO >
789 struct IsLower< SMatEvalExpr<MT,SO> > : public IsTrue< IsLower<MT>::value >
790 {};
792 //*************************************************************************************************
793 
794 
795 
796 
797 //=================================================================================================
798 //
799 // ISUNILOWER SPECIALIZATIONS
800 //
801 //=================================================================================================
802 
803 //*************************************************************************************************
805 template< typename MT, bool SO >
806 struct IsUniLower< SMatEvalExpr<MT,SO> > : public IsTrue< IsUniLower<MT>::value >
807 {};
809 //*************************************************************************************************
810 
811 
812 
813 
814 //=================================================================================================
815 //
816 // ISSTRICTLYLOWER SPECIALIZATIONS
817 //
818 //=================================================================================================
819 
820 //*************************************************************************************************
822 template< typename MT, bool SO >
823 struct IsStrictlyLower< SMatEvalExpr<MT,SO> > : public IsTrue< IsStrictlyLower<MT>::value >
824 {};
826 //*************************************************************************************************
827 
828 
829 
830 
831 //=================================================================================================
832 //
833 // ISUPPER SPECIALIZATIONS
834 //
835 //=================================================================================================
836 
837 //*************************************************************************************************
839 template< typename MT, bool SO >
840 struct IsUpper< SMatEvalExpr<MT,SO> > : public IsTrue< IsUpper<MT>::value >
841 {};
843 //*************************************************************************************************
844 
845 
846 
847 
848 //=================================================================================================
849 //
850 // ISUNIUPPER SPECIALIZATIONS
851 //
852 //=================================================================================================
853 
854 //*************************************************************************************************
856 template< typename MT, bool SO >
857 struct IsUniUpper< SMatEvalExpr<MT,SO> > : public IsTrue< IsUniUpper<MT>::value >
858 {};
860 //*************************************************************************************************
861 
862 
863 
864 
865 //=================================================================================================
866 //
867 // ISSTRICTLYUPPER SPECIALIZATIONS
868 //
869 //=================================================================================================
870 
871 //*************************************************************************************************
873 template< typename MT, bool SO >
874 struct IsStrictlyUpper< SMatEvalExpr<MT,SO> > : public IsTrue< IsStrictlyUpper<MT>::value >
875 {};
877 //*************************************************************************************************
878 
879 
880 
881 
882 //=================================================================================================
883 //
884 // EXPRESSION TRAIT SPECIALIZATIONS
885 //
886 //=================================================================================================
887 
888 //*************************************************************************************************
890 template< typename MT >
891 struct SMatEvalExprTrait< SMatEvalExpr<MT,false> >
892 {
893  public:
894  //**********************************************************************************************
895  typedef typename SelectType< IsSparseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
896  , SMatEvalExpr<MT,false>
897  , INVALID_TYPE >::Type Type;
898  //**********************************************************************************************
899 };
901 //*************************************************************************************************
902 
903 
904 //*************************************************************************************************
906 template< typename MT >
907 struct TSMatEvalExprTrait< SMatEvalExpr<MT,true> >
908 {
909  public:
910  //**********************************************************************************************
911  typedef typename SelectType< IsSparseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
912  , SMatEvalExpr<MT,true>
913  , INVALID_TYPE >::Type Type;
914  //**********************************************************************************************
915 };
917 //*************************************************************************************************
918 
919 
920 //*************************************************************************************************
922 template< typename MT, bool SO, bool AF >
923 struct SubmatrixExprTrait< SMatEvalExpr<MT,SO>, AF >
924 {
925  public:
926  //**********************************************************************************************
927  typedef typename EvalExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
928  //**********************************************************************************************
929 };
931 //*************************************************************************************************
932 
933 
934 //*************************************************************************************************
936 template< typename MT, bool SO >
937 struct RowExprTrait< SMatEvalExpr<MT,SO> >
938 {
939  public:
940  //**********************************************************************************************
941  typedef typename EvalExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
942  //**********************************************************************************************
943 };
945 //*************************************************************************************************
946 
947 
948 //*************************************************************************************************
950 template< typename MT, bool SO >
951 struct ColumnExprTrait< SMatEvalExpr<MT,SO> >
952 {
953  public:
954  //**********************************************************************************************
955  typedef typename EvalExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
956  //**********************************************************************************************
957 };
959 //*************************************************************************************************
960 
961 } // namespace blaze
962 
963 #endif
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: SMatEvalExpr.h:106
BLAZE_ALWAYS_INLINE 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:879
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
Header file for basic type definitions.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatEvalExpr.h:159
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
Header file for the ColumnExprTrait class template.
Header file for the TSMatEvalExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
Header file for the MatEvalExpr base class.
Header file for the Computation base class.
Operand operand() const
Returns the sparse matrix operand.
Definition: SMatEvalExpr.h:190
Header file for the IsUniLower type trait.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2503
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.
SMatEvalExpr< MT, SO > This
Type of this SMatEvalExpr instance.
Definition: SMatEvalExpr.h:101
Header file for the SparseMatrix base class.
Constraint on the data type.
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 IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
BLAZE_ALWAYS_INLINE 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:635
Header file for the Columns type trait.
Header file for the IsLower type trait.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the sparse matrix expression.
Definition: SMatEvalExpr.h:112
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatEvalExpr.h:137
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2504
Constraints on the storage order of matrix types.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatEvalExpr.h:149
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatEvalExpr.h:180
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 IsStrictlyLower type trait.
Operand sm_
Sparse matrix of the evaluation expression.
Definition: SMatEvalExpr.h:231
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatEvalExpr.h:169
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
MT::ElementType ElementType
Resulting element type.
Definition: SMatEvalExpr.h:105
Utility type for generic codes.
BLAZE_ALWAYS_INLINE 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:742
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatEvalExpr.h:202
Header file for the EvalExprTrait class template.
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:681
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatEvalExpr.h:224
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatEvalExpr.h:109
Header file for the IsRowMajorMatrix type trait.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< 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:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
Header file for the IsTrue value trait.
Expression object for the forced evaluation of sparse matrices.The SMatEvalExpr class represents the ...
Definition: Forward.h:92
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatEvalExpr.h:214
SMatEvalExpr(const MT &sm)
Constructor for the SMatEvalExpr class.
Definition: SMatEvalExpr.h:125
Header file for the IsUpper type trait.
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: SMatEvalExpr.h:102
EnableIf< IsDenseVector< VT1 > >::Type smpMultAssign(Vector< 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:189
#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
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatEvalExpr.h:104
#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
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatEvalExpr.h:103
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE 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:849