TDMatSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDMATSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDMATSMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
74 #include <blaze/util/Assert.h>
76 #include <blaze/util/EnableIf.h>
77 #include <blaze/util/Exception.h>
78 #include <blaze/util/InvalidType.h>
80 #include <blaze/util/mpl/And.h>
81 #include <blaze/util/mpl/Max.h>
82 #include <blaze/util/SelectType.h>
83 #include <blaze/util/Types.h>
85 
86 
87 namespace blaze {
88 
89 //=================================================================================================
90 //
91 // CLASS TDMATSMATSUBEXPR
92 //
93 //=================================================================================================
94 
95 //*************************************************************************************************
102 template< typename MT1 // Type of the left-hand side dense matrix
103  , typename MT2 > // Type of the right-hand side sparse matrix
104 class TDMatSMatSubExpr : public DenseMatrix< TDMatSMatSubExpr<MT1,MT2>, true >
105  , private MatMatSubExpr
106  , private Computation
107 {
108  private:
109  //**Type definitions****************************************************************************
110  typedef typename MT1::ResultType RT1;
111  typedef typename MT2::ResultType RT2;
112  typedef typename MT1::ReturnType RN1;
113  typedef typename MT2::ReturnType RN2;
114  //**********************************************************************************************
115 
116  //**Return type evaluation**********************************************************************
118 
123  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
124 
127  //**********************************************************************************************
128 
129  //**Parallel evaluation strategy****************************************************************
131 
136  template< typename MT >
137  struct UseSMPAssign {
138  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
139  };
141  //**********************************************************************************************
142 
143  public:
144  //**Type definitions****************************************************************************
150 
153 
155  typedef const ResultType CompositeType;
156 
158  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
159 
161  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
162  //**********************************************************************************************
163 
164  //**Compilation flags***************************************************************************
166  enum { vectorizable = 0 };
167 
169  enum { smpAssignable = 0 };
170  //**********************************************************************************************
171 
172  //**Constructor*********************************************************************************
178  explicit inline TDMatSMatSubExpr( const MT1& lhs, const MT2& rhs )
179  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
180  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction expression
181  {
182  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
183  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
184  }
185  //**********************************************************************************************
186 
187  //**Access operator*****************************************************************************
194  inline ReturnType operator()( size_t i, size_t j ) const {
195  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
196  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
197  return lhs_(i,j) - rhs_(i,j);
198  }
199  //**********************************************************************************************
200 
201  //**At function*********************************************************************************
209  inline ReturnType at( size_t i, size_t j ) const {
210  if( i >= lhs_.rows() ) {
211  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
212  }
213  if( j >= lhs_.columns() ) {
214  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
215  }
216  return (*this)(i,j);
217  }
218  //**********************************************************************************************
219 
220  //**Rows function*******************************************************************************
225  inline size_t rows() const {
226  return lhs_.rows();
227  }
228  //**********************************************************************************************
229 
230  //**Columns function****************************************************************************
235  inline size_t columns() const {
236  return lhs_.columns();
237  }
238  //**********************************************************************************************
239 
240  //**Left operand access*************************************************************************
245  inline LeftOperand leftOperand() const {
246  return lhs_;
247  }
248  //**********************************************************************************************
249 
250  //**Right operand access************************************************************************
255  inline RightOperand rightOperand() const {
256  return rhs_;
257  }
258  //**********************************************************************************************
259 
260  //**********************************************************************************************
266  template< typename T >
267  inline bool canAlias( const T* alias ) const {
268  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
269  ( rhs_.canAlias( alias ) );
270  }
271  //**********************************************************************************************
272 
273  //**********************************************************************************************
279  template< typename T >
280  inline bool isAliased( const T* alias ) const {
281  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
282  }
283  //**********************************************************************************************
284 
285  private:
286  //**Member variables****************************************************************************
287  LeftOperand lhs_;
288  RightOperand rhs_;
289  //**********************************************************************************************
290 
291  //**Assignment to dense matrices****************************************************************
303  template< typename MT // Type of the target dense matrix
304  , bool SO2 > // Storage order of the target dense matrix
305  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
306  {
308 
309  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
310  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
311 
312  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
313  subAssign( ~lhs, rhs.rhs_ );
314  }
315  else {
316  assign ( ~lhs, rhs.lhs_ );
317  subAssign( ~lhs, rhs.rhs_ );
318  }
319  }
321  //**********************************************************************************************
322 
323  //**Assignment to sparse matrices***************************************************************
335  template< typename MT // Type of the target sparse matrix
336  , bool SO2 > // Storage order of the target sparse matrix
337  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
338  {
340 
341  typedef typename SelectType< SO2, ResultType, OppositeType >::Type TmpType;
342 
349 
350  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
351  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
352 
353  const TmpType tmp( serial( rhs ) );
354  assign( ~lhs, tmp );
355  }
357  //**********************************************************************************************
358 
359  //**Addition assignment to dense matrices*******************************************************
372  template< typename MT // Type of the target dense matrix
373  , bool SO2 > // Storage order of the target dense matrix
374  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
375  {
377 
378  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
379  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
380 
381  addAssign( ~lhs, rhs.lhs_ );
382  subAssign( ~lhs, rhs.rhs_ );
383  }
385  //**********************************************************************************************
386 
387  //**Addition assignment to sparse matrices******************************************************
388  // No special implementation for the addition assignment to sparse matrices.
389  //**********************************************************************************************
390 
391  //**Subtraction assignment to dense matrices****************************************************
404  template< typename MT // Type of the target dense matrix
405  , bool SO2 > // Storage order of the target dense matrix
406  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
407  {
409 
410  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
411  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
412 
413  subAssign( ~lhs, rhs.lhs_ );
414  addAssign( ~lhs, rhs.rhs_ );
415  }
417  //**********************************************************************************************
418 
419  //**Subtraction assignment to sparse matrices***************************************************
420  // No special implementation for the subtraction assignment to sparse matrices.
421  //**********************************************************************************************
422 
423  //**Multiplication assignment to dense matrices*************************************************
424  // No special implementation for the multiplication assignment to dense matrices.
425  //**********************************************************************************************
426 
427  //**Multiplication assignment to sparse matrices************************************************
428  // No special implementation for the multiplication assignment to sparse matrices.
429  //**********************************************************************************************
430 
431  //**SMP assignment to dense matrices************************************************************
445  template< typename MT // Type of the target dense matrix
446  , bool SO2 > // Storage order of the target dense matrix
447  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
448  smpAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
449  {
451 
452  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
453  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
454 
455  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
456  smpSubAssign( ~lhs, rhs.rhs_ );
457  }
458  else {
459  smpAssign ( ~lhs, rhs.lhs_ );
460  smpSubAssign( ~lhs, rhs.rhs_ );
461  }
462  }
464  //**********************************************************************************************
465 
466  //**SMP assignment to sparse matrices***********************************************************
480  template< typename MT // Type of the target sparse matrix
481  , bool SO2 > // Storage order of the target sparse matrix
482  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
483  smpAssign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
484  {
486 
487  typedef typename SelectType< SO2, ResultType, OppositeType >::Type TmpType;
488 
495 
496  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
497  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
498 
499  const TmpType tmp( rhs );
500  smpAssign( ~lhs, tmp );
501  }
503  //**********************************************************************************************
504 
505  //**SMP addition assignment to dense matrices***************************************************
520  template< typename MT // Type of the target dense matrix
521  , bool SO2 > // Storage order of the target dense matrix
522  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
523  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
524  {
526 
527  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
528  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
529 
530  smpAddAssign( ~lhs, rhs.lhs_ );
531  smpSubAssign( ~lhs, rhs.rhs_ );
532  }
534  //**********************************************************************************************
535 
536  //**SMP addition assignment to sparse matrices**************************************************
537  // No special implementation for the SMP addition assignment to sparse matrices.
538  //**********************************************************************************************
539 
540  //**SMP subtraction assignment to dense matrices************************************************
555  template< typename MT // Type of the target dense matrix
556  , bool SO2 > // Storage order of the target dense matrix
557  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
558  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
559  {
561 
562  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
563  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
564 
565  smpSubAssign( ~lhs, rhs.lhs_ );
566  smpAddAssign( ~lhs, rhs.rhs_ );
567  }
569  //**********************************************************************************************
570 
571  //**SMP subtraction assignment to sparse matrices***********************************************
572  // No special implementation for the SMP subtraction assignment to sparse matrices.
573  //**********************************************************************************************
574 
575  //**SMP multiplication assignment to dense matrices*********************************************
576  // No special implementation for the SMP multiplication assignment to dense matrices.
577  //**********************************************************************************************
578 
579  //**SMP multiplication assignment to sparse matrices********************************************
580  // No special implementation for the SMP multiplication assignment to sparse matrices.
581  //**********************************************************************************************
582 
583  //**Compile time checks*************************************************************************
591  //**********************************************************************************************
592 };
593 //*************************************************************************************************
594 
595 
596 
597 
598 //=================================================================================================
599 //
600 // GLOBAL BINARY ARITHMETIC OPERATORS
601 //
602 //=================================================================================================
603 
604 //*************************************************************************************************
635 template< typename T1 // Type of the left-hand side dense matrix
636  , typename T2 > // Type of the right-hand side sparse matrix
637 inline const TDMatSMatSubExpr<T1,T2>
639 {
641 
642  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
643  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
644  }
645 
646  return TDMatSMatSubExpr<T1,T2>( ~lhs, ~rhs );
647 }
648 //*************************************************************************************************
649 
650 
651 
652 
653 //=================================================================================================
654 //
655 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
656 //
657 //=================================================================================================
658 
659 //*************************************************************************************************
672 template< typename T1 // Type of the dense matrix of the left-hand side expression
673  , typename T2 // Type of the sparse matrix of the left-hand side expression
674  , typename T3 // Type of the right-hand side dense matrix
675  , bool SO > // Storage order of the right-hand side dense matrix
676 inline const typename AddExprTrait< TDMatSMatSubExpr<T1,T2>, T3 >::Type
677  operator+( const TDMatSMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
678 {
680 
681  return ( lhs.leftOperand() + (~rhs) ) - lhs.rightOperand();
682 }
684 //*************************************************************************************************
685 
686 
687 //*************************************************************************************************
700 template< typename T1 // Type of the dense matrix of the left-hand side expression
701  , typename T2 // Type of the sparse matrix of the left-hand side expression
702  , typename T3 // Type of the right-hand side dense matrix
703  , bool SO > // Storage order of the right-hand side dense matrix
704 inline const typename SubExprTrait< TDMatSMatSubExpr<T1,T2>, T3 >::Type
705  operator-( const TDMatSMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
706 {
708 
709  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
710 }
712 //*************************************************************************************************
713 
714 
715 
716 
717 //=================================================================================================
718 //
719 // ROWS SPECIALIZATIONS
720 //
721 //=================================================================================================
722 
723 //*************************************************************************************************
725 template< typename MT1, typename MT2 >
726 struct Rows< TDMatSMatSubExpr<MT1,MT2> >
727  : public Max< Rows<MT1>, Rows<MT2> >
728 {};
730 //*************************************************************************************************
731 
732 
733 
734 
735 //=================================================================================================
736 //
737 // COLUMNS SPECIALIZATIONS
738 //
739 //=================================================================================================
740 
741 //*************************************************************************************************
743 template< typename MT1, typename MT2 >
744 struct Columns< TDMatSMatSubExpr<MT1,MT2> >
745  : public Max< Columns<MT1>, Columns<MT2> >
746 {};
748 //*************************************************************************************************
749 
750 
751 
752 
753 //=================================================================================================
754 //
755 // ISSYMMETRIC SPECIALIZATIONS
756 //
757 //=================================================================================================
758 
759 //*************************************************************************************************
761 template< typename MT1, typename MT2 >
762 struct IsSymmetric< TDMatSMatSubExpr<MT1,MT2> >
763  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
764 {};
766 //*************************************************************************************************
767 
768 
769 
770 
771 //=================================================================================================
772 //
773 // ISHERMITIAN SPECIALIZATIONS
774 //
775 //=================================================================================================
776 
777 //*************************************************************************************************
779 template< typename MT1, typename MT2 >
780 struct IsHermitian< TDMatSMatSubExpr<MT1,MT2> >
781  : public IsTrue< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
782 {};
784 //*************************************************************************************************
785 
786 
787 
788 
789 //=================================================================================================
790 //
791 // ISLOWER SPECIALIZATIONS
792 //
793 //=================================================================================================
794 
795 //*************************************************************************************************
797 template< typename MT1, typename MT2 >
798 struct IsLower< TDMatSMatSubExpr<MT1,MT2> >
799  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
800 {};
802 //*************************************************************************************************
803 
804 
805 
806 
807 //=================================================================================================
808 //
809 // ISUNILOWER SPECIALIZATIONS
810 //
811 //=================================================================================================
812 
813 //*************************************************************************************************
815 template< typename MT1, typename MT2 >
816 struct IsUniLower< TDMatSMatSubExpr<MT1,MT2> >
817  : public IsTrue< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
818 {};
820 //*************************************************************************************************
821 
822 
823 
824 
825 //=================================================================================================
826 //
827 // ISSTRICTLYLOWER SPECIALIZATIONS
828 //
829 //=================================================================================================
830 
831 //*************************************************************************************************
833 template< typename MT1, typename MT2 >
834 struct IsStrictlyLower< TDMatSMatSubExpr<MT1,MT2> >
835  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
836 {};
838 //*************************************************************************************************
839 
840 
841 
842 
843 //=================================================================================================
844 //
845 // ISUPPER SPECIALIZATIONS
846 //
847 //=================================================================================================
848 
849 //*************************************************************************************************
851 template< typename MT1, typename MT2 >
852 struct IsUpper< TDMatSMatSubExpr<MT1,MT2> >
853  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
854 {};
856 //*************************************************************************************************
857 
858 
859 
860 
861 //=================================================================================================
862 //
863 // ISUNIUPPER SPECIALIZATIONS
864 //
865 //=================================================================================================
866 
867 //*************************************************************************************************
869 template< typename MT1, typename MT2 >
870 struct IsUniUpper< TDMatSMatSubExpr<MT1,MT2> >
871  : public IsTrue< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
872 {};
874 //*************************************************************************************************
875 
876 
877 
878 
879 //=================================================================================================
880 //
881 // ISSTRICTLYUPPER SPECIALIZATIONS
882 //
883 //=================================================================================================
884 
885 //*************************************************************************************************
887 template< typename MT1, typename MT2 >
888 struct IsStrictlyUpper< TDMatSMatSubExpr<MT1,MT2> >
889  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
890 {};
892 //*************************************************************************************************
893 
894 
895 
896 
897 //=================================================================================================
898 //
899 // EXPRESSION TRAIT SPECIALIZATIONS
900 //
901 //=================================================================================================
902 
903 //*************************************************************************************************
905 template< typename MT1, typename MT2, typename MT3 >
906 struct DMatDMatAddExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
907 {
908  public:
909  //**********************************************************************************************
911  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
912  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
913  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
914  , typename DMatSMatSubExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
915  , INVALID_TYPE >::Type Type;
917  //**********************************************************************************************
918 };
920 //*************************************************************************************************
921 
922 
923 //*************************************************************************************************
925 template< typename MT1, typename MT2, typename MT3 >
926 struct DMatTDMatAddExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
927 {
928  public:
929  //**********************************************************************************************
931  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
932  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
933  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
934  , typename TDMatSMatSubExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
935  , INVALID_TYPE >::Type Type;
937  //**********************************************************************************************
938 };
940 //*************************************************************************************************
941 
942 
943 //*************************************************************************************************
945 template< typename MT1, typename MT2, typename MT3 >
946 struct DMatDMatSubExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
947 {
948  public:
949  //**********************************************************************************************
951  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
952  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
953  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
954  , typename DMatSMatSubExprTrait< typename TDMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
955  , INVALID_TYPE >::Type Type;
957  //**********************************************************************************************
958 };
960 //*************************************************************************************************
961 
962 
963 //*************************************************************************************************
965 template< typename MT1, typename MT2, typename MT3 >
966 struct DMatTDMatSubExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
967 {
968  public:
969  //**********************************************************************************************
971  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
972  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
973  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
974  , typename TDMatSMatSubExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
975  , INVALID_TYPE >::Type Type;
977  //**********************************************************************************************
978 };
980 //*************************************************************************************************
981 
982 
983 //*************************************************************************************************
985 template< typename MT1, typename MT2, bool AF >
986 struct SubmatrixExprTrait< TDMatSMatSubExpr<MT1,MT2>, AF >
987 {
988  public:
989  //**********************************************************************************************
990  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
991  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
992  //**********************************************************************************************
993 };
995 //*************************************************************************************************
996 
997 
998 //*************************************************************************************************
1000 template< typename MT1, typename MT2 >
1001 struct RowExprTrait< TDMatSMatSubExpr<MT1,MT2> >
1002 {
1003  public:
1004  //**********************************************************************************************
1005  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
1006  , typename RowExprTrait<const MT2>::Type >::Type Type;
1007  //**********************************************************************************************
1008 };
1010 //*************************************************************************************************
1011 
1012 
1013 //*************************************************************************************************
1015 template< typename MT1, typename MT2 >
1016 struct ColumnExprTrait< TDMatSMatSubExpr<MT1,MT2> >
1017 {
1018  public:
1019  //**********************************************************************************************
1020  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
1021  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1022  //**********************************************************************************************
1023 };
1025 //*************************************************************************************************
1026 
1027 } // namespace blaze
1028 
1029 #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
Header file for the Max class template.
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:287
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TDMatSMatSubExpr.h:235
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.
Header file for basic type definitions.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSMatSubExpr.h:155
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:161
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: TDMatSMatSubExpr.h:126
#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.
Header file for the IsColumnMajorMatrix type trait.
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TDMatSMatSubExpr.h:194
Header file for the And class template.
Header file for the AddExprTrait class template.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
Header file for the Computation base class.
Constraints on the storage order of matrix types.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSMatSubExpr.h:280
Header file for the IsUniLower type trait.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:110
LeftOperand leftOperand() const
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSMatSubExpr.h:245
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:117
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:146
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:288
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 IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:113
Header file for the IsSymmetric type trait.
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
ResultType::ElementType ElementType
Resulting element type.
Definition: TDMatSMatSubExpr.h:149
#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
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:610
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
Header file for the MatMatSubExpr base class.
TDMatSMatSubExpr< MT1, MT2 > This
Type of this TDMatSMatSubExpr instance.
Definition: TDMatSMatSubExpr.h:145
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TDMatSMatSubExpr.h:225
Header file for the IsLower type trait.
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
#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
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:152
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:111
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:112
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: TDMatSMatSubExpr.h:209
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.
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TDMatSMatSubExpr.h:267
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
Utility type for generic codes.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:158
Constraints on the storage order of matrix types.
#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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:148
Header file for the IsRowMajorMatrix type trait.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TDMatSMatSubExpr.h:147
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
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
Header file for the IsTrue value trait.
#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
TDMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TDMatSMatSubExpr class.
Definition: TDMatSMatSubExpr.h:178
Header file for the IsUpper type trait.
Header file for exception macros.
Header file for the IsHermitian type trait.
Header file for the SubExprTrait class template.
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: TDMatSMatSubExpr.h:255
#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
Expression object for transpose dense matrix-sparse matrix subtractions.The TDMatSMatSubExpr class re...
Definition: Forward.h:142
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79
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.