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 <blaze/math/Aliases.h>
46 #include <blaze/math/Exception.h>
63 #include <blaze/util/Assert.h>
66 #include <blaze/util/InvalidType.h>
67 #include <blaze/util/mpl/If.h>
68 #include <blaze/util/Types.h>
69 
70 
71 namespace blaze {
72 
73 //=================================================================================================
74 //
75 // CLASS DMATEVALEXPR
76 //
77 //=================================================================================================
78 
79 //*************************************************************************************************
86 template< typename MT // Type of the dense matrix
87  , bool SO > // Storage order
89  : public MatEvalExpr< DenseMatrix< DMatEvalExpr<MT,SO>, SO > >
90  , private Computation
91 {
92  public:
93  //**Type definitions****************************************************************************
100 
102  using CompositeType = const ResultType;
103 
105  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
106  //**********************************************************************************************
107 
108  //**Compilation flags***************************************************************************
110  enum : bool { simdEnabled = false };
111 
113  enum : bool { smpAssignable = MT::smpAssignable };
114  //**********************************************************************************************
115 
116  //**Constructor*********************************************************************************
121  explicit inline DMatEvalExpr( const MT& dm ) noexcept
122  : dm_( dm ) // Dense matrix of the evaluation expression
123  {}
124  //**********************************************************************************************
125 
126  //**Access operator*****************************************************************************
133  inline ReturnType operator()( size_t i, size_t j ) const {
134  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
135  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
136  return dm_(i,j);
137  }
138  //**********************************************************************************************
139 
140  //**At function*********************************************************************************
148  inline ReturnType at( size_t i, size_t j ) const {
149  if( i >= dm_.rows() ) {
150  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
151  }
152  if( j >= dm_.columns() ) {
153  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
154  }
155  return (*this)(i,j);
156  }
157  //**********************************************************************************************
158 
159  //**Rows function*******************************************************************************
164  inline size_t rows() const noexcept {
165  return dm_.rows();
166  }
167  //**********************************************************************************************
168 
169  //**Columns function****************************************************************************
174  inline size_t columns() const noexcept {
175  return dm_.columns();
176  }
177  //**********************************************************************************************
178 
179  //**Operand access******************************************************************************
184  inline Operand operand() const noexcept {
185  return dm_;
186  }
187  //**********************************************************************************************
188 
189  //**********************************************************************************************
195  template< typename T >
196  inline bool canAlias( const T* alias ) const noexcept {
197  return dm_.canAlias( alias );
198  }
199  //**********************************************************************************************
200 
201  //**********************************************************************************************
207  template< typename T >
208  inline bool isAliased( const T* alias ) const noexcept {
209  return dm_.isAliased( alias );
210  }
211  //**********************************************************************************************
212 
213  //**********************************************************************************************
218  inline bool isAligned() const noexcept {
219  return dm_.isAligned();
220  }
221  //**********************************************************************************************
222 
223  //**********************************************************************************************
228  inline bool canSMPAssign() const noexcept {
229  return dm_.canSMPAssign();
230  }
231  //**********************************************************************************************
232 
233  private:
234  //**Member variables****************************************************************************
236  //**********************************************************************************************
237 
238  //**Assignment to dense matrices****************************************************************
250  template< typename MT2 // Type of the target dense matrix
251  , bool SO2 > // Storage order of the target dense matrix
252  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
253  {
255 
256  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
257  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
258 
259  assign( ~lhs, rhs.dm_ );
260  }
262  //**********************************************************************************************
263 
264  //**Assignment to sparse matrices***************************************************************
276  template< typename MT2 // Type of the target sparse matrix
277  , bool SO2 > // Storage order of the target dense matrix
278  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
279  {
281 
282  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
283  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
284 
285  assign( ~lhs, rhs.dm_ );
286  }
288  //**********************************************************************************************
289 
290  //**Addition assignment to dense matrices*******************************************************
302  template< typename MT2 // Type of the target dense matrix
303  , bool SO2 > // Storage order of the target dense matrix
304  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
305  {
307 
308  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
309  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
310 
311  addAssign( ~lhs, rhs.dm_ );
312  }
314  //**********************************************************************************************
315 
316  //**Addition assignment to sparse matrices******************************************************
328  template< typename MT2 // Type of the target sparse matrix
329  , bool SO2 > // Storage order of the target dense matrix
330  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
331  {
333 
334  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
335  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
336 
337  addAssign( ~lhs, rhs.dm_ );
338  }
340  //**********************************************************************************************
341 
342  //**Subtraction assignment to dense matrices****************************************************
354  template< typename MT2 // Type of the target dense matrix
355  , bool SO2 > // Storage order of the target dense matrix
356  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
357  {
359 
360  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
361  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
362 
363  subAssign( ~lhs, rhs.dm_ );
364  }
366  //**********************************************************************************************
367 
368  //**Subtraction assignment to sparse matrices***************************************************
380  template< typename MT2 // Type of the target sparse matrix
381  , bool SO2 > // Storage order of the target dense matrix
382  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
383  {
385 
386  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
387  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
388 
389  subAssign( ~lhs, rhs.dm_ );
390  }
392  //**********************************************************************************************
393 
394  //**Schur product assignment to dense matrices**************************************************
406  template< typename MT2 // Type of the target dense matrix
407  , bool SO2 > // Storage order of the target dense matrix
408  friend inline void schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
409  {
411 
412  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
413  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
414 
415  schurAssign( ~lhs, rhs.dm_ );
416  }
418  //**********************************************************************************************
419 
420  //**Schur product assignment to sparse matrices*************************************************
432  template< typename MT2 // Type of the target sparse matrix
433  , bool SO2 > // Storage order of the target dense matrix
434  friend inline void schurAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
435  {
437 
438  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
439  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
440 
441  schurAssign( ~lhs, rhs.dm_ );
442  }
444  //**********************************************************************************************
445 
446  //**Multiplication assignment to dense matrices*************************************************
458  template< typename MT2 // Type of the target dense matrix
459  , bool SO2 > // Storage order of the target dense matrix
460  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
461  {
463 
464  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
465  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
466 
467  multAssign( ~lhs, rhs.dm_ );
468  }
470  //**********************************************************************************************
471 
472  //**Multiplication assignment to sparse matrices************************************************
484  template< typename MT2 // Type of the target sparse matrix
485  , bool SO2 > // Storage order of the target dense matrix
486  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
487  {
489 
490  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
491  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
492 
493  multAssign( ~lhs, rhs.dm_ );
494  }
496  //**********************************************************************************************
497 
498  //**SMP assignment to dense matrices************************************************************
510  template< typename MT2 // Type of the target dense matrix
511  , bool SO2 > // Storage order of the target dense matrix
512  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
513  {
515 
516  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
517  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
518 
519  smpAssign( ~lhs, rhs.dm_ );
520  }
522  //**********************************************************************************************
523 
524  //**SMP 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 smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& 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  smpAssign( ~lhs, rhs.dm_ );
546  }
548  //**********************************************************************************************
549 
550  //**SMP addition assignment to dense matrices***************************************************
562  template< typename MT2 // Type of the target dense matrix
563  , bool SO2 > // Storage order of the target dense matrix
564  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
565  {
567 
568  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
569  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
570 
571  smpAddAssign( ~lhs, rhs.dm_ );
572  }
574  //**********************************************************************************************
575 
576  //**SMP addition assignment to sparse matrices**************************************************
588  template< typename MT2 // Type of the target sparse matrix
589  , bool SO2 > // Storage order of the target dense matrix
590  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
591  {
593 
594  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
595  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
596 
597  smpAddAssign( ~lhs, rhs.dm_ );
598  }
600  //**********************************************************************************************
601 
602  //**SMP subtraction assignment to dense matrices************************************************
614  template< typename MT2 // Type of the target dense matrix
615  , bool SO2 > // Storage order of the target dense matrix
616  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
617  {
619 
620  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
621  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
622 
623  smpSubAssign( ~lhs, rhs.dm_ );
624  }
626  //**********************************************************************************************
627 
628  //**SMP subtraction assignment to sparse matrices***********************************************
640  template< typename MT2 // Type of the target sparse matrix
641  , bool SO2 > // Storage order of the target dense matrix
642  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
643  {
645 
646  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
647  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
648 
649  smpSubAssign( ~lhs, rhs.dm_ );
650  }
652  //**********************************************************************************************
653 
654  //**SMP Schur product assignment to dense matrices**********************************************
666  template< typename MT2 // Type of the target dense matrix
667  , bool SO2 > // Storage order of the target dense matrix
668  friend inline void smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
669  {
671 
672  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
673  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
674 
675  smpSchurAssign( ~lhs, rhs.dm_ );
676  }
678  //**********************************************************************************************
679 
680  //**SMP Schur product assignment to sparse matrices*********************************************
692  template< typename MT2 // Type of the target sparse matrix
693  , bool SO2 > // Storage order of the target dense matrix
694  friend inline void smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
695  {
697 
698  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
699  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
700 
701  smpSchurAssign( ~lhs, rhs.dm_ );
702  }
704  //**********************************************************************************************
705 
706  //**SMP multiplication assignment to dense matrices*********************************************
719  template< typename MT2 // Type of the target dense matrix
720  , bool SO2 > // Storage order of the target dense matrix
721  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
722  {
724 
725  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
726  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
727 
728  smpMultAssign( ~lhs, rhs.dm_ );
729  }
731  //**********************************************************************************************
732 
733  //**SMP multiplication assignment to sparse matrices********************************************
746  template< typename MT2 // Type of the target sparse matrix
747  , bool SO2 > // Storage order of the target dense matrix
748  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
749  {
751 
752  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
753  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
754 
755  smpMultAssign( ~lhs, rhs.dm_ );
756  }
758  //**********************************************************************************************
759 
760  //**Compile time checks*************************************************************************
765  //**********************************************************************************************
766 };
767 //*************************************************************************************************
768 
769 
770 
771 
772 //=================================================================================================
773 //
774 // GLOBAL FUNCTIONS
775 //
776 //=================================================================================================
777 
778 //*************************************************************************************************
795 template< typename MT // Type of the dense matrix
796  , bool SO > // Storage order
797 inline decltype(auto) eval( const DenseMatrix<MT,SO>& dm )
798 {
800 
801  using ReturnType = const DMatEvalExpr<MT,SO>;
802  return ReturnType( ~dm );
803 }
804 //*************************************************************************************************
805 
806 
807 
808 
809 //=================================================================================================
810 //
811 // GLOBAL RESTRUCTURING FUNCTIONS
812 //
813 //=================================================================================================
814 
815 //*************************************************************************************************
826 template< typename MT // Type of the dense matrix
827  , bool SO > // Storage order
828 inline decltype(auto) eval( const DMatEvalExpr<MT,SO>& dm )
829 {
830  return dm;
831 }
833 //*************************************************************************************************
834 
835 
836 
837 
838 //=================================================================================================
839 //
840 // ROWS SPECIALIZATIONS
841 //
842 //=================================================================================================
843 
844 //*************************************************************************************************
846 template< typename MT, bool SO >
847 struct Rows< DMatEvalExpr<MT,SO> >
848  : public Rows<MT>
849 {};
851 //*************************************************************************************************
852 
853 
854 
855 
856 //=================================================================================================
857 //
858 // COLUMNS SPECIALIZATIONS
859 //
860 //=================================================================================================
861 
862 //*************************************************************************************************
864 template< typename MT, bool SO >
865 struct Columns< DMatEvalExpr<MT,SO> >
866  : public Columns<MT>
867 {};
869 //*************************************************************************************************
870 
871 
872 
873 
874 //=================================================================================================
875 //
876 // ISALIGNED SPECIALIZATIONS
877 //
878 //=================================================================================================
879 
880 //*************************************************************************************************
882 template< typename MT, bool SO >
883 struct IsAligned< DMatEvalExpr<MT,SO> >
884  : public BoolConstant< IsAligned<MT>::value >
885 {};
887 //*************************************************************************************************
888 
889 
890 
891 
892 //=================================================================================================
893 //
894 // ISSYMMETRIC SPECIALIZATIONS
895 //
896 //=================================================================================================
897 
898 //*************************************************************************************************
900 template< typename MT, bool SO >
901 struct IsSymmetric< DMatEvalExpr<MT,SO> >
902  : public BoolConstant< IsSymmetric<MT>::value >
903 {};
905 //*************************************************************************************************
906 
907 
908 
909 
910 //=================================================================================================
911 //
912 // ISHERMITIAN SPECIALIZATIONS
913 //
914 //=================================================================================================
915 
916 //*************************************************************************************************
918 template< typename MT, bool SO >
919 struct IsHermitian< DMatEvalExpr<MT,SO> >
920  : public BoolConstant< IsHermitian<MT>::value >
921 {};
923 //*************************************************************************************************
924 
925 
926 
927 
928 //=================================================================================================
929 //
930 // ISLOWER SPECIALIZATIONS
931 //
932 //=================================================================================================
933 
934 //*************************************************************************************************
936 template< typename MT, bool SO >
937 struct IsLower< DMatEvalExpr<MT,SO> >
938  : public BoolConstant< IsLower<MT>::value >
939 {};
941 //*************************************************************************************************
942 
943 
944 
945 
946 //=================================================================================================
947 //
948 // ISUNILOWER SPECIALIZATIONS
949 //
950 //=================================================================================================
951 
952 //*************************************************************************************************
954 template< typename MT, bool SO >
955 struct IsUniLower< DMatEvalExpr<MT,SO> >
956  : public BoolConstant< IsUniLower<MT>::value >
957 {};
959 //*************************************************************************************************
960 
961 
962 
963 
964 //=================================================================================================
965 //
966 // ISSTRICTLYLOWER SPECIALIZATIONS
967 //
968 //=================================================================================================
969 
970 //*************************************************************************************************
972 template< typename MT, bool SO >
973 struct IsStrictlyLower< DMatEvalExpr<MT,SO> >
974  : public BoolConstant< IsStrictlyLower<MT>::value >
975 {};
977 //*************************************************************************************************
978 
979 
980 
981 
982 //=================================================================================================
983 //
984 // ISUPPER SPECIALIZATIONS
985 //
986 //=================================================================================================
987 
988 //*************************************************************************************************
990 template< typename MT, bool SO >
991 struct IsUpper< DMatEvalExpr<MT,SO> >
992  : public BoolConstant< IsUpper<MT>::value >
993 {};
995 //*************************************************************************************************
996 
997 
998 
999 
1000 //=================================================================================================
1001 //
1002 // ISUNIUPPER SPECIALIZATIONS
1003 //
1004 //=================================================================================================
1005 
1006 //*************************************************************************************************
1008 template< typename MT, bool SO >
1009 struct IsUniUpper< DMatEvalExpr<MT,SO> >
1010  : public BoolConstant< IsUniUpper<MT>::value >
1011 {};
1013 //*************************************************************************************************
1014 
1015 
1016 
1017 
1018 //=================================================================================================
1019 //
1020 // ISSTRICTLYUPPER SPECIALIZATIONS
1021 //
1022 //=================================================================================================
1023 
1024 //*************************************************************************************************
1026 template< typename MT, bool SO >
1027 struct IsStrictlyUpper< DMatEvalExpr<MT,SO> >
1028  : public BoolConstant< IsStrictlyUpper<MT>::value >
1029 {};
1031 //*************************************************************************************************
1032 
1033 } // namespace blaze
1034 
1035 #endif
DMatEvalExpr(const MT &dm) noexcept
Constructor for the DMatEvalExpr class.
Definition: DMatEvalExpr.h:121
Header file for auxiliary alias declarations.
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
EnableIf_< IsDenseMatrix< MT1 > > smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:196
Header file for basic type definitions.
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:164
#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
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
#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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatEvalExpr.h:148
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
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatEvalExpr.h:105
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
Header file for the MatEvalExpr base class.
Header file for the Computation base class.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatEvalExpr.h:228
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatEvalExpr.h:184
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
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:343
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:133
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
Constraint on the data type.
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
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
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatEvalExpr.h:218
Header file for the If class template.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatEvalExpr.h:133
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:102
#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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatEvalExpr.h:196
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:797
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Header file for the exception macros of the math module.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatEvalExpr.h:164
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatEvalExpr.h:96
Header file for all forward declarations for expression class templates.
Header file for the IsStrictlyLower type trait.
Operand dm_
Dense matrix of the evaluation expression.
Definition: DMatEvalExpr.h:235
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatEvalExpr.h:174
Header file for run time assertion macros.
Utility type for generic codes.
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:154
Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for a...
Definition: MatEvalExpr.h:66
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatEvalExpr.h:98
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatEvalExpr.h:95
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatEvalExpr.h:99
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatEvalExpr.h:208
Expression object for the forced evaluation of dense matrices.The DMatEvalExpr class represents the c...
Definition: DMatEvalExpr.h:88
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:66
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatEvalExpr.h:97
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatEvalExpr.h:102
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 function trace functionality.