DMatTDMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTDMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTDMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
70 #include <blaze/util/Assert.h>
72 #include <blaze/util/DisableIf.h>
73 #include <blaze/util/EnableIf.h>
75 #include <blaze/util/mpl/And.h>
76 #include <blaze/util/mpl/Max.h>
77 #include <blaze/util/mpl/Not.h>
78 #include <blaze/util/SelectType.h>
79 #include <blaze/util/Types.h>
81 
82 
83 namespace blaze {
84 
85 //=================================================================================================
86 //
87 // CLASS DMATTDMATSUBEXPR
88 //
89 //=================================================================================================
90 
91 //*************************************************************************************************
98 template< typename MT1 // Type of the left-hand side dense matrix
99  , typename MT2 > // Type of the right-hand side dense matrix
100 class DMatTDMatSubExpr : public DenseMatrix< DMatTDMatSubExpr<MT1,MT2>, false >
101  , private MatMatSubExpr
102  , private Computation
103 {
104  private:
105  //**Type definitions****************************************************************************
106  typedef typename MT1::ResultType RT1;
107  typedef typename MT2::ResultType RT2;
108  typedef typename MT1::ReturnType RN1;
109  typedef typename MT2::ReturnType RN2;
110  typedef typename MT1::CompositeType CT1;
111  typedef typename MT2::CompositeType CT2;
112  //**********************************************************************************************
113 
114  //**Return type evaluation**********************************************************************
116 
121  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
122 
125  //**********************************************************************************************
126 
127  //**Serial evaluation strategy******************************************************************
129 
135  enum { useAssign = RequiresEvaluation<MT1>::value || RequiresEvaluation<MT2>::value || !returnExpr };
136 
138  template< typename MT >
140  struct UseAssign {
141  enum { value = useAssign };
142  };
144  //**********************************************************************************************
145 
146  //**Parallel evaluation strategy****************************************************************
148 
154  template< typename MT >
155  struct UseSMPAssign {
156  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) && useAssign };
157  };
159  //**********************************************************************************************
160 
161  public:
162  //**Type definitions****************************************************************************
168 
171 
173  typedef const ResultType CompositeType;
174 
176  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
177 
179  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
180  //**********************************************************************************************
181 
182  //**Compilation flags***************************************************************************
184  enum { vectorizable = 0 };
185 
187  enum { smpAssignable = MT1::smpAssignable && MT2::smpAssignable };
188  //**********************************************************************************************
189 
190  //**Constructor*********************************************************************************
196  explicit inline DMatTDMatSubExpr( const MT1& lhs, const MT2& rhs )
197  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
198  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
199  {
200  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
201  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
202  }
203  //**********************************************************************************************
204 
205  //**Access operator*****************************************************************************
212  inline ReturnType operator()( size_t i, size_t j ) const {
213  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
214  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
215  return lhs_(i,j) - rhs_(i,j);
216  }
217  //**********************************************************************************************
218 
219  //**Rows function*******************************************************************************
224  inline size_t rows() const {
225  return lhs_.rows();
226  }
227  //**********************************************************************************************
228 
229  //**Columns function****************************************************************************
234  inline size_t columns() const {
235  return lhs_.columns();
236  }
237  //**********************************************************************************************
238 
239  //**Left operand access*************************************************************************
244  inline LeftOperand leftOperand() const {
245  return lhs_;
246  }
247  //**********************************************************************************************
248 
249  //**Right operand access************************************************************************
254  inline RightOperand rightOperand() const {
255  return rhs_;
256  }
257  //**********************************************************************************************
258 
259  //**********************************************************************************************
265  template< typename T >
266  inline bool canAlias( const T* alias ) const {
267  return ( IsExpression<MT1>::value && ( RequiresEvaluation<MT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
268  ( IsExpression<MT2>::value && ( RequiresEvaluation<MT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
269  }
270  //**********************************************************************************************
271 
272  //**********************************************************************************************
278  template< typename T >
279  inline bool isAliased( const T* alias ) const {
280  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
281  }
282  //**********************************************************************************************
283 
284  //**********************************************************************************************
289  inline bool isAligned() const {
290  return lhs_.isAligned() && rhs_.isAligned();
291  }
292  //**********************************************************************************************
293 
294  //**********************************************************************************************
299  inline bool canSMPAssign() const {
300  return lhs_.canSMPAssign() || rhs_.canSMPAssign() ||
302  }
303  //**********************************************************************************************
304 
305  private:
306  //**Member variables****************************************************************************
307  LeftOperand lhs_;
308  RightOperand rhs_;
309  //**********************************************************************************************
310 
311  //**Assignment to dense matrices****************************************************************
325  template< typename MT // Type of the target dense matrix
326  , bool SO2 > // Storage order of the target dense matrix
327  friend inline typename DisableIf< UseAssign<MT> >::Type
328  assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
329  {
331 
332  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
333  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
334 
335  const size_t m( rhs.rows() );
336  const size_t n( rhs.columns() );
337  const size_t block( 16UL );
338 
339  for( size_t ii=0UL; ii<m; ii+=block ) {
340  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
341  for( size_t jj=0UL; jj<n; jj+=block ) {
342  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
343  for( size_t i=ii; i<iend; ++i ) {
344  for( size_t j=jj; j<jend; ++j ) {
345  (~lhs)(i,j) = rhs.lhs_(i,j) - rhs.rhs_(i,j);
346  }
347  }
348  }
349  }
350  }
352  //**********************************************************************************************
353 
354  //**Assignment to dense matrices****************************************************************
368  template< typename MT // Type of the target dense matrix
369  , bool SO2 > // Storage order of the target dense matrix
370  friend inline typename EnableIf< UseAssign<MT> >::Type
371  assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
372  {
374 
375  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
376  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
377 
378  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
379  subAssign( ~lhs, rhs.rhs_ );
380  }
381  else {
382  assign ( ~lhs, rhs.lhs_ );
383  subAssign( ~lhs, rhs.rhs_ );
384  }
385  }
387  //**********************************************************************************************
388 
389  //**Assignment to sparse matrices***************************************************************
401  template< typename MT // Type of the target sparse matrix
402  , bool SO2 > // Storage order of the target sparse matrix
403  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
404  {
406 
407  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
408 
415 
416  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
417  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
418 
419  const TmpType tmp( serial( rhs ) );
420  assign( ~lhs, tmp );
421  }
423  //**********************************************************************************************
424 
425  //**Addition assignment to dense matrices*******************************************************
440  template< typename MT // Type of the target dense matrix
441  , bool SO2 > // Storage order of the target dense matrix
442  friend inline typename DisableIf< UseAssign<MT> >::Type
443  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
444  {
446 
447  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
448  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
449 
450  const size_t m( rhs.rows() );
451  const size_t n( rhs.columns() );
452  const size_t block( 16UL );
453 
454  for( size_t ii=0UL; ii<m; ii+=block ) {
455  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
456  for( size_t jj=0UL; jj<n; jj+=block ) {
457  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
458  for( size_t i=ii; i<iend; ++i ) {
459  for( size_t j=jj; j<jend; ++j ) {
460  (~lhs)(i,j) += rhs.lhs_(i,j) - rhs.rhs_(i,j);
461  }
462  }
463  }
464  }
465  }
467  //**********************************************************************************************
468 
469  //**Addition assignment to dense matrices*******************************************************
484  template< typename MT // Type of the target dense matrix
485  , bool SO2 > // Storage order of the target dense matrix
486  friend inline typename EnableIf< UseAssign<MT> >::Type
487  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
488  {
490 
491  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
492  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
493 
494  addAssign( ~lhs, rhs.lhs_ );
495  subAssign( ~lhs, rhs.rhs_ );
496  }
498  //**********************************************************************************************
499 
500  //**Addition assignment to sparse matrices******************************************************
501  // No special implementation for the addition assignment to sparse matrices.
502  //**********************************************************************************************
503 
504  //**Subtraction assignment to dense matrices****************************************************
519  template< typename MT // Type of the target dense matrix
520  , bool SO2 > // Storage order of the target dense matrix
521  friend inline typename DisableIf< UseAssign<MT> >::Type
522  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
523  {
525 
526  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
527  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
528 
529  const size_t m( rhs.rows() );
530  const size_t n( rhs.columns() );
531  const size_t block( 16UL );
532 
533  for( size_t ii=0UL; ii<m; ii+=block ) {
534  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
535  for( size_t jj=0UL; jj<n; jj+=block ) {
536  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
537  for( size_t i=ii; i<iend; ++i ) {
538  for( size_t j=jj; j<jend; ++j ) {
539  (~lhs)(i,j) -= rhs.lhs_(i,j) - rhs.rhs_(i,j);
540  }
541  }
542  }
543  }
544  }
546  //**********************************************************************************************
547 
548  //**Subtraction assignment to dense matrices****************************************************
563  template< typename MT // Type of the target dense matrix
564  , bool SO2 > // Storage order of the target dense matrix
565  friend inline typename EnableIf< UseAssign<MT> >::Type
566  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
567  {
569 
570  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
571  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
572 
573  subAssign( ~lhs, rhs.lhs_ );
574  addAssign( ~lhs, rhs.rhs_ );
575  }
577  //**********************************************************************************************
578 
579  //**Subtraction assignment to sparse matrices***************************************************
580  // No special implementation for the subtraction assignment to sparse matrices.
581  //**********************************************************************************************
582 
583  //**Multiplication assignment to dense matrices*************************************************
584  // No special implementation for the multiplication assignment to dense matrices.
585  //**********************************************************************************************
586 
587  //**Multiplication assignment to sparse matrices************************************************
588  // No special implementation for the multiplication assignment to sparse matrices.
589  //**********************************************************************************************
590 
591  //**SMP assignment to dense matrices************************************************************
605  template< typename MT // Type of the target dense matrix
606  , bool SO2 > // Storage order of the target dense matrix
607  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
608  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
609  {
611 
612  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
613  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
614 
615  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
616  smpSubAssign( ~lhs, rhs.rhs_ );
617  }
618  else {
619  smpAssign ( ~lhs, rhs.lhs_ );
620  smpSubAssign( ~lhs, rhs.rhs_ );
621  }
622  }
624  //**********************************************************************************************
625 
626  //**SMP assignment to sparse matrices***********************************************************
640  template< typename MT // Type of the target sparse matrix
641  , bool SO2 > // Storage order of the target sparse matrix
642  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
643  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
644  {
646 
647  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
648 
655 
656  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
657  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
658 
659  const TmpType tmp( rhs );
660  smpAssign( ~lhs, tmp );
661  }
663  //**********************************************************************************************
664 
665  //**SMP addition assignment to dense matrices***************************************************
680  template< typename MT // Type of the target dense matrix
681  , bool SO2 > // Storage order of the target dense matrix
682  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
683  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
684  {
686 
687  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
688  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
689 
690  smpAddAssign( ~lhs, rhs.lhs_ );
691  smpSubAssign( ~lhs, rhs.rhs_ );
692  }
694  //**********************************************************************************************
695 
696  //**SMP addition assignment to sparse matrices**************************************************
697  // No special implementation for the SMP addition assignment to sparse matrices.
698  //**********************************************************************************************
699 
700  //**SMP subtraction assignment to dense matrices************************************************
715  template< typename MT // Type of the target dense matrix
716  , bool SO2 > // Storage order of the target dense matrix
717  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
718  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
719  {
721 
722  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
723  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
724 
725  smpSubAssign( ~lhs, rhs.lhs_ );
726  smpAddAssign( ~lhs, rhs.rhs_ );
727  }
729  //**********************************************************************************************
730 
731  //**SMP subtraction assignment to sparse matrices***********************************************
732  // No special implementation for the SMP subtraction assignment to sparse matrices.
733  //**********************************************************************************************
734 
735  //**SMP multiplication assignment to dense matrices*********************************************
736  // No special implementation for the SMP multiplication assignment to dense matrices.
737  //**********************************************************************************************
738 
739  //**SMP multiplication assignment to sparse matrices********************************************
740  // No special implementation for the SMP multiplication assignment to sparse matrices.
741  //**********************************************************************************************
742 
743  //**Compile time checks*************************************************************************
750  //**********************************************************************************************
751 };
752 //*************************************************************************************************
753 
754 
755 
756 
757 //=================================================================================================
758 //
759 // GLOBAL BINARY ARITHMETIC OPERATORS
760 //
761 //=================================================================================================
762 
763 //*************************************************************************************************
792 template< typename T1 // Type of the left-hand side dense matrix
793  , typename T2 > // Type of the right-hand side dense matrix
794 inline typename EnableIf< And< Not< IsSymmetric<T1> >, Not< IsSymmetric<T2> > >
795  , const DMatTDMatSubExpr<T1,T2> >::Type
797 {
799 
800  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
801  throw std::invalid_argument( "Matrix sizes do not match" );
802 
803  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
804 }
805 //*************************************************************************************************
806 
807 
808 //*************************************************************************************************
837 template< typename T1 // Type of the left-hand side dense matrix
838  , typename T2 > // Type of the right-hand side dense matrix
839 inline typename EnableIf< And< Not< IsSymmetric<T1> >, Not< IsSymmetric<T2> > >
840  , const DMatTDMatSubExpr<T1,T2> >::Type
842 {
844 
845  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
846  throw std::invalid_argument( "Matrix sizes do not match" );
847 
848  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
849 }
850 //*************************************************************************************************
851 
852 
853 
854 
855 //=================================================================================================
856 //
857 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
858 //
859 //=================================================================================================
860 
861 //*************************************************************************************************
875 template< typename T1 // Type of the left-hand side dense matrix
876  , typename T2 > // Type of the right-hand side dense matrix
877 inline typename EnableIf< And< IsSymmetric<T1>, Not< IsSymmetric<T2> > >
878  , const typename SubExprTrait<T1,T2>::Type >::Type
879  operator-( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,true>& rhs )
880 {
882 
883  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
884  throw std::invalid_argument( "Matrix sizes do not match" );
885 
886  return trans( ~lhs ) - ~rhs;
887 }
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 typename EnableIf< IsSymmetric<T2>
909  , const typename SubExprTrait<T1,T2>::Type >::Type
910  operator-( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,true>& rhs )
911 {
913 
914  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
915  throw std::invalid_argument( "Matrix sizes do not match" );
916 
917  return (~lhs) - trans( ~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 typename EnableIf< And< Not< IsSymmetric<T1> >, IsSymmetric<T2> >
940  , const typename SubExprTrait<T1,T2>::Type >::Type
941  operator-( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,false>& rhs )
942 {
944 
945  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
946  throw std::invalid_argument( "Matrix sizes do not match" );
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 typename EnableIf< IsSymmetric<T1>
971  , const typename SubExprTrait<T1,T2>::Type >::Type
972  operator-( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,false>& rhs )
973 {
975 
976  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
977  throw std::invalid_argument( "Matrix sizes do not match" );
978 
979  return trans( ~lhs ) - (~rhs);
980 }
982 //*************************************************************************************************
983 
984 
985 
986 
987 //=================================================================================================
988 //
989 // ROWS SPECIALIZATIONS
990 //
991 //=================================================================================================
992 
993 //*************************************************************************************************
995 template< typename MT1, typename MT2 >
996 struct Rows< DMatTDMatSubExpr<MT1,MT2> >
997  : public Max< Rows<MT1>, Rows<MT2> >::Type
998 {};
1000 //*************************************************************************************************
1001 
1002 
1003 
1004 
1005 //=================================================================================================
1006 //
1007 // COLUMNS SPECIALIZATIONS
1008 //
1009 //=================================================================================================
1010 
1011 //*************************************************************************************************
1013 template< typename MT1, typename MT2 >
1014 struct Columns< DMatTDMatSubExpr<MT1,MT2> >
1015  : public Max< Columns<MT1>, Columns<MT2> >::Type
1016 {};
1018 //*************************************************************************************************
1019 
1020 
1021 
1022 
1023 //=================================================================================================
1024 //
1025 // ISSYMMETRIC SPECIALIZATIONS
1026 //
1027 //=================================================================================================
1028 
1029 //*************************************************************************************************
1031 template< typename MT1, typename MT2 >
1032 struct IsSymmetric< DMatTDMatSubExpr<MT1,MT2> >
1033  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
1034 {};
1036 //*************************************************************************************************
1037 
1038 
1039 
1040 
1041 //=================================================================================================
1042 //
1043 // ISLOWER SPECIALIZATIONS
1044 //
1045 //=================================================================================================
1046 
1047 //*************************************************************************************************
1049 template< typename MT1, typename MT2 >
1050 struct IsLower< DMatTDMatSubExpr<MT1,MT2> >
1051  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
1052 {};
1054 //*************************************************************************************************
1055 
1056 
1057 
1058 
1059 //=================================================================================================
1060 //
1061 // ISUNILOWER SPECIALIZATIONS
1062 //
1063 //=================================================================================================
1064 
1065 //*************************************************************************************************
1067 template< typename MT1, typename MT2 >
1068 struct IsUniLower< DMatTDMatSubExpr<MT1,MT2> >
1069  : public IsTrue< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
1070 {};
1072 //*************************************************************************************************
1073 
1074 
1075 
1076 
1077 //=================================================================================================
1078 //
1079 // ISSTRICTLYLOWER SPECIALIZATIONS
1080 //
1081 //=================================================================================================
1082 
1083 //*************************************************************************************************
1085 template< typename MT1, typename MT2 >
1086 struct IsStrictlyLower< DMatTDMatSubExpr<MT1,MT2> >
1087  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
1088 {};
1090 //*************************************************************************************************
1091 
1092 
1093 
1094 
1095 //=================================================================================================
1096 //
1097 // ISUPPER SPECIALIZATIONS
1098 //
1099 //=================================================================================================
1100 
1101 //*************************************************************************************************
1103 template< typename MT1, typename MT2 >
1104 struct IsUpper< DMatTDMatSubExpr<MT1,MT2> >
1105  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
1106 {};
1108 //*************************************************************************************************
1109 
1110 
1111 
1112 
1113 //=================================================================================================
1114 //
1115 // ISUNIUPPER SPECIALIZATIONS
1116 //
1117 //=================================================================================================
1118 
1119 //*************************************************************************************************
1121 template< typename MT1, typename MT2 >
1122 struct IsUniUpper< DMatTDMatSubExpr<MT1,MT2> >
1123  : public IsTrue< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1124 {};
1126 //*************************************************************************************************
1127 
1128 
1129 
1130 
1131 //=================================================================================================
1132 //
1133 // ISSTRICTLYUPPER SPECIALIZATIONS
1134 //
1135 //=================================================================================================
1136 
1137 //*************************************************************************************************
1139 template< typename MT1, typename MT2 >
1140 struct IsStrictlyUpper< DMatTDMatSubExpr<MT1,MT2> >
1141  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1142 {};
1144 //*************************************************************************************************
1145 
1146 
1147 
1148 
1149 //=================================================================================================
1150 //
1151 // EXPRESSION TRAIT SPECIALIZATIONS
1152 //
1153 //=================================================================================================
1154 
1155 //*************************************************************************************************
1157 template< typename MT1, typename MT2, bool AF >
1158 struct SubmatrixExprTrait< DMatTDMatSubExpr<MT1,MT2>, AF >
1159 {
1160  public:
1161  //**********************************************************************************************
1162  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
1163  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
1164  //**********************************************************************************************
1165 };
1167 //*************************************************************************************************
1168 
1169 
1170 //*************************************************************************************************
1172 template< typename MT1, typename MT2 >
1173 struct RowExprTrait< DMatTDMatSubExpr<MT1,MT2> >
1174 {
1175  public:
1176  //**********************************************************************************************
1177  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
1178  , typename RowExprTrait<const MT2>::Type >::Type Type;
1179  //**********************************************************************************************
1180 };
1182 //*************************************************************************************************
1183 
1184 
1185 //*************************************************************************************************
1187 template< typename MT1, typename MT2 >
1188 struct ColumnExprTrait< DMatTDMatSubExpr<MT1,MT2> >
1189 {
1190  public:
1191  //**********************************************************************************************
1192  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
1193  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1194  //**********************************************************************************************
1195 };
1197 //*************************************************************************************************
1198 
1199 } // namespace blaze
1200 
1201 #endif
Constraint on the data type.
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:109
Header file for the Max class template.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatTDMatSubExpr.h:266
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
Header file for the subtraction trait.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:166
Header file for basic type definitions.
const size_t SMP_DMATTDMATSUB_THRESHOLD
SMP row-major dense matrix/column-major dense matrix subtraction threshold.This threshold specifies w...
Definition: Thresholds.h:788
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b)
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:946
Header file for the ColumnExprTrait class template.
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatTDMatSubExpr.h:124
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
Header file for the And class template.
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:307
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:110
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:108
Header file for the IsUniLower type trait.
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.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:170
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:107
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:90
Expression object for dense matrix-transpose dense matrix subtractions.The DMatTDMatSubExpr class rep...
Definition: DMatTDMatSubExpr.h:100
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTDMatSubExpr.h:173
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the DisableIf class template.
Header file for the IsTemporary type trait class.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:106
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a...
Definition: MatMatSubExpr.h:65
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#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: StorageOrder.h:161
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatTDMatSubExpr.h:279
Header file for the DenseMatrix base class.
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
Header file for the Columns type trait.
Header file for the Not class template.
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatTDMatSubExpr.h:167
Header file for the MatMatSubExpr base class.
DMatTDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatTDMatSubExpr class.
Definition: DMatTDMatSubExpr.h:196
Header file for the IsLower type trait.
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:308
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:164
#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:78
Constraints on the storage order of matrix types.
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:104
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the serial shim.
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_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:325
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTDMatSubExpr.h:289
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:111
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the SubmatrixExprTrait class template.
#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: StorageOrder.h:81
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
BLAZE_ALWAYS_INLINE void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:742
DMatTDMatSubExpr< MT1, MT2 > This
Type of this DMatTDMatSubExpr instance.
Definition: DMatTDMatSubExpr.h:163
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTDMatSubExpr.h:212
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatTDMatSubExpr.h:224
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:176
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
#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:283
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:179
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:937
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatTDMatSubExpr.h:244
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
Header file for the IsTrue value trait.
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: DMatTDMatSubExpr.h:254
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatSubExpr.h:165
Base template for the SubTrait class.
Definition: SubTrait.h:150
Header file for the IsUpper type trait.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTDMatSubExpr.h:165
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatTDMatSubExpr.h:299
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatTDMatSubExpr.h:234
Header file for the SubExprTrait class template.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#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:87
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:849