All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatSerialExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_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 DMATSERIALEXPR
79 //
80 //=================================================================================================
81 
82 //*************************************************************************************************
89 template< typename MT // Type of the dense matrix
90  , bool SO > // Storage order
91 class DMatSerialExpr : public DenseMatrix< DMatSerialExpr<MT,SO>, SO >
92  , private MatSerialExpr
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 DMatSerialExpr( const MT& dm )
125  : dm_( dm ) // Dense matrix of the serial 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  //**Conversion operator*************************************************************************
178  inline operator Operand() const {
179  return dm_;
180  }
181  //**********************************************************************************************
182 
183  //**********************************************************************************************
189  template< typename T >
190  inline bool canAlias( const T* alias ) const {
191  return dm_.canAlias( alias );
192  }
193  //**********************************************************************************************
194 
195  //**********************************************************************************************
201  template< typename T >
202  inline bool isAliased( const T* alias ) const {
203  return dm_.isAliased( alias );
204  }
205  //**********************************************************************************************
206 
207  //**********************************************************************************************
212  inline bool isAligned() const {
213  return dm_.isAligned();
214  }
215  //**********************************************************************************************
216 
217  //**********************************************************************************************
222  inline bool canSMPAssign() const {
223  return dm_.canSMPAssign();
224  }
225  //**********************************************************************************************
226 
227  private:
228  //**Member variables****************************************************************************
230  //**********************************************************************************************
231 
232  //**Assignment to dense matrices****************************************************************
244  template< typename MT2 // Type of the target dense matrix
245  , bool SO2 > // Storage order of the target dense matrix
246  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
247  {
249 
250  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
251  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
252 
253  assign( ~lhs, rhs.dm_ );
254  }
256  //**********************************************************************************************
257 
258  //**Assignment to sparse matrices***************************************************************
270  template< typename MT2 // Type of the target sparse matrix
271  , bool SO2 > // Storage order of the target dense matrix
272  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
273  {
275 
276  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
277  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
278 
279  assign( ~lhs, rhs.dm_ );
280  }
282  //**********************************************************************************************
283 
284  //**Addition assignment to dense matrices*******************************************************
296  template< typename MT2 // Type of the target dense matrix
297  , bool SO2 > // Storage order of the target dense matrix
298  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
299  {
301 
302  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
303  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
304 
305  addAssign( ~lhs, rhs.dm_ );
306  }
308  //**********************************************************************************************
309 
310  //**Addition assignment to sparse matrices******************************************************
322  template< typename MT2 // Type of the target sparse matrix
323  , bool SO2 > // Storage order of the target dense matrix
324  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
325  {
327 
328  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
329  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
330 
331  addAssign( ~lhs, rhs.dm_ );
332  }
334  //**********************************************************************************************
335 
336  //**Subtraction assignment to dense matrices****************************************************
349  template< typename MT2 // Type of the target dense matrix
350  , bool SO2 > // Storage order of the target dense matrix
351  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
352  {
354 
355  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
356  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
357 
358  subAssign( ~lhs, rhs.dm_ );
359  }
361  //**********************************************************************************************
362 
363  //**Subtraction assignment to sparse matrices***************************************************
376  template< typename MT2 // Type of the target sparse matrix
377  , bool SO2 > // Storage order of the target dense matrix
378  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& 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.dm_ );
386  }
388  //**********************************************************************************************
389 
390  //**Multiplication assignment to dense matrices*************************************************
403  template< typename MT2 // Type of the target dense matrix
404  , bool SO2 > // Storage order of the target dense matrix
405  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
406  {
408 
409  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
410  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
411 
412  multAssign( ~lhs, rhs.sm_ );
413  }
415  //**********************************************************************************************
416 
417  //**Multiplication assignment to sparse matrices************************************************
430  template< typename MT2 // Type of the target sparse matrix
431  , bool SO2 > // Storage order of the target sparse matrix
432  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
433  {
435 
436  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
437  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
438 
439  multAssign( ~lhs, rhs.sm_ );
440  }
442  //**********************************************************************************************
443 
444  //**SMP assignment to dense matrices************************************************************
456  template< typename MT2 // Type of the target dense matrix
457  , bool SO2 > // Storage order of the target dense matrix
458  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
459  {
461 
462  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
463  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
464 
465  assign( ~lhs, rhs.dm_ );
466  }
468  //**********************************************************************************************
469 
470  //**SMP assignment to sparse matrices***********************************************************
482  template< typename MT2 // Type of the target sparse matrix
483  , bool SO2 > // Storage order of the target dense matrix
484  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
485  {
487 
488  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
489  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
490 
491  assign( ~lhs, rhs.dm_ );
492  }
494  //**********************************************************************************************
495 
496  //**SMP addition assignment to dense matrices***************************************************
509  template< typename MT2 // Type of the target dense matrix
510  , bool SO2 > // Storage order of the target dense matrix
511  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
512  {
514 
515  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
516  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
517 
518  addAssign( ~lhs, rhs.dm_ );
519  }
521  //**********************************************************************************************
522 
523  //**SMP addition assignment to sparse matrices**************************************************
536  template< typename MT2 // Type of the target sparse matrix
537  , bool SO2 > // Storage order of the target dense matrix
538  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
539  {
541 
542  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
543  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
544 
545  addAssign( ~lhs, rhs.dm_ );
546  }
548  //**********************************************************************************************
549 
550  //**SMP subtraction assignment to dense matrices************************************************
563  template< typename MT2 // Type of the target dense matrix
564  , bool SO2 > // Storage order of the target dense matrix
565  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
566  {
568 
569  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
570  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
571 
572  subAssign( ~lhs, rhs.dm_ );
573  }
575  //**********************************************************************************************
576 
577  //**SMP subtraction assignment to sparse matrices***********************************************
590  template< typename MT2 // Type of the target sparse matrix
591  , bool SO2 > // Storage order of the target dense matrix
592  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
593  {
595 
596  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
597  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
598 
599  subAssign( ~lhs, rhs.dm_ );
600  }
602  //**********************************************************************************************
603 
604  //**SMP multiplication assignment to dense matrices*********************************************
617  template< typename MT2 // Type of the target dense matrix
618  , bool SO2 > // Storage order of the target dense matrix
619  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
620  {
622 
623  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
624  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
625 
626  multAssign( ~lhs, rhs.sm_ );
627  }
629  //**********************************************************************************************
630 
631  //**SMP multiplication assignment to sparse matrices********************************************
644  template< typename MT2 // Type of the target sparse matrix
645  , bool SO2 > // Storage order of the target sparse matrix
646  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
647  {
649 
650  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
651  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
652 
653  multAssign( ~lhs, rhs.sm_ );
654  }
656  //**********************************************************************************************
657 
658  //**Compile time checks*************************************************************************
663  //**********************************************************************************************
664 };
665 //*************************************************************************************************
666 
667 
668 
669 
670 //=================================================================================================
671 //
672 // GLOBAL FUNCTIONS
673 //
674 //=================================================================================================
675 
676 //*************************************************************************************************
693 template< typename MT // Type of the dense matrix
694  , bool SO > // Storage order
696 {
698 
699  return DMatSerialExpr<MT,SO>( ~dm );
700 }
701 //*************************************************************************************************
702 
703 
704 
705 
706 //=================================================================================================
707 //
708 // GLOBAL RESTRUCTURING FUNCTIONS
709 //
710 //=================================================================================================
711 
712 //*************************************************************************************************
723 template< typename MT // Type of the dense matrix
724  , bool SO > // Storage order
725 inline const DMatSerialExpr<MT,SO> serial( const DMatSerialExpr<MT,SO>& dm )
726 {
727  return dm;
728 }
730 //*************************************************************************************************
731 
732 
733 
734 
735 //=================================================================================================
736 //
737 // ROWS SPECIALIZATIONS
738 //
739 //=================================================================================================
740 
741 //*************************************************************************************************
743 template< typename MT, bool SO >
744 struct Rows< DMatSerialExpr<MT,SO> > : public Rows<MT>
745 {};
747 //*************************************************************************************************
748 
749 
750 
751 
752 //=================================================================================================
753 //
754 // COLUMNS SPECIALIZATIONS
755 //
756 //=================================================================================================
757 
758 //*************************************************************************************************
760 template< typename MT, bool SO >
761 struct Columns< DMatSerialExpr<MT,SO> > : public Columns<MT>
762 {};
764 //*************************************************************************************************
765 
766 
767 
768 
769 //=================================================================================================
770 //
771 // ISSYMMETRIC SPECIALIZATIONS
772 //
773 //=================================================================================================
774 
775 //*************************************************************************************************
777 template< typename MT, bool SO >
778 struct IsSymmetric< DMatSerialExpr<MT,SO> > : public IsTrue< IsSymmetric<MT>::value >
779 {};
781 //*************************************************************************************************
782 
783 
784 
785 
786 //=================================================================================================
787 //
788 // ISLOWER SPECIALIZATIONS
789 //
790 //=================================================================================================
791 
792 //*************************************************************************************************
794 template< typename MT, bool SO >
795 struct IsLower< DMatSerialExpr<MT,SO> > : public IsTrue< IsLower<MT>::value >
796 {};
798 //*************************************************************************************************
799 
800 
801 
802 
803 //=================================================================================================
804 //
805 // ISUPPER SPECIALIZATIONS
806 //
807 //=================================================================================================
808 
809 //*************************************************************************************************
811 template< typename MT, bool SO >
812 struct IsUpper< DMatSerialExpr<MT,SO> > : public IsTrue< IsUpper<MT>::value >
813 {};
815 //*************************************************************************************************
816 
817 
818 
819 
820 //=================================================================================================
821 //
822 // EXPRESSION TRAIT SPECIALIZATIONS
823 //
824 //=================================================================================================
825 
826 //*************************************************************************************************
828 template< typename MT >
829 struct DMatSerialExprTrait< DMatSerialExpr<MT,false> >
830 {
831  public:
832  //**********************************************************************************************
833  typedef typename SelectType< IsDenseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
834  , DMatSerialExpr<MT,false>
835  , INVALID_TYPE >::Type Type;
836  //**********************************************************************************************
837 };
839 //*************************************************************************************************
840 
841 
842 //*************************************************************************************************
844 template< typename MT >
845 struct TDMatSerialExprTrait< DMatSerialExpr<MT,true> >
846 {
847  public:
848  //**********************************************************************************************
849  typedef typename SelectType< IsDenseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
850  , DMatSerialExpr<MT,true>
851  , INVALID_TYPE >::Type Type;
852  //**********************************************************************************************
853 };
855 //*************************************************************************************************
856 
857 
858 //*************************************************************************************************
860 template< typename MT, bool SO, bool AF >
861 struct SubmatrixExprTrait< DMatSerialExpr<MT,SO>, AF >
862 {
863  public:
864  //**********************************************************************************************
865  typedef typename SerialExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
866  //**********************************************************************************************
867 };
869 //*************************************************************************************************
870 
871 
872 //*************************************************************************************************
874 template< typename MT, bool SO >
875 struct RowExprTrait< DMatSerialExpr<MT,SO> >
876 {
877  public:
878  //**********************************************************************************************
879  typedef typename SerialExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
880  //**********************************************************************************************
881 };
883 //*************************************************************************************************
884 
885 
886 //*************************************************************************************************
888 template< typename MT, bool SO >
889 struct ColumnExprTrait< DMatSerialExpr<MT,SO> >
890 {
891  public:
892  //**********************************************************************************************
893  typedef typename SerialExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
894  //**********************************************************************************************
895 };
897 //*************************************************************************************************
898 
899 } // namespace blaze
900 
901 #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.
Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a ...
Definition: MatSerialExpr.h:65
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatSerialExpr.h:100
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatSerialExpr.h:158
#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
#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.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:695
Header file for the Computation base class.
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: DMatSerialExpr.h:98
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSerialExpr.h:136
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatSerialExpr.h:212
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
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSerialExpr.h:105
Constraint on the data type.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatSerialExpr.h:148
Constraint on the data type.
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
DMatSerialExpr< MT, SO > This
Type of this DMatSerialExpr instance.
Definition: DMatSerialExpr.h:97
Header file for the IsSymmetric type trait.
Expression object for the forced serial evaluation of dense matrices.The DMatSerialExpr class represe...
Definition: DMatSerialExpr.h:91
Header file for the DMatSerialExprTrait class template.
MT::ElementType ElementType
Resulting element type.
Definition: DMatSerialExpr.h:101
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.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatSerialExpr.h:190
DMatSerialExpr(const MT &dm)
Constructor for the DMatSerialExpr class.
Definition: DMatSerialExpr.h:124
Header file for the IsLower type trait.
Header file for the SerialExprTrait class template.
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
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 MatSerialExpr base class.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatSerialExpr.h:222
Header file for the TDMatSerialExprTrait class template.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatSerialExpr.h:202
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.
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSerialExpr.h:99
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
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DMatSerialExpr.h:102
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the dense matrix expression.
Definition: DMatSerialExpr.h:108
Header file for the IsRowMajorMatrix type trait.
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
#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:2473
Header file for the IsTrue value trait.
Header file for basic type definitions.
Operand operand() const
Returns the dense matrix operand.
Definition: DMatSerialExpr.h:168
Header file for the IsUpper type trait.
Operand dm_
Dense matrix of the serial evaluation expression.
Definition: DMatSerialExpr.h:229
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
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