DMatTDMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTDMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTDMATADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
49 #include <blaze/math/Exception.h>
74 #include <blaze/system/Blocking.h>
76 #include <blaze/util/Assert.h>
78 #include <blaze/util/DisableIf.h>
79 #include <blaze/util/EnableIf.h>
82 #include <blaze/util/mpl/And.h>
83 #include <blaze/util/mpl/If.h>
84 #include <blaze/util/mpl/Max.h>
85 #include <blaze/util/mpl/Not.h>
86 #include <blaze/util/mpl/Or.h>
87 #include <blaze/util/Types.h>
88 
89 
90 namespace blaze {
91 
92 //=================================================================================================
93 //
94 // CLASS DMATTDMATADDEXPR
95 //
96 //=================================================================================================
97 
98 //*************************************************************************************************
105 template< typename MT1 // Type of the left-hand side dense matrix
106  , typename MT2 > // Type of the right-hand side dense matrix
107 class DMatTDMatAddExpr : public DenseMatrix< DMatTDMatAddExpr<MT1,MT2>, false >
108  , private MatMatAddExpr
109  , private Computation
110 {
111  private:
112  //**Type definitions****************************************************************************
119  //**********************************************************************************************
120 
121  //**Return type evaluation**********************************************************************
123 
128  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
129 
132  //**********************************************************************************************
133 
134  //**Serial evaluation strategy******************************************************************
136 
142  enum : bool { useAssign = RequiresEvaluation<MT1>::value || RequiresEvaluation<MT2>::value || !returnExpr };
143 
145  template< typename MT >
147  struct UseAssign {
148  enum : bool { value = useAssign };
149  };
151  //**********************************************************************************************
152 
153  //**Parallel evaluation strategy****************************************************************
155 
161  template< typename MT >
162  struct UseSMPAssign {
163  enum : bool { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) && useAssign };
164  };
166  //**********************************************************************************************
167 
168  public:
169  //**Type definitions****************************************************************************
175 
178 
180  typedef const ResultType CompositeType;
181 
183  typedef If_< IsExpression<MT1>, const MT1, const MT1& > LeftOperand;
184 
186  typedef If_< IsExpression<MT2>, const MT2, const MT2& > RightOperand;
187  //**********************************************************************************************
188 
189  //**Compilation flags***************************************************************************
191  enum : bool { simdEnabled = false };
192 
194  enum : bool { smpAssignable = MT1::smpAssignable && MT2::smpAssignable };
195  //**********************************************************************************************
196 
197  //**Constructor*********************************************************************************
203  explicit inline DMatTDMatAddExpr( const MT1& lhs, const MT2& rhs ) noexcept
204  : lhs_( lhs ) // Left-hand side dense matrix of the addition expression
205  , rhs_( rhs ) // Right-hand side dense matrix of the addition expression
206  {
207  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
208  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
209  }
210  //**********************************************************************************************
211 
212  //**Access operator*****************************************************************************
219  inline ReturnType operator()( size_t i, size_t j ) const {
220  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
221  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
222  return lhs_(i,j) + rhs_(i,j);
223  }
224  //**********************************************************************************************
225 
226  //**At function*********************************************************************************
234  inline ReturnType at( size_t i, size_t j ) const {
235  if( i >= lhs_.rows() ) {
236  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
237  }
238  if( j >= lhs_.columns() ) {
239  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
240  }
241  return (*this)(i,j);
242  }
243  //**********************************************************************************************
244 
245  //**Rows function*******************************************************************************
250  inline size_t rows() const noexcept {
251  return lhs_.rows();
252  }
253  //**********************************************************************************************
254 
255  //**Columns function****************************************************************************
260  inline size_t columns() const noexcept {
261  return lhs_.columns();
262  }
263  //**********************************************************************************************
264 
265  //**Left operand access*************************************************************************
270  inline LeftOperand leftOperand() const noexcept {
271  return lhs_;
272  }
273  //**********************************************************************************************
274 
275  //**Right operand access************************************************************************
280  inline RightOperand rightOperand() const noexcept {
281  return rhs_;
282  }
283  //**********************************************************************************************
284 
285  //**********************************************************************************************
291  template< typename T >
292  inline bool canAlias( const T* alias ) const noexcept {
293  return ( IsExpression<MT1>::value && ( RequiresEvaluation<MT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
294  ( IsExpression<MT2>::value && ( RequiresEvaluation<MT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
295  }
296  //**********************************************************************************************
297 
298  //**********************************************************************************************
304  template< typename T >
305  inline bool isAliased( const T* alias ) const noexcept {
306  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
307  }
308  //**********************************************************************************************
309 
310  //**********************************************************************************************
315  inline bool isAligned() const noexcept {
316  return lhs_.isAligned() && rhs_.isAligned();
317  }
318  //**********************************************************************************************
319 
320  //**********************************************************************************************
325  inline bool canSMPAssign() const noexcept {
326  return lhs_.canSMPAssign() || rhs_.canSMPAssign() ||
327  ( rows() * columns() >= SMP_DMATTDMATADD_THRESHOLD );
328  }
329  //**********************************************************************************************
330 
331  private:
332  //**Member variables****************************************************************************
333  LeftOperand lhs_;
334  RightOperand rhs_;
335  //**********************************************************************************************
336 
337  //**Assignment to dense matrices****************************************************************
351  template< typename MT // Type of the target dense matrix
352  , bool SO2 > // Storage order of the target dense matrix
353  friend inline DisableIf_< UseAssign<MT> >
354  assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
355  {
357 
358  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
359  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
360 
361  const size_t m( rhs.rows() );
362  const size_t n( rhs.columns() );
363  const size_t block( BLOCK_SIZE );
364 
365  for( size_t ii=0UL; ii<m; ii+=block ) {
366  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
367  for( size_t jj=0UL; jj<n; jj+=block ) {
368  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
369  for( size_t i=ii; i<iend; ++i ) {
370  for( size_t j=jj; j<jend; ++j ) {
371  (~lhs)(i,j) = rhs.lhs_(i,j) + rhs.rhs_(i,j);
372  }
373  }
374  }
375  }
376  }
378  //**********************************************************************************************
379 
380  //**Assignment to dense matrices****************************************************************
394  template< typename MT // Type of the target dense matrix
395  , bool SO2 > // Storage order of the target dense matrix
396  friend inline EnableIf_< UseAssign<MT> >
397  assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
398  {
400 
401  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
402  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
403 
404  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
405  addAssign( ~lhs, rhs.rhs_ );
406  }
407  else if( !IsExpression<MT2>::value && isSame( ~lhs, rhs.rhs_ ) ) {
408  addAssign( ~lhs, rhs.lhs_ );
409  }
410  else {
411  assign ( ~lhs, rhs.lhs_ );
412  addAssign( ~lhs, rhs.rhs_ );
413  }
414  }
416  //**********************************************************************************************
417 
418  //**Assignment to sparse matrices***************************************************************
430  template< typename MT // Type of the target sparse matrix
431  , bool SO2 > // Storage order of the target sparse matrix
432  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
433  {
435 
436  typedef IfTrue_< SO2, OppositeType, ResultType > TmpType;
437 
443  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<TmpType> );
444 
445  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
446  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
447 
448  const TmpType tmp( serial( rhs ) );
449  assign( ~lhs, tmp );
450  }
452  //**********************************************************************************************
453 
454  //**Addition assignment to dense matrices*******************************************************
468  template< typename MT // Type of the target dense matrix
469  , bool SO2 > // Storage order of the target dense matrix
470  friend inline DisableIf_< UseAssign<MT> >
471  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
472  {
474 
475  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
476  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
477 
478  const size_t m( rhs.rows() );
479  const size_t n( rhs.columns() );
480  const size_t block( BLOCK_SIZE );
481 
482  for( size_t ii=0UL; ii<m; ii+=block ) {
483  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
484  for( size_t jj=0UL; jj<n; jj+=block ) {
485  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
486  for( size_t i=ii; i<iend; ++i ) {
487  for( size_t j=jj; j<jend; ++j ) {
488  (~lhs)(i,j) += rhs.lhs_(i,j) + rhs.rhs_(i,j);
489  }
490  }
491  }
492  }
493  }
495  //**********************************************************************************************
496 
497  //**Addition assignment to dense matrices*******************************************************
511  template< typename MT // Type of the target dense matrix
512  , bool SO2 > // Storage order of the target dense matrix
513  friend inline EnableIf_< UseAssign<MT> >
514  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
515  {
517 
518  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
519  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
520 
521  addAssign( ~lhs, rhs.lhs_ );
522  addAssign( ~lhs, rhs.rhs_ );
523  }
525  //**********************************************************************************************
526 
527  //**Addition assignment to sparse matrices******************************************************
528  // No special implementation for the addition assignment to sparse matrices.
529  //**********************************************************************************************
530 
531  //**Subtraction assignment to dense matrices****************************************************
545  template< typename MT // Type of the target dense matrix
546  , bool SO2 > // Storage order of the target dense matrix
547  friend inline DisableIf_< UseAssign<MT> >
548  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
549  {
551 
552  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
553  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
554 
555  const size_t m( rhs.rows() );
556  const size_t n( rhs.columns() );
557  const size_t block( BLOCK_SIZE );
558 
559  for( size_t ii=0UL; ii<m; ii+=block ) {
560  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
561  for( size_t jj=0UL; jj<n; jj+=block ) {
562  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
563  for( size_t i=ii; i<iend; ++i ) {
564  for( size_t j=jj; j<jend; ++j ) {
565  (~lhs)(i,j) -= rhs.lhs_(i,j) + rhs.rhs_(i,j);
566  }
567  }
568  }
569  }
570  }
572  //**********************************************************************************************
573 
574  //**Subtraction assignment to dense matrices****************************************************
588  template< typename MT // Type of the target dense matrix
589  , bool SO2 > // Storage order of the target dense matrix
590  friend inline EnableIf_< UseAssign<MT> >
591  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& 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.lhs_ );
599  subAssign( ~lhs, rhs.rhs_ );
600  }
602  //**********************************************************************************************
603 
604  //**Subtraction assignment to sparse matrices***************************************************
605  // No special implementation for the subtraction assignment to sparse matrices.
606  //**********************************************************************************************
607 
608  //**Multiplication assignment to dense matrices*************************************************
609  // No special implementation for the multiplication assignment to dense matrices.
610  //**********************************************************************************************
611 
612  //**Multiplication assignment to sparse matrices************************************************
613  // No special implementation for the multiplication assignment to sparse matrices.
614  //**********************************************************************************************
615 
616  //**SMP assignment to dense matrices************************************************************
630  template< typename MT // Type of the target dense matrix
631  , bool SO2 > // Storage order of the target dense matrix
632  friend inline EnableIf_< UseSMPAssign<MT> >
633  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
634  {
636 
637  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
638  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
639 
640  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
641  smpAddAssign( ~lhs, rhs.rhs_ );
642  }
643  else if( !IsExpression<MT2>::value && isSame( ~lhs, rhs.rhs_ ) ) {
644  smpAddAssign( ~lhs, rhs.lhs_ );
645  }
646  else {
647  smpAssign ( ~lhs, rhs.lhs_ );
648  smpAddAssign( ~lhs, rhs.rhs_ );
649  }
650  }
652  //**********************************************************************************************
653 
654  //**SMP assignment to sparse matrices***********************************************************
668  template< typename MT // Type of the target sparse matrix
669  , bool SO2 > // Storage order of the target sparse matrix
670  friend inline EnableIf_< UseSMPAssign<MT> >
671  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
672  {
674 
675  typedef IfTrue_< SO2, OppositeType, ResultType > TmpType;
676 
682  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<TmpType> );
683 
684  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
685  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
686 
687  const TmpType tmp( rhs );
688  smpAssign( ~lhs, tmp );
689  }
691  //**********************************************************************************************
692 
693  //**SMP addition assignment to dense matrices***************************************************
708  template< typename MT // Type of the target dense matrix
709  , bool SO2 > // Storage order of the target dense matrix
710  friend inline EnableIf_< UseSMPAssign<MT> >
711  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
712  {
714 
715  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
716  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
717 
718  smpAddAssign( ~lhs, rhs.lhs_ );
719  smpAddAssign( ~lhs, rhs.rhs_ );
720  }
722  //**********************************************************************************************
723 
724  //**SMP addition assignment to sparse matrices**************************************************
725  // No special implementation for the SMP addition assignment to sparse matrices.
726  //**********************************************************************************************
727 
728  //**SMP subtraction assignment to dense matrices************************************************
743  template< typename MT // Type of the target dense matrix
744  , bool SO2 > // Storage order of the target dense matrix
745  friend inline EnableIf_< UseSMPAssign<MT> >
746  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatAddExpr& rhs )
747  {
749 
750  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
751  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
752 
753  smpSubAssign( ~lhs, rhs.lhs_ );
754  smpSubAssign( ~lhs, rhs.rhs_ );
755  }
757  //**********************************************************************************************
758 
759  //**SMP subtraction assignment to sparse matrices***********************************************
760  // No special implementation for the SMP subtraction assignment to sparse matrices.
761  //**********************************************************************************************
762 
763  //**SMP multiplication assignment to dense matrices*********************************************
764  // No special implementation for the SMP multiplication assignment to dense matrices.
765  //**********************************************************************************************
766 
767  //**SMP multiplication assignment to sparse matrices********************************************
768  // No special implementation for the SMP multiplication assignment to sparse matrices.
769  //**********************************************************************************************
770 
771  //**Compile time checks*************************************************************************
779  //**********************************************************************************************
780 };
781 //*************************************************************************************************
782 
783 
784 
785 
786 //=================================================================================================
787 //
788 // GLOBAL BINARY ARITHMETIC OPERATORS
789 //
790 //=================================================================================================
791 
792 //*************************************************************************************************
821 template< typename T1 // Type of the left-hand side dense matrix
822  , typename T2 > // Type of the right-hand side dense matrix
823 inline EnableIf_< And< Not< IsSymmetric<T1> >, Not< IsSymmetric<T2> > >
824  , const DMatTDMatAddExpr<T1,T2> >
826 {
828 
829  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
830  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
831  }
832 
833  return DMatTDMatAddExpr<T1,T2>( ~lhs, ~rhs );
834 }
835 //*************************************************************************************************
836 
837 
838 //*************************************************************************************************
867 template< typename T1 // Type of the left-hand side dense matrix
868  , typename T2 > // Type of the right-hand side dense matrix
869 inline EnableIf_< And< Not< IsSymmetric<T1> >, Not< IsSymmetric<T2> > >
870  , const DMatTDMatAddExpr<T2,T1> >
872 {
874 
875  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
876  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
877  }
878 
879  return DMatTDMatAddExpr<T2,T1>( ~rhs, ~lhs );
880 }
881 //*************************************************************************************************
882 
883 
884 
885 
886 //=================================================================================================
887 //
888 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
889 //
890 //=================================================================================================
891 
892 //*************************************************************************************************
906 template< typename T1 // Type of the left-hand side dense matrix
907  , typename T2 > // Type of the right-hand side dense matrix
908 inline EnableIf_< And< IsSymmetric<T1>, Not< IsSymmetric<T2> > >, const AddExprTrait_<T1,T2> >
909  operator+( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,true>& rhs )
910 {
912 
913  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
914  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
915  }
916 
917  return trans( ~lhs ) + ~rhs;
918 }
920 //*************************************************************************************************
921 
922 
923 //*************************************************************************************************
937 template< typename T1 // Type of the left-hand side dense matrix
938  , typename T2 > // Type of the right-hand side dense matrix
939 inline EnableIf_< IsSymmetric<T2>, const AddExprTrait_<T1,T2> >
940  operator+( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,true>& rhs )
941 {
943 
944  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
945  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
946  }
947 
948  return (~lhs) + trans( ~rhs );
949 }
951 //*************************************************************************************************
952 
953 
954 //*************************************************************************************************
968 template< typename T1 // Type of the left-hand side dense matrix
969  , typename T2 > // Type of the right-hand side dense matrix
970 inline EnableIf_< And< Not< IsSymmetric<T1> >, IsSymmetric<T2> >, const AddExprTrait_<T2,T1> >
971  operator+( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,false>& rhs )
972 {
974 
975  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
976  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
977  }
978 
979  return trans( ~rhs ) + (~lhs);
980 }
982 //*************************************************************************************************
983 
984 
985 //*************************************************************************************************
999 template< typename T1 // Type of the left-hand side dense matrix
1000  , typename T2 > // Type of the right-hand side dense matrix
1001 inline EnableIf_< IsSymmetric<T1>, const AddExprTrait_<T2,T1> >
1002  operator+( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,false>& rhs )
1003 {
1005 
1006  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
1007  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
1008  }
1009 
1010  return (~rhs) + trans( ~lhs );
1011 }
1013 //*************************************************************************************************
1014 
1015 
1016 
1017 
1018 //=================================================================================================
1019 //
1020 // ROWS SPECIALIZATIONS
1021 //
1022 //=================================================================================================
1023 
1024 //*************************************************************************************************
1026 template< typename MT1, typename MT2 >
1027 struct Rows< DMatTDMatAddExpr<MT1,MT2> >
1028  : public Max< Rows<MT1>, Rows<MT2> >
1029 {};
1031 //*************************************************************************************************
1032 
1033 
1034 
1035 
1036 //=================================================================================================
1037 //
1038 // COLUMNS SPECIALIZATIONS
1039 //
1040 //=================================================================================================
1041 
1042 //*************************************************************************************************
1044 template< typename MT1, typename MT2 >
1045 struct Columns< DMatTDMatAddExpr<MT1,MT2> >
1046  : public Max< Columns<MT1>, Columns<MT2> >
1047 {};
1049 //*************************************************************************************************
1050 
1051 
1052 
1053 
1054 //=================================================================================================
1055 //
1056 // ISALIGNED SPECIALIZATIONS
1057 //
1058 //=================================================================================================
1059 
1060 //*************************************************************************************************
1062 template< typename MT1, typename MT2 >
1063 struct IsAligned< DMatTDMatAddExpr<MT1,MT2> >
1064  : public BoolConstant< And< IsAligned<MT1>, IsAligned<MT2> >::value >
1065 {};
1067 //*************************************************************************************************
1068 
1069 
1070 
1071 
1072 //=================================================================================================
1073 //
1074 // ISSYMMETRIC SPECIALIZATIONS
1075 //
1076 //=================================================================================================
1077 
1078 //*************************************************************************************************
1080 template< typename MT1, typename MT2 >
1081 struct IsSymmetric< DMatTDMatAddExpr<MT1,MT2> >
1082  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
1083 {};
1085 //*************************************************************************************************
1086 
1087 
1088 
1089 
1090 //=================================================================================================
1091 //
1092 // ISHERMITIAN SPECIALIZATIONS
1093 //
1094 //=================================================================================================
1095 
1096 //*************************************************************************************************
1098 template< typename MT1, typename MT2 >
1099 struct IsHermitian< DMatTDMatAddExpr<MT1,MT2> >
1100  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
1101 {};
1103 //*************************************************************************************************
1104 
1105 
1106 
1107 
1108 //=================================================================================================
1109 //
1110 // ISLOWER SPECIALIZATIONS
1111 //
1112 //=================================================================================================
1113 
1114 //*************************************************************************************************
1116 template< typename MT1, typename MT2 >
1117 struct IsLower< DMatTDMatAddExpr<MT1,MT2> >
1118  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
1119 {};
1121 //*************************************************************************************************
1122 
1123 
1124 
1125 
1126 //=================================================================================================
1127 //
1128 // ISUNILOWER SPECIALIZATIONS
1129 //
1130 //=================================================================================================
1131 
1132 //*************************************************************************************************
1134 template< typename MT1, typename MT2 >
1135 struct IsUniLower< DMatTDMatAddExpr<MT1,MT2> >
1136  : public BoolConstant< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
1137  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
1138 {};
1140 //*************************************************************************************************
1141 
1142 
1143 
1144 
1145 //=================================================================================================
1146 //
1147 // ISSTRICTLYLOWER SPECIALIZATIONS
1148 //
1149 //=================================================================================================
1150 
1151 //*************************************************************************************************
1153 template< typename MT1, typename MT2 >
1154 struct IsStrictlyLower< DMatTDMatAddExpr<MT1,MT2> >
1155  : public BoolConstant< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
1156 {};
1158 //*************************************************************************************************
1159 
1160 
1161 
1162 
1163 //=================================================================================================
1164 //
1165 // ISUPPER SPECIALIZATIONS
1166 //
1167 //=================================================================================================
1168 
1169 //*************************************************************************************************
1171 template< typename MT1, typename MT2 >
1172 struct IsUpper< DMatTDMatAddExpr<MT1,MT2> >
1173  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
1174 {};
1176 //*************************************************************************************************
1177 
1178 
1179 
1180 
1181 //=================================================================================================
1182 //
1183 // ISUNIUPPER SPECIALIZATIONS
1184 //
1185 //=================================================================================================
1186 
1187 //*************************************************************************************************
1189 template< typename MT1, typename MT2 >
1190 struct IsUniUpper< DMatTDMatAddExpr<MT1,MT2> >
1191  : public BoolConstant< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
1192  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
1193 {};
1195 //*************************************************************************************************
1196 
1197 
1198 
1199 
1200 //=================================================================================================
1201 //
1202 // ISSTRICTLYUPPER SPECIALIZATIONS
1203 //
1204 //=================================================================================================
1205 
1206 //*************************************************************************************************
1208 template< typename MT1, typename MT2 >
1209 struct IsStrictlyUpper< DMatTDMatAddExpr<MT1,MT2> >
1210  : public BoolConstant< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1211 {};
1213 //*************************************************************************************************
1214 
1215 
1216 
1217 
1218 //=================================================================================================
1219 //
1220 // EXPRESSION TRAIT SPECIALIZATIONS
1221 //
1222 //=================================================================================================
1223 
1224 //*************************************************************************************************
1226 template< typename MT1, typename MT2, bool AF >
1227 struct SubmatrixExprTrait< DMatTDMatAddExpr<MT1,MT2>, AF >
1228 {
1229  public:
1230  //**********************************************************************************************
1231  using Type = AddExprTrait_< SubmatrixExprTrait_<const MT1,AF>
1232  , SubmatrixExprTrait_<const MT2,AF> >;
1233  //**********************************************************************************************
1234 };
1236 //*************************************************************************************************
1237 
1238 
1239 //*************************************************************************************************
1241 template< typename MT1, typename MT2 >
1242 struct RowExprTrait< DMatTDMatAddExpr<MT1,MT2> >
1243 {
1244  public:
1245  //**********************************************************************************************
1246  using Type = AddExprTrait_< RowExprTrait_<const MT1>
1247  , RowExprTrait_<const MT2> >;
1248  //**********************************************************************************************
1249 };
1251 //*************************************************************************************************
1252 
1253 
1254 //*************************************************************************************************
1256 template< typename MT1, typename MT2 >
1257 struct ColumnExprTrait< DMatTDMatAddExpr<MT1,MT2> >
1258 {
1259  public:
1260  //**********************************************************************************************
1261  using Type = AddExprTrait_< ColumnExprTrait_<const MT1>
1262  , ColumnExprTrait_<const MT2> >;
1263  //**********************************************************************************************
1264 };
1266 //*************************************************************************************************
1267 
1268 } // namespace blaze
1269 
1270 #endif
ReturnType_< MT2 > RN2
Return type of the right-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:116
#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
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatTDMatAddExpr.h:173
Header file for auxiliary alias declarations.
Header file for the Max class template.
Header file for kernel specific block sizes.
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.
DMatTDMatAddExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the DMatTDMatAddExpr class.
Definition: DMatTDMatAddExpr.h:203
Header file for the IsUniUpper type trait.
If_< IsExpression< MT2 >, const MT2, const MT2 & > RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:186
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.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DMatTDMatAddExpr.h:174
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 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.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatTDMatAddExpr.h:260
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
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
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
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatTDMatAddExpr.h:325
Header file for the Computation base class.
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
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
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
Constraint on the data type.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Header file for the DisableIf class template.
Header file for the IsTemporary type trait class.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatTDMatAddExpr.h:234
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTDMatAddExpr.h:180
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
If_< IsExpression< MT1 >, const MT1, const MT1 & > LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:183
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.
ResultType_< MT2 > RT2
Result type of the right-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:114
Header file for the Not class template.
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
AddTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: DMatTDMatAddExpr.h:171
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
#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
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTDMatAddExpr.h:172
Constraints on the storage order of matrix types.
Header file for the exception macros of the math module.
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose dense matrix operand.
Definition: DMatTDMatAddExpr.h:280
#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
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTDMatAddExpr.h:315
AddExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: DMatTDMatAddExpr.h:131
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
DMatTDMatAddExpr< MT1, MT2 > This
Type of this DMatTDMatAdd instance.
Definition: DMatTDMatAddExpr.h:170
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
LeftOperand lhs_
Left-hand side dense matrix of the addition expression.
Definition: DMatTDMatAddExpr.h:333
Header file for run time assertion macros.
Header file for the addition trait.
RightOperand rhs_
Right-hand side dense matrix of the addition expression.
Definition: DMatTDMatAddExpr.h:334
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.
ReturnType_< MT1 > RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:115
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
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
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
CompositeType_< MT1 > CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:117
ResultType_< MT1 > RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:113
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTDMatAddExpr.h:219
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DMatTDMatAddExpr.h:177
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatTDMatAddExpr.h:292
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:950
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
#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
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatTDMatAddExpr.h:270
Header file for the IntegralConstant class template.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatTDMatAddExpr.h:305
CompositeType_< MT2 > CT2
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatAddExpr.h:118
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.
Header file for the IsHermitian type trait.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
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
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:71
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatTDMatAddExpr.h:250
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
Expression object for dense matrix-transpose dense matrix additions.The DMatTDMatAddExpr class repres...
Definition: DMatTDMatAddExpr.h:107