All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatEvalExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATEVALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATEVALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <cmath>
65 #include <blaze/util/Assert.h>
67 #include <blaze/util/InvalidType.h>
69 #include <blaze/util/SelectType.h>
70 #include <blaze/util/Types.h>
72 
73 
74 namespace blaze {
75 
76 //=================================================================================================
77 //
78 // CLASS DMATEVALEXPR
79 //
80 //=================================================================================================
81 
82 //*************************************************************************************************
89 template< typename MT // Type of the dense matrix
90  , bool SO > // Storage order
91 class DMatEvalExpr : public DenseMatrix< DMatEvalExpr<MT,SO>, SO >
92  , private MatEvalExpr
93  , private Computation
94 {
95  public:
96  //**Type definitions****************************************************************************
98  typedef typename MT::ResultType ResultType;
99  typedef typename MT::OppositeType OppositeType;
100  typedef typename MT::TransposeType TransposeType;
101  typedef typename MT::ElementType ElementType;
102  typedef typename MT::ReturnType ReturnType;
103 
105  typedef const ResultType CompositeType;
106 
108  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type Operand;
109  //**********************************************************************************************
110 
111  //**Compilation flags***************************************************************************
113  enum { vectorizable = 0 };
114 
116  enum { smpAssignable = MT::smpAssignable };
117  //**********************************************************************************************
118 
119  //**Constructor*********************************************************************************
124  explicit inline DMatEvalExpr( const MT& dm )
125  : dm_( dm ) // Dense matrix of the evaluation expression
126  {}
127  //**********************************************************************************************
128 
129  //**Access operator*****************************************************************************
136  inline ReturnType operator()( size_t i, size_t j ) const {
137  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
138  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
139  return dm_(i,j);
140  }
141  //**********************************************************************************************
142 
143  //**Rows function*******************************************************************************
148  inline size_t rows() const {
149  return dm_.rows();
150  }
151  //**********************************************************************************************
152 
153  //**Columns function****************************************************************************
158  inline size_t columns() const {
159  return dm_.columns();
160  }
161  //**********************************************************************************************
162 
163  //**Operand access******************************************************************************
168  inline Operand operand() const {
169  return dm_;
170  }
171  //**********************************************************************************************
172 
173  //**********************************************************************************************
179  template< typename T >
180  inline bool canAlias( const T* alias ) const {
181  return dm_.canAlias( alias );
182  }
183  //**********************************************************************************************
184 
185  //**********************************************************************************************
191  template< typename T >
192  inline bool isAliased( const T* alias ) const {
193  return dm_.isAliased( alias );
194  }
195  //**********************************************************************************************
196 
197  //**********************************************************************************************
202  inline bool isAligned() const {
203  return dm_.isAligned();
204  }
205  //**********************************************************************************************
206 
207  //**********************************************************************************************
212  inline bool canSMPAssign() const {
213  return dm_.canSMPAssign();
214  }
215  //**********************************************************************************************
216 
217  private:
218  //**Member variables****************************************************************************
220  //**********************************************************************************************
221 
222  //**Assignment to dense matrices****************************************************************
234  template< typename MT2 // Type of the target dense matrix
235  , bool SO2 > // Storage order of the target dense matrix
236  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
237  {
239 
240  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
241  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
242 
243  assign( ~lhs, rhs.dm_ );
244  }
246  //**********************************************************************************************
247 
248  //**Assignment to sparse matrices***************************************************************
260  template< typename MT2 // Type of the target sparse matrix
261  , bool SO2 > // Storage order of the target dense matrix
262  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
263  {
265 
266  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
267  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
268 
269  assign( ~lhs, rhs.dm_ );
270  }
272  //**********************************************************************************************
273 
274  //**Addition assignment to dense matrices*******************************************************
286  template< typename MT2 // Type of the target dense matrix
287  , bool SO2 > // Storage order of the target dense matrix
288  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
289  {
291 
292  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
293  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
294 
295  addAssign( ~lhs, rhs.dm_ );
296  }
298  //**********************************************************************************************
299 
300  //**Addition assignment to sparse matrices******************************************************
312  template< typename MT2 // Type of the target sparse matrix
313  , bool SO2 > // Storage order of the target dense matrix
314  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
315  {
317 
318  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
319  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
320 
321  addAssign( ~lhs, rhs.dm_ );
322  }
324  //**********************************************************************************************
325 
326  //**Subtraction assignment to dense matrices****************************************************
338  template< typename MT2 // Type of the target dense matrix
339  , bool SO2 > // Storage order of the target dense matrix
340  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
341  {
343 
344  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
345  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
346 
347  subAssign( ~lhs, rhs.dm_ );
348  }
350  //**********************************************************************************************
351 
352  //**Subtraction assignment to sparse matrices***************************************************
364  template< typename MT2 // Type of the target sparse matrix
365  , bool SO2 > // Storage order of the target dense matrix
366  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
367  {
369 
370  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
371  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
372 
373  subAssign( ~lhs, rhs.dm_ );
374  }
376  //**********************************************************************************************
377 
378  //**Multiplication assignment to dense matrices*************************************************
390  template< typename MT2 // Type of the target dense matrix
391  , bool SO2 > // Storage order of the target dense matrix
392  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
393  {
395 
396  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
397  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
398 
399  multAssign( ~lhs, rhs.dm_ );
400  }
402  //**********************************************************************************************
403 
404  //**Multiplication assignment to sparse matrices************************************************
416  template< typename MT2 // Type of the target sparse matrix
417  , bool SO2 > // Storage order of the target dense matrix
418  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
419  {
421 
422  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
423  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
424 
425  multAssign( ~lhs, rhs.dm_ );
426  }
428  //**********************************************************************************************
429 
430  //**SMP assignment to dense matrices************************************************************
442  template< typename MT2 // Type of the target dense matrix
443  , bool SO2 > // Storage order of the target dense matrix
444  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
445  {
447 
448  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
449  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
450 
451  smpAssign( ~lhs, rhs.dm_ );
452  }
454  //**********************************************************************************************
455 
456  //**SMP assignment to sparse matrices***********************************************************
468  template< typename MT2 // Type of the target sparse matrix
469  , bool SO2 > // Storage order of the target dense matrix
470  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
471  {
473 
474  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
475  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
476 
477  smpAssign( ~lhs, rhs.dm_ );
478  }
480  //**********************************************************************************************
481 
482  //**SMP addition assignment to dense matrices***************************************************
494  template< typename MT2 // Type of the target dense matrix
495  , bool SO2 > // Storage order of the target dense matrix
496  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
497  {
499 
500  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
501  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
502 
503  smpAddAssign( ~lhs, rhs.dm_ );
504  }
506  //**********************************************************************************************
507 
508  //**SMP addition assignment to sparse matrices**************************************************
520  template< typename MT2 // Type of the target sparse matrix
521  , bool SO2 > // Storage order of the target dense matrix
522  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
523  {
525 
526  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
527  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
528 
529  smpAddAssign( ~lhs, rhs.dm_ );
530  }
532  //**********************************************************************************************
533 
534  //**SMP subtraction assignment to dense matrices************************************************
546  template< typename MT2 // Type of the target dense matrix
547  , bool SO2 > // Storage order of the target dense matrix
548  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
549  {
551 
552  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
553  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
554 
555  smpSubAssign( ~lhs, rhs.dm_ );
556  }
558  //**********************************************************************************************
559 
560  //**SMP subtraction assignment to sparse matrices***********************************************
572  template< typename MT2 // Type of the target sparse matrix
573  , bool SO2 > // Storage order of the target dense matrix
574  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
575  {
577 
578  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
579  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
580 
581  smpSubAssign( ~lhs, rhs.dm_ );
582  }
584  //**********************************************************************************************
585 
586  //**SMP multiplication assignment to dense matrices*********************************************
599  template< typename MT2 // Type of the target dense matrix
600  , bool SO2 > // Storage order of the target dense matrix
601  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
602  {
604 
605  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
606  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
607 
608  smpMultAssign( ~lhs, rhs.dm_ );
609  }
611  //**********************************************************************************************
612 
613  //**SMP multiplication assignment to sparse matrices********************************************
626  template< typename MT2 // Type of the target sparse matrix
627  , bool SO2 > // Storage order of the target dense matrix
628  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
629  {
631 
632  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
633  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
634 
635  smpMultAssign( ~lhs, rhs.dm_ );
636  }
638  //**********************************************************************************************
639 
640  //**Compile time checks*************************************************************************
645  //**********************************************************************************************
646 };
647 //*************************************************************************************************
648 
649 
650 
651 
652 //=================================================================================================
653 //
654 // GLOBAL FUNCTIONS
655 //
656 //=================================================================================================
657 
658 //*************************************************************************************************
675 template< typename MT // Type of the dense matrix
676  , bool SO > // Storage order
677 inline const DMatEvalExpr<MT,SO> eval( const DenseMatrix<MT,SO>& dm )
678 {
680 
681  return DMatEvalExpr<MT,SO>( ~dm );
682 }
683 //*************************************************************************************************
684 
685 
686 
687 
688 //=================================================================================================
689 //
690 // GLOBAL RESTRUCTURING FUNCTIONS
691 //
692 //=================================================================================================
693 
694 //*************************************************************************************************
705 template< typename MT // Type of the dense matrix
706  , bool SO > // Storage order
707 inline const DMatEvalExpr<MT,SO> eval( const DMatEvalExpr<MT,SO>& dm )
708 {
709  return dm;
710 }
712 //*************************************************************************************************
713 
714 
715 
716 
717 //=================================================================================================
718 //
719 // ROWS SPECIALIZATIONS
720 //
721 //=================================================================================================
722 
723 //*************************************************************************************************
725 template< typename MT, bool SO >
726 struct Rows< DMatEvalExpr<MT,SO> > : public Rows<MT>
727 {};
729 //*************************************************************************************************
730 
731 
732 
733 
734 //=================================================================================================
735 //
736 // COLUMNS SPECIALIZATIONS
737 //
738 //=================================================================================================
739 
740 //*************************************************************************************************
742 template< typename MT, bool SO >
743 struct Columns< DMatEvalExpr<MT,SO> > : public Columns<MT>
744 {};
746 //*************************************************************************************************
747 
748 
749 
750 
751 //=================================================================================================
752 //
753 // ISSYMMETRIC SPECIALIZATIONS
754 //
755 //=================================================================================================
756 
757 //*************************************************************************************************
759 template< typename MT, bool SO >
760 struct IsSymmetric< DMatEvalExpr<MT,SO> > : public IsTrue< IsSymmetric<MT>::value >
761 {};
763 //*************************************************************************************************
764 
765 
766 
767 
768 //=================================================================================================
769 //
770 // ISLOWER SPECIALIZATIONS
771 //
772 //=================================================================================================
773 
774 //*************************************************************************************************
776 template< typename MT, bool SO >
777 struct IsLower< DMatEvalExpr<MT,SO> > : public IsTrue< IsLower<MT>::value >
778 {};
780 //*************************************************************************************************
781 
782 
783 
784 
785 //=================================================================================================
786 //
787 // ISUPPER SPECIALIZATIONS
788 //
789 //=================================================================================================
790 
791 //*************************************************************************************************
793 template< typename MT, bool SO >
794 struct IsUpper< DMatEvalExpr<MT,SO> > : public IsTrue< IsUpper<MT>::value >
795 {};
797 //*************************************************************************************************
798 
799 
800 
801 
802 //=================================================================================================
803 //
804 // EXPRESSION TRAIT SPECIALIZATIONS
805 //
806 //=================================================================================================
807 
808 //*************************************************************************************************
810 template< typename MT >
811 struct DMatEvalExprTrait< DMatEvalExpr<MT,false> >
812 {
813  public:
814  //**********************************************************************************************
815  typedef typename SelectType< IsDenseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
816  , DMatEvalExpr<MT,false>
817  , INVALID_TYPE >::Type Type;
818  //**********************************************************************************************
819 };
821 //*************************************************************************************************
822 
823 
824 //*************************************************************************************************
826 template< typename MT >
827 struct TDMatEvalExprTrait< DMatEvalExpr<MT,true> >
828 {
829  public:
830  //**********************************************************************************************
831  typedef typename SelectType< IsDenseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
832  , DMatEvalExpr<MT,true>
833  , INVALID_TYPE >::Type Type;
834  //**********************************************************************************************
835 };
837 //*************************************************************************************************
838 
839 
840 //*************************************************************************************************
842 template< typename MT, bool SO, bool AF >
843 struct SubmatrixExprTrait< DMatEvalExpr<MT,SO>, AF >
844 {
845  public:
846  //**********************************************************************************************
847  typedef typename EvalExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
848  //**********************************************************************************************
849 };
851 //*************************************************************************************************
852 
853 
854 //*************************************************************************************************
856 template< typename MT, bool SO >
857 struct RowExprTrait< DMatEvalExpr<MT,SO> >
858 {
859  public:
860  //**********************************************************************************************
861  typedef typename EvalExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
862  //**********************************************************************************************
863 };
865 //*************************************************************************************************
866 
867 
868 //*************************************************************************************************
870 template< typename MT, bool SO >
871 struct ColumnExprTrait< DMatEvalExpr<MT,SO> >
872 {
873  public:
874  //**********************************************************************************************
875  typedef typename EvalExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
876  //**********************************************************************************************
877 };
879 //*************************************************************************************************
880 
881 } // namespace blaze
882 
883 #endif
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 DMatEvalExprTrait class template.
#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
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatEvalExpr.h:148
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
Header file for the MatEvalExpr base class.
Header file for the Computation base class.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2474
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.
Operand operand() const
Returns the dense matrix operand.
Definition: DMatEvalExpr.h:168
Constraint on the data type.
DMatEvalExpr< MT, SO > This
Type of this DMatEvalExpr instance.
Definition: DMatEvalExpr.h:97
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the dense matrix expression.
Definition: DMatEvalExpr.h:108
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 IsSymmetric type trait.
DMatEvalExpr(const MT &dm)
Constructor for the DMatEvalExpr class.
Definition: DMatEvalExpr.h:124
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatEvalExpr.h:202
Header file for the DenseMatrix base class.
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.
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatEvalExpr.h:99
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatEvalExpr.h:105
Header file for the IsLower type trait.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2475
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2476
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatEvalExpr.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 IsDenseMatrix type trait.
Operand dm_
Dense matrix of the evaluation expression.
Definition: DMatEvalExpr.h:219
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DMatEvalExpr.h:102
MT::ElementType ElementType
Resulting element type.
Definition: DMatEvalExpr.h:101
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:2477
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
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
Header file for the EvalExprTrait class template.
Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for a...
Definition: MatEvalExpr.h:65
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatEvalExpr.h:192
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:677
Header file for the IsRowMajorMatrix type trait.
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatEvalExpr.h:100
Expression object for the forced evaluation of dense matrices.The DMatEvalExpr class represents the c...
Definition: DMatEvalExpr.h:91
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
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
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatEvalExpr.h:212
#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
Header file for the TDMatEvalExprTrait class template.
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2473
Header file for the IsTrue value trait.
Header file for basic type definitions.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatEvalExpr.h:158
Header file for the IsUpper type trait.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatEvalExpr.h:136
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::ResultType ResultType
Result type for expression template evaluations.
Definition: DMatEvalExpr.h:98
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