DMatDMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATDMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATDMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
51 #include <blaze/math/Intrinsics.h>
70 #include <blaze/system/Inline.h>
72 #include <blaze/util/Assert.h>
74 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/mpl/And.h>
77 #include <blaze/util/mpl/Max.h>
78 #include <blaze/util/SelectType.h>
79 #include <blaze/util/Types.h>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS DMATDMATSUBEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename MT1 // Type of the left-hand side dense matrix
100  , typename MT2 // Type of the right-hand side dense matrix
101  , bool SO > // Storage order
102 class DMatDMatSubExpr : public DenseMatrix< DMatDMatSubExpr<MT1,MT2,SO>, SO >
103  , private MatMatSubExpr
104  , private Computation
105 {
106  private:
107  //**Type definitions****************************************************************************
108  typedef typename MT1::ResultType RT1;
109  typedef typename MT2::ResultType RT2;
110  typedef typename MT1::ReturnType RN1;
111  typedef typename MT2::ReturnType RN2;
112  typedef typename MT1::CompositeType CT1;
113  typedef typename MT2::CompositeType CT2;
114  typedef typename MT1::ElementType ET1;
115  typedef typename MT2::ElementType ET2;
116  //**********************************************************************************************
117 
118  //**Return type evaluation**********************************************************************
120 
125  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
126 
129  //**********************************************************************************************
130 
131  //**Serial evaluation strategy******************************************************************
133 
139  enum { useAssign = RequiresEvaluation<MT1>::value || RequiresEvaluation<MT2>::value || !returnExpr };
140 
142  template< typename MT >
144  struct UseAssign {
145  enum { value = useAssign };
146  };
148  //**********************************************************************************************
149 
150  //**Parallel evaluation strategy****************************************************************
152 
158  template< typename MT >
159  struct UseSMPAssign {
160  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) && useAssign };
161  };
163  //**********************************************************************************************
164 
165  public:
166  //**Type definitions****************************************************************************
173 
176 
179 
181  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
182 
184  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
185  //**********************************************************************************************
186 
187  //**ConstIterator class definition**************************************************************
191  {
192  public:
193  //**Type definitions*************************************************************************
194  typedef std::random_access_iterator_tag IteratorCategory;
195  typedef ElementType ValueType;
196  typedef ElementType* PointerType;
197  typedef ElementType& ReferenceType;
199 
200  // STL iterator requirements
201  typedef IteratorCategory iterator_category;
202  typedef ValueType value_type;
203  typedef PointerType pointer;
204  typedef ReferenceType reference;
205  typedef DifferenceType difference_type;
206 
209 
212  //*******************************************************************************************
213 
214  //**Constructor******************************************************************************
220  explicit inline ConstIterator( LeftIteratorType left, RightIteratorType right )
221  : left_ ( left ) // Iterator to the current left-hand side element
222  , right_( right ) // Iterator to the current right-hand side element
223  {}
224  //*******************************************************************************************
225 
226  //**Addition assignment operator*************************************************************
232  inline ConstIterator& operator+=( size_t inc ) {
233  left_ += inc;
234  right_ += inc;
235  return *this;
236  }
237  //*******************************************************************************************
238 
239  //**Subtraction assignment operator**********************************************************
245  inline ConstIterator& operator-=( size_t dec ) {
246  left_ -= dec;
247  right_ -= dec;
248  return *this;
249  }
250  //*******************************************************************************************
251 
252  //**Prefix increment operator****************************************************************
258  ++left_;
259  ++right_;
260  return *this;
261  }
262  //*******************************************************************************************
263 
264  //**Postfix increment operator***************************************************************
269  inline const ConstIterator operator++( int ) {
270  return ConstIterator( left_++, right_++ );
271  }
272  //*******************************************************************************************
273 
274  //**Prefix decrement operator****************************************************************
280  --left_;
281  --right_;
282  return *this;
283  }
284  //*******************************************************************************************
285 
286  //**Postfix decrement operator***************************************************************
291  inline const ConstIterator operator--( int ) {
292  return ConstIterator( left_--, right_-- );
293  }
294  //*******************************************************************************************
295 
296  //**Element access operator******************************************************************
301  inline ReturnType operator*() const {
302  return (*left_) - (*right_);
303  }
304  //*******************************************************************************************
305 
306  //**Load function****************************************************************************
311  inline IntrinsicType load() const {
312  return left_.load() - right_.load();
313  }
314  //*******************************************************************************************
315 
316  //**Equality operator************************************************************************
322  inline bool operator==( const ConstIterator& rhs ) const {
323  return left_ == rhs.left_;
324  }
325  //*******************************************************************************************
326 
327  //**Inequality operator**********************************************************************
333  inline bool operator!=( const ConstIterator& rhs ) const {
334  return left_ != rhs.left_;
335  }
336  //*******************************************************************************************
337 
338  //**Less-than operator***********************************************************************
344  inline bool operator<( const ConstIterator& rhs ) const {
345  return left_ < rhs.left_;
346  }
347  //*******************************************************************************************
348 
349  //**Greater-than operator********************************************************************
355  inline bool operator>( const ConstIterator& rhs ) const {
356  return left_ > rhs.left_;
357  }
358  //*******************************************************************************************
359 
360  //**Less-or-equal-than operator**************************************************************
366  inline bool operator<=( const ConstIterator& rhs ) const {
367  return left_ <= rhs.left_;
368  }
369  //*******************************************************************************************
370 
371  //**Greater-or-equal-than operator***********************************************************
377  inline bool operator>=( const ConstIterator& rhs ) const {
378  return left_ >= rhs.left_;
379  }
380  //*******************************************************************************************
381 
382  //**Subtraction operator*********************************************************************
388  inline DifferenceType operator-( const ConstIterator& rhs ) const {
389  return left_ - rhs.left_;
390  }
391  //*******************************************************************************************
392 
393  //**Addition operator************************************************************************
400  friend inline const ConstIterator operator+( const ConstIterator& it, size_t inc ) {
401  return ConstIterator( it.left_ + inc, it.right_ + inc );
402  }
403  //*******************************************************************************************
404 
405  //**Addition operator************************************************************************
412  friend inline const ConstIterator operator+( size_t inc, const ConstIterator& it ) {
413  return ConstIterator( it.left_ + inc, it.right_ + inc );
414  }
415  //*******************************************************************************************
416 
417  //**Subtraction operator*********************************************************************
424  friend inline const ConstIterator operator-( const ConstIterator& it, size_t dec ) {
425  return ConstIterator( it.left_ - dec, it.right_ - dec );
426  }
427  //*******************************************************************************************
428 
429  private:
430  //**Member variables*************************************************************************
431  LeftIteratorType left_;
432  RightIteratorType right_;
433  //*******************************************************************************************
434  };
435  //**********************************************************************************************
436 
437  //**Compilation flags***************************************************************************
439  enum { vectorizable = MT1::vectorizable && MT2::vectorizable &&
442 
444  enum { smpAssignable = MT1::smpAssignable && MT2::smpAssignable };
445  //**********************************************************************************************
446 
447  //**Constructor*********************************************************************************
453  explicit inline DMatDMatSubExpr( const MT1& lhs, const MT2& rhs )
454  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
455  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
456  {
457  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
458  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
459  }
460  //**********************************************************************************************
461 
462  //**Access operator*****************************************************************************
469  inline ReturnType operator()( size_t i, size_t j ) const {
470  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
471  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
472  return lhs_(i,j) - rhs_(i,j);
473  }
474  //**********************************************************************************************
475 
476  //**Load function*******************************************************************************
483  BLAZE_ALWAYS_INLINE IntrinsicType load( size_t i, size_t j ) const {
484  typedef IntrinsicTrait<ElementType> IT;
485  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
486  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
487  BLAZE_INTERNAL_ASSERT( !SO || ( i % IT::size == 0UL ), "Invalid row access index" );
488  BLAZE_INTERNAL_ASSERT( SO || ( j % IT::size == 0UL ), "Invalid column access index" );
489  const IntrinsicType xmm1( lhs_.load(i,j) );
490  const IntrinsicType xmm2( rhs_.load(i,j) );
491  return xmm1 - xmm2;
492  }
493  //**********************************************************************************************
494 
495  //**Begin function******************************************************************************
501  inline ConstIterator begin( size_t i ) const {
502  return ConstIterator( lhs_.begin(i), rhs_.begin(i) );
503  }
504  //**********************************************************************************************
505 
506  //**End function********************************************************************************
512  inline ConstIterator end( size_t i ) const {
513  return ConstIterator( lhs_.end(i), rhs_.end(i) );
514  }
515  //**********************************************************************************************
516 
517  //**Rows function*******************************************************************************
522  inline size_t rows() const {
523  return lhs_.rows();
524  }
525  //**********************************************************************************************
526 
527  //**Columns function****************************************************************************
532  inline size_t columns() const {
533  return lhs_.columns();
534  }
535  //**********************************************************************************************
536 
537  //**Left operand access*************************************************************************
542  inline LeftOperand leftOperand() const {
543  return lhs_;
544  }
545  //**********************************************************************************************
546 
547  //**Right operand access************************************************************************
552  inline RightOperand rightOperand() const {
553  return rhs_;
554  }
555  //**********************************************************************************************
556 
557  //**********************************************************************************************
563  template< typename T >
564  inline bool canAlias( const T* alias ) const {
565  return ( IsExpression<MT1>::value && ( RequiresEvaluation<MT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
566  ( IsExpression<MT2>::value && ( RequiresEvaluation<MT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
567  }
568  //**********************************************************************************************
569 
570  //**********************************************************************************************
576  template< typename T >
577  inline bool isAliased( const T* alias ) const {
578  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
579  }
580  //**********************************************************************************************
581 
582  //**********************************************************************************************
587  inline bool isAligned() const {
588  return lhs_.isAligned() && rhs_.isAligned();
589  }
590  //**********************************************************************************************
591 
592  //**********************************************************************************************
597  inline bool canSMPAssign() const {
598  return lhs_.canSMPAssign() || rhs_.canSMPAssign() ||
599  ( ( ( SO == rowMajor ) ? rows() : columns() ) > SMP_DMATDMATSUB_THRESHOLD );
600  }
601  //**********************************************************************************************
602 
603  private:
604  //**Member variables****************************************************************************
605  LeftOperand lhs_;
606  RightOperand rhs_;
607  //**********************************************************************************************
608 
609  //**Assignment to dense matrices****************************************************************
623  template< typename MT // Type of the target dense matrix
624  , bool SO2 > // Storage order of the target dense matrix
625  friend inline typename EnableIf< UseAssign<MT> >::Type
626  assign( DenseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
627  {
629 
630  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
631  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
632 
633  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
634  subAssign( ~lhs, rhs.rhs_ );
635  }
636  else {
637  assign ( ~lhs, rhs.lhs_ );
638  subAssign( ~lhs, rhs.rhs_ );
639  }
640  }
642  //**********************************************************************************************
643 
644  //**Assignment to sparse matrices***************************************************************
658  template< typename MT // Type of the target sparse matrix
659  , bool SO2 > // Storage order of the target sparse matrix
660  friend inline typename EnableIf< UseAssign<MT> >::Type
661  assign( SparseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
662  {
664 
666 
673 
674  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
675  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
676 
677  const TmpType tmp( serial( rhs ) );
678  assign( ~lhs, tmp );
679  }
681  //**********************************************************************************************
682 
683  //**Addition assignment to dense matrices*******************************************************
697  template< typename MT // Type of the target dense matrix
698  , bool SO2 > // Storage order of the target dense matrix
699  friend inline typename EnableIf< UseAssign<MT> >::Type
700  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
701  {
703 
704  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
705  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
706 
707  addAssign( ~lhs, rhs.lhs_ );
708  subAssign( ~lhs, rhs.rhs_ );
709  }
711  //**********************************************************************************************
712 
713  //**Addition assignment to sparse matrices******************************************************
714  // No special implementation for the addition assignment to sparse matrices.
715  //**********************************************************************************************
716 
717  //**Subtraction assignment to dense matrices****************************************************
731  template< typename MT // Type of the target dense matrix
732  , bool SO2 > // Storage order of the target dense matrix
733  friend inline typename EnableIf< UseAssign<MT> >::Type
734  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
735  {
737 
738  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
739  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
740 
741  subAssign( ~lhs, rhs.lhs_ );
742  addAssign( ~lhs, rhs.rhs_ );
743  }
745  //**********************************************************************************************
746 
747  //**Subtraction assignment to sparse matrices***************************************************
748  // No special implementation for the subtraction assignment to sparse matrices.
749  //**********************************************************************************************
750 
751  //**Multiplication assignment to dense matrices*************************************************
752  // No special implementation for the multiplication assignment to dense matrices.
753  //**********************************************************************************************
754 
755  //**Multiplication assignment to sparse matrices************************************************
756  // No special implementation for the multiplication assignment to sparse matrices.
757  //**********************************************************************************************
758 
759  //**SMP assignment to dense matrices************************************************************
773  template< typename MT // Type of the target dense matrix
774  , bool SO2 > // Storage order of the target dense matrix
775  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
776  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
777  {
779 
780  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
781  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
782 
783  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
784  smpSubAssign( ~lhs, rhs.rhs_ );
785  }
786  else {
787  smpAssign ( ~lhs, rhs.lhs_ );
788  smpSubAssign( ~lhs, rhs.rhs_ );
789  }
790  }
792  //**********************************************************************************************
793 
794  //**SMP assignment to sparse matrices***********************************************************
808  template< typename MT // Type of the target sparse matrix
809  , bool SO2 > // Storage order of the target sparse matrix
810  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
811  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
812  {
814 
815  typedef typename SelectType< SO == SO2, ResultType, OppositeType >::Type TmpType;
816 
823 
824  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
825  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
826 
827  const TmpType tmp( rhs );
828  smpAssign( ~lhs, tmp );
829  }
831  //**********************************************************************************************
832 
833  //**SMP addition assignment to dense matrices***************************************************
847  template< typename MT // Type of the target dense matrix
848  , bool SO2 > // Storage order of the target dense matrix
849  friend inline typename EnableIf< UseAssign<MT> >::Type
850  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
851  {
853 
854  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
855  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
856 
857  smpAddAssign( ~lhs, rhs.lhs_ );
858  smpSubAssign( ~lhs, rhs.rhs_ );
859  }
861  //**********************************************************************************************
862 
863  //**SMP addition assignment to sparse matrices**************************************************
864  // No special implementation for the SMP addition assignment to sparse matrices.
865  //**********************************************************************************************
866 
867  //**SMP subtraction assignment to dense matrices************************************************
881  template< typename MT // Type of the target dense matrix
882  , bool SO2 > // Storage order of the target dense matrix
883  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
884  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatDMatSubExpr& rhs )
885  {
887 
888  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
889  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
890 
891  smpSubAssign( ~lhs, rhs.lhs_ );
892  smpAddAssign( ~lhs, rhs.rhs_ );
893  }
895  //**********************************************************************************************
896 
897  //**SMP subtraction assignment to sparse matrices***********************************************
898  // No special implementation for the SMP subtraction assignment to sparse matrices.
899  //**********************************************************************************************
900 
901  //**SMP multiplication assignment to dense matrices*********************************************
902  // No special implementation for the SMP multiplication assignment to dense matrices.
903  //**********************************************************************************************
904 
905  //**SMP multiplication assignment to sparse matrices********************************************
906  // No special implementation for the SMP multiplication assignment to sparse matrices.
907  //**********************************************************************************************
908 
909  //**Compile time checks*************************************************************************
915  //**********************************************************************************************
916 };
917 //*************************************************************************************************
918 
919 
920 
921 
922 //=================================================================================================
923 //
924 // GLOBAL BINARY ARITHMETIC OPERATORS
925 //
926 //=================================================================================================
927 
928 //*************************************************************************************************
953 template< typename T1 // Type of the left-hand side dense matrix
954  , typename T2 // Type of the right-hand side dense matrix
955  , bool SO > // Storage order
956 inline const DMatDMatSubExpr<T1,T2,SO>
958 {
960 
961  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
962  throw std::invalid_argument( "Matrix sizes do not match" );
963 
964  return DMatDMatSubExpr<T1,T2,SO>( ~lhs, ~rhs );
965 }
966 //*************************************************************************************************
967 
968 
969 
970 
971 //=================================================================================================
972 //
973 // ROWS SPECIALIZATIONS
974 //
975 //=================================================================================================
976 
977 //*************************************************************************************************
979 template< typename MT1, typename MT2, bool SO >
980 struct Rows< DMatDMatSubExpr<MT1,MT2,SO> >
981  : public Max< Rows<MT1>, Rows<MT2> >::Type
982 {};
984 //*************************************************************************************************
985 
986 
987 
988 
989 //=================================================================================================
990 //
991 // COLUMNS SPECIALIZATIONS
992 //
993 //=================================================================================================
994 
995 //*************************************************************************************************
997 template< typename MT1, typename MT2, bool SO >
998 struct Columns< DMatDMatSubExpr<MT1,MT2,SO> >
999  : public Max< Columns<MT1>, Columns<MT2> >::Type
1000 {};
1002 //*************************************************************************************************
1003 
1004 
1005 
1006 
1007 //=================================================================================================
1008 //
1009 // ISSYMMETRIC SPECIALIZATIONS
1010 //
1011 //=================================================================================================
1012 
1013 //*************************************************************************************************
1015 template< typename MT1, typename MT2, bool SO >
1016 struct IsSymmetric< DMatDMatSubExpr<MT1,MT2,SO> >
1017  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
1018 {};
1020 //*************************************************************************************************
1021 
1022 
1023 
1024 
1025 //=================================================================================================
1026 //
1027 // ISLOWER SPECIALIZATIONS
1028 //
1029 //=================================================================================================
1030 
1031 //*************************************************************************************************
1033 template< typename MT1, typename MT2, bool SO >
1034 struct IsLower< DMatDMatSubExpr<MT1,MT2,SO> >
1035  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
1036 {};
1038 //*************************************************************************************************
1039 
1040 
1041 
1042 
1043 //=================================================================================================
1044 //
1045 // ISUNILOWER SPECIALIZATIONS
1046 //
1047 //=================================================================================================
1048 
1049 //*************************************************************************************************
1051 template< typename MT1, typename MT2, bool SO >
1052 struct IsUniLower< DMatDMatSubExpr<MT1,MT2,SO> >
1053  : public IsTrue< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
1054 {};
1056 //*************************************************************************************************
1057 
1058 
1059 
1060 
1061 //=================================================================================================
1062 //
1063 // ISSTRICTLYLOWER SPECIALIZATIONS
1064 //
1065 //=================================================================================================
1066 
1067 //*************************************************************************************************
1069 template< typename MT1, typename MT2, bool SO >
1070 struct IsStrictlyLower< DMatDMatSubExpr<MT1,MT2,SO> >
1071  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
1072 {};
1074 //*************************************************************************************************
1075 
1076 
1077 
1078 
1079 //=================================================================================================
1080 //
1081 // ISUPPER SPECIALIZATIONS
1082 //
1083 //=================================================================================================
1084 
1085 //*************************************************************************************************
1087 template< typename MT1, typename MT2, bool SO >
1088 struct IsUpper< DMatDMatSubExpr<MT1,MT2,SO> >
1089  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
1090 {};
1092 //*************************************************************************************************
1093 
1094 
1095 
1096 
1097 //=================================================================================================
1098 //
1099 // ISUNIUPPER SPECIALIZATIONS
1100 //
1101 //=================================================================================================
1102 
1103 //*************************************************************************************************
1105 template< typename MT1, typename MT2, bool SO >
1106 struct IsUniUpper< DMatDMatSubExpr<MT1,MT2,SO> >
1107  : public IsTrue< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1108 {};
1110 //*************************************************************************************************
1111 
1112 
1113 
1114 
1115 //=================================================================================================
1116 //
1117 // ISSTRICTLYUPPER SPECIALIZATIONS
1118 //
1119 //=================================================================================================
1120 
1121 //*************************************************************************************************
1123 template< typename MT1, typename MT2, bool SO >
1124 struct IsStrictlyUpper< DMatDMatSubExpr<MT1,MT2,SO> >
1125  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1126 {};
1128 //*************************************************************************************************
1129 
1130 
1131 
1132 
1133 //=================================================================================================
1134 //
1135 // EXPRESSION TRAIT SPECIALIZATIONS
1136 //
1137 //=================================================================================================
1138 
1139 //*************************************************************************************************
1141 template< typename MT1, typename MT2, bool SO, bool AF >
1142 struct SubmatrixExprTrait< DMatDMatSubExpr<MT1,MT2,SO>, AF >
1143 {
1144  public:
1145  //**********************************************************************************************
1146  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
1147  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
1148  //**********************************************************************************************
1149 };
1151 //*************************************************************************************************
1152 
1153 
1154 //*************************************************************************************************
1156 template< typename MT1, typename MT2, bool SO >
1157 struct RowExprTrait< DMatDMatSubExpr<MT1,MT2,SO> >
1158 {
1159  public:
1160  //**********************************************************************************************
1161  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
1162  , typename RowExprTrait<const MT2>::Type >::Type Type;
1163  //**********************************************************************************************
1164 };
1166 //*************************************************************************************************
1167 
1168 
1169 //*************************************************************************************************
1171 template< typename MT1, typename MT2, bool SO >
1172 struct ColumnExprTrait< DMatDMatSubExpr<MT1,MT2,SO> >
1173 {
1174  public:
1175  //**********************************************************************************************
1176  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
1177  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1178  //**********************************************************************************************
1179 };
1181 //*************************************************************************************************
1182 
1183 } // namespace blaze
1184 
1185 #endif
Constraint on the data type.
Pointer difference type of the Blaze library.
Header file for the Max class template.
const ConstIterator operator++(int)
Post-increment operator.
Definition: DMatDMatSubExpr.h:269
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DMatDMatSubExpr.h:301
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.
ConstIterator & operator++()
Pre-increment operator.
Definition: DMatDMatSubExpr.h:257
Header file for the IsUniUpper type trait.
Header file for the subtraction trait.
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:264
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatDMatSubExpr.h:564
bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatDMatSubExpr.h:355
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatDMatSubExpr.h:175
ElementType * PointerType
Pointer return type.
Definition: DMatDMatSubExpr.h:196
IntrinsicTrait< ElementType >::Type IntrinsicType
Resulting intrinsic element type.
Definition: DMatDMatSubExpr.h:172
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:242
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
DMatDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatDMatSubExpr class.
Definition: DMatDMatSubExpr.h:453
#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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatDMatSubExpr.h:469
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.
Header file for the IsSame and IsStrictlySame type traits.
IntrinsicType load() const
Access to the intrinsic elements of the matrix.
Definition: DMatDMatSubExpr.h:311
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:110
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
ConstIterator & operator--()
Pre-decrement operator.
Definition: DMatDMatSubExpr.h:279
Header file for the And class template.
PointerType pointer
Pointer return type.
Definition: DMatDMatSubExpr.h:203
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
Header file for the Computation base class.
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType.
Definition: IsSame.h:158
MT2::ConstIterator RightIteratorType
ConstIterator type of the right-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:211
Header file for the RequiresEvaluation type trait.
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
Iterator over the elements of the dense matrix.
Definition: DMatDMatSubExpr.h:190
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
Constraint on the data type.
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatDMatSubExpr.h:171
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:112
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
DifferenceType difference_type
Difference between two iterators.
Definition: DMatDMatSubExpr.h:205
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: DMatDMatSubExpr.h:606
Expression object for dense matrix-dense matrix subtractions.The DMatDMatSubExpr class represents the...
Definition: DMatDMatSubExpr.h:102
BLAZE_ALWAYS_INLINE IntrinsicType load(size_t i, size_t j) const
Access to the intrinsic elements of the matrix.
Definition: DMatDMatSubExpr.h:483
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatDMatSubExpr.h:522
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatDMatSubExpr.h:168
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_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: DMatDMatSubExpr.h:501
ElementType ValueType
Type of the underlying elements.
Definition: DMatDMatSubExpr.h:195
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
const size_t SMP_DMATDMATSUB_THRESHOLD
SMP row-major dense matrix/row-major dense matrix subtraction threshold.This threshold specifies when...
Definition: Thresholds.h:763
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.
DMatDMatSubExpr< MT1, MT2, SO > This
Type of this DMatDMatSubExpr instance.
Definition: DMatDMatSubExpr.h:167
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DMatDMatSubExpr.h:194
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:181
RightIteratorType right_
Iterator to the current right-hand side element.
Definition: DMatDMatSubExpr.h:432
Header file for the MatMatSubExpr base class.
ReferenceType reference
Reference return type.
Definition: DMatDMatSubExpr.h:204
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatDMatSubExpr.h:597
Header file for the IsLower type trait.
ConstIterator(LeftIteratorType left, RightIteratorType right)
Constructor for the ConstIterator class.
Definition: DMatDMatSubExpr.h:220
#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
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatDMatSubExpr.h:587
Constraints on the storage order of matrix types.
MT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:114
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: DMatDMatSubExpr.h:512
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:104
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatDMatSubExpr.h:170
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:184
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.
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatDMatSubExpr.h:366
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatDMatSubExpr.h:169
ValueType value_type
Type of the underlying elements.
Definition: DMatDMatSubExpr.h:202
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DMatDMatSubExpr.h:333
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DMatDMatSubExpr.h:388
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:113
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:749
Header file for run time assertion macros.
MT2::ElementType ET2
Element type of the right-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:115
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
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DMatDMatSubExpr.h:322
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
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DMatDMatSubExpr.h:412
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:111
ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DMatDMatSubExpr.h:245
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DMatDMatSubExpr.h:424
#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
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatDMatSubExpr.h:377
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: DMatDMatSubExpr.h:552
Header file for all intrinsic functionality.
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DMatDMatSubExpr.h:198
ElementType & ReferenceType
Reference return type.
Definition: DMatDMatSubExpr.h:197
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:109
const bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
SelectType< useAssign, const ResultType, const DMatDMatSubExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: DMatDMatSubExpr.h:178
IteratorCategory iterator_category
The iterator category.
Definition: DMatDMatSubExpr.h:201
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
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatDMatSubExpr.h:542
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatDMatSubExpr.h:128
#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
LeftIteratorType left_
Iterator to the current left-hand side element.
Definition: DMatDMatSubExpr.h:431
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
Header file for the IsTrue value trait.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatDMatSubExpr.h:577
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:108
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatDMatSubExpr.h:344
MT1::ConstIterator LeftIteratorType
ConstIterator type of the left-hand side dense matrix expression.
Definition: DMatDMatSubExpr.h:208
#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
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatDMatSubExpr.h:605
Header file for the IsUpper type trait.
friend const ConstIterator operator+(const ConstIterator &it, size_t inc)
Addition between a ConstIterator and an integral value.
Definition: DMatDMatSubExpr.h:400
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatDMatSubExpr.h:532
const ConstIterator operator--(int)
Post-decrement operator.
Definition: DMatDMatSubExpr.h:291
Header file for the SubExprTrait class template.
System settings for the inline keywords.
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
ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DMatDMatSubExpr.h:232