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>
44 #include <blaze/math/Aliases.h>
47 #include <blaze/math/Exception.h>
73 #include <blaze/util/Assert.h>
76 #include <blaze/util/InvalidType.h>
78 #include <blaze/util/mpl/And.h>
79 #include <blaze/util/mpl/If.h>
80 #include <blaze/util/Types.h>
81 
82 
83 namespace blaze {
84 
85 //=================================================================================================
86 //
87 // CLASS DMATEVALEXPR
88 //
89 //=================================================================================================
90 
91 //*************************************************************************************************
98 template< typename MT // Type of the dense matrix
99  , bool SO > // Storage order
100 class DMatEvalExpr : public DenseMatrix< DMatEvalExpr<MT,SO>, SO >
101  , private MatEvalExpr
102  , private Computation
103 {
104  public:
105  //**Type definitions****************************************************************************
112 
114  typedef const ResultType CompositeType;
115 
117  typedef If_< IsExpression<MT>, const MT, const MT& > Operand;
118  //**********************************************************************************************
119 
120  //**Compilation flags***************************************************************************
122  enum : bool { simdEnabled = false };
123 
125  enum : bool { smpAssignable = MT::smpAssignable };
126  //**********************************************************************************************
127 
128  //**Constructor*********************************************************************************
133  explicit inline DMatEvalExpr( const MT& dm ) noexcept
134  : dm_( dm ) // Dense matrix of the evaluation expression
135  {}
136  //**********************************************************************************************
137 
138  //**Access operator*****************************************************************************
145  inline ReturnType operator()( size_t i, size_t j ) const {
146  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
147  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
148  return dm_(i,j);
149  }
150  //**********************************************************************************************
151 
152  //**At function*********************************************************************************
160  inline ReturnType at( size_t i, size_t j ) const {
161  if( i >= dm_.rows() ) {
162  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
163  }
164  if( j >= dm_.columns() ) {
165  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
166  }
167  return (*this)(i,j);
168  }
169  //**********************************************************************************************
170 
171  //**Rows function*******************************************************************************
176  inline size_t rows() const noexcept {
177  return dm_.rows();
178  }
179  //**********************************************************************************************
180 
181  //**Columns function****************************************************************************
186  inline size_t columns() const noexcept {
187  return dm_.columns();
188  }
189  //**********************************************************************************************
190 
191  //**Operand access******************************************************************************
196  inline Operand operand() const noexcept {
197  return dm_;
198  }
199  //**********************************************************************************************
200 
201  //**********************************************************************************************
207  template< typename T >
208  inline bool canAlias( const T* alias ) const noexcept {
209  return dm_.canAlias( alias );
210  }
211  //**********************************************************************************************
212 
213  //**********************************************************************************************
219  template< typename T >
220  inline bool isAliased( const T* alias ) const noexcept {
221  return dm_.isAliased( alias );
222  }
223  //**********************************************************************************************
224 
225  //**********************************************************************************************
230  inline bool isAligned() const noexcept {
231  return dm_.isAligned();
232  }
233  //**********************************************************************************************
234 
235  //**********************************************************************************************
240  inline bool canSMPAssign() const noexcept {
241  return dm_.canSMPAssign();
242  }
243  //**********************************************************************************************
244 
245  private:
246  //**Member variables****************************************************************************
247  Operand dm_;
248  //**********************************************************************************************
249 
250  //**Assignment to dense matrices****************************************************************
262  template< typename MT2 // Type of the target dense matrix
263  , bool SO2 > // Storage order of the target dense matrix
264  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
265  {
267 
268  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
269  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
270 
271  assign( ~lhs, rhs.dm_ );
272  }
274  //**********************************************************************************************
275 
276  //**Assignment to sparse matrices***************************************************************
288  template< typename MT2 // Type of the target sparse matrix
289  , bool SO2 > // Storage order of the target dense matrix
290  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
291  {
293 
294  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
295  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
296 
297  assign( ~lhs, rhs.dm_ );
298  }
300  //**********************************************************************************************
301 
302  //**Addition assignment to dense matrices*******************************************************
314  template< typename MT2 // Type of the target dense matrix
315  , bool SO2 > // Storage order of the target dense matrix
316  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
317  {
319 
320  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
321  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
322 
323  addAssign( ~lhs, rhs.dm_ );
324  }
326  //**********************************************************************************************
327 
328  //**Addition assignment to sparse matrices******************************************************
340  template< typename MT2 // Type of the target sparse matrix
341  , bool SO2 > // Storage order of the target dense matrix
342  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
343  {
345 
346  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
347  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
348 
349  addAssign( ~lhs, rhs.dm_ );
350  }
352  //**********************************************************************************************
353 
354  //**Subtraction assignment to dense matrices****************************************************
366  template< typename MT2 // Type of the target dense matrix
367  , bool SO2 > // Storage order of the target dense matrix
368  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
369  {
371 
372  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
373  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
374 
375  subAssign( ~lhs, rhs.dm_ );
376  }
378  //**********************************************************************************************
379 
380  //**Subtraction assignment to sparse matrices***************************************************
392  template< typename MT2 // Type of the target sparse matrix
393  , bool SO2 > // Storage order of the target dense matrix
394  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
395  {
397 
398  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
399  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
400 
401  subAssign( ~lhs, rhs.dm_ );
402  }
404  //**********************************************************************************************
405 
406  //**Multiplication assignment to dense matrices*************************************************
418  template< typename MT2 // Type of the target dense matrix
419  , bool SO2 > // Storage order of the target dense matrix
420  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
421  {
423 
424  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
425  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
426 
427  multAssign( ~lhs, rhs.dm_ );
428  }
430  //**********************************************************************************************
431 
432  //**Multiplication assignment to sparse matrices************************************************
444  template< typename MT2 // Type of the target sparse matrix
445  , bool SO2 > // Storage order of the target dense matrix
446  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
447  {
449 
450  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
451  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
452 
453  multAssign( ~lhs, rhs.dm_ );
454  }
456  //**********************************************************************************************
457 
458  //**SMP assignment to dense matrices************************************************************
470  template< typename MT2 // Type of the target dense matrix
471  , bool SO2 > // Storage order of the target dense matrix
472  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
473  {
475 
476  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
477  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
478 
479  smpAssign( ~lhs, rhs.dm_ );
480  }
482  //**********************************************************************************************
483 
484  //**SMP assignment to sparse matrices***********************************************************
496  template< typename MT2 // Type of the target sparse matrix
497  , bool SO2 > // Storage order of the target dense matrix
498  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
499  {
501 
502  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
503  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
504 
505  smpAssign( ~lhs, rhs.dm_ );
506  }
508  //**********************************************************************************************
509 
510  //**SMP addition assignment to dense matrices***************************************************
522  template< typename MT2 // Type of the target dense matrix
523  , bool SO2 > // Storage order of the target dense matrix
524  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
525  {
527 
528  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
529  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
530 
531  smpAddAssign( ~lhs, rhs.dm_ );
532  }
534  //**********************************************************************************************
535 
536  //**SMP addition assignment to sparse matrices**************************************************
548  template< typename MT2 // Type of the target sparse matrix
549  , bool SO2 > // Storage order of the target dense matrix
550  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
551  {
553 
554  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
555  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
556 
557  smpAddAssign( ~lhs, rhs.dm_ );
558  }
560  //**********************************************************************************************
561 
562  //**SMP subtraction assignment to dense matrices************************************************
574  template< typename MT2 // Type of the target dense matrix
575  , bool SO2 > // Storage order of the target dense matrix
576  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
577  {
579 
580  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
581  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
582 
583  smpSubAssign( ~lhs, rhs.dm_ );
584  }
586  //**********************************************************************************************
587 
588  //**SMP subtraction assignment to sparse matrices***********************************************
600  template< typename MT2 // Type of the target sparse matrix
601  , bool SO2 > // Storage order of the target dense matrix
602  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
603  {
605 
606  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
607  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
608 
609  smpSubAssign( ~lhs, rhs.dm_ );
610  }
612  //**********************************************************************************************
613 
614  //**SMP multiplication assignment to dense matrices*********************************************
627  template< typename MT2 // Type of the target dense matrix
628  , bool SO2 > // Storage order of the target dense matrix
629  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
630  {
632 
633  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
634  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
635 
636  smpMultAssign( ~lhs, rhs.dm_ );
637  }
639  //**********************************************************************************************
640 
641  //**SMP multiplication assignment to sparse matrices********************************************
654  template< typename MT2 // Type of the target sparse matrix
655  , bool SO2 > // Storage order of the target dense matrix
656  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
657  {
659 
660  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
661  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
662 
663  smpMultAssign( ~lhs, rhs.dm_ );
664  }
666  //**********************************************************************************************
667 
668  //**Compile time checks*************************************************************************
673  //**********************************************************************************************
674 };
675 //*************************************************************************************************
676 
677 
678 
679 
680 //=================================================================================================
681 //
682 // GLOBAL FUNCTIONS
683 //
684 //=================================================================================================
685 
686 //*************************************************************************************************
703 template< typename MT // Type of the dense matrix
704  , bool SO > // Storage order
705 inline const DMatEvalExpr<MT,SO> eval( const DenseMatrix<MT,SO>& dm )
706 {
708 
709  return DMatEvalExpr<MT,SO>( ~dm );
710 }
711 //*************************************************************************************************
712 
713 
714 
715 
716 //=================================================================================================
717 //
718 // GLOBAL RESTRUCTURING FUNCTIONS
719 //
720 //=================================================================================================
721 
722 //*************************************************************************************************
733 template< typename MT // Type of the dense matrix
734  , bool SO > // Storage order
735 inline const DMatEvalExpr<MT,SO> eval( const DMatEvalExpr<MT,SO>& dm )
736 {
737  return dm;
738 }
740 //*************************************************************************************************
741 
742 
743 
744 
745 //=================================================================================================
746 //
747 // ROWS SPECIALIZATIONS
748 //
749 //=================================================================================================
750 
751 //*************************************************************************************************
753 template< typename MT, bool SO >
754 struct Rows< DMatEvalExpr<MT,SO> > : public Rows<MT>
755 {};
757 //*************************************************************************************************
758 
759 
760 
761 
762 //=================================================================================================
763 //
764 // COLUMNS SPECIALIZATIONS
765 //
766 //=================================================================================================
767 
768 //*************************************************************************************************
770 template< typename MT, bool SO >
771 struct Columns< DMatEvalExpr<MT,SO> > : public Columns<MT>
772 {};
774 //*************************************************************************************************
775 
776 
777 
778 
779 //=================================================================================================
780 //
781 // ISALIGNED SPECIALIZATIONS
782 //
783 //=================================================================================================
784 
785 //*************************************************************************************************
787 template< typename MT, bool SO >
788 struct IsAligned< DMatEvalExpr<MT,SO> >
789  : public BoolConstant< IsAligned<MT>::value >
790 {};
792 //*************************************************************************************************
793 
794 
795 
796 
797 //=================================================================================================
798 //
799 // ISSYMMETRIC SPECIALIZATIONS
800 //
801 //=================================================================================================
802 
803 //*************************************************************************************************
805 template< typename MT, bool SO >
806 struct IsSymmetric< DMatEvalExpr<MT,SO> >
807  : public BoolConstant< IsSymmetric<MT>::value >
808 {};
810 //*************************************************************************************************
811 
812 
813 
814 
815 //=================================================================================================
816 //
817 // ISHERMITIAN SPECIALIZATIONS
818 //
819 //=================================================================================================
820 
821 //*************************************************************************************************
823 template< typename MT, bool SO >
824 struct IsHermitian< DMatEvalExpr<MT,SO> >
825  : public BoolConstant< IsHermitian<MT>::value >
826 {};
828 //*************************************************************************************************
829 
830 
831 
832 
833 //=================================================================================================
834 //
835 // ISLOWER SPECIALIZATIONS
836 //
837 //=================================================================================================
838 
839 //*************************************************************************************************
841 template< typename MT, bool SO >
842 struct IsLower< DMatEvalExpr<MT,SO> >
843  : public BoolConstant< IsLower<MT>::value >
844 {};
846 //*************************************************************************************************
847 
848 
849 
850 
851 //=================================================================================================
852 //
853 // ISUNILOWER SPECIALIZATIONS
854 //
855 //=================================================================================================
856 
857 //*************************************************************************************************
859 template< typename MT, bool SO >
860 struct IsUniLower< DMatEvalExpr<MT,SO> >
861  : public BoolConstant< IsUniLower<MT>::value >
862 {};
864 //*************************************************************************************************
865 
866 
867 
868 
869 //=================================================================================================
870 //
871 // ISSTRICTLYLOWER SPECIALIZATIONS
872 //
873 //=================================================================================================
874 
875 //*************************************************************************************************
877 template< typename MT, bool SO >
878 struct IsStrictlyLower< DMatEvalExpr<MT,SO> >
879  : public BoolConstant< IsStrictlyLower<MT>::value >
880 {};
882 //*************************************************************************************************
883 
884 
885 
886 
887 //=================================================================================================
888 //
889 // ISUPPER SPECIALIZATIONS
890 //
891 //=================================================================================================
892 
893 //*************************************************************************************************
895 template< typename MT, bool SO >
896 struct IsUpper< DMatEvalExpr<MT,SO> >
897  : public BoolConstant< IsUpper<MT>::value >
898 {};
900 //*************************************************************************************************
901 
902 
903 
904 
905 //=================================================================================================
906 //
907 // ISUNIUPPER SPECIALIZATIONS
908 //
909 //=================================================================================================
910 
911 //*************************************************************************************************
913 template< typename MT, bool SO >
914 struct IsUniUpper< DMatEvalExpr<MT,SO> >
915  : public BoolConstant< IsUniUpper<MT>::value >
916 {};
918 //*************************************************************************************************
919 
920 
921 
922 
923 //=================================================================================================
924 //
925 // ISSTRICTLYUPPER SPECIALIZATIONS
926 //
927 //=================================================================================================
928 
929 //*************************************************************************************************
931 template< typename MT, bool SO >
932 struct IsStrictlyUpper< DMatEvalExpr<MT,SO> >
933  : public BoolConstant< IsStrictlyUpper<MT>::value >
934 {};
936 //*************************************************************************************************
937 
938 
939 
940 
941 //=================================================================================================
942 //
943 // EXPRESSION TRAIT SPECIALIZATIONS
944 //
945 //=================================================================================================
946 
947 //*************************************************************************************************
949 template< typename MT >
950 struct DMatEvalExprTrait< DMatEvalExpr<MT,false> >
951 {
952  public:
953  //**********************************************************************************************
954  using Type = If_< And< IsDenseMatrix<MT>, IsRowMajorMatrix<MT> >
955  , DMatEvalExpr<MT,false>
956  , INVALID_TYPE >;
957  //**********************************************************************************************
958 };
960 //*************************************************************************************************
961 
962 
963 //*************************************************************************************************
965 template< typename MT >
966 struct TDMatEvalExprTrait< DMatEvalExpr<MT,true> >
967 {
968  public:
969  //**********************************************************************************************
970  using Type = If_< And< IsDenseMatrix<MT>, IsColumnMajorMatrix<MT> >
971  , DMatEvalExpr<MT,true>
972  , INVALID_TYPE >;
973  //**********************************************************************************************
974 };
976 //*************************************************************************************************
977 
978 
979 //*************************************************************************************************
981 template< typename MT, bool SO, bool AF >
982 struct SubmatrixExprTrait< DMatEvalExpr<MT,SO>, AF >
983 {
984  public:
985  //**********************************************************************************************
986  using Type = EvalExprTrait_< SubmatrixExprTrait_<const MT,AF> >;
987  //**********************************************************************************************
988 };
990 //*************************************************************************************************
991 
992 
993 //*************************************************************************************************
995 template< typename MT, bool SO >
996 struct RowExprTrait< DMatEvalExpr<MT,SO> >
997 {
998  public:
999  //**********************************************************************************************
1000  using Type = EvalExprTrait_< RowExprTrait_<const MT> >;
1001  //**********************************************************************************************
1002 };
1004 //*************************************************************************************************
1005 
1006 
1007 //*************************************************************************************************
1009 template< typename MT, bool SO >
1010 struct ColumnExprTrait< DMatEvalExpr<MT,SO> >
1011 {
1012  public:
1013  //**********************************************************************************************
1014  using Type = EvalExprTrait_< ColumnExprTrait_<const MT> >;
1015  //**********************************************************************************************
1016 };
1018 //*************************************************************************************************
1019 
1020 } // namespace blaze
1021 
1022 #endif
DMatEvalExpr(const MT &dm) noexcept
Constructor for the DMatEvalExpr class.
Definition: DMatEvalExpr.h:133
Header file for auxiliary alias declarations.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatEvalExpr.h:208
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.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatEvalExpr.h:160
EnableIf_< IsDenseMatrix< MT1 > > 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
#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:63
#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:61
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatEvalExpr.h:176
EnableIf_< IsDenseVector< VT1 > > 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:193
Header file for the And class template.
Header file for the MatEvalExpr base class.
Header file for the Computation base class.
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
EnableIf_< IsDenseMatrix< MT1 > > 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
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:109
Constraint on the data type.
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatEvalExpr.h:108
Constraint on the data type.
DMatEvalExpr< MT, SO > This
Type of this DMatEvalExpr instance.
Definition: DMatEvalExpr.h:106
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatEvalExpr.h:111
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
If_< IsExpression< MT >, const MT, const MT & > Operand
Composite data type of the dense matrix expression.
Definition: DMatEvalExpr.h:117
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatEvalExpr.h:109
EnableIf_< IsDenseMatrix< MT1 > > 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
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatEvalExpr.h:114
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
Constraints on the storage order of matrix types.
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatEvalExpr.h:230
Header file for the exception macros of the math module.
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:247
Header file for the SubmatrixExprTrait class template.
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatEvalExpr.h:196
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatEvalExpr.h:240
Header file for run time assertion macros.
Utility type for generic codes.
Header file for the EvalExprTrait class template.
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for a...
Definition: MatEvalExpr.h:65
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:705
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
Header file for the IsRowMajorMatrix type trait.
Expression object for the forced evaluation of dense matrices.The DMatEvalExpr class represents the c...
Definition: DMatEvalExpr.h:100
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
#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
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatEvalExpr.h:107
Header file for the TDMatEvalExprTrait class template.
Header file for the IntegralConstant class template.
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatEvalExpr.h:110
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
Header file for the IsUpper type trait.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatEvalExpr.h:186
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatEvalExpr.h:220
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatEvalExpr.h:145
Header file for the IsHermitian type trait.
#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.