TDMatSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDMATSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDMATSMATADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
78 #include <blaze/util/Assert.h>
80 #include <blaze/util/EnableIf.h>
82 #include <blaze/util/InvalidType.h>
84 #include <blaze/util/mpl/And.h>
85 #include <blaze/util/mpl/If.h>
86 #include <blaze/util/mpl/Max.h>
87 #include <blaze/util/mpl/Or.h>
88 #include <blaze/util/Types.h>
89 
90 
91 namespace blaze {
92 
93 //=================================================================================================
94 //
95 // CLASS TDMATSMATADDEXPR
96 //
97 //=================================================================================================
98 
99 //*************************************************************************************************
106 template< typename MT1 // Type of the left-hand side dense matrix
107  , typename MT2 > // Type of the right-hand side sparse matrix
108 class TDMatSMatAddExpr : public DenseMatrix< TDMatSMatAddExpr<MT1,MT2>, true >
109  , private MatMatAddExpr
110  , private Computation
111 {
112  private:
113  //**Type definitions****************************************************************************
118  //**********************************************************************************************
119 
120  //**Return type evaluation**********************************************************************
122 
127  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
128 
131  //**********************************************************************************************
132 
133  //**Parallel evaluation strategy****************************************************************
135 
140  template< typename MT >
141  struct UseSMPAssign {
142  enum : bool { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
143  };
145  //**********************************************************************************************
146 
147  public:
148  //**Type definitions****************************************************************************
154 
157 
159  typedef const ResultType CompositeType;
160 
162  typedef If_< IsExpression<MT1>, const MT1, const MT1& > LeftOperand;
163 
165  typedef If_< IsExpression<MT2>, const MT2, const MT2& > RightOperand;
166  //**********************************************************************************************
167 
168  //**Compilation flags***************************************************************************
170  enum : bool { simdEnabled = false };
171 
173  enum : bool { smpAssignable = false };
174  //**********************************************************************************************
175 
176  //**Constructor*********************************************************************************
182  explicit inline TDMatSMatAddExpr( const MT1& lhs, const MT2& rhs ) noexcept
183  : lhs_( lhs ) // Left-hand side dense matrix of the addition expression
184  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
185  {
186  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
187  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
188  }
189  //**********************************************************************************************
190 
191  //**Access operator*****************************************************************************
198  inline ReturnType operator()( size_t i, size_t j ) const {
199  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
200  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
201  return lhs_(i,j) + rhs_(i,j);
202  }
203  //**********************************************************************************************
204 
205  //**At function*********************************************************************************
213  inline ReturnType at( size_t i, size_t j ) const {
214  if( i >= lhs_.rows() ) {
215  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
216  }
217  if( j >= lhs_.columns() ) {
218  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
219  }
220  return (*this)(i,j);
221  }
222  //**********************************************************************************************
223 
224  //**Rows function*******************************************************************************
229  inline size_t rows() const noexcept {
230  return lhs_.rows();
231  }
232  //**********************************************************************************************
233 
234  //**Columns function****************************************************************************
239  inline size_t columns() const noexcept {
240  return lhs_.columns();
241  }
242  //**********************************************************************************************
243 
244  //**Left operand access*************************************************************************
249  inline LeftOperand leftOperand() const noexcept {
250  return lhs_;
251  }
252  //**********************************************************************************************
253 
254  //**Right operand access************************************************************************
259  inline RightOperand rightOperand() const noexcept {
260  return rhs_;
261  }
262  //**********************************************************************************************
263 
264  //**********************************************************************************************
270  template< typename T >
271  inline bool canAlias( const T* alias ) const noexcept {
272  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
273  ( rhs_.canAlias( alias ) );
274  }
275  //**********************************************************************************************
276 
277  //**********************************************************************************************
283  template< typename T >
284  inline bool isAliased( const T* alias ) const noexcept {
285  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
286  }
287  //**********************************************************************************************
288 
289  private:
290  //**Member variables****************************************************************************
291  LeftOperand lhs_;
292  RightOperand rhs_;
293  //**********************************************************************************************
294 
295  //**Assignment to dense matrices****************************************************************
307  template< typename MT // Type of the target dense matrix
308  , bool SO2 > // Storage order of the target dense matrix
309  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
310  {
312 
313  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
314  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
315 
316  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
317  addAssign( ~lhs, rhs.rhs_ );
318  }
319  else {
320  assign ( ~lhs, rhs.lhs_ );
321  addAssign( ~lhs, rhs.rhs_ );
322  }
323  }
325  //**********************************************************************************************
326 
327  //**Assignment to sparse matrices***************************************************************
339  template< typename MT // Type of the target sparse matrix
340  , bool SO2 > // Storage order of the target sparse matrix
341  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
342  {
344 
346 
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  const TmpType tmp( serial( rhs ) );
358  assign( ~lhs, tmp );
359  }
361  //**********************************************************************************************
362 
363  //**Addition assignment to dense matrices*******************************************************
376  template< typename MT // Type of the target dense matrix
377  , bool SO2 > // Storage order of the target dense matrix
378  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
379  {
381 
382  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
383  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
384 
385  addAssign( ~lhs, rhs.lhs_ );
386  addAssign( ~lhs, rhs.rhs_ );
387  }
389  //**********************************************************************************************
390 
391  //**Addition assignment to sparse matrices******************************************************
392  // No special implementation for the addition assignment to sparse matrices.
393  //**********************************************************************************************
394 
395  //**Subtraction assignment to dense matrices****************************************************
408  template< typename MT // Type of the target dense matrix
409  , bool SO2 > // Storage order of the target dense matrix
410  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
411  {
413 
414  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
415  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
416 
417  subAssign( ~lhs, rhs.lhs_ );
418  subAssign( ~lhs, rhs.rhs_ );
419  }
421  //**********************************************************************************************
422 
423  //**Subtraction assignment to sparse matrices***************************************************
424  // No special implementation for the subtraction assignment to sparse matrices.
425  //**********************************************************************************************
426 
427  //**Multiplication assignment to dense matrices*************************************************
428  // No special implementation for the multiplication assignment to dense matrices.
429  //**********************************************************************************************
430 
431  //**Multiplication assignment to sparse matrices************************************************
432  // No special implementation for the multiplication assignment to sparse matrices.
433  //**********************************************************************************************
434 
435  //**SMP assignment to dense matrices************************************************************
449  template< typename MT // Type of the target dense matrix
450  , bool SO2 > // Storage order of the target dense matrix
451  friend inline EnableIf_< UseSMPAssign<MT> >
452  smpAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
453  {
455 
456  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
457  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
458 
459  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
460  smpAddAssign( ~lhs, rhs.rhs_ );
461  }
462  else {
463  smpAssign ( ~lhs, rhs.lhs_ );
464  smpAddAssign( ~lhs, rhs.rhs_ );
465  }
466  }
468  //**********************************************************************************************
469 
470  //**SMP assignment to sparse matrices***********************************************************
484  template< typename MT // Type of the target sparse matrix
485  , bool SO2 > // Storage order of the target sparse matrix
486  friend inline EnableIf_< UseSMPAssign<MT> >
487  smpAssign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
488  {
490 
491  typedef IfTrue_< SO2, ResultType, OppositeType > TmpType;
492 
498  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<TmpType> );
499 
500  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
501  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
502 
503  const TmpType tmp( rhs );
504  smpAssign( ~lhs, tmp );
505  }
507  //**********************************************************************************************
508 
509  //**SMP addition assignment to dense matrices***************************************************
524  template< typename MT // Type of the target dense matrix
525  , bool SO2 > // Storage order of the target dense matrix
526  friend inline EnableIf_< UseSMPAssign<MT> >
527  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
528  {
530 
531  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
532  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
533 
534  smpAddAssign( ~lhs, rhs.lhs_ );
535  smpAddAssign( ~lhs, rhs.rhs_ );
536  }
538  //**********************************************************************************************
539 
540  //**SMP addition assignment to sparse matrices**************************************************
541  // No special implementation for the SMP addition assignment to sparse matrices.
542  //**********************************************************************************************
543 
544  //**SMP subtraction assignment to dense matrices************************************************
559  template< typename MT // Type of the target dense matrix
560  , bool SO2 > // Storage order of the target dense matrix
561  friend inline EnableIf_< UseSMPAssign<MT> >
562  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
563  {
565 
566  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
567  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
568 
569  smpSubAssign( ~lhs, rhs.lhs_ );
570  smpSubAssign( ~lhs, rhs.rhs_ );
571  }
573  //**********************************************************************************************
574 
575  //**SMP subtraction assignment to sparse matrices***********************************************
576  // No special implementation for the SMP subtraction assignment to sparse matrices.
577  //**********************************************************************************************
578 
579  //**SMP multiplication assignment to dense matrices*********************************************
580  // No special implementation for the SMP multiplication assignment to dense matrices.
581  //**********************************************************************************************
582 
583  //**SMP multiplication assignment to sparse matrices********************************************
584  // No special implementation for the SMP multiplication assignment to sparse matrices.
585  //**********************************************************************************************
586 
587  //**Compile time checks*************************************************************************
595  //**********************************************************************************************
596 };
597 //*************************************************************************************************
598 
599 
600 
601 
602 //=================================================================================================
603 //
604 // GLOBAL BINARY ARITHMETIC OPERATORS
605 //
606 //=================================================================================================
607 
608 //*************************************************************************************************
639 template< typename T1 // Type of the left-hand side dense matrix
640  , typename T2 > // Type of the right-hand side sparse matrix
641 const TDMatSMatAddExpr<T1,T2>
643 {
645 
646  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
647  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
648  }
649 
650  return TDMatSMatAddExpr<T1,T2>( ~lhs, ~rhs );
651 }
652 //*************************************************************************************************
653 
654 
655 //*************************************************************************************************
686 template< typename T1 // Type of the left-hand side dense matrix
687  , typename T2 > // Type of the right-hand side sparse matrix
688 const TDMatSMatAddExpr<T1,T2>
690 {
692 
693  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
694  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
695  }
696 
697  return TDMatSMatAddExpr<T1,T2>( ~rhs, ~lhs );
698 }
699 //*************************************************************************************************
700 
701 
702 
703 
704 //=================================================================================================
705 //
706 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
707 //
708 //=================================================================================================
709 
710 //*************************************************************************************************
723 template< typename T1 // Type of the dense matrix of the left-hand side expression
724  , typename T2 // Type of the sparse matrix of the left-hand side expression
725  , typename T3 // Type of the right-hand side dense matrix
726  , bool SO > // Storage order of the right-hand side dense matrix
727 inline const AddExprTrait_< TDMatSMatAddExpr<T1,T2>, T3 >
728  operator+( const TDMatSMatAddExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
729 {
731 
732  return ( lhs.leftOperand() + (~rhs) ) + lhs.rightOperand();
733 }
735 //*************************************************************************************************
736 
737 
738 //*************************************************************************************************
751 template< typename T1 // Type of the dense matrix of the left-hand side expression
752  , typename T2 // Type of the sparse matrix of the left-hand side expression
753  , typename T3 // Type of the right-hand side dense matrix
754  , bool SO > // Storage order of the right-hand side dense matrix
755 inline const SubExprTrait_< TDMatSMatAddExpr<T1,T2>, T3 >
756  operator-( const TDMatSMatAddExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
757 {
759 
760  return ( lhs.leftOperand() - (~rhs) ) + lhs.rightOperand();
761 }
763 //*************************************************************************************************
764 
765 
766 
767 
768 //=================================================================================================
769 //
770 // ROWS SPECIALIZATIONS
771 //
772 //=================================================================================================
773 
774 //*************************************************************************************************
776 template< typename MT1, typename MT2 >
777 struct Rows< TDMatSMatAddExpr<MT1,MT2> >
778  : public Max< Rows<MT1>, Rows<MT2> >
779 {};
781 //*************************************************************************************************
782 
783 
784 
785 
786 //=================================================================================================
787 //
788 // COLUMNS SPECIALIZATIONS
789 //
790 //=================================================================================================
791 
792 //*************************************************************************************************
794 template< typename MT1, typename MT2 >
795 struct Columns< TDMatSMatAddExpr<MT1,MT2> >
796  : public Max< Columns<MT1>, Columns<MT2> >
797 {};
799 //*************************************************************************************************
800 
801 
802 
803 
804 //=================================================================================================
805 //
806 // ISSYMMETRIC SPECIALIZATIONS
807 //
808 //=================================================================================================
809 
810 //*************************************************************************************************
812 template< typename MT1, typename MT2 >
813 struct IsSymmetric< TDMatSMatAddExpr<MT1,MT2> >
814  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
815 {};
817 //*************************************************************************************************
818 
819 
820 
821 
822 //=================================================================================================
823 //
824 // ISHERMITIAN SPECIALIZATIONS
825 //
826 //=================================================================================================
827 
828 //*************************************************************************************************
830 template< typename MT1, typename MT2 >
831 struct IsHermitian< TDMatSMatAddExpr<MT1,MT2> >
832  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
833 {};
835 //*************************************************************************************************
836 
837 
838 
839 
840 //=================================================================================================
841 //
842 // ISLOWER SPECIALIZATIONS
843 //
844 //=================================================================================================
845 
846 //*************************************************************************************************
848 template< typename MT1, typename MT2 >
849 struct IsLower< TDMatSMatAddExpr<MT1,MT2> >
850  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
851 {};
853 //*************************************************************************************************
854 
855 
856 
857 
858 //=================================================================================================
859 //
860 // ISUNILOWER SPECIALIZATIONS
861 //
862 //=================================================================================================
863 
864 //*************************************************************************************************
866 template< typename MT1, typename MT2 >
867 struct IsUniLower< TDMatSMatAddExpr<MT1,MT2> >
868  : public BoolConstant< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
869  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
870 {};
872 //*************************************************************************************************
873 
874 
875 
876 
877 //=================================================================================================
878 //
879 // ISSTRICTLYLOWER SPECIALIZATIONS
880 //
881 //=================================================================================================
882 
883 //*************************************************************************************************
885 template< typename MT1, typename MT2 >
886 struct IsStrictlyLower< TDMatSMatAddExpr<MT1,MT2> >
887  : public BoolConstant< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
888 {};
890 //*************************************************************************************************
891 
892 
893 
894 
895 //=================================================================================================
896 //
897 // ISUPPER SPECIALIZATIONS
898 //
899 //=================================================================================================
900 
901 //*************************************************************************************************
903 template< typename MT1, typename MT2 >
904 struct IsUpper< TDMatSMatAddExpr<MT1,MT2> >
905  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
906 {};
908 //*************************************************************************************************
909 
910 
911 
912 
913 //=================================================================================================
914 //
915 // ISUNIUPPER SPECIALIZATIONS
916 //
917 //=================================================================================================
918 
919 //*************************************************************************************************
921 template< typename MT1, typename MT2 >
922 struct IsUniUpper< TDMatSMatAddExpr<MT1,MT2> >
923  : public BoolConstant< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
924  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
925 {};
927 //*************************************************************************************************
928 
929 
930 
931 
932 //=================================================================================================
933 //
934 // ISSTRICTLYUPPER SPECIALIZATIONS
935 //
936 //=================================================================================================
937 
938 //*************************************************************************************************
940 template< typename MT1, typename MT2 >
941 struct IsStrictlyUpper< TDMatSMatAddExpr<MT1,MT2> >
942  : public BoolConstant< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
943 {};
945 //*************************************************************************************************
946 
947 
948 
949 
950 //=================================================================================================
951 //
952 // EXPRESSION TRAIT SPECIALIZATIONS
953 //
954 //=================================================================================================
955 
956 //*************************************************************************************************
958 template< typename MT1, typename MT2, typename MT3 >
959 struct DMatDMatAddExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
960 {
961  public:
962  //**********************************************************************************************
964  using Type = If_< And< IsDenseMatrix<MT1>, IsColumnMajorMatrix<MT1>
965  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
966  , IsDenseMatrix<MT3>, IsRowMajorMatrix<MT3> >
967  , DMatSMatAddExprTrait_< TDMatDMatAddExprTrait_<MT1,MT3>, MT2 >
968  , INVALID_TYPE >;
970  //**********************************************************************************************
971 };
973 //*************************************************************************************************
974 
975 
976 //*************************************************************************************************
978 template< typename MT1, typename MT2, typename MT3 >
979 struct DMatTDMatAddExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
980 {
981  public:
982  //**********************************************************************************************
984  using Type = If_< And< IsDenseMatrix<MT1>, IsColumnMajorMatrix<MT1>
985  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
986  , IsDenseMatrix<MT3>, IsColumnMajorMatrix<MT3> >
987  , TDMatSMatAddExprTrait_< TDMatTDMatAddExprTrait_<MT1,MT3>, MT2 >
988  , INVALID_TYPE >;
990  //**********************************************************************************************
991 };
993 //*************************************************************************************************
994 
995 
996 //*************************************************************************************************
998 template< typename MT1, typename MT2, typename MT3 >
999 struct DMatDMatSubExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
1000 {
1001  public:
1002  //**********************************************************************************************
1004  using Type = If_< And< IsDenseMatrix<MT1>, IsColumnMajorMatrix<MT1>
1005  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
1006  , IsDenseMatrix<MT3>, IsRowMajorMatrix<MT3> >
1007  , DMatSMatAddExprTrait_< TDMatDMatSubExprTrait_<MT1,MT3>, MT2 >
1008  , INVALID_TYPE >;
1010  //**********************************************************************************************
1011 };
1013 //*************************************************************************************************
1014 
1015 
1016 //*************************************************************************************************
1018 template< typename MT1, typename MT2, typename MT3 >
1019 struct DMatTDMatSubExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
1020 {
1021  public:
1022  //**********************************************************************************************
1024  using Type = If_< And< IsDenseMatrix<MT1>, IsColumnMajorMatrix<MT1>
1025  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
1026  , IsDenseMatrix<MT3>, IsColumnMajorMatrix<MT3> >
1027  , TDMatSMatAddExprTrait_< TDMatTDMatSubExprTrait_<MT1,MT3>, MT2 >
1028  , INVALID_TYPE >;
1030  //**********************************************************************************************
1031 };
1033 //*************************************************************************************************
1034 
1035 
1036 //*************************************************************************************************
1038 template< typename MT1, typename MT2, bool AF >
1039 struct SubmatrixExprTrait< TDMatSMatAddExpr<MT1,MT2>, AF >
1040 {
1041  public:
1042  //**********************************************************************************************
1043  using Type = AddExprTrait_< SubmatrixExprTrait_<const MT1,AF>
1044  , SubmatrixExprTrait_<const MT2,AF> >;
1045  //**********************************************************************************************
1046 };
1048 //*************************************************************************************************
1049 
1050 
1051 //*************************************************************************************************
1053 template< typename MT1, typename MT2 >
1054 struct RowExprTrait< TDMatSMatAddExpr<MT1,MT2> >
1055 {
1056  public:
1057  //**********************************************************************************************
1058  using Type = AddExprTrait_< RowExprTrait_<const MT1>
1059  , RowExprTrait_<const MT2> >;
1060  //**********************************************************************************************
1061 };
1063 //*************************************************************************************************
1064 
1065 
1066 //*************************************************************************************************
1068 template< typename MT1, typename MT2 >
1069 struct ColumnExprTrait< TDMatSMatAddExpr<MT1,MT2> >
1070 {
1071  public:
1072  //**********************************************************************************************
1073  using Type = AddExprTrait_< ColumnExprTrait_<const MT1>
1074  , ColumnExprTrait_<const MT2> >;
1075  //**********************************************************************************************
1076 };
1078 //*************************************************************************************************
1079 
1080 } // namespace blaze
1081 
1082 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
Header file for the Max class template.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TDMatSMatAddExpr.h:153
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:70
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:653
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:160
Header file for the IsSparseMatrix type trait.
Header file for the serial shim.
#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
TDMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TDMatSMatAddExpr class.
Definition: TDMatSMatAddExpr.h:182
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:699
Header file for the And class template.
Header file for the AddExprTrait class template.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:723
Header file for the Computation base class.
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:731
Constraints on the storage order of matrix types.
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:109
LeftOperand lhs_
Left-hand side dense matrix of the addition expression.
Definition: TDMatSMatAddExpr.h:291
Constraint on the data type.
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
If_< IsExpression< MT2 >, const MT2, const MT2 & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDMatSMatAddExpr.h:165
Constraint on the data type.
Constraint on the data type.
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
typename AddExprTrait< T1, T2 >::Type AddExprTrait_
Auxiliary alias declaration for the AddExprTrait class template.The AddExprTrait_ alias declaration p...
Definition: AddExprTrait.h:219
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: ColumnMajorMatrix.h:61
ReturnType_< MT1 > RN1
Return type of the left-hand side dense matrix expression.
Definition: TDMatSMatAddExpr.h:116
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TDMatSMatAddExpr.h:229
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: TDMatSMatAddExpr.h:292
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
Header file for the Or class template.
#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
Header file for the IsLower type trait.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TDMatSMatAddExpr.h:198
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:60
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TDMatSMatAddExpr.h:239
Constraints on the storage order of matrix types.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TDMatSMatAddExpr.h:271
Header file for the exception macros of the math module.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatAddExpr.h:109
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 EnableIf class template.
Header file for the IsStrictlyLower type trait.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSMatAddExpr.h:284
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSMatAddExpr.h:159
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: RowMajorMatrix.h:61
Header file for run time assertion macros.
Utility type for generic codes.
Header file for the addition trait.
ReturnType_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: TDMatSMatAddExpr.h:117
ResultType_< MT1 > RT1
Result type of the left-hand side dense matrix expression.
Definition: TDMatSMatAddExpr.h:114
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSMatAddExpr.h:152
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
Constraint on the data type.
TDMatSMatAddExpr< MT1, MT2 > This
Type of this TDMatSMatAddExpr instance.
Definition: TDMatSMatAddExpr.h:149
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSMatAddExpr.h:249
Constraints on the storage order of matrix types.
Header file for the MatMatAddExpr base class.
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TDMatSMatAddExpr.h:259
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: TDMatSMatAddExpr.h:156
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TDMatSMatAddExpr.h:213
Header file for the IsRowMajorMatrix type trait.
AddExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: TDMatSMatAddExpr.h:130
Expression object for dense matrix-sparse matrix additions.The TDMatSMatAddExpr class represents the ...
Definition: Forward.h:130
#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
Header file for the IntegralConstant class template.
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: TDMatSMatAddExpr.h:115
AddTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TDMatSMatAddExpr.h:150
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.
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TDMatSMatAddExpr.h:151
Header file for the IsHermitian type trait.
Header file for the SubExprTrait class template.
typename AddTrait< T1, T2 >::Type AddTrait_
Auxiliary alias declaration for the AddTrait class template.The AddTrait_ alias declaration provides ...
Definition: AddTrait.h:245
#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
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:61
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:71
If_< IsExpression< MT1 >, const MT1, const MT1 & > LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSMatAddExpr.h:162
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.