DMatSerialExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <cmath>
71 #include <blaze/util/Assert.h>
73 #include <blaze/util/Exception.h>
74 #include <blaze/util/InvalidType.h>
76 #include <blaze/util/SelectType.h>
77 #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****************************************************************************
105  typedef typename MT::ResultType ResultType;
106  typedef typename MT::OppositeType OppositeType;
107  typedef typename MT::TransposeType TransposeType;
108  typedef typename MT::ElementType ElementType;
109  typedef typename MT::ReturnType ReturnType;
110 
112  typedef const ResultType CompositeType;
113 
115  typedef typename SelectType< IsExpression<MT>::value, const MT, const MT& >::Type Operand;
116  //**********************************************************************************************
117 
118  //**Compilation flags***************************************************************************
120  enum { vectorizable = 0 };
121 
123  enum { smpAssignable = MT::smpAssignable };
124  //**********************************************************************************************
125 
126  //**Constructor*********************************************************************************
131  explicit inline DMatSerialExpr( const MT& dm )
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 {
175  return dm_.rows();
176  }
177  //**********************************************************************************************
178 
179  //**Columns function****************************************************************************
184  inline size_t columns() const {
185  return dm_.columns();
186  }
187  //**********************************************************************************************
188 
189  //**Operand access******************************************************************************
194  inline Operand operand() const {
195  return dm_;
196  }
197  //**********************************************************************************************
198 
199  //**Conversion operator*************************************************************************
204  inline operator Operand() const {
205  return dm_;
206  }
207  //**********************************************************************************************
208 
209  //**********************************************************************************************
215  template< typename T >
216  inline bool canAlias( const T* alias ) const {
217  return dm_.canAlias( alias );
218  }
219  //**********************************************************************************************
220 
221  //**********************************************************************************************
227  template< typename T >
228  inline bool isAliased( const T* alias ) const {
229  return dm_.isAliased( alias );
230  }
231  //**********************************************************************************************
232 
233  //**********************************************************************************************
238  inline bool isAligned() const {
239  return dm_.isAligned();
240  }
241  //**********************************************************************************************
242 
243  //**********************************************************************************************
248  inline bool canSMPAssign() const {
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> > : public IsTrue< IsAligned<MT>::value >
805 {};
807 //*************************************************************************************************
808 
809 
810 
811 
812 //=================================================================================================
813 //
814 // ISSYMMETRIC SPECIALIZATIONS
815 //
816 //=================================================================================================
817 
818 //*************************************************************************************************
820 template< typename MT, bool SO >
821 struct IsSymmetric< DMatSerialExpr<MT,SO> > : public IsTrue< IsSymmetric<MT>::value >
822 {};
824 //*************************************************************************************************
825 
826 
827 
828 
829 //=================================================================================================
830 //
831 // ISHERMITIAN SPECIALIZATIONS
832 //
833 //=================================================================================================
834 
835 //*************************************************************************************************
837 template< typename MT, bool SO >
838 struct IsHermitian< DMatSerialExpr<MT,SO> > : public IsTrue< IsHermitian<MT>::value >
839 {};
841 //*************************************************************************************************
842 
843 
844 
845 
846 //=================================================================================================
847 //
848 // ISLOWER SPECIALIZATIONS
849 //
850 //=================================================================================================
851 
852 //*************************************************************************************************
854 template< typename MT, bool SO >
855 struct IsLower< DMatSerialExpr<MT,SO> > : public IsTrue< IsLower<MT>::value >
856 {};
858 //*************************************************************************************************
859 
860 
861 
862 
863 //=================================================================================================
864 //
865 // ISUNILOWER SPECIALIZATIONS
866 //
867 //=================================================================================================
868 
869 //*************************************************************************************************
871 template< typename MT, bool SO >
872 struct IsUniLower< DMatSerialExpr<MT,SO> > : public IsTrue< IsUniLower<MT>::value >
873 {};
875 //*************************************************************************************************
876 
877 
878 
879 
880 //=================================================================================================
881 //
882 // ISSTRICTLYLOWER SPECIALIZATIONS
883 //
884 //=================================================================================================
885 
886 //*************************************************************************************************
888 template< typename MT, bool SO >
889 struct IsStrictlyLower< DMatSerialExpr<MT,SO> > : public IsTrue< IsStrictlyLower<MT>::value >
890 {};
892 //*************************************************************************************************
893 
894 
895 
896 
897 //=================================================================================================
898 //
899 // ISUPPER SPECIALIZATIONS
900 //
901 //=================================================================================================
902 
903 //*************************************************************************************************
905 template< typename MT, bool SO >
906 struct IsUpper< DMatSerialExpr<MT,SO> > : public IsTrue< IsUpper<MT>::value >
907 {};
909 //*************************************************************************************************
910 
911 
912 
913 
914 //=================================================================================================
915 //
916 // ISUNIUPPER SPECIALIZATIONS
917 //
918 //=================================================================================================
919 
920 //*************************************************************************************************
922 template< typename MT, bool SO >
923 struct IsUniUpper< DMatSerialExpr<MT,SO> > : public IsTrue< IsUniUpper<MT>::value >
924 {};
926 //*************************************************************************************************
927 
928 
929 
930 
931 //=================================================================================================
932 //
933 // ISSTRICTLYUPPER SPECIALIZATIONS
934 //
935 //=================================================================================================
936 
937 //*************************************************************************************************
939 template< typename MT, bool SO >
940 struct IsStrictlyUpper< DMatSerialExpr<MT,SO> > : public IsTrue< IsStrictlyUpper<MT>::value >
941 {};
943 //*************************************************************************************************
944 
945 
946 
947 
948 //=================================================================================================
949 //
950 // EXPRESSION TRAIT SPECIALIZATIONS
951 //
952 //=================================================================================================
953 
954 //*************************************************************************************************
956 template< typename MT >
957 struct DMatSerialExprTrait< DMatSerialExpr<MT,false> >
958 {
959  public:
960  //**********************************************************************************************
961  typedef typename SelectType< IsDenseMatrix<MT>::value && IsRowMajorMatrix<MT>::value
962  , DMatSerialExpr<MT,false>
963  , INVALID_TYPE >::Type Type;
964  //**********************************************************************************************
965 };
967 //*************************************************************************************************
968 
969 
970 //*************************************************************************************************
972 template< typename MT >
973 struct TDMatSerialExprTrait< DMatSerialExpr<MT,true> >
974 {
975  public:
976  //**********************************************************************************************
977  typedef typename SelectType< IsDenseMatrix<MT>::value && IsColumnMajorMatrix<MT>::value
978  , DMatSerialExpr<MT,true>
979  , INVALID_TYPE >::Type Type;
980  //**********************************************************************************************
981 };
983 //*************************************************************************************************
984 
985 
986 //*************************************************************************************************
988 template< typename MT, bool SO, bool AF >
989 struct SubmatrixExprTrait< DMatSerialExpr<MT,SO>, AF >
990 {
991  public:
992  //**********************************************************************************************
993  typedef typename SerialExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
994  //**********************************************************************************************
995 };
997 //*************************************************************************************************
998 
999 
1000 //*************************************************************************************************
1002 template< typename MT, bool SO >
1003 struct RowExprTrait< DMatSerialExpr<MT,SO> >
1004 {
1005  public:
1006  //**********************************************************************************************
1007  typedef typename SerialExprTrait< typename RowExprTrait<const MT>::Type >::Type Type;
1008  //**********************************************************************************************
1009 };
1011 //*************************************************************************************************
1012 
1013 
1014 //*************************************************************************************************
1016 template< typename MT, bool SO >
1017 struct ColumnExprTrait< DMatSerialExpr<MT,SO> >
1018 {
1019  public:
1020  //**********************************************************************************************
1021  typedef typename SerialExprTrait< typename ColumnExprTrait<const MT>::Type >::Type Type;
1022  //**********************************************************************************************
1023 };
1025 //*************************************************************************************************
1026 
1027 } // namespace blaze
1028 
1029 #endif
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
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
MT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatSerialExpr.h:107
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatSerialExpr.h:184
#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:81
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
Header file for the Computation base class.
MT::ResultType ResultType
Result type for expression template evaluations.
Definition: DMatSerialExpr.h:105
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSerialExpr.h:143
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatSerialExpr.h:238
Header file for the IsUniLower type trait.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2584
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:117
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSerialExpr.h:112
Constraint on the data type.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatSerialExpr.h:174
Constraint on the data type.
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
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
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.
MT::ElementType ElementType
Resulting element type.
Definition: DMatSerialExpr.h:108
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatSerialExpr.h:216
DMatSerialExpr(const MT &dm)
Constructor for the DMatSerialExpr class.
Definition: DMatSerialExpr.h:131
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
Header file for the SerialExprTrait class template.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2585
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the IsDenseMatrix type trait.
Header file for the MatSerialExpr base class.
Header file for the IsStrictlyLower type trait.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatSerialExpr.h:248
Header file for the TDMatSerialExprTrait class template.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatSerialExpr.h:228
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Utility type for generic codes.
MT::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSerialExpr.h:106
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatSerialExpr.h:158
MT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DMatSerialExpr.h:109
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type Operand
Composite data type of the dense matrix expression.
Definition: DMatSerialExpr.h:115
Header file for the IsRowMajorMatrix type trait.
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
Header file for the IsTrue value trait.
Operand operand() const
Returns the dense matrix operand.
Definition: DMatSerialExpr.h:194
Header file for the IsUpper type trait.
Header file for exception macros.
Operand dm_
Dense matrix of the serial evaluation expression.
Definition: DMatSerialExpr.h:255
Header file for the IsHermitian type trait.
EnableIf< IsDenseVector< VT1 > >::Type smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:189
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.