Blaze  3.6
DMatSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <utility>
44 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
61 #include <blaze/util/Assert.h>
62 #include <blaze/util/DisableIf.h>
63 #include <blaze/util/EnableIf.h>
66 #include <blaze/util/MaybeUnused.h>
67 #include <blaze/util/mpl/If.h>
68 #include <blaze/util/Types.h>
70 
71 
72 namespace blaze {
73 
74 //=================================================================================================
75 //
76 // CLASS DMATSMATSUBEXPR
77 //
78 //=================================================================================================
79 
80 //*************************************************************************************************
87 template< typename MT1 // Type of the left-hand side dense matrix
88  , typename MT2 // Type of the right-hand side sparse matrix
89  , bool SO > // Storage order
91  : public MatMatSubExpr< DenseMatrix< DMatSMatSubExpr<MT1,MT2,SO>, SO > >
92  , private Computation
93 {
94  private:
95  //**Type definitions****************************************************************************
100  //**********************************************************************************************
101 
102  //**Return type evaluation**********************************************************************
104 
109  static constexpr bool returnExpr = ( !IsTemporary_v<RN1> && !IsTemporary_v<RN2> );
110 
112  using ExprReturnType = decltype( std::declval<RN1>() - std::declval<RN2>() );
113  //**********************************************************************************************
114 
115  //**Parallel evaluation strategy****************************************************************
117 
122  template< typename MT >
123  static constexpr bool UseSMPAssign_v = ( !MT1::smpAssignable || !MT2::smpAssignable );
125  //**********************************************************************************************
126 
127  public:
128  //**Type definitions****************************************************************************
135 
138 
140  using CompositeType = const ResultType;
141 
143  using LeftOperand = If_t< IsExpression_v<MT1>, const MT1, const MT1& >;
144 
146  using RightOperand = If_t< IsExpression_v<MT2>, const MT2, const MT2& >;
147  //**********************************************************************************************
148 
149  //**Compilation flags***************************************************************************
151  static constexpr bool simdEnabled = false;
152 
154  static constexpr bool smpAssignable = false;
155  //**********************************************************************************************
156 
157  //**Constructor*********************************************************************************
163  explicit inline DMatSMatSubExpr( const MT1& lhs, const MT2& rhs ) noexcept
164  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
165  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction expression
166  {
167  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
168  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
169  }
170  //**********************************************************************************************
171 
172  //**Access operator*****************************************************************************
179  inline ReturnType operator()( size_t i, size_t j ) const {
180  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
181  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
182  return lhs_(i,j) - rhs_(i,j);
183  }
184  //**********************************************************************************************
185 
186  //**At function*********************************************************************************
194  inline ReturnType at( size_t i, size_t j ) const {
195  if( i >= lhs_.rows() ) {
196  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
197  }
198  if( j >= lhs_.columns() ) {
199  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
200  }
201  return (*this)(i,j);
202  }
203  //**********************************************************************************************
204 
205  //**Rows function*******************************************************************************
210  inline size_t rows() const noexcept {
211  return lhs_.rows();
212  }
213  //**********************************************************************************************
214 
215  //**Columns function****************************************************************************
220  inline size_t columns() const noexcept {
221  return lhs_.columns();
222  }
223  //**********************************************************************************************
224 
225  //**Left operand access*************************************************************************
230  inline LeftOperand leftOperand() const noexcept {
231  return lhs_;
232  }
233  //**********************************************************************************************
234 
235  //**Right operand access************************************************************************
240  inline RightOperand rightOperand() const noexcept {
241  return rhs_;
242  }
243  //**********************************************************************************************
244 
245  //**********************************************************************************************
251  template< typename T >
252  inline bool canAlias( const T* alias ) const noexcept {
253  return ( IsExpression_v<MT1> && lhs_.canAlias( alias ) ) ||
254  ( rhs_.canAlias( alias ) );
255  }
256  //**********************************************************************************************
257 
258  //**********************************************************************************************
264  template< typename T >
265  inline bool isAliased( const T* alias ) const noexcept {
266  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
267  }
268  //**********************************************************************************************
269 
270  private:
271  //**Member variables****************************************************************************
274  //**********************************************************************************************
275 
276  //**Assignment to dense matrices****************************************************************
288  template< typename MT // Type of the target dense matrix
289  , bool SO2 > // Storage order of the target dense matrix
290  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
291  {
293 
294  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
295  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
296 
297  if( !IsOperation_v<MT1> && isSame( ~lhs, rhs.lhs_ ) ) {
298  subAssign( ~lhs, rhs.rhs_ );
299  }
300  else {
301  assign ( ~lhs, rhs.lhs_ );
302  subAssign( ~lhs, rhs.rhs_ );
303  }
304  }
306  //**********************************************************************************************
307 
308  //**Assignment to sparse matrices***************************************************************
320  template< typename MT // Type of the target sparse matrix
321  , bool SO2 > // Storage order of the target sparse matrix
322  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
323  {
325 
327 
334 
335  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
336  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
337 
338  const TmpType tmp( serial( rhs ) );
339  assign( ~lhs, tmp );
340  }
342  //**********************************************************************************************
343 
344  //**Addition assignment to dense matrices*******************************************************
356  template< typename MT // Type of the target dense matrix
357  , bool SO2 > // Storage order of the target dense matrix
358  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
359  {
361 
362  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
363  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
364 
365  addAssign( ~lhs, rhs.lhs_ );
366  subAssign( ~lhs, rhs.rhs_ );
367  }
369  //**********************************************************************************************
370 
371  //**Addition assignment to sparse matrices******************************************************
372  // No special implementation for the addition assignment to sparse matrices.
373  //**********************************************************************************************
374 
375  //**Subtraction assignment to dense matrices****************************************************
387  template< typename MT // Type of the target dense matrix
388  , bool SO2 > // Storage order of the target dense matrix
389  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
390  {
392 
393  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
394  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
395 
396  subAssign( ~lhs, rhs.lhs_ );
397  addAssign( ~lhs, rhs.rhs_ );
398  }
400  //**********************************************************************************************
401 
402  //**Subtraction assignment to sparse matrices***************************************************
403  // No special implementation for the subtraction assignment to sparse matrices.
404  //**********************************************************************************************
405 
406  //**Schur product assignment to dense matrices**************************************************
418  template< typename MT // Type of the target dense matrix
419  , bool SO2 > // Storage order of the target dense matrix
420  friend inline void schurAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
421  {
423 
427 
428  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
429  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
430 
431  const ResultType tmp( serial( rhs ) );
432  schurAssign( ~lhs, tmp );
433  }
435  //**********************************************************************************************
436 
437  //**Schur product assignment to sparse matrices*************************************************
438  // No special implementation for the Schur product assignment to sparse matrices.
439  //**********************************************************************************************
440 
441  //**Multiplication assignment to dense matrices*************************************************
442  // No special implementation for the multiplication assignment to dense matrices.
443  //**********************************************************************************************
444 
445  //**Multiplication assignment to sparse matrices************************************************
446  // No special implementation for the multiplication assignment to sparse matrices.
447  //**********************************************************************************************
448 
449  //**SMP assignment to dense matrices************************************************************
463  template< typename MT // Type of the target dense matrix
464  , bool SO2 > // Storage order of the target dense matrix
465  friend inline auto smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
466  -> EnableIf_t< UseSMPAssign_v<MT> >
467  {
469 
470  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
471  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
472 
473  if( !IsOperation_v<MT1> && isSame( ~lhs, rhs.lhs_ ) ) {
474  smpSubAssign( ~lhs, rhs.rhs_ );
475  }
476  else {
477  smpAssign ( ~lhs, rhs.lhs_ );
478  smpSubAssign( ~lhs, rhs.rhs_ );
479  }
480  }
482  //**********************************************************************************************
483 
484  //**SMP assignment to sparse matrices***********************************************************
498  template< typename MT // Type of the target sparse matrix
499  , bool SO2 > // Storage order of the target sparse matrix
500  friend inline auto smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
501  -> EnableIf_t< UseSMPAssign_v<MT> >
502  {
504 
505  using TmpType = If_t< SO == SO2, ResultType, OppositeType >;
506 
513 
514  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
515  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
516 
517  const TmpType tmp( rhs );
518  smpAssign( ~lhs, tmp );
519  }
521  //**********************************************************************************************
522 
523  //**SMP addition assignment to dense matrices***************************************************
537  template< typename MT // Type of the target dense matrix
538  , bool SO2 > // Storage order of the target dense matrix
539  friend inline auto smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
540  -> EnableIf_t< UseSMPAssign_v<MT> >
541  {
543 
544  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
545  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
546 
547  smpAddAssign( ~lhs, rhs.lhs_ );
548  smpSubAssign( ~lhs, rhs.rhs_ );
549  }
551  //**********************************************************************************************
552 
553  //**SMP addition assignment to sparse matrices**************************************************
554  // No special implementation for the SMP addition assignment to sparse matrices.
555  //**********************************************************************************************
556 
557  //**SMP subtraction assignment to dense matrices************************************************
571  template< typename MT // Type of the target dense matrix
572  , bool SO2 > // Storage order of the target dense matrix
573  friend inline auto smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
574  -> EnableIf_t< UseSMPAssign_v<MT> >
575  {
577 
578  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
579  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
580 
581  smpSubAssign( ~lhs, rhs.lhs_ );
582  smpAddAssign( ~lhs, rhs.rhs_ );
583  }
585  //**********************************************************************************************
586 
587  //**SMP subtraction assignment to sparse matrices***********************************************
588  // No special implementation for the SMP subtraction assignment to sparse matrices.
589  //**********************************************************************************************
590 
591  //**SMP Schur product assignment to dense matrices**********************************************
606  template< typename MT // Type of the target dense matrix
607  , bool SO2 > // Storage order of the target dense matrix
608  friend inline auto smpSchurAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
609  -> EnableIf_t< UseSMPAssign_v<MT> >
610  {
612 
616 
617  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
618  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
619 
620  const ResultType tmp( rhs );
621  smpSchurAssign( ~lhs, tmp );
622  }
624  //**********************************************************************************************
625 
626  //**SMP Schur product assignment to sparse matrices*********************************************
627  // No special implementation for the SMP Schur product assignment to sparse matrices.
628  //**********************************************************************************************
629 
630  //**SMP multiplication assignment to dense matrices*********************************************
631  // No special implementation for the SMP multiplication assignment to dense matrices.
632  //**********************************************************************************************
633 
634  //**SMP multiplication assignment to sparse matrices********************************************
635  // No special implementation for the SMP multiplication assignment to sparse matrices.
636  //**********************************************************************************************
637 
638  //**Compile time checks*************************************************************************
645  //**********************************************************************************************
646 };
647 //*************************************************************************************************
648 
649 
650 
651 
652 //=================================================================================================
653 //
654 // GLOBAL BINARY ARITHMETIC OPERATORS
655 //
656 //=================================================================================================
657 
658 //*************************************************************************************************
671 template< typename MT1 // Type of the left-hand side dense matrix
672  , typename MT2 // Type of the right-hand side sparse matrix
673  , bool SO // Storage order
674  , DisableIf_t< IsZero_v<MT2> &&
675  IsSame_v< ElementType_t<MT1>, ElementType_t<MT2> > >* = nullptr >
676 inline const DMatSMatSubExpr<MT1,MT2,SO>
677  dmatsmatsub( const DenseMatrix<MT1,SO>& lhs, const SparseMatrix<MT2,SO>& rhs )
678 {
680 
681  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == (~rhs).rows() , "Invalid number of rows" );
682  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == (~rhs).columns(), "Invalid number of columns" );
683 
684  return DMatSMatSubExpr<MT1,MT2,SO>( ~lhs, ~rhs );
685 }
687 //*************************************************************************************************
688 
689 
690 //*************************************************************************************************
703 template< typename MT1 // Type of the left-hand side dense matrix
704  , typename MT2 // Type of the right-hand side sparse matrix
705  , bool SO // Storage order
706  , EnableIf_t< IsZero_v<MT2> &&
707  IsSame_v< ElementType_t<MT1>, ElementType_t<MT2> > >* = nullptr >
708 inline const MT1&
709  dmatsmatsub( const DenseMatrix<MT1,SO>& lhs, const SparseMatrix<MT2,SO>& rhs )
710 {
712 
713  MAYBE_UNUSED( rhs );
714 
715  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == (~rhs).rows() , "Invalid number of rows" );
716  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == (~rhs).columns(), "Invalid number of columns" );
717 
718  return (~lhs);
719 }
721 //*************************************************************************************************
722 
723 
724 //*************************************************************************************************
753 template< typename MT1 // Type of the left-hand side dense matrix
754  , typename MT2 // Type of the right-hand side sparse matrix
755  , bool SO > // Storage order
756 inline decltype(auto)
757  operator-( const DenseMatrix<MT1,SO>& lhs, const SparseMatrix<MT2,SO>& rhs )
758 {
760 
761  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
762  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
763  }
764 
765  return dmatsmatsub( ~lhs, ~rhs );
766 }
767 //*************************************************************************************************
768 
769 
770 
771 
772 //=================================================================================================
773 //
774 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
775 //
776 //=================================================================================================
777 
778 //*************************************************************************************************
791 template< typename MT1 // Type of the dense matrix of the left-hand side expression
792  , typename MT2 // Type of the sparse matrix of the left-hand side expression
793  , bool SO1 // Storage order of the left-hand side expression
794  , typename MT3 // Type of the right-hand side dense matrix
795  , bool SO2 > // Storage order of the right-hand side dense matrix
796 inline decltype(auto)
797  operator+( const DMatSMatSubExpr<MT1,MT2,SO1>& lhs, const DenseMatrix<MT3,SO2>& rhs )
798 {
800 
801  return ( lhs.leftOperand() + (~rhs) ) - lhs.rightOperand();
802 }
804 //*************************************************************************************************
805 
806 
807 //*************************************************************************************************
820 template< typename MT1 // Type of the dense matrix of the left-hand side expression
821  , typename MT2 // Type of the sparse matrix of the left-hand side expression
822  , bool SO1 // Storage order of the left-hand side expression
823  , typename MT3 // Type of the right-hand side dense matrix
824  , bool SO2 > // Storage order of the right-hand side dense matrix
825 inline decltype(auto)
826  operator-( const DMatSMatSubExpr<MT1,MT2,SO1>& lhs, const DenseMatrix<MT3,SO2>& rhs )
827 {
829 
830  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
831 }
833 //*************************************************************************************************
834 
835 } // namespace blaze
836 
837 #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
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: DMatSMatSubExpr.h:273
Header file for auxiliary alias declarations.
typename SubTrait< T1, T2 >::Type SubTrait_t
Auxiliary alias declaration for the SubTrait class template.The SubTrait_t alias declaration provides...
Definition: SubTrait.h:238
Header file for the subtraction trait.
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:992
Header file for basic type definitions.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatSMatSubExpr.h:252
If_t< IsExpression_v< MT2 >, const MT2, const MT2 & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:146
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSMatSubExpr.h:179
typename If< Condition, T1, T2 >::Type If_t
Auxiliary alias template for the If class template.The If_t alias template provides a convenient shor...
Definition: If.h:109
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.The ResultType_t alias declaration provides ...
Definition: Aliases.h:390
Header file for the serial shim.
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:63
#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
Header file for the IsSame and IsStrictlySame type traits.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatSMatSubExpr.h:220
Header file for the MAYBE_UNUSED function template.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatSMatSubExpr.h:265
Header file for the Computation base class.
static constexpr bool returnExpr
Compilation switch for the selection of the subscript operator return type.
Definition: DMatSMatSubExpr.h:109
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.The ReturnType_t alias declaration provides ...
Definition: Aliases.h:410
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes....
Definition: DenseMatrix.h:81
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes....
Definition: Forward.h:145
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provide...
Definition: Aliases.h:170
ResultType_t< MT1 > RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:96
Constraint on the data type.
Constraint on the data type.
If_t< IsExpression_v< MT1 >, const MT1, const MT1 & > LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:143
decltype(std::declval< RN1 >() - std::declval< RN2 >()) ExprReturnType
Expression return type for the subscript operator.
Definition: DMatSMatSubExpr.h:112
Header file for the DisableIf class template.
ElementType_t< ResultType > ElementType
Resulting element type.
Definition: DMatSMatSubExpr.h:134
Header file for the IsTemporary type trait class.
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatSMatSubExpr.h:272
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: DMatSMatSubExpr.h:240
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:58
Header file for the If class template.
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSMatSubExpr.h:140
#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 MatMatSubExpr base class.
Header file for the IsOperation type trait class.
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DMatSMatSubExpr.h:154
Constraints on the storage order of matrix types.
OppositeType_t< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSMatSubExpr.h:132
Header file for the exception macros of the math module.
Constraint on the data type.
Header file for the EnableIf class template.
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.The OppositeType_t alias declaration provi...
Definition: Aliases.h:270
ReturnType_t< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:99
TransposeType_t< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatSMatSubExpr.h:133
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatSMatSubExpr.h:230
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.The TransposeType_t alias declaration pro...
Definition: Aliases.h:470
Header file for run time assertion macros.
Expression object for dense matrix-sparse matrix subtractions.The DMatSMatSubExpr class represents th...
Definition: DMatSMatSubExpr.h:90
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatSMatSubExpr.h:194
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DMatSMatSubExpr.h:151
Header file for the IsZero type trait.
#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
Header file for all forward declarations for expression class templates.
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatSMatSubExpr.h:210
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:808
#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
auto smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:194
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
#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
ReturnType_t< MT1 > RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:98
const If_t< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DMatSMatSubExpr.h:137
ResultType_t< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:97
DMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the DMatSMatSubExpr class.
Definition: DMatSMatSubExpr.h:163
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:66
Header file for the IntegralConstant class template.
#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:103
SubTrait_t< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: DMatSMatSubExpr.h:131
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression,...
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
Header file for the IsExpression type trait class.
Header file for the function trace functionality.