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 
72 #include <blaze/system/Blocking.h>
74 #include <blaze/util/Assert.h>
76 #include <blaze/util/DisableIf.h>
77 #include <blaze/util/EnableIf.h>
78 #include <blaze/util/Exception.h>
80 #include <blaze/util/mpl/And.h>
81 #include <blaze/util/mpl/Max.h>
82 #include <blaze/util/mpl/Not.h>
83 #include <blaze/util/SelectType.h>
84 #include <blaze/util/Types.h>
86 
87 
88 namespace blaze {
89 
90 //=================================================================================================
91 //
92 // CLASS DMATTDMATSUBEXPR
93 //
94 //=================================================================================================
95 
96 //*************************************************************************************************
103 template< typename MT1 // Type of the left-hand side dense matrix
104  , typename MT2 > // Type of the right-hand side dense matrix
105 class DMatTDMatSubExpr : public DenseMatrix< DMatTDMatSubExpr<MT1,MT2>, false >
106  , private MatMatSubExpr
107  , private Computation
108 {
109  private:
110  //**Type definitions****************************************************************************
111  typedef typename MT1::ResultType RT1;
112  typedef typename MT2::ResultType RT2;
113  typedef typename MT1::ReturnType RN1;
114  typedef typename MT2::ReturnType RN2;
115  typedef typename MT1::CompositeType CT1;
116  typedef typename MT2::CompositeType CT2;
117  //**********************************************************************************************
118 
119  //**Return type evaluation**********************************************************************
121 
126  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
127 
130  //**********************************************************************************************
131 
132  //**Serial evaluation strategy******************************************************************
134 
140  enum { useAssign = RequiresEvaluation<MT1>::value || RequiresEvaluation<MT2>::value || !returnExpr };
141 
143  template< typename MT >
145  struct UseAssign {
146  enum { value = useAssign };
147  };
149  //**********************************************************************************************
150 
151  //**Parallel evaluation strategy****************************************************************
153 
159  template< typename MT >
160  struct UseSMPAssign {
161  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) && useAssign };
162  };
164  //**********************************************************************************************
165 
166  public:
167  //**Type definitions****************************************************************************
173 
176 
178  typedef const ResultType CompositeType;
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  //**Compilation flags***************************************************************************
189  enum { vectorizable = 0 };
190 
192  enum { smpAssignable = MT1::smpAssignable && MT2::smpAssignable };
193  //**********************************************************************************************
194 
195  //**Constructor*********************************************************************************
201  explicit inline DMatTDMatSubExpr( const MT1& lhs, const MT2& rhs )
202  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
203  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
204  {
205  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
206  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
207  }
208  //**********************************************************************************************
209 
210  //**Access operator*****************************************************************************
217  inline ReturnType operator()( size_t i, size_t j ) const {
218  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
219  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
220  return lhs_(i,j) - rhs_(i,j);
221  }
222  //**********************************************************************************************
223 
224  //**At function*********************************************************************************
232  inline ReturnType at( size_t i, size_t j ) const {
233  if( i >= lhs_.rows() ) {
234  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
235  }
236  if( j >= lhs_.columns() ) {
237  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
238  }
239  return (*this)(i,j);
240  }
241  //**********************************************************************************************
242 
243  //**Rows function*******************************************************************************
248  inline size_t rows() const {
249  return lhs_.rows();
250  }
251  //**********************************************************************************************
252 
253  //**Columns function****************************************************************************
258  inline size_t columns() const {
259  return lhs_.columns();
260  }
261  //**********************************************************************************************
262 
263  //**Left operand access*************************************************************************
268  inline LeftOperand leftOperand() const {
269  return lhs_;
270  }
271  //**********************************************************************************************
272 
273  //**Right operand access************************************************************************
278  inline RightOperand rightOperand() const {
279  return rhs_;
280  }
281  //**********************************************************************************************
282 
283  //**********************************************************************************************
289  template< typename T >
290  inline bool canAlias( const T* alias ) const {
291  return ( IsExpression<MT1>::value && ( RequiresEvaluation<MT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
292  ( IsExpression<MT2>::value && ( RequiresEvaluation<MT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
293  }
294  //**********************************************************************************************
295 
296  //**********************************************************************************************
302  template< typename T >
303  inline bool isAliased( const T* alias ) const {
304  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
305  }
306  //**********************************************************************************************
307 
308  //**********************************************************************************************
313  inline bool isAligned() const {
314  return lhs_.isAligned() && rhs_.isAligned();
315  }
316  //**********************************************************************************************
317 
318  //**********************************************************************************************
323  inline bool canSMPAssign() const {
324  return lhs_.canSMPAssign() || rhs_.canSMPAssign() ||
325  ( rows() > SMP_DMATTDMATSUB_THRESHOLD );
326  }
327  //**********************************************************************************************
328 
329  private:
330  //**Member variables****************************************************************************
331  LeftOperand lhs_;
332  RightOperand rhs_;
333  //**********************************************************************************************
334 
335  //**Assignment to dense matrices****************************************************************
349  template< typename MT // Type of the target dense matrix
350  , bool SO2 > // Storage order of the target dense matrix
351  friend inline typename DisableIf< UseAssign<MT> >::Type
352  assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
353  {
355 
356  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
357  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
358 
359  const size_t m( rhs.rows() );
360  const size_t n( rhs.columns() );
361  const size_t block( BLOCK_SIZE );
362 
363  for( size_t ii=0UL; ii<m; ii+=block ) {
364  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
365  for( size_t jj=0UL; jj<n; jj+=block ) {
366  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
367  for( size_t i=ii; i<iend; ++i ) {
368  for( size_t j=jj; j<jend; ++j ) {
369  (~lhs)(i,j) = rhs.lhs_(i,j) - rhs.rhs_(i,j);
370  }
371  }
372  }
373  }
374  }
376  //**********************************************************************************************
377 
378  //**Assignment to dense matrices****************************************************************
392  template< typename MT // Type of the target dense matrix
393  , bool SO2 > // Storage order of the target dense matrix
394  friend inline typename EnableIf< UseAssign<MT> >::Type
395  assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
396  {
398 
399  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
400  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
401 
402  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
403  subAssign( ~lhs, rhs.rhs_ );
404  }
405  else {
406  assign ( ~lhs, rhs.lhs_ );
407  subAssign( ~lhs, rhs.rhs_ );
408  }
409  }
411  //**********************************************************************************************
412 
413  //**Assignment to sparse matrices***************************************************************
425  template< typename MT // Type of the target sparse matrix
426  , bool SO2 > // Storage order of the target sparse matrix
427  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
428  {
430 
431  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
432 
439 
440  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
441  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
442 
443  const TmpType tmp( serial( rhs ) );
444  assign( ~lhs, tmp );
445  }
447  //**********************************************************************************************
448 
449  //**Addition assignment to dense matrices*******************************************************
464  template< typename MT // Type of the target dense matrix
465  , bool SO2 > // Storage order of the target dense matrix
466  friend inline typename DisableIf< UseAssign<MT> >::Type
467  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
468  {
470 
471  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
472  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
473 
474  const size_t m( rhs.rows() );
475  const size_t n( rhs.columns() );
476  const size_t block( BLOCK_SIZE );
477 
478  for( size_t ii=0UL; ii<m; ii+=block ) {
479  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
480  for( size_t jj=0UL; jj<n; jj+=block ) {
481  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
482  for( size_t i=ii; i<iend; ++i ) {
483  for( size_t j=jj; j<jend; ++j ) {
484  (~lhs)(i,j) += rhs.lhs_(i,j) - rhs.rhs_(i,j);
485  }
486  }
487  }
488  }
489  }
491  //**********************************************************************************************
492 
493  //**Addition assignment to dense matrices*******************************************************
508  template< typename MT // Type of the target dense matrix
509  , bool SO2 > // Storage order of the target dense matrix
510  friend inline typename EnableIf< UseAssign<MT> >::Type
511  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
512  {
514 
515  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
516  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
517 
518  addAssign( ~lhs, rhs.lhs_ );
519  subAssign( ~lhs, rhs.rhs_ );
520  }
522  //**********************************************************************************************
523 
524  //**Addition assignment to sparse matrices******************************************************
525  // No special implementation for the addition assignment to sparse matrices.
526  //**********************************************************************************************
527 
528  //**Subtraction assignment to dense matrices****************************************************
543  template< typename MT // Type of the target dense matrix
544  , bool SO2 > // Storage order of the target dense matrix
545  friend inline typename DisableIf< UseAssign<MT> >::Type
546  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
547  {
549 
550  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
551  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
552 
553  const size_t m( rhs.rows() );
554  const size_t n( rhs.columns() );
555  const size_t block( BLOCK_SIZE );
556 
557  for( size_t ii=0UL; ii<m; ii+=block ) {
558  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
559  for( size_t jj=0UL; jj<n; jj+=block ) {
560  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
561  for( size_t i=ii; i<iend; ++i ) {
562  for( size_t j=jj; j<jend; ++j ) {
563  (~lhs)(i,j) -= rhs.lhs_(i,j) - rhs.rhs_(i,j);
564  }
565  }
566  }
567  }
568  }
570  //**********************************************************************************************
571 
572  //**Subtraction assignment to dense matrices****************************************************
587  template< typename MT // Type of the target dense matrix
588  , bool SO2 > // Storage order of the target dense matrix
589  friend inline typename EnableIf< UseAssign<MT> >::Type
590  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
591  {
593 
594  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
595  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
596 
597  subAssign( ~lhs, rhs.lhs_ );
598  addAssign( ~lhs, rhs.rhs_ );
599  }
601  //**********************************************************************************************
602 
603  //**Subtraction assignment to sparse matrices***************************************************
604  // No special implementation for the subtraction assignment to sparse matrices.
605  //**********************************************************************************************
606 
607  //**Multiplication assignment to dense matrices*************************************************
608  // No special implementation for the multiplication assignment to dense matrices.
609  //**********************************************************************************************
610 
611  //**Multiplication assignment to sparse matrices************************************************
612  // No special implementation for the multiplication assignment to sparse matrices.
613  //**********************************************************************************************
614 
615  //**SMP assignment to dense matrices************************************************************
629  template< typename MT // Type of the target dense matrix
630  , bool SO2 > // Storage order of the target dense matrix
631  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
632  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
633  {
635 
636  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
637  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
638 
639  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
640  smpSubAssign( ~lhs, rhs.rhs_ );
641  }
642  else {
643  smpAssign ( ~lhs, rhs.lhs_ );
644  smpSubAssign( ~lhs, rhs.rhs_ );
645  }
646  }
648  //**********************************************************************************************
649 
650  //**SMP assignment to sparse matrices***********************************************************
664  template< typename MT // Type of the target sparse matrix
665  , bool SO2 > // Storage order of the target sparse matrix
666  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
667  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
668  {
670 
671  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
672 
679 
680  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
681  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
682 
683  const TmpType tmp( rhs );
684  smpAssign( ~lhs, tmp );
685  }
687  //**********************************************************************************************
688 
689  //**SMP addition assignment to dense matrices***************************************************
704  template< typename MT // Type of the target dense matrix
705  , bool SO2 > // Storage order of the target dense matrix
706  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
707  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
708  {
710 
711  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
712  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
713 
714  smpAddAssign( ~lhs, rhs.lhs_ );
715  smpSubAssign( ~lhs, rhs.rhs_ );
716  }
718  //**********************************************************************************************
719 
720  //**SMP addition assignment to sparse matrices**************************************************
721  // No special implementation for the SMP addition assignment to sparse matrices.
722  //**********************************************************************************************
723 
724  //**SMP subtraction assignment to dense matrices************************************************
739  template< typename MT // Type of the target dense matrix
740  , bool SO2 > // Storage order of the target dense matrix
741  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
742  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
743  {
745 
746  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
747  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
748 
749  smpSubAssign( ~lhs, rhs.lhs_ );
750  smpAddAssign( ~lhs, rhs.rhs_ );
751  }
753  //**********************************************************************************************
754 
755  //**SMP subtraction assignment to sparse matrices***********************************************
756  // No special implementation for the SMP subtraction assignment to sparse matrices.
757  //**********************************************************************************************
758 
759  //**SMP multiplication assignment to dense matrices*********************************************
760  // No special implementation for the SMP multiplication assignment to dense matrices.
761  //**********************************************************************************************
762 
763  //**SMP multiplication assignment to sparse matrices********************************************
764  // No special implementation for the SMP multiplication assignment to sparse matrices.
765  //**********************************************************************************************
766 
767  //**Compile time checks*************************************************************************
774  //**********************************************************************************************
775 };
776 //*************************************************************************************************
777 
778 
779 
780 
781 //=================================================================================================
782 //
783 // GLOBAL BINARY ARITHMETIC OPERATORS
784 //
785 //=================================================================================================
786 
787 //*************************************************************************************************
816 template< typename T1 // Type of the left-hand side dense matrix
817  , typename T2 > // Type of the right-hand side dense matrix
818 inline typename EnableIf< And< Not< IsSymmetric<T1> >, Not< IsSymmetric<T2> > >
819  , const DMatTDMatSubExpr<T1,T2> >::Type
821 {
823 
824  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
825  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
826  }
827 
828  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
829 }
830 //*************************************************************************************************
831 
832 
833 //*************************************************************************************************
862 template< typename T1 // Type of the left-hand side dense matrix
863  , typename T2 > // Type of the right-hand side dense matrix
864 inline typename EnableIf< And< Not< IsSymmetric<T1> >, Not< IsSymmetric<T2> > >
865  , const DMatTDMatSubExpr<T1,T2> >::Type
867 {
869 
870  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
871  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
872  }
873 
874  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
875 }
876 //*************************************************************************************************
877 
878 
879 
880 
881 //=================================================================================================
882 //
883 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
884 //
885 //=================================================================================================
886 
887 //*************************************************************************************************
901 template< typename T1 // Type of the left-hand side dense matrix
902  , typename T2 > // Type of the right-hand side dense matrix
903 inline typename EnableIf< And< IsSymmetric<T1>, Not< IsSymmetric<T2> > >
904  , const typename SubExprTrait<T1,T2>::Type >::Type
905  operator-( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,true>& rhs )
906 {
908 
909  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
910  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
911  }
912 
913  return trans( ~lhs ) - ~rhs;
914 }
916 //*************************************************************************************************
917 
918 
919 //*************************************************************************************************
933 template< typename T1 // Type of the left-hand side dense matrix
934  , typename T2 > // Type of the right-hand side dense matrix
935 inline typename EnableIf< IsSymmetric<T2>
936  , const typename SubExprTrait<T1,T2>::Type >::Type
937  operator-( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,true>& rhs )
938 {
940 
941  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
942  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
943  }
944 
945  return (~lhs) - trans( ~rhs );
946 }
948 //*************************************************************************************************
949 
950 
951 //*************************************************************************************************
965 template< typename T1 // Type of the left-hand side dense matrix
966  , typename T2 > // Type of the right-hand side dense matrix
967 inline typename EnableIf< And< Not< IsSymmetric<T1> >, IsSymmetric<T2> >
968  , const typename SubExprTrait<T1,T2>::Type >::Type
969  operator-( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,false>& rhs )
970 {
972 
973  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
974  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
975  }
976 
977  return (~lhs) - trans( ~rhs );
978 }
980 //*************************************************************************************************
981 
982 
983 //*************************************************************************************************
997 template< typename T1 // Type of the left-hand side dense matrix
998  , typename T2 > // Type of the right-hand side dense matrix
999 inline typename EnableIf< IsSymmetric<T1>
1000  , const typename SubExprTrait<T1,T2>::Type >::Type
1001  operator-( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,false>& rhs )
1002 {
1004 
1005  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
1006  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
1007  }
1008 
1009  return trans( ~lhs ) - (~rhs);
1010 }
1012 //*************************************************************************************************
1013 
1014 
1015 
1016 
1017 //=================================================================================================
1018 //
1019 // ROWS SPECIALIZATIONS
1020 //
1021 //=================================================================================================
1022 
1023 //*************************************************************************************************
1025 template< typename MT1, typename MT2 >
1026 struct Rows< DMatTDMatSubExpr<MT1,MT2> >
1027  : public Max< Rows<MT1>, Rows<MT2> >
1028 {};
1030 //*************************************************************************************************
1031 
1032 
1033 
1034 
1035 //=================================================================================================
1036 //
1037 // COLUMNS SPECIALIZATIONS
1038 //
1039 //=================================================================================================
1040 
1041 //*************************************************************************************************
1043 template< typename MT1, typename MT2 >
1044 struct Columns< DMatTDMatSubExpr<MT1,MT2> >
1045  : public Max< Columns<MT1>, Columns<MT2> >
1046 {};
1048 //*************************************************************************************************
1049 
1050 
1051 
1052 
1053 //=================================================================================================
1054 //
1055 // ISALIGNED SPECIALIZATIONS
1056 //
1057 //=================================================================================================
1058 
1059 //*************************************************************************************************
1061 template< typename MT1, typename MT2 >
1062 struct IsAligned< DMatTDMatSubExpr<MT1,MT2> >
1063  : public IsTrue< And< IsAligned<MT1>, IsAligned<MT2> >::value >
1064 {};
1066 //*************************************************************************************************
1067 
1068 
1069 
1070 
1071 //=================================================================================================
1072 //
1073 // ISSYMMETRIC SPECIALIZATIONS
1074 //
1075 //=================================================================================================
1076 
1077 //*************************************************************************************************
1079 template< typename MT1, typename MT2 >
1080 struct IsSymmetric< DMatTDMatSubExpr<MT1,MT2> >
1081  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
1082 {};
1084 //*************************************************************************************************
1085 
1086 
1087 
1088 
1089 //=================================================================================================
1090 //
1091 // ISHERMITIAN SPECIALIZATIONS
1092 //
1093 //=================================================================================================
1094 
1095 //*************************************************************************************************
1097 template< typename MT1, typename MT2 >
1098 struct IsHermitian< DMatTDMatSubExpr<MT1,MT2> >
1099  : public IsTrue< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
1100 {};
1102 //*************************************************************************************************
1103 
1104 
1105 
1106 
1107 //=================================================================================================
1108 //
1109 // ISLOWER SPECIALIZATIONS
1110 //
1111 //=================================================================================================
1112 
1113 //*************************************************************************************************
1115 template< typename MT1, typename MT2 >
1116 struct IsLower< DMatTDMatSubExpr<MT1,MT2> >
1117  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
1118 {};
1120 //*************************************************************************************************
1121 
1122 
1123 
1124 
1125 //=================================================================================================
1126 //
1127 // ISUNILOWER SPECIALIZATIONS
1128 //
1129 //=================================================================================================
1130 
1131 //*************************************************************************************************
1133 template< typename MT1, typename MT2 >
1134 struct IsUniLower< DMatTDMatSubExpr<MT1,MT2> >
1135  : public IsTrue< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
1136 {};
1138 //*************************************************************************************************
1139 
1140 
1141 
1142 
1143 //=================================================================================================
1144 //
1145 // ISSTRICTLYLOWER SPECIALIZATIONS
1146 //
1147 //=================================================================================================
1148 
1149 //*************************************************************************************************
1151 template< typename MT1, typename MT2 >
1152 struct IsStrictlyLower< DMatTDMatSubExpr<MT1,MT2> >
1153  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
1154 {};
1156 //*************************************************************************************************
1157 
1158 
1159 
1160 
1161 //=================================================================================================
1162 //
1163 // ISUPPER SPECIALIZATIONS
1164 //
1165 //=================================================================================================
1166 
1167 //*************************************************************************************************
1169 template< typename MT1, typename MT2 >
1170 struct IsUpper< DMatTDMatSubExpr<MT1,MT2> >
1171  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
1172 {};
1174 //*************************************************************************************************
1175 
1176 
1177 
1178 
1179 //=================================================================================================
1180 //
1181 // ISUNIUPPER SPECIALIZATIONS
1182 //
1183 //=================================================================================================
1184 
1185 //*************************************************************************************************
1187 template< typename MT1, typename MT2 >
1188 struct IsUniUpper< DMatTDMatSubExpr<MT1,MT2> >
1189  : public IsTrue< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1190 {};
1192 //*************************************************************************************************
1193 
1194 
1195 
1196 
1197 //=================================================================================================
1198 //
1199 // ISSTRICTLYUPPER SPECIALIZATIONS
1200 //
1201 //=================================================================================================
1202 
1203 //*************************************************************************************************
1205 template< typename MT1, typename MT2 >
1206 struct IsStrictlyUpper< DMatTDMatSubExpr<MT1,MT2> >
1207  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1208 {};
1210 //*************************************************************************************************
1211 
1212 
1213 
1214 
1215 //=================================================================================================
1216 //
1217 // EXPRESSION TRAIT SPECIALIZATIONS
1218 //
1219 //=================================================================================================
1220 
1221 //*************************************************************************************************
1223 template< typename MT1, typename MT2, bool AF >
1224 struct SubmatrixExprTrait< DMatTDMatSubExpr<MT1,MT2>, AF >
1225 {
1226  public:
1227  //**********************************************************************************************
1228  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
1229  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
1230  //**********************************************************************************************
1231 };
1233 //*************************************************************************************************
1234 
1235 
1236 //*************************************************************************************************
1238 template< typename MT1, typename MT2 >
1239 struct RowExprTrait< DMatTDMatSubExpr<MT1,MT2> >
1240 {
1241  public:
1242  //**********************************************************************************************
1243  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
1244  , typename RowExprTrait<const MT2>::Type >::Type Type;
1245  //**********************************************************************************************
1246 };
1248 //*************************************************************************************************
1249 
1250 
1251 //*************************************************************************************************
1253 template< typename MT1, typename MT2 >
1254 struct ColumnExprTrait< DMatTDMatSubExpr<MT1,MT2> >
1255 {
1256  public:
1257  //**********************************************************************************************
1258  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
1259  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1260  //**********************************************************************************************
1261 };
1263 //*************************************************************************************************
1264 
1265 } // namespace blaze
1266 
1267 #endif
Constraint on the data type.
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:114
Header file for the Max class template.
Header file for kernel specific block sizes.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatTDMatSubExpr.h:290
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:171
Header file for basic type definitions.
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
#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:647
Header file for the ColumnExprTrait class template.
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatTDMatSubExpr.h:129
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:259
Header file for the And class template.
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:331
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:115
Header file for the Computation base class.
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:113
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:175
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.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
Expression object for dense matrix-transpose dense matrix subtractions.The DMatTDMatSubExpr class rep...
Definition: DMatTDMatSubExpr.h:105
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTDMatSubExpr.h:178
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:111
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: ColumnMajorMatrix.h:79
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatTDMatSubExpr.h:303
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
Header file for the Not class template.
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatTDMatSubExpr.h:172
Header file for the MatMatSubExpr base class.
DMatTDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatTDMatSubExpr class.
Definition: DMatTDMatSubExpr.h:201
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:332
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:642
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:169
#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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatTDMatSubExpr.h:232
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:164
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTDMatSubExpr.h:313
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:116
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: RowMajorMatrix.h:79
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
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
DMatTDMatSubExpr< MT1, MT2 > This
Type of this DMatTDMatSubExpr instance.
Definition: DMatTDMatSubExpr.h:168
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:217
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatTDMatSubExpr.h:248
Constraints on the storage order of matrix types.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:181
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:122
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:184
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:944
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:268
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
Header file for the IsTrue value trait.
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: DMatTDMatSubExpr.h:278
#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:138
Header file for the IsUpper type trait.
Header file for exception macros.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTDMatSubExpr.h:170
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatTDMatSubExpr.h:323
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatTDMatSubExpr.h:258
Header file for the IsHermitian type trait.
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.