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>
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 DMATEVALEXPR
83 //
84 //=================================================================================================
85 
86 //*************************************************************************************************
93 template< typename MT // Type of the dense matrix
94  , bool SO > // Storage order
95 class DMatEvalExpr : public DenseMatrix< DMatEvalExpr<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 { vectorizable = 0 };
118 
120  enum { smpAssignable = MT::smpAssignable };
121  //**********************************************************************************************
122 
123  //**Constructor*********************************************************************************
128  explicit inline DMatEvalExpr( const MT& dm )
129  : dm_( dm ) // Dense matrix of the evaluation expression
130  {}
131  //**********************************************************************************************
132 
133  //**Access operator*****************************************************************************
140  inline ReturnType operator()( size_t i, size_t j ) const {
141  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
142  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
143  return dm_(i,j);
144  }
145  //**********************************************************************************************
146 
147  //**Rows function*******************************************************************************
152  inline size_t rows() const {
153  return dm_.rows();
154  }
155  //**********************************************************************************************
156 
157  //**Columns function****************************************************************************
162  inline size_t columns() const {
163  return dm_.columns();
164  }
165  //**********************************************************************************************
166 
167  //**Operand access******************************************************************************
172  inline Operand operand() const {
173  return dm_;
174  }
175  //**********************************************************************************************
176 
177  //**********************************************************************************************
183  template< typename T >
184  inline bool canAlias( const T* alias ) const {
185  return dm_.canAlias( alias );
186  }
187  //**********************************************************************************************
188 
189  //**********************************************************************************************
195  template< typename T >
196  inline bool isAliased( const T* alias ) const {
197  return dm_.isAliased( alias );
198  }
199  //**********************************************************************************************
200 
201  //**********************************************************************************************
206  inline bool isAligned() const {
207  return dm_.isAligned();
208  }
209  //**********************************************************************************************
210 
211  //**********************************************************************************************
216  inline bool canSMPAssign() const {
217  return dm_.canSMPAssign();
218  }
219  //**********************************************************************************************
220 
221  private:
222  //**Member variables****************************************************************************
223  Operand dm_;
224  //**********************************************************************************************
225 
226  //**Assignment to dense matrices****************************************************************
238  template< typename MT2 // Type of the target dense matrix
239  , bool SO2 > // Storage order of the target dense matrix
240  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
241  {
243 
244  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
245  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
246 
247  assign( ~lhs, rhs.dm_ );
248  }
250  //**********************************************************************************************
251 
252  //**Assignment to sparse matrices***************************************************************
264  template< typename MT2 // Type of the target sparse matrix
265  , bool SO2 > // Storage order of the target dense matrix
266  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
267  {
269 
270  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
271  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
272 
273  assign( ~lhs, rhs.dm_ );
274  }
276  //**********************************************************************************************
277 
278  //**Addition assignment to dense matrices*******************************************************
290  template< typename MT2 // Type of the target dense matrix
291  , bool SO2 > // Storage order of the target dense matrix
292  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
293  {
295 
296  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
297  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
298 
299  addAssign( ~lhs, rhs.dm_ );
300  }
302  //**********************************************************************************************
303 
304  //**Addition assignment to sparse matrices******************************************************
316  template< typename MT2 // Type of the target sparse matrix
317  , bool SO2 > // Storage order of the target dense matrix
318  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
319  {
321 
322  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
323  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
324 
325  addAssign( ~lhs, rhs.dm_ );
326  }
328  //**********************************************************************************************
329 
330  //**Subtraction assignment to dense matrices****************************************************
342  template< typename MT2 // Type of the target dense matrix
343  , bool SO2 > // Storage order of the target dense matrix
344  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
345  {
347 
348  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
349  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
350 
351  subAssign( ~lhs, rhs.dm_ );
352  }
354  //**********************************************************************************************
355 
356  //**Subtraction assignment to sparse matrices***************************************************
368  template< typename MT2 // Type of the target sparse matrix
369  , bool SO2 > // Storage order of the target dense matrix
370  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
371  {
373 
374  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
375  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
376 
377  subAssign( ~lhs, rhs.dm_ );
378  }
380  //**********************************************************************************************
381 
382  //**Multiplication assignment to dense matrices*************************************************
394  template< typename MT2 // Type of the target dense matrix
395  , bool SO2 > // Storage order of the target dense matrix
396  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
397  {
399 
400  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
401  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
402 
403  multAssign( ~lhs, rhs.dm_ );
404  }
406  //**********************************************************************************************
407 
408  //**Multiplication assignment to sparse matrices************************************************
420  template< typename MT2 // Type of the target sparse matrix
421  , bool SO2 > // Storage order of the target dense matrix
422  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
423  {
425 
426  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
427  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
428 
429  multAssign( ~lhs, rhs.dm_ );
430  }
432  //**********************************************************************************************
433 
434  //**SMP assignment to dense matrices************************************************************
446  template< typename MT2 // Type of the target dense matrix
447  , bool SO2 > // Storage order of the target dense matrix
448  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
449  {
451 
452  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
453  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
454 
455  smpAssign( ~lhs, rhs.dm_ );
456  }
458  //**********************************************************************************************
459 
460  //**SMP assignment to sparse matrices***********************************************************
472  template< typename MT2 // Type of the target sparse matrix
473  , bool SO2 > // Storage order of the target dense matrix
474  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
475  {
477 
478  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
479  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
480 
481  smpAssign( ~lhs, rhs.dm_ );
482  }
484  //**********************************************************************************************
485 
486  //**SMP addition assignment to dense matrices***************************************************
498  template< typename MT2 // Type of the target dense matrix
499  , bool SO2 > // Storage order of the target dense matrix
500  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
501  {
503 
504  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
505  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
506 
507  smpAddAssign( ~lhs, rhs.dm_ );
508  }
510  //**********************************************************************************************
511 
512  //**SMP addition assignment to sparse matrices**************************************************
524  template< typename MT2 // Type of the target sparse matrix
525  , bool SO2 > // Storage order of the target dense matrix
526  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
527  {
529 
530  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
531  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
532 
533  smpAddAssign( ~lhs, rhs.dm_ );
534  }
536  //**********************************************************************************************
537 
538  //**SMP subtraction assignment to dense matrices************************************************
550  template< typename MT2 // Type of the target dense matrix
551  , bool SO2 > // Storage order of the target dense matrix
552  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
553  {
555 
556  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
557  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
558 
559  smpSubAssign( ~lhs, rhs.dm_ );
560  }
562  //**********************************************************************************************
563 
564  //**SMP subtraction assignment to sparse matrices***********************************************
576  template< typename MT2 // Type of the target sparse matrix
577  , bool SO2 > // Storage order of the target dense matrix
578  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
579  {
581 
582  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
583  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
584 
585  smpSubAssign( ~lhs, rhs.dm_ );
586  }
588  //**********************************************************************************************
589 
590  //**SMP multiplication assignment to dense matrices*********************************************
603  template< typename MT2 // Type of the target dense matrix
604  , bool SO2 > // Storage order of the target dense matrix
605  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
606  {
608 
609  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
610  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
611 
612  smpMultAssign( ~lhs, rhs.dm_ );
613  }
615  //**********************************************************************************************
616 
617  //**SMP multiplication assignment to sparse matrices********************************************
630  template< typename MT2 // Type of the target sparse matrix
631  , bool SO2 > // Storage order of the target dense matrix
632  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
633  {
635 
636  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
637  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
638 
639  smpMultAssign( ~lhs, rhs.dm_ );
640  }
642  //**********************************************************************************************
643 
644  //**Compile time checks*************************************************************************
649  //**********************************************************************************************
650 };
651 //*************************************************************************************************
652 
653 
654 
655 
656 //=================================================================================================
657 //
658 // GLOBAL FUNCTIONS
659 //
660 //=================================================================================================
661 
662 //*************************************************************************************************
679 template< typename MT // Type of the dense matrix
680  , bool SO > // Storage order
681 inline const DMatEvalExpr<MT,SO> eval( const DenseMatrix<MT,SO>& dm )
682 {
684 
685  return DMatEvalExpr<MT,SO>( ~dm );
686 }
687 //*************************************************************************************************
688 
689 
690 
691 
692 //=================================================================================================
693 //
694 // GLOBAL RESTRUCTURING FUNCTIONS
695 //
696 //=================================================================================================
697 
698 //*************************************************************************************************
709 template< typename MT // Type of the dense matrix
710  , bool SO > // Storage order
711 inline const DMatEvalExpr<MT,SO> eval( const DMatEvalExpr<MT,SO>& dm )
712 {
713  return dm;
714 }
716 //*************************************************************************************************
717 
718 
719 
720 
721 //=================================================================================================
722 //
723 // ROWS SPECIALIZATIONS
724 //
725 //=================================================================================================
726 
727 //*************************************************************************************************
729 template< typename MT, bool SO >
730 struct Rows< DMatEvalExpr<MT,SO> > : public Rows<MT>
731 {};
733 //*************************************************************************************************
734 
735 
736 
737 
738 //=================================================================================================
739 //
740 // COLUMNS SPECIALIZATIONS
741 //
742 //=================================================================================================
743 
744 //*************************************************************************************************
746 template< typename MT, bool SO >
747 struct Columns< DMatEvalExpr<MT,SO> > : public Columns<MT>
748 {};
750 //*************************************************************************************************
751 
752 
753 
754 
755 //=================================================================================================
756 //
757 // ISSYMMETRIC SPECIALIZATIONS
758 //
759 //=================================================================================================
760 
761 //*************************************************************************************************
763 template< typename MT, bool SO >
764 struct IsSymmetric< DMatEvalExpr<MT,SO> > : public IsTrue< IsSymmetric<MT>::value >
765 {};
767 //*************************************************************************************************
768 
769 
770 
771 
772 //=================================================================================================
773 //
774 // ISLOWER SPECIALIZATIONS
775 //
776 //=================================================================================================
777 
778 //*************************************************************************************************
780 template< typename MT, bool SO >
781 struct IsLower< DMatEvalExpr<MT,SO> > : public IsTrue< IsLower<MT>::value >
782 {};
784 //*************************************************************************************************
785 
786 
787 
788 
789 //=================================================================================================
790 //
791 // ISUNILOWER SPECIALIZATIONS
792 //
793 //=================================================================================================
794 
795 //*************************************************************************************************
797 template< typename MT, bool SO >
798 struct IsUniLower< DMatEvalExpr<MT,SO> > : public IsTrue< IsUniLower<MT>::value >
799 {};
801 //*************************************************************************************************
802 
803 
804 
805 
806 //=================================================================================================
807 //
808 // ISSTRICTLYLOWER SPECIALIZATIONS
809 //
810 //=================================================================================================
811 
812 //*************************************************************************************************
814 template< typename MT, bool SO >
815 struct IsStrictlyLower< DMatEvalExpr<MT,SO> > : public IsTrue< IsStrictlyLower<MT>::value >
816 {};
818 //*************************************************************************************************
819 
820 
821 
822 
823 //=================================================================================================
824 //
825 // ISUPPER SPECIALIZATIONS
826 //
827 //=================================================================================================
828 
829 //*************************************************************************************************
831 template< typename MT, bool SO >
832 struct IsUpper< DMatEvalExpr<MT,SO> > : public IsTrue< IsUpper<MT>::value >
833 {};
835 //*************************************************************************************************
836 
837 
838 
839 
840 //=================================================================================================
841 //
842 // ISUNIUPPER SPECIALIZATIONS
843 //
844 //=================================================================================================
845 
846 //*************************************************************************************************
848 template< typename MT, bool SO >
849 struct IsUniUpper< DMatEvalExpr<MT,SO> > : public IsTrue< IsUniUpper<MT>::value >
850 {};
852 //*************************************************************************************************
853 
854 
855 
856 
857 //=================================================================================================
858 //
859 // ISSTRICTLYUPPER SPECIALIZATIONS
860 //
861 //=================================================================================================
862 
863 //*************************************************************************************************
865 template< typename MT, bool SO >
866 struct IsStrictlyUpper< DMatEvalExpr<MT,SO> > : public IsTrue< IsStrictlyUpper<MT>::value >
867 {};
869 //*************************************************************************************************
870 
871 
872 
873 
874 //=================================================================================================
875 //
876 // EXPRESSION TRAIT SPECIALIZATIONS
877 //
878 //=================================================================================================
879 
880 //*************************************************************************************************
882 template< typename MT >
883 struct DMatEvalExprTrait< DMatEvalExpr<MT,false> >
884 {
885  public:
886  //**********************************************************************************************
887  typedef typename SelectType< IsDenseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
888  , DMatEvalExpr<MT,false>
889  , INVALID_TYPE >::Type Type;
890  //**********************************************************************************************
891 };
893 //*************************************************************************************************
894 
895 
896 //*************************************************************************************************
898 template< typename MT >
899 struct TDMatEvalExprTrait< DMatEvalExpr<MT,true> >
900 {
901  public:
902  //**********************************************************************************************
903  typedef typename SelectType< IsDenseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
904  , DMatEvalExpr<MT,true>
905  , INVALID_TYPE >::Type Type;
906  //**********************************************************************************************
907 };
909 //*************************************************************************************************
910 
911 
912 //*************************************************************************************************
914 template< typename MT, bool SO, bool AF >
915 struct SubmatrixExprTrait< DMatEvalExpr<MT,SO>, AF >
916 {
917  public:
918  //**********************************************************************************************
919  typedef typename EvalExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
920  //**********************************************************************************************
921 };
923 //*************************************************************************************************
924 
925 
926 //*************************************************************************************************
928 template< typename MT, bool SO >
929 struct RowExprTrait< DMatEvalExpr<MT,SO> >
930 {
931  public:
932  //**********************************************************************************************
933  typedef typename EvalExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
934  //**********************************************************************************************
935 };
937 //*************************************************************************************************
938 
939 
940 //*************************************************************************************************
942 template< typename MT, bool SO >
943 struct ColumnExprTrait< DMatEvalExpr<MT,SO> >
944 {
945  public:
946  //**********************************************************************************************
947  typedef typename EvalExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
948  //**********************************************************************************************
949 };
951 //*************************************************************************************************
952 
953 } // namespace blaze
954 
955 #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 IsUniUpper type trait.
Header file for basic type definitions.
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:152
#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.
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.
Operand operand() const
Returns the dense matrix operand.
Definition: DMatEvalExpr.h:172
Constraint on the data type.
DMatEvalExpr< MT, SO > This
Type of this DMatEvalExpr instance.
Definition: DMatEvalExpr.h:101
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the dense matrix expression.
Definition: DMatEvalExpr.h:112
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.
DMatEvalExpr(const MT &dm)
Constructor for the DMatEvalExpr class.
Definition: DMatEvalExpr.h:128
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatEvalExpr.h:206
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:103
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatEvalExpr.h:109
Header file for the IsLower type trait.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2504
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatEvalExpr.h:184
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.
Header file for the IsStrictlyLower type trait.
Operand dm_
Dense matrix of the evaluation expression.
Definition: DMatEvalExpr.h:223
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DMatEvalExpr.h:106
MT::ElementType ElementType
Resulting element type.
Definition: DMatEvalExpr.h:105
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
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:196
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:681
Header file for the IsRowMajorMatrix type trait.
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatEvalExpr.h:104
Expression object for the forced evaluation of dense matrices.The DMatEvalExpr class represents the c...
Definition: DMatEvalExpr.h:95
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:216
#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:2502
Header file for the IsTrue value trait.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatEvalExpr.h:162
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:140
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:102
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