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 
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 TDMATSMATSUBEXPR
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
100 class TDMatSMatSubExpr
101  : public MatMatSubExpr< DenseMatrix< TDMatSMatSubExpr<MT1,MT2>, true > >
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 TDMatSMatSubExpr( 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 TDMatSMatSubExpr& 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 TDMatSMatSubExpr& 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 TDMatSMatSubExpr& 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 TDMatSMatSubExpr& 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 TDMatSMatSubExpr& 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 //*************************************************************************************************
706 template< typename MT1 // Type of the left-hand side dense matrix
707  , typename MT2 > // Type of the right-hand side sparse matrix
708 inline decltype(auto)
709  operator-( const DenseMatrix<MT1,true>& lhs, const SparseMatrix<MT2,false>& rhs )
710 {
712 
713  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
714  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
715  }
716 
718  return ReturnType( ~lhs, ~rhs );
719 }
720 //*************************************************************************************************
721 
722 
723 
724 
725 //=================================================================================================
726 //
727 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
728 //
729 //=================================================================================================
730 
731 //*************************************************************************************************
744 template< typename MT1 // Type of the dense matrix of the left-hand side expression
745  , typename MT2 // Type of the sparse matrix of the left-hand side expression
746  , typename MT3 // Type of the right-hand side dense matrix
747  , bool SO > // Storage order of the right-hand side dense matrix
748 inline decltype(auto)
750 {
752 
753  return ( lhs.leftOperand() + (~rhs) ) - lhs.rightOperand();
754 }
756 //*************************************************************************************************
757 
758 
759 //*************************************************************************************************
772 template< typename MT1 // Type of the dense matrix of the left-hand side expression
773  , typename MT2 // Type of the sparse matrix of the left-hand side expression
774  , typename MT3 // Type of the right-hand side dense matrix
775  , bool SO > // Storage order of the right-hand side dense matrix
776 inline decltype(auto)
778 {
780 
781  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
782 }
784 //*************************************************************************************************
785 
786 
787 
788 
789 //=================================================================================================
790 //
791 // ROWS SPECIALIZATIONS
792 //
793 //=================================================================================================
794 
795 //*************************************************************************************************
797 template< typename MT1, typename MT2 >
798 struct Rows< TDMatSMatSubExpr<MT1,MT2> >
799  : public Maximum< Rows<MT1>, Rows<MT2> >
800 {};
802 //*************************************************************************************************
803 
804 
805 
806 
807 //=================================================================================================
808 //
809 // COLUMNS SPECIALIZATIONS
810 //
811 //=================================================================================================
812 
813 //*************************************************************************************************
815 template< typename MT1, typename MT2 >
816 struct Columns< TDMatSMatSubExpr<MT1,MT2> >
817  : public Maximum< Columns<MT1>, Columns<MT2> >
818 {};
820 //*************************************************************************************************
821 
822 
823 
824 
825 //=================================================================================================
826 //
827 // ISSYMMETRIC SPECIALIZATIONS
828 //
829 //=================================================================================================
830 
831 //*************************************************************************************************
833 template< typename MT1, typename MT2 >
834 struct IsSymmetric< TDMatSMatSubExpr<MT1,MT2> >
835  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
836 {};
838 //*************************************************************************************************
839 
840 
841 
842 
843 //=================================================================================================
844 //
845 // ISHERMITIAN SPECIALIZATIONS
846 //
847 //=================================================================================================
848 
849 //*************************************************************************************************
851 template< typename MT1, typename MT2 >
852 struct IsHermitian< TDMatSMatSubExpr<MT1,MT2> >
853  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
854 {};
856 //*************************************************************************************************
857 
858 
859 
860 
861 //=================================================================================================
862 //
863 // ISLOWER SPECIALIZATIONS
864 //
865 //=================================================================================================
866 
867 //*************************************************************************************************
869 template< typename MT1, typename MT2 >
870 struct IsLower< TDMatSMatSubExpr<MT1,MT2> >
871  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
872 {};
874 //*************************************************************************************************
875 
876 
877 
878 
879 //=================================================================================================
880 //
881 // ISUNILOWER SPECIALIZATIONS
882 //
883 //=================================================================================================
884 
885 //*************************************************************************************************
887 template< typename MT1, typename MT2 >
888 struct IsUniLower< TDMatSMatSubExpr<MT1,MT2> >
889  : public BoolConstant< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
890 {};
892 //*************************************************************************************************
893 
894 
895 
896 
897 //=================================================================================================
898 //
899 // ISSTRICTLYLOWER SPECIALIZATIONS
900 //
901 //=================================================================================================
902 
903 //*************************************************************************************************
905 template< typename MT1, typename MT2 >
906 struct IsStrictlyLower< TDMatSMatSubExpr<MT1,MT2> >
907  : public BoolConstant< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
908 {};
910 //*************************************************************************************************
911 
912 
913 
914 
915 //=================================================================================================
916 //
917 // ISUPPER SPECIALIZATIONS
918 //
919 //=================================================================================================
920 
921 //*************************************************************************************************
923 template< typename MT1, typename MT2 >
924 struct IsUpper< TDMatSMatSubExpr<MT1,MT2> >
925  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
926 {};
928 //*************************************************************************************************
929 
930 
931 
932 
933 //=================================================================================================
934 //
935 // ISUNIUPPER SPECIALIZATIONS
936 //
937 //=================================================================================================
938 
939 //*************************************************************************************************
941 template< typename MT1, typename MT2 >
942 struct IsUniUpper< TDMatSMatSubExpr<MT1,MT2> >
943  : public BoolConstant< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
944 {};
946 //*************************************************************************************************
947 
948 
949 
950 
951 //=================================================================================================
952 //
953 // ISSTRICTLYUPPER SPECIALIZATIONS
954 //
955 //=================================================================================================
956 
957 //*************************************************************************************************
959 template< typename MT1, typename MT2 >
960 struct IsStrictlyUpper< TDMatSMatSubExpr<MT1,MT2> >
961  : public BoolConstant< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
962 {};
964 //*************************************************************************************************
965 
966 } // namespace blaze
967 
968 #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.
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:283
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TDMatSMatSubExpr.h:143
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
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.
Compile time check whether the given type is an operational expression template.This type trait class...
Definition: IsOperation.h:71
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:144
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
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
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TDMatSMatSubExpr.h:221
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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TDMatSMatSubExpr.h:205
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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TDMatSMatSubExpr.h:263
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
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
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TDMatSMatSubExpr.h:251
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
SubTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:142
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.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSMatSubExpr.h:276
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:284
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
#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
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSMatSubExpr.h:241
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
#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
SubExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: TDMatSMatSubExpr.h:122
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
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_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:109
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
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:107
Constraint on the data type.
Header file for all forward declarations for expression class templates.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TDMatSMatSubExpr.h:145
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:148
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TDMatSMatSubExpr.h:231
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:154
#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.
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:157
ReturnType_< MT1 > RN1
Return type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:108
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
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TDMatSMatSubExpr.h:190
TDMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TDMatSMatSubExpr class.
Definition: TDMatSMatSubExpr.h:174
typename SubTrait< T1, T2 >::Type SubTrait_
Auxiliary alias declaration for the SubTrait class template.The SubTrait_ alias declaration provides ...
Definition: SubTrait.h:250
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
#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.
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
Expression object for transpose dense matrix-sparse matrix subtractions.The TDMatSMatSubExpr class re...
Definition: Forward.h:152
#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
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSMatSubExpr.h:151
Header file for the IsExpression type trait class.
Header file for the function trace functionality.
ResultType_< MT1 > RT1
Result type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:106