DMatTSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTSMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
51 #include <blaze/math/Exception.h>
72 #include <blaze/util/Assert.h>
73 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/InvalidType.h>
77 #include <blaze/util/mpl/And.h>
78 #include <blaze/util/mpl/If.h>
79 #include <blaze/util/mpl/Maximum.h>
80 #include <blaze/util/Types.h>
81 
82 
83 namespace blaze {
84 
85 //=================================================================================================
86 //
87 // CLASS DMATTSMATSUBEXPR
88 //
89 //=================================================================================================
90 
91 //*************************************************************************************************
98 template< typename MT1 // Type of the left-hand side dense matrix
99  , typename MT2 > // Type of the right-hand side sparse matrix
101  : public MatMatSubExpr< DenseMatrix< DMatTSMatSubExpr<MT1,MT2>, false > >
102  , private Computation
103 {
104  private:
105  //**Type definitions****************************************************************************
110  //**********************************************************************************************
111 
112  //**Return type evaluation**********************************************************************
114 
119  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
120 
123  //**********************************************************************************************
124 
125  //**Parallel evaluation strategy****************************************************************
127 
132  template< typename MT >
133  struct UseSMPAssign {
134  enum : bool { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
135  };
137  //**********************************************************************************************
138 
139  public:
140  //**Type definitions****************************************************************************
146 
149 
151  using CompositeType = const ResultType;
152 
154  using LeftOperand = If_< IsExpression<MT1>, const MT1, const MT1& >;
155 
157  using RightOperand = If_< IsExpression<MT2>, const MT2, const MT2& >;
158  //**********************************************************************************************
159 
160  //**Compilation flags***************************************************************************
162  enum : bool { simdEnabled = false };
163 
165  enum : bool { smpAssignable = false };
166  //**********************************************************************************************
167 
168  //**Constructor*********************************************************************************
174  explicit inline DMatTSMatSubExpr( const MT1& lhs, const MT2& rhs ) noexcept
175  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
176  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction expression
177  {
178  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
179  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
180  }
181  //**********************************************************************************************
182 
183  //**Access operator*****************************************************************************
190  inline ReturnType operator()( size_t i, size_t j ) const {
191  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
192  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
193  return lhs_(i,j) - rhs_(i,j);
194  }
195  //**********************************************************************************************
196 
197  //**At function*********************************************************************************
205  inline ReturnType at( size_t i, size_t j ) const {
206  if( i >= lhs_.rows() ) {
207  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
208  }
209  if( j >= lhs_.columns() ) {
210  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
211  }
212  return (*this)(i,j);
213  }
214  //**********************************************************************************************
215 
216  //**Rows function*******************************************************************************
221  inline size_t rows() const noexcept {
222  return lhs_.rows();
223  }
224  //**********************************************************************************************
225 
226  //**Columns function****************************************************************************
231  inline size_t columns() const noexcept {
232  return lhs_.columns();
233  }
234  //**********************************************************************************************
235 
236  //**Left operand access*************************************************************************
241  inline LeftOperand leftOperand() const noexcept {
242  return lhs_;
243  }
244  //**********************************************************************************************
245 
246  //**Right operand access************************************************************************
251  inline RightOperand rightOperand() const noexcept {
252  return rhs_;
253  }
254  //**********************************************************************************************
255 
256  //**********************************************************************************************
262  template< typename T >
263  inline bool canAlias( const T* alias ) const noexcept {
264  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
265  ( rhs_.canAlias( alias ) );
266  }
267  //**********************************************************************************************
268 
269  //**********************************************************************************************
275  template< typename T >
276  inline bool isAliased( const T* alias ) const noexcept {
277  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
278  }
279  //**********************************************************************************************
280 
281  private:
282  //**Member variables****************************************************************************
285  //**********************************************************************************************
286 
287  //**Assignment to dense matrices****************************************************************
299  template< typename MT // Type of the target dense matrix
300  , bool SO2 > // Storage order of the target dense matrix
301  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatTSMatSubExpr& rhs )
302  {
304 
305  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
306  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
307 
308  if( !IsOperation<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
309  subAssign( ~lhs, rhs.rhs_ );
310  }
311  else {
312  assign ( ~lhs, rhs.lhs_ );
313  subAssign( ~lhs, rhs.rhs_ );
314  }
315  }
317  //**********************************************************************************************
318 
319  //**Assignment to sparse matrices***************************************************************
331  template< typename MT // Type of the target sparse matrix
332  , bool SO2 > // Storage order of the target sparse matrix
333  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatTSMatSubExpr& rhs )
334  {
336 
338 
345 
346  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
347  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
348 
349  const TmpType tmp( serial( rhs ) );
350  assign( ~lhs, tmp );
351  }
353  //**********************************************************************************************
354 
355  //**Addition assignment to dense matrices*******************************************************
368  template< typename MT // Type of the target dense matrix
369  , bool SO2 > // Storage order of the target dense matrix
370  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTSMatSubExpr& rhs )
371  {
373 
374  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
375  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
376 
377  addAssign( ~lhs, rhs.lhs_ );
378  subAssign( ~lhs, rhs.rhs_ );
379  }
381  //**********************************************************************************************
382 
383  //**Addition assignment to sparse matrices******************************************************
384  // No special implementation for the addition assignment to sparse matrices.
385  //**********************************************************************************************
386 
387  //**Subtraction assignment to dense matrices****************************************************
400  template< typename MT // Type of the target dense matrix
401  , bool SO2 > // Storage order of the target dense matrix
402  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTSMatSubExpr& rhs )
403  {
405 
406  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
407  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
408 
409  subAssign( ~lhs, rhs.lhs_ );
410  addAssign( ~lhs, rhs.rhs_ );
411  }
413  //**********************************************************************************************
414 
415  //**Subtraction assignment to sparse matrices***************************************************
416  // No special implementation for the subtraction assignment to sparse matrices.
417  //**********************************************************************************************
418 
419  //**Schur product assignment to dense matrices**************************************************
432  template< typename MT // Type of the target dense matrix
433  , bool SO2 > // Storage order of the target dense matrix
434  friend inline void schurAssign( DenseMatrix<MT,SO2>& lhs, const DMatTSMatSubExpr& rhs )
435  {
437 
441 
442  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
443  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
444 
445  const ResultType tmp( serial( rhs ) );
446  schurAssign( ~lhs, tmp );
447  }
449  //**********************************************************************************************
450 
451  //**Schur product assignment to sparse matrices*************************************************
452  // No special implementation for the Schur product assignment to sparse matrices.
453  //**********************************************************************************************
454 
455  //**Multiplication assignment to dense matrices*************************************************
456  // No special implementation for the multiplication assignment to dense matrices.
457  //**********************************************************************************************
458 
459  //**Multiplication assignment to sparse matrices************************************************
460  // No special implementation for the multiplication assignment to sparse matrices.
461  //**********************************************************************************************
462 
463  //**SMP assignment to dense matrices************************************************************
477  template< typename MT // Type of the target dense matrix
478  , bool SO2 > // Storage order of the target dense matrix
479  friend inline EnableIf_< UseSMPAssign<MT> >
481  {
483 
484  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
485  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
486 
487  if( !IsOperation<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
488  smpSubAssign( ~lhs, rhs.rhs_ );
489  }
490  else {
491  smpAssign ( ~lhs, rhs.lhs_ );
492  smpSubAssign( ~lhs, rhs.rhs_ );
493  }
494  }
496  //**********************************************************************************************
497 
498  //**SMP assignment to sparse matrices***********************************************************
512  template< typename MT // Type of the target sparse matrix
513  , bool SO2 > // Storage order of the target sparse matrix
514  friend inline EnableIf_< UseSMPAssign<MT> >
516  {
518 
520 
527 
528  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
529  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
530 
531  const TmpType tmp( rhs );
532  smpAssign( ~lhs, tmp );
533  }
535  //**********************************************************************************************
536 
537  //**SMP addition assignment to dense matrices***************************************************
552  template< typename MT // Type of the target dense matrix
553  , bool SO2 > // Storage order of the target dense matrix
554  friend inline EnableIf_< UseSMPAssign<MT> >
556  {
558 
559  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
560  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
561 
562  smpAddAssign( ~lhs, rhs.lhs_ );
563  smpSubAssign( ~lhs, rhs.rhs_ );
564  }
566  //**********************************************************************************************
567 
568  //**SMP addition assignment to sparse matrices**************************************************
569  // No special implementation for the SMP addition assignment to sparse matrices.
570  //**********************************************************************************************
571 
572  //**SMP 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 EnableIf_< UseSMPAssign<MT> >
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  smpSubAssign( ~lhs, rhs.lhs_ );
598  smpAddAssign( ~lhs, rhs.rhs_ );
599  }
601  //**********************************************************************************************
602 
603  //**SMP subtraction assignment to sparse matrices***********************************************
604  // No special implementation for the SMP subtraction assignment to sparse matrices.
605  //**********************************************************************************************
606 
607  //**SMP Schur product assignment to dense matrices**********************************************
622  template< typename MT // Type of the target dense matrix
623  , bool SO2 > // Storage order of the target dense matrix
624  friend inline EnableIf_< UseSMPAssign<MT> >
626  {
628 
632 
633  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
634  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
635 
636  const ResultType tmp( rhs );
637  smpSchurAssign( ~lhs, tmp );
638  }
640  //**********************************************************************************************
641 
642  //**SMP Schur product assignment to sparse matrices*********************************************
643  // No special implementation for the SMP Schur product assignment to sparse matrices.
644  //**********************************************************************************************
645 
646  //**SMP multiplication assignment to dense matrices*********************************************
647  // No special implementation for the SMP multiplication assignment to dense matrices.
648  //**********************************************************************************************
649 
650  //**SMP multiplication assignment to sparse matrices********************************************
651  // No special implementation for the SMP multiplication assignment to sparse matrices.
652  //**********************************************************************************************
653 
654  //**Compile time checks*************************************************************************
662  //**********************************************************************************************
663 };
664 //*************************************************************************************************
665 
666 
667 
668 
669 //=================================================================================================
670 //
671 // GLOBAL BINARY ARITHMETIC OPERATORS
672 //
673 //=================================================================================================
674 
675 //*************************************************************************************************
705 template< typename MT1 // Type of the left-hand side dense matrix
706  , typename MT2 > // Type of the right-hand side sparse matrix
707 inline decltype(auto)
708  operator-( const DenseMatrix<MT1,false>& lhs, const SparseMatrix<MT2,true>& rhs )
709 {
711 
712  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
713  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
714  }
715 
717  return ReturnType( ~lhs, ~rhs );
718 }
719 //*************************************************************************************************
720 
721 
722 
723 
724 //=================================================================================================
725 //
726 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
727 //
728 //=================================================================================================
729 
730 //*************************************************************************************************
743 template< typename MT1 // Type of the dense matrix of the left-hand side expression
744  , typename MT2 // Type of the sparse matrix of the left-hand side expression
745  , typename MT3 // Type of the right-hand side dense matrix
746  , bool SO > // Storage order of the right-hand side dense matrix
747 inline decltype(auto)
749 {
751 
752  return ( lhs.leftOperand() + (~rhs) ) - lhs.rightOperand();
753 }
755 //*************************************************************************************************
756 
757 
758 //*************************************************************************************************
771 template< typename MT1 // Type of the dense matrix of the left-hand side expression
772  , typename MT2 // Type of the sparse matrix of the left-hand side expression
773  , typename MT3 // Type of the right-hand side dense matrix
774  , bool SO > // Storage order of the right-hand side dense matrix
775 inline decltype(auto)
777 {
779 
780  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
781 }
783 //*************************************************************************************************
784 
785 
786 
787 
788 //=================================================================================================
789 //
790 // ROWS SPECIALIZATIONS
791 //
792 //=================================================================================================
793 
794 //*************************************************************************************************
796 template< typename MT1, typename MT2 >
797 struct Rows< DMatTSMatSubExpr<MT1,MT2> >
798  : public Maximum< Rows<MT1>, Rows<MT2> >
799 {};
801 //*************************************************************************************************
802 
803 
804 
805 
806 //=================================================================================================
807 //
808 // COLUMNS SPECIALIZATIONS
809 //
810 //=================================================================================================
811 
812 //*************************************************************************************************
814 template< typename MT1, typename MT2 >
815 struct Columns< DMatTSMatSubExpr<MT1,MT2> >
816  : public Maximum< Columns<MT1>, Columns<MT2> >
817 {};
819 //*************************************************************************************************
820 
821 
822 
823 
824 //=================================================================================================
825 //
826 // ISSYMMETRIC SPECIALIZATIONS
827 //
828 //=================================================================================================
829 
830 //*************************************************************************************************
832 template< typename MT1, typename MT2 >
833 struct IsSymmetric< DMatTSMatSubExpr<MT1,MT2> >
834  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
835 {};
837 //*************************************************************************************************
838 
839 
840 
841 
842 //=================================================================================================
843 //
844 // ISHERMITIAN SPECIALIZATIONS
845 //
846 //=================================================================================================
847 
848 //*************************************************************************************************
850 template< typename MT1, typename MT2 >
851 struct IsHermitian< DMatTSMatSubExpr<MT1,MT2> >
852  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
853 {};
855 //*************************************************************************************************
856 
857 
858 
859 
860 //=================================================================================================
861 //
862 // ISLOWER SPECIALIZATIONS
863 //
864 //=================================================================================================
865 
866 //*************************************************************************************************
868 template< typename MT1, typename MT2 >
869 struct IsLower< DMatTSMatSubExpr<MT1,MT2> >
870  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
871 {};
873 //*************************************************************************************************
874 
875 
876 
877 
878 //=================================================================================================
879 //
880 // ISUNILOWER SPECIALIZATIONS
881 //
882 //=================================================================================================
883 
884 //*************************************************************************************************
886 template< typename MT1, typename MT2 >
887 struct IsUniLower< DMatTSMatSubExpr<MT1,MT2> >
888  : public BoolConstant< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
889 {};
891 //*************************************************************************************************
892 
893 
894 
895 
896 //=================================================================================================
897 //
898 // ISSTRICTLYLOWER SPECIALIZATIONS
899 //
900 //=================================================================================================
901 
902 //*************************************************************************************************
904 template< typename MT1, typename MT2 >
905 struct IsStrictlyLower< DMatTSMatSubExpr<MT1,MT2> >
906  : public BoolConstant< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
907 {};
909 //*************************************************************************************************
910 
911 
912 
913 
914 //=================================================================================================
915 //
916 // ISUPPER SPECIALIZATIONS
917 //
918 //=================================================================================================
919 
920 //*************************************************************************************************
922 template< typename MT1, typename MT2 >
923 struct IsUpper< DMatTSMatSubExpr<MT1,MT2> >
924  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
925 {};
927 //*************************************************************************************************
928 
929 
930 
931 
932 //=================================================================================================
933 //
934 // ISUNIUPPER SPECIALIZATIONS
935 //
936 //=================================================================================================
937 
938 //*************************************************************************************************
940 template< typename MT1, typename MT2 >
941 struct IsUniUpper< DMatTSMatSubExpr<MT1,MT2> >
942  : public BoolConstant< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
943 {};
945 //*************************************************************************************************
946 
947 
948 
949 
950 //=================================================================================================
951 //
952 // ISSTRICTLYUPPER SPECIALIZATIONS
953 //
954 //=================================================================================================
955 
956 //*************************************************************************************************
958 template< typename MT1, typename MT2 >
959 struct IsStrictlyUpper< DMatTSMatSubExpr<MT1,MT2> >
960  : public BoolConstant< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
961 {};
963 //*************************************************************************************************
964 
965 } // namespace blaze
966 
967 #endif
Constraint on the data type.
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
SubTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: DMatTSMatSubExpr.h:142
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTSMatSubExpr.h:143
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatTSMatSubExpr.h:157
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:70
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
EnableIf_< IsDenseMatrix< MT1 > > smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:196
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatTSMatSubExpr.h:283
Header file for the subtraction trait.
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:786
Header file for basic type definitions.
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DMatTSMatSubExpr.h:148
Compile time check whether the given type is an operational expression template.This type trait class...
Definition: IsOperation.h:71
EnableIf_< IsDenseMatrix< MT1 > > smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:164
SubExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: DMatTSMatSubExpr.h:122
Header file for the serial shim.
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:61
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatTSMatSubExpr.h:144
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:699
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DMatTSMatSubExpr.h:145
Header file for the And class template.
Compile time value evaluation.The Maximum alias declaration selects the larger of the two given templ...
Definition: Maximum.h:73
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
ResultType_< MT1 > RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTSMatSubExpr.h:106
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:731
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose sparse matrix operand.
Definition: DMatTSMatSubExpr.h:251
Constraints on the storage order of matrix types.
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:133
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatTSMatSubExpr.h:276
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
typename SubExprTrait< T1, T2 >::Type SubExprTrait_
Auxiliary alias declaration for the SubExprTrait class template.The SubExprTrait_ alias declaration p...
Definition: SubExprTrait.h:112
Constraint on the data type.
Constraint on the data type.
Header file for the Maximum class template.
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Header file for the IsTemporary type trait class.
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:67
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
Expression object for dense matrix-transpose sparse matrix subtractions.The DMatTSMatSubExpr class re...
Definition: DMatTSMatSubExpr.h:100
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: ColumnMajorMatrix.h:61
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:102
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatTSMatSubExpr.h:107
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
DMatTSMatSubExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the DMatTSMatSubExpr class.
Definition: DMatTSMatSubExpr.h:174
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Header file for the MatMatSubExpr base class.
Header file for the IsOperation type trait class.
Header file for the IsLower type trait.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatTSMatSubExpr.h:205
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Constraint on the data type.
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTSMatSubExpr.h:151
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
ReturnType_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatTSMatSubExpr.h:109
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: RowMajorMatrix.h:61
Header file for run time assertion macros.
Utility type for generic codes.
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:154
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Constraints on the storage order of matrix types.
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:819
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTSMatSubExpr.h:154
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatTSMatSubExpr.h:221
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: DMatTSMatSubExpr.h:284
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatTSMatSubExpr.h:231
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:66
typename SubTrait< T1, T2 >::Type SubTrait_
Auxiliary alias declaration for the SubTrait class template.The SubTrait_ alias declaration provides ...
Definition: SubTrait.h:250
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatTSMatSubExpr.h:241
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTSMatSubExpr.h:190
#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:108
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
ReturnType_< MT1 > RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatTSMatSubExpr.h:108
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatTSMatSubExpr.h:263
Header file for the IsHermitian type trait.
Header file for the SubExprTrait class template.
#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
#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:61
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:95
Header file for the IsExpression type trait class.
Header file for the function trace functionality.