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 <blaze/math/Aliases.h>
46 #include <blaze/math/Exception.h>
72 #include <blaze/util/Assert.h>
75 #include <blaze/util/InvalidType.h>
76 #include <blaze/util/mpl/And.h>
77 #include <blaze/util/mpl/If.h>
78 #include <blaze/util/Types.h>
79 
80 
81 namespace blaze {
82 
83 //=================================================================================================
84 //
85 // CLASS DMATSERIALEXPR
86 //
87 //=================================================================================================
88 
89 //*************************************************************************************************
96 template< typename MT // Type of the dense matrix
97  , bool SO > // Storage order
98 class DMatSerialExpr : public DenseMatrix< DMatSerialExpr<MT,SO>, SO >
99  , private MatSerialExpr
100  , private Computation
101 {
102  public:
103  //**Type definitions****************************************************************************
110 
112  typedef const ResultType CompositeType;
113 
115  typedef If_< IsExpression<MT>, const MT, const MT& > Operand;
116  //**********************************************************************************************
117 
118  //**Compilation flags***************************************************************************
120  enum : bool { simdEnabled = false };
121 
123  enum : bool { smpAssignable = MT::smpAssignable };
124  //**********************************************************************************************
125 
126  //**Constructor*********************************************************************************
131  explicit inline DMatSerialExpr( const MT& dm ) noexcept
132  : dm_( dm ) // Dense matrix of the serial evaluation expression
133  {}
134  //**********************************************************************************************
135 
136  //**Access operator*****************************************************************************
143  inline ReturnType operator()( size_t i, size_t j ) const {
144  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
145  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
146  return dm_(i,j);
147  }
148  //**********************************************************************************************
149 
150  //**At function*********************************************************************************
158  inline ReturnType at( size_t i, size_t j ) const {
159  if( i >= dm_.rows() ) {
160  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
161  }
162  if( j >= dm_.columns() ) {
163  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
164  }
165  return (*this)(i,j);
166  }
167  //**********************************************************************************************
168 
169  //**Rows function*******************************************************************************
174  inline size_t rows() const noexcept {
175  return dm_.rows();
176  }
177  //**********************************************************************************************
178 
179  //**Columns function****************************************************************************
184  inline size_t columns() const noexcept {
185  return dm_.columns();
186  }
187  //**********************************************************************************************
188 
189  //**Operand access******************************************************************************
194  inline Operand operand() const noexcept {
195  return dm_;
196  }
197  //**********************************************************************************************
198 
199  //**Conversion operator*************************************************************************
204  inline operator Operand() const noexcept {
205  return dm_;
206  }
207  //**********************************************************************************************
208 
209  //**********************************************************************************************
215  template< typename T >
216  inline bool canAlias( const T* alias ) const noexcept {
217  return dm_.canAlias( alias );
218  }
219  //**********************************************************************************************
220 
221  //**********************************************************************************************
227  template< typename T >
228  inline bool isAliased( const T* alias ) const noexcept {
229  return dm_.isAliased( alias );
230  }
231  //**********************************************************************************************
232 
233  //**********************************************************************************************
238  inline bool isAligned() const noexcept {
239  return dm_.isAligned();
240  }
241  //**********************************************************************************************
242 
243  //**********************************************************************************************
248  inline bool canSMPAssign() const noexcept {
249  return dm_.canSMPAssign();
250  }
251  //**********************************************************************************************
252 
253  private:
254  //**Member variables****************************************************************************
255  Operand dm_;
256  //**********************************************************************************************
257 
258  //**Assignment to dense matrices****************************************************************
270  template< typename MT2 // Type of the target dense matrix
271  , bool SO2 > // Storage order of the target dense matrix
272  friend inline void assign( DenseMatrix<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  //**Assignment to sparse matrices***************************************************************
296  template< typename MT2 // Type of the target sparse matrix
297  , bool SO2 > // Storage order of the target dense matrix
298  friend inline void assign( SparseMatrix<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  assign( ~lhs, rhs.dm_ );
306  }
308  //**********************************************************************************************
309 
310  //**Addition assignment to dense matrices*******************************************************
322  template< typename MT2 // Type of the target dense matrix
323  , bool SO2 > // Storage order of the target dense matrix
324  friend inline void addAssign( DenseMatrix<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  //**Addition assignment to sparse matrices******************************************************
348  template< typename MT2 // Type of the target sparse matrix
349  , bool SO2 > // Storage order of the target dense matrix
350  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
351  {
353 
354  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
355  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
356 
357  addAssign( ~lhs, rhs.dm_ );
358  }
360  //**********************************************************************************************
361 
362  //**Subtraction assignment to dense matrices****************************************************
375  template< typename MT2 // Type of the target dense matrix
376  , bool SO2 > // Storage order of the target dense matrix
377  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
378  {
380 
381  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
382  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
383 
384  subAssign( ~lhs, rhs.dm_ );
385  }
387  //**********************************************************************************************
388 
389  //**Subtraction assignment to sparse matrices***************************************************
402  template< typename MT2 // Type of the target sparse matrix
403  , bool SO2 > // Storage order of the target dense matrix
404  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
405  {
407 
408  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
409  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
410 
411  subAssign( ~lhs, rhs.dm_ );
412  }
414  //**********************************************************************************************
415 
416  //**Multiplication assignment to dense matrices*************************************************
429  template< typename MT2 // Type of the target dense matrix
430  , bool SO2 > // Storage order of the target dense matrix
431  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
432  {
434 
435  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
436  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
437 
438  multAssign( ~lhs, rhs.sm_ );
439  }
441  //**********************************************************************************************
442 
443  //**Multiplication assignment to sparse matrices************************************************
456  template< typename MT2 // Type of the target sparse matrix
457  , bool SO2 > // Storage order of the target sparse matrix
458  friend inline void multAssign( SparseMatrix<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  multAssign( ~lhs, rhs.sm_ );
466  }
468  //**********************************************************************************************
469 
470  //**SMP assignment to dense matrices************************************************************
482  template< typename MT2 // Type of the target dense matrix
483  , bool SO2 > // Storage order of the target dense matrix
484  friend inline void smpAssign( DenseMatrix<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 assignment to sparse matrices***********************************************************
508  template< typename MT2 // Type of the target sparse matrix
509  , bool SO2 > // Storage order of the target dense matrix
510  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
511  {
513 
514  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
515  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
516 
517  assign( ~lhs, rhs.dm_ );
518  }
520  //**********************************************************************************************
521 
522  //**SMP addition assignment to dense matrices***************************************************
535  template< typename MT2 // Type of the target dense matrix
536  , bool SO2 > // Storage order of the target dense matrix
537  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
538  {
540 
541  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
542  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
543 
544  addAssign( ~lhs, rhs.dm_ );
545  }
547  //**********************************************************************************************
548 
549  //**SMP addition assignment to sparse matrices**************************************************
562  template< typename MT2 // Type of the target sparse matrix
563  , bool SO2 > // Storage order of the target dense matrix
564  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& 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  addAssign( ~lhs, rhs.dm_ );
572  }
574  //**********************************************************************************************
575 
576  //**SMP subtraction assignment to dense matrices************************************************
589  template< typename MT2 // Type of the target dense matrix
590  , bool SO2 > // Storage order of the target dense matrix
591  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
592  {
594 
595  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
596  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
597 
598  subAssign( ~lhs, rhs.dm_ );
599  }
601  //**********************************************************************************************
602 
603  //**SMP subtraction assignment to sparse matrices***********************************************
616  template< typename MT2 // Type of the target sparse matrix
617  , bool SO2 > // Storage order of the target dense matrix
618  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
619  {
621 
622  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
623  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
624 
625  subAssign( ~lhs, rhs.dm_ );
626  }
628  //**********************************************************************************************
629 
630  //**SMP multiplication assignment to dense matrices*********************************************
643  template< typename MT2 // Type of the target dense matrix
644  , bool SO2 > // Storage order of the target dense matrix
645  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
646  {
648 
649  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
650  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
651 
652  multAssign( ~lhs, rhs.sm_ );
653  }
655  //**********************************************************************************************
656 
657  //**SMP multiplication assignment to sparse matrices********************************************
670  template< typename MT2 // Type of the target sparse matrix
671  , bool SO2 > // Storage order of the target sparse matrix
672  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
673  {
675 
676  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
677  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
678 
679  multAssign( ~lhs, rhs.sm_ );
680  }
682  //**********************************************************************************************
683 
684  //**Compile time checks*************************************************************************
689  //**********************************************************************************************
690 };
691 //*************************************************************************************************
692 
693 
694 
695 
696 //=================================================================================================
697 //
698 // GLOBAL FUNCTIONS
699 //
700 //=================================================================================================
701 
702 //*************************************************************************************************
719 template< typename MT // Type of the dense matrix
720  , bool SO > // Storage order
722 {
724 
725  return DMatSerialExpr<MT,SO>( ~dm );
726 }
727 //*************************************************************************************************
728 
729 
730 
731 
732 //=================================================================================================
733 //
734 // GLOBAL RESTRUCTURING FUNCTIONS
735 //
736 //=================================================================================================
737 
738 //*************************************************************************************************
749 template< typename MT // Type of the dense matrix
750  , bool SO > // Storage order
751 inline const DMatSerialExpr<MT,SO> serial( const DMatSerialExpr<MT,SO>& dm )
752 {
753  return dm;
754 }
756 //*************************************************************************************************
757 
758 
759 
760 
761 //=================================================================================================
762 //
763 // ROWS SPECIALIZATIONS
764 //
765 //=================================================================================================
766 
767 //*************************************************************************************************
769 template< typename MT, bool SO >
770 struct Rows< DMatSerialExpr<MT,SO> > : public Rows<MT>
771 {};
773 //*************************************************************************************************
774 
775 
776 
777 
778 //=================================================================================================
779 //
780 // COLUMNS SPECIALIZATIONS
781 //
782 //=================================================================================================
783 
784 //*************************************************************************************************
786 template< typename MT, bool SO >
787 struct Columns< DMatSerialExpr<MT,SO> > : public Columns<MT>
788 {};
790 //*************************************************************************************************
791 
792 
793 
794 
795 //=================================================================================================
796 //
797 // ISALIGNED SPECIALIZATIONS
798 //
799 //=================================================================================================
800 
801 //*************************************************************************************************
803 template< typename MT, bool SO >
804 struct IsAligned< DMatSerialExpr<MT,SO> >
805  : public BoolConstant< IsAligned<MT>::value >
806 {};
808 //*************************************************************************************************
809 
810 
811 
812 
813 //=================================================================================================
814 //
815 // ISSYMMETRIC SPECIALIZATIONS
816 //
817 //=================================================================================================
818 
819 //*************************************************************************************************
821 template< typename MT, bool SO >
822 struct IsSymmetric< DMatSerialExpr<MT,SO> >
823  : public BoolConstant< IsSymmetric<MT>::value >
824 {};
826 //*************************************************************************************************
827 
828 
829 
830 
831 //=================================================================================================
832 //
833 // ISHERMITIAN SPECIALIZATIONS
834 //
835 //=================================================================================================
836 
837 //*************************************************************************************************
839 template< typename MT, bool SO >
840 struct IsHermitian< DMatSerialExpr<MT,SO> >
841  : public BoolConstant< IsHermitian<MT>::value >
842 {};
844 //*************************************************************************************************
845 
846 
847 
848 
849 //=================================================================================================
850 //
851 // ISLOWER SPECIALIZATIONS
852 //
853 //=================================================================================================
854 
855 //*************************************************************************************************
857 template< typename MT, bool SO >
858 struct IsLower< DMatSerialExpr<MT,SO> >
859  : public BoolConstant< IsLower<MT>::value >
860 {};
862 //*************************************************************************************************
863 
864 
865 
866 
867 //=================================================================================================
868 //
869 // ISUNILOWER SPECIALIZATIONS
870 //
871 //=================================================================================================
872 
873 //*************************************************************************************************
875 template< typename MT, bool SO >
876 struct IsUniLower< DMatSerialExpr<MT,SO> >
877  : public BoolConstant< IsUniLower<MT>::value >
878 {};
880 //*************************************************************************************************
881 
882 
883 
884 
885 //=================================================================================================
886 //
887 // ISSTRICTLYLOWER SPECIALIZATIONS
888 //
889 //=================================================================================================
890 
891 //*************************************************************************************************
893 template< typename MT, bool SO >
894 struct IsStrictlyLower< DMatSerialExpr<MT,SO> >
895  : public BoolConstant< IsStrictlyLower<MT>::value >
896 {};
898 //*************************************************************************************************
899 
900 
901 
902 
903 //=================================================================================================
904 //
905 // ISUPPER SPECIALIZATIONS
906 //
907 //=================================================================================================
908 
909 //*************************************************************************************************
911 template< typename MT, bool SO >
912 struct IsUpper< DMatSerialExpr<MT,SO> >
913  : public BoolConstant< IsUpper<MT>::value >
914 {};
916 //*************************************************************************************************
917 
918 
919 
920 
921 //=================================================================================================
922 //
923 // ISUNIUPPER SPECIALIZATIONS
924 //
925 //=================================================================================================
926 
927 //*************************************************************************************************
929 template< typename MT, bool SO >
930 struct IsUniUpper< DMatSerialExpr<MT,SO> >
931  : public BoolConstant< IsUniUpper<MT>::value >
932 {};
934 //*************************************************************************************************
935 
936 
937 
938 
939 //=================================================================================================
940 //
941 // ISSTRICTLYUPPER SPECIALIZATIONS
942 //
943 //=================================================================================================
944 
945 //*************************************************************************************************
947 template< typename MT, bool SO >
948 struct IsStrictlyUpper< DMatSerialExpr<MT,SO> >
949  : public BoolConstant< IsStrictlyUpper<MT>::value >
950 {};
952 //*************************************************************************************************
953 
954 
955 
956 
957 //=================================================================================================
958 //
959 // EXPRESSION TRAIT SPECIALIZATIONS
960 //
961 //=================================================================================================
962 
963 //*************************************************************************************************
965 template< typename MT >
966 struct DMatSerialExprTrait< DMatSerialExpr<MT,false> >
967 {
968  public:
969  //**********************************************************************************************
972  , INVALID_TYPE >;
973  //**********************************************************************************************
974 };
976 //*************************************************************************************************
977 
978 
979 //*************************************************************************************************
981 template< typename MT >
982 struct TDMatSerialExprTrait< DMatSerialExpr<MT,true> >
983 {
984  public:
985  //**********************************************************************************************
988  , INVALID_TYPE >;
989  //**********************************************************************************************
990 };
992 //*************************************************************************************************
993 
994 
995 //*************************************************************************************************
997 template< typename MT, bool SO, bool AF >
998 struct SubmatrixExprTrait< DMatSerialExpr<MT,SO>, AF >
999 {
1000  public:
1001  //**********************************************************************************************
1003  //**********************************************************************************************
1004 };
1006 //*************************************************************************************************
1007 
1008 
1009 //*************************************************************************************************
1011 template< typename MT, bool SO >
1012 struct RowExprTrait< DMatSerialExpr<MT,SO> >
1013 {
1014  public:
1015  //**********************************************************************************************
1017  //**********************************************************************************************
1018 };
1020 //*************************************************************************************************
1021 
1022 
1023 //*************************************************************************************************
1025 template< typename MT, bool SO >
1026 struct ColumnExprTrait< DMatSerialExpr<MT,SO> >
1027 {
1028  public:
1029  //**********************************************************************************************
1031  //**********************************************************************************************
1032 };
1034 //*************************************************************************************************
1035 
1036 } // namespace blaze
1037 
1038 #endif
Header file for auxiliary alias declarations.
DMatSerialExpr(const MT &dm) noexcept
Constructor for the DMatSerialExpr class.
Definition: DMatSerialExpr.h:131
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatSerialExpr.h:228
Header file for basic type definitions.
Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a ...
Definition: MatSerialExpr.h:65
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
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
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatSerialExpr.h:238
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSerialExpr.h:106
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.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatSerialExpr.h:216
Evaluation of the expression type of a dense matrix serial evaluation operation.Via this type trait i...
Definition: DMatSerialExprTrait.h:74
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatSerialExpr.h:109
Header file for the Computation base class.
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: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:71
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:119
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSerialExpr.h:112
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
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.
DMatSerialExpr< MT, SO > This
Type of this DMatSerialExpr instance.
Definition: DMatSerialExpr.h:104
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.
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:83
Expression object for the forced serial evaluation of dense matrices.The DMatSerialExpr class represe...
Definition: DMatSerialExpr.h:98
Header file for the DMatSerialExprTrait class template.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSerialExpr.h:143
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
Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to...
Definition: SubmatrixExprTrait.h:80
Header file for the IsLower type trait.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatSerialExpr.h:174
Header file for the IsAligned type trait.
Header file for the SerialExprTrait class template.
Evaluation of the expression type of a dense matrix serial evaluation operation.Via this type trait i...
Definition: TDMatSerialExprTrait.h:74
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.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Evaluation of the expression type type of a row operation.Via this type trait it is possible to evalu...
Definition: RowExprTrait.h:79
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 noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatSerialExpr.h:248
Header file for the IsStrictlyLower type trait.
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
Header file for the TDMatSerialExprTrait class template.
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatSerialExpr.h:108
Header file for the SubmatrixExprTrait class template.
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatSerialExpr.h:115
Header file for run time assertion macros.
Compile time check for column-major matrix types.This type trait tests whether or not the given templ...
Definition: IsColumnMajorMatrix.h:83
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:160
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:93
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatSerialExpr.h:184
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
Header file for the IsRowMajorMatrix type trait.
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatSerialExpr.h:107
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatSerialExpr.h:105
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatSerialExpr.h:158
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:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatSerialExpr.h:194
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.
Operand dm_
Dense matrix of the serial evaluation expression.
Definition: DMatSerialExpr.h:255
Header file for the IsHermitian type trait.
Evaluation of the expression type type of a column operation.Via this type trait it is possible to ev...
Definition: ColumnExprTrait.h:78
#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
typename SerialExprTrait< T >::Type SerialExprTrait_
Auxiliary alias declaration for the SerialExprTrait class template.The SerialExprTrait_ alias declara...
Definition: SerialExprTrait.h:142
Header file for the IsExpression type trait class.
Header file for the function trace functionality.