DMatTSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTSMATADDEXPR_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 DMATTSMATADDEXPR
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 DMatTSMatAddExpr : public DenseMatrix< DMatTSMatAddExpr<MT1,MT2>, false >
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 DMatTSMatAddExpr( 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 {
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_.canAlias( alias ) || rhs_.canAlias( 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 DMatTSMatAddExpr& 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 DMatTSMatAddExpr& 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 DMatTSMatAddExpr& 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 DMatTSMatAddExpr& 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 DMatTSMatAddExpr& 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 DMatTSMatAddExpr& rhs )
488  {
490 
491  typedef IfTrue_< SO2, OppositeType, ResultType > 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 DMatTSMatAddExpr& 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 DMatTSMatAddExpr& 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 //*************************************************************************************************
638 template< typename T1 // Type of the left-hand side dense matrix
639  , typename T2 > // Type of the right-hand side sparse matrix
640 const DMatTSMatAddExpr<T1,T2>
642 {
644 
645  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
646  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
647  }
648 
649  return DMatTSMatAddExpr<T1,T2>( ~lhs, ~rhs );
650 }
651 //*************************************************************************************************
652 
653 
654 //*************************************************************************************************
684 template< typename T1 // Type of the left-hand side dense matrix
685  , typename T2 > // Type of the right-hand side sparse matrix
686 const DMatTSMatAddExpr<T1,T2>
688 {
690 
691  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
692  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
693  }
694 
695  return DMatTSMatAddExpr<T1,T2>( ~rhs, ~lhs );
696 }
697 //*************************************************************************************************
698 
699 
700 
701 
702 //=================================================================================================
703 //
704 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
705 //
706 //=================================================================================================
707 
708 //*************************************************************************************************
721 template< typename T1 // Type of the dense matrix of the left-hand side expression
722  , typename T2 // Type of the sparse matrix of the left-hand side expression
723  , typename T3 // Type of the right-hand side dense matrix
724  , bool SO > // Storage order of the right-hand side dense matrix
725 inline const AddExprTrait_< DMatTSMatAddExpr<T1,T2>, T3 >
726  operator+( const DMatTSMatAddExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
727 {
729 
730  return ( lhs.leftOperand() + (~rhs) ) + lhs.rightOperand();
731 }
733 //*************************************************************************************************
734 
735 
736 //*************************************************************************************************
749 template< typename T1 // Type of the dense matrix of the left-hand side expression
750  , typename T2 // Type of the sparse matrix of the left-hand side expression
751  , typename T3 // Type of the right-hand side dense matrix
752  , bool SO > // Storage order of the right-hand side dense matrix
753 inline const SubExprTrait_< DMatTSMatAddExpr<T1,T2>, T3 >
754  operator-( const DMatTSMatAddExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
755 {
757 
758  return ( lhs.leftOperand() - (~rhs) ) + lhs.rightOperand();
759 }
761 //*************************************************************************************************
762 
763 
764 
765 
766 //=================================================================================================
767 //
768 // ROWS SPECIALIZATIONS
769 //
770 //=================================================================================================
771 
772 //*************************************************************************************************
774 template< typename MT1, typename MT2 >
775 struct Rows< DMatTSMatAddExpr<MT1,MT2> >
776  : public Max< Rows<MT1>, Rows<MT2> >
777 {};
779 //*************************************************************************************************
780 
781 
782 
783 
784 //=================================================================================================
785 //
786 // COLUMNS SPECIALIZATIONS
787 //
788 //=================================================================================================
789 
790 //*************************************************************************************************
792 template< typename MT1, typename MT2 >
793 struct Columns< DMatTSMatAddExpr<MT1,MT2> >
794  : public Max< Columns<MT1>, Columns<MT2> >
795 {};
797 //*************************************************************************************************
798 
799 
800 
801 
802 //=================================================================================================
803 //
804 // ISSYMMETRIC SPECIALIZATIONS
805 //
806 //=================================================================================================
807 
808 //*************************************************************************************************
810 template< typename MT1, typename MT2 >
811 struct IsSymmetric< DMatTSMatAddExpr<MT1,MT2> >
812  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
813 {};
815 //*************************************************************************************************
816 
817 
818 
819 
820 //=================================================================================================
821 //
822 // ISHERMITIAN SPECIALIZATIONS
823 //
824 //=================================================================================================
825 
826 //*************************************************************************************************
828 template< typename MT1, typename MT2 >
829 struct IsHermitian< DMatTSMatAddExpr<MT1,MT2> >
830  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
831 {};
833 //*************************************************************************************************
834 
835 
836 
837 
838 //=================================================================================================
839 //
840 // ISLOWER SPECIALIZATIONS
841 //
842 //=================================================================================================
843 
844 //*************************************************************************************************
846 template< typename MT1, typename MT2 >
847 struct IsLower< DMatTSMatAddExpr<MT1,MT2> >
848  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
849 {};
851 //*************************************************************************************************
852 
853 
854 
855 
856 //=================================================================================================
857 //
858 // ISUNILOWER SPECIALIZATIONS
859 //
860 //=================================================================================================
861 
862 //*************************************************************************************************
864 template< typename MT1, typename MT2 >
865 struct IsUniLower< DMatTSMatAddExpr<MT1,MT2> >
866  : public BoolConstant< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
867  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
868 {};
870 //*************************************************************************************************
871 
872 
873 
874 
875 //=================================================================================================
876 //
877 // ISSTRICTLYLOWER SPECIALIZATIONS
878 //
879 //=================================================================================================
880 
881 //*************************************************************************************************
883 template< typename MT1, typename MT2 >
884 struct IsStrictlyLower< DMatTSMatAddExpr<MT1,MT2> >
885  : public BoolConstant< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
886 {};
888 //*************************************************************************************************
889 
890 
891 
892 
893 //=================================================================================================
894 //
895 // ISUPPER SPECIALIZATIONS
896 //
897 //=================================================================================================
898 
899 //*************************************************************************************************
901 template< typename MT1, typename MT2 >
902 struct IsUpper< DMatTSMatAddExpr<MT1,MT2> >
903  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
904 {};
906 //*************************************************************************************************
907 
908 
909 
910 
911 //=================================================================================================
912 //
913 // ISUNIUPPER SPECIALIZATIONS
914 //
915 //=================================================================================================
916 
917 //*************************************************************************************************
919 template< typename MT1, typename MT2 >
920 struct IsUniUpper< DMatTSMatAddExpr<MT1,MT2> >
921  : public BoolConstant< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
922  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
923 {};
925 //*************************************************************************************************
926 
927 
928 
929 
930 //=================================================================================================
931 //
932 // ISSTRICTLYUPPER SPECIALIZATIONS
933 //
934 //=================================================================================================
935 
936 //*************************************************************************************************
938 template< typename MT1, typename MT2 >
939 struct IsStrictlyUpper< DMatTSMatAddExpr<MT1,MT2> >
940  : public BoolConstant< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
941 {};
943 //*************************************************************************************************
944 
945 
946 
947 
948 //=================================================================================================
949 //
950 // EXPRESSION TRAIT SPECIALIZATIONS
951 //
952 //=================================================================================================
953 
954 //*************************************************************************************************
956 template< typename MT1, typename MT2, typename MT3 >
957 struct DMatDMatAddExprTrait< DMatTSMatAddExpr<MT1,MT2>, MT3 >
958 {
959  public:
960  //**********************************************************************************************
962  using Type = If_< And< IsDenseMatrix<MT1>, IsRowMajorMatrix<MT1>
963  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
964  , IsDenseMatrix<MT3>, IsRowMajorMatrix<MT3> >
965  , DMatTSMatAddExprTrait_< DMatDMatAddExprTrait_<MT1,MT3>, MT2 >
966  , INVALID_TYPE >;
968  //**********************************************************************************************
969 };
971 //*************************************************************************************************
972 
973 
974 //*************************************************************************************************
976 template< typename MT1, typename MT2, typename MT3 >
977 struct DMatTDMatAddExprTrait< DMatTSMatAddExpr<MT1,MT2>, MT3 >
978 {
979  public:
980  //**********************************************************************************************
982  using Type = If_< And< IsDenseMatrix<MT1>, IsRowMajorMatrix<MT1>
983  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
984  , IsDenseMatrix<MT3>, IsColumnMajorMatrix<MT3> >
985  , DMatTSMatAddExprTrait_< DMatTDMatAddExprTrait_<MT1,MT3>, MT2 >
986  , INVALID_TYPE >;
988  //**********************************************************************************************
989 };
991 //*************************************************************************************************
992 
993 
994 //*************************************************************************************************
996 template< typename MT1, typename MT2, typename MT3 >
997 struct DMatDMatSubExprTrait< DMatTSMatAddExpr<MT1,MT2>, MT3 >
998 {
999  public:
1000  //**********************************************************************************************
1002  using Type = If_< And< IsDenseMatrix<MT1>, IsRowMajorMatrix<MT1>
1003  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
1004  , IsDenseMatrix<MT3>, IsRowMajorMatrix<MT3> >
1005  , DMatTSMatAddExprTrait_< DMatDMatSubExprTrait_<MT1,MT3>, MT2 >
1006  , INVALID_TYPE >;
1008  //**********************************************************************************************
1009 };
1011 //*************************************************************************************************
1012 
1013 
1014 //*************************************************************************************************
1016 template< typename MT1, typename MT2, typename MT3 >
1017 struct DMatTDMatSubExprTrait< DMatTSMatAddExpr<MT1,MT2>, MT3 >
1018 {
1019  public:
1020  //**********************************************************************************************
1022  using Type = If_< And< IsDenseMatrix<MT1>, IsRowMajorMatrix<MT1>
1023  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
1024  , IsDenseMatrix<MT3>, IsColumnMajorMatrix<MT3> >
1025  , DMatTSMatAddExprTrait_< DMatTDMatSubExprTrait_<MT1,MT3>, MT2 >
1026  , INVALID_TYPE >;
1028  //**********************************************************************************************
1029 };
1031 //*************************************************************************************************
1032 
1033 
1034 //*************************************************************************************************
1036 template< typename MT1, typename MT2, bool AF >
1037 struct SubmatrixExprTrait< DMatTSMatAddExpr<MT1,MT2>, AF >
1038 {
1039  public:
1040  //**********************************************************************************************
1041  using Type = AddExprTrait_< SubmatrixExprTrait_<const MT1,AF>
1042  , SubmatrixExprTrait_<const MT2,AF> >;
1043  //**********************************************************************************************
1044 };
1046 //*************************************************************************************************
1047 
1048 
1049 //*************************************************************************************************
1051 template< typename MT1, typename MT2 >
1052 struct RowExprTrait< DMatTSMatAddExpr<MT1,MT2> >
1053 {
1054  public:
1055  //**********************************************************************************************
1056  using Type = AddExprTrait_< RowExprTrait_<const MT1>
1057  , RowExprTrait_<const MT2> >;
1058  //**********************************************************************************************
1059 };
1061 //*************************************************************************************************
1062 
1063 
1064 //*************************************************************************************************
1066 template< typename MT1, typename MT2 >
1067 struct ColumnExprTrait< DMatTSMatAddExpr<MT1,MT2> >
1068 {
1069  public:
1070  //**********************************************************************************************
1071  using Type = AddExprTrait_< ColumnExprTrait_<const MT1>
1072  , ColumnExprTrait_<const MT2> >;
1073  //**********************************************************************************************
1074 };
1076 //*************************************************************************************************
1077 
1078 } // namespace blaze
1079 
1080 #endif
ResultType_< MT1 > RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTSMatAddExpr.h:114
#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.
LeftOperand lhs_
Left-hand side dense matrix of the addition expression.
Definition: DMatTSMatAddExpr.h:291
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
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
If_< IsExpression< MT1 >, const MT1, const MT1 & > LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTSMatAddExpr.h:162
Header file for the And class template.
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: DMatTSMatAddExpr.h:292
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.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatTSMatAddExpr.h:271
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:109
Constraint on the data type.
typename 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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatTSMatAddExpr.h:213
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.
ReturnType_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatTSMatAddExpr.h:117
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
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatTSMatAddExpr.h:229
DMatTSMatAddExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the DMatTSMatAddExpr class.
Definition: DMatTSMatAddExpr.h:182
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
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a ta...
Definition: MatMatAddExpr.h:65
Header file for the IsLower type trait.
AddExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: DMatTSMatAddExpr.h:130
#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
Constraints on the storage order of matrix types.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTSMatAddExpr.h:198
Header file for the exception macros of the math module.
ReturnType_< MT1 > RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatTSMatAddExpr.h:116
#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.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DMatTSMatAddExpr.h:153
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
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatTSMatAddExpr.h:152
DMatTSMatAddExpr< MT1, MT2 > This
Type of this DMatTSMatAddExpr instance.
Definition: DMatTSMatAddExpr.h:149
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose sparse matrix operand.
Definition: DMatTSMatAddExpr.h:259
Header file for run time assertion macros.
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTSMatAddExpr.h:159
Utility type for generic codes.
Header file for the addition trait.
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.
AddTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: DMatTSMatAddExpr.h:150
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatTSMatAddExpr.h:249
Constraints on the storage order of matrix types.
Header file for the MatMatAddExpr base class.
Expression object for dense matrix-sparse matrix additions.The DMatTSMatAddExpr class represents the ...
Definition: DMatTSMatAddExpr.h:108
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
#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
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatTSMatAddExpr.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
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatTSMatAddExpr.h:284
#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
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTSMatAddExpr.h:151
Header file for the IntegralConstant class template.
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DMatTSMatAddExpr.h:156
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.
If_< IsExpression< MT2 >, const MT2, const MT2 & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatTSMatAddExpr.h:165
Header file for the IsHermitian type trait.
Header file for the SubExprTrait class template.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatTSMatAddExpr.h:239
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
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.