DMatEvalExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATEVALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATEVALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
46 #include <blaze/math/Exception.h>
53 #include <blaze/util/Assert.h>
55 #include <blaze/util/mpl/If.h>
56 #include <blaze/util/Types.h>
57 
58 
59 namespace blaze {
60 
61 //=================================================================================================
62 //
63 // CLASS DMATEVALEXPR
64 //
65 //=================================================================================================
66 
67 //*************************************************************************************************
74 template< typename MT // Type of the dense matrix
75  , bool SO > // Storage order
77  : public MatEvalExpr< DenseMatrix< DMatEvalExpr<MT,SO>, SO > >
78  , private Computation
79 {
80  public:
81  //**Type definitions****************************************************************************
89 
91  using CompositeType = const ResultType;
92 
94  using Operand = If_t< IsExpression_v<MT>, const MT, const MT& >;
95  //**********************************************************************************************
96 
97  //**Compilation flags***************************************************************************
99  static constexpr bool simdEnabled = false;
100 
102  static constexpr bool smpAssignable = MT::smpAssignable;
103  //**********************************************************************************************
104 
105  //**Constructor*********************************************************************************
110  explicit inline DMatEvalExpr( const MT& dm ) noexcept
111  : dm_( dm ) // Dense matrix of the evaluation expression
112  {}
113  //**********************************************************************************************
114 
115  //**Access operator*****************************************************************************
122  inline ReturnType operator()( size_t i, size_t j ) const {
123  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
124  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
125  return dm_(i,j);
126  }
127  //**********************************************************************************************
128 
129  //**At function*********************************************************************************
137  inline ReturnType at( size_t i, size_t j ) const {
138  if( i >= dm_.rows() ) {
139  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
140  }
141  if( j >= dm_.columns() ) {
142  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
143  }
144  return (*this)(i,j);
145  }
146  //**********************************************************************************************
147 
148  //**Rows function*******************************************************************************
153  inline size_t rows() const noexcept {
154  return dm_.rows();
155  }
156  //**********************************************************************************************
157 
158  //**Columns function****************************************************************************
163  inline size_t columns() const noexcept {
164  return dm_.columns();
165  }
166  //**********************************************************************************************
167 
168  //**Operand access******************************************************************************
173  inline Operand operand() const noexcept {
174  return dm_;
175  }
176  //**********************************************************************************************
177 
178  //**********************************************************************************************
184  template< typename T >
185  inline bool canAlias( const T* alias ) const noexcept {
186  return dm_.canAlias( alias );
187  }
188  //**********************************************************************************************
189 
190  //**********************************************************************************************
196  template< typename T >
197  inline bool isAliased( const T* alias ) const noexcept {
198  return dm_.isAliased( alias );
199  }
200  //**********************************************************************************************
201 
202  //**********************************************************************************************
207  inline bool isAligned() const noexcept {
208  return dm_.isAligned();
209  }
210  //**********************************************************************************************
211 
212  //**********************************************************************************************
217  inline bool canSMPAssign() const noexcept {
218  return dm_.canSMPAssign();
219  }
220  //**********************************************************************************************
221 
222  private:
223  //**Member variables****************************************************************************
225  //**********************************************************************************************
226 
227  //**Assignment to dense matrices****************************************************************
239  template< typename MT2 // Type of the target dense matrix
240  , bool SO2 > // Storage order of the target dense matrix
241  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
242  {
244 
245  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
246  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
247 
248  assign( ~lhs, rhs.dm_ );
249  }
251  //**********************************************************************************************
252 
253  //**Assignment to sparse matrices***************************************************************
265  template< typename MT2 // Type of the target sparse matrix
266  , bool SO2 > // Storage order of the target dense matrix
267  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
268  {
270 
271  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
272  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
273 
274  assign( ~lhs, rhs.dm_ );
275  }
277  //**********************************************************************************************
278 
279  //**Addition assignment to dense matrices*******************************************************
291  template< typename MT2 // Type of the target dense matrix
292  , bool SO2 > // Storage order of the target dense matrix
293  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
294  {
296 
297  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
298  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
299 
300  addAssign( ~lhs, rhs.dm_ );
301  }
303  //**********************************************************************************************
304 
305  //**Addition assignment to sparse matrices******************************************************
317  template< typename MT2 // Type of the target sparse matrix
318  , bool SO2 > // Storage order of the target dense matrix
319  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
320  {
322 
323  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
324  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
325 
326  addAssign( ~lhs, rhs.dm_ );
327  }
329  //**********************************************************************************************
330 
331  //**Subtraction assignment to dense matrices****************************************************
343  template< typename MT2 // Type of the target dense matrix
344  , bool SO2 > // Storage order of the target dense matrix
345  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
346  {
348 
349  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
350  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
351 
352  subAssign( ~lhs, rhs.dm_ );
353  }
355  //**********************************************************************************************
356 
357  //**Subtraction assignment to sparse matrices***************************************************
369  template< typename MT2 // Type of the target sparse matrix
370  , bool SO2 > // Storage order of the target dense matrix
371  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
372  {
374 
375  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
376  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
377 
378  subAssign( ~lhs, rhs.dm_ );
379  }
381  //**********************************************************************************************
382 
383  //**Schur product assignment to dense matrices**************************************************
395  template< typename MT2 // Type of the target dense matrix
396  , bool SO2 > // Storage order of the target dense matrix
397  friend inline void schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
398  {
400 
401  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
402  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
403 
404  schurAssign( ~lhs, rhs.dm_ );
405  }
407  //**********************************************************************************************
408 
409  //**Schur product assignment to sparse matrices*************************************************
421  template< typename MT2 // Type of the target sparse matrix
422  , bool SO2 > // Storage order of the target dense matrix
423  friend inline void schurAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
424  {
426 
427  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
428  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
429 
430  schurAssign( ~lhs, rhs.dm_ );
431  }
433  //**********************************************************************************************
434 
435  //**Multiplication assignment to dense matrices*************************************************
447  template< typename MT2 // Type of the target dense matrix
448  , bool SO2 > // Storage order of the target dense matrix
449  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
450  {
452 
453  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
454  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
455 
456  multAssign( ~lhs, rhs.dm_ );
457  }
459  //**********************************************************************************************
460 
461  //**Multiplication assignment to sparse matrices************************************************
473  template< typename MT2 // Type of the target sparse matrix
474  , bool SO2 > // Storage order of the target dense matrix
475  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
476  {
478 
479  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
480  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
481 
482  multAssign( ~lhs, rhs.dm_ );
483  }
485  //**********************************************************************************************
486 
487  //**SMP assignment to dense matrices************************************************************
499  template< typename MT2 // Type of the target dense matrix
500  , bool SO2 > // Storage order of the target dense matrix
501  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
502  {
504 
505  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
506  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
507 
508  smpAssign( ~lhs, rhs.dm_ );
509  }
511  //**********************************************************************************************
512 
513  //**SMP assignment to sparse matrices***********************************************************
525  template< typename MT2 // Type of the target sparse matrix
526  , bool SO2 > // Storage order of the target dense matrix
527  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
528  {
530 
531  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
532  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
533 
534  smpAssign( ~lhs, rhs.dm_ );
535  }
537  //**********************************************************************************************
538 
539  //**SMP addition assignment to dense matrices***************************************************
551  template< typename MT2 // Type of the target dense matrix
552  , bool SO2 > // Storage order of the target dense matrix
553  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
554  {
556 
557  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
558  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
559 
560  smpAddAssign( ~lhs, rhs.dm_ );
561  }
563  //**********************************************************************************************
564 
565  //**SMP addition assignment to sparse matrices**************************************************
577  template< typename MT2 // Type of the target sparse matrix
578  , bool SO2 > // Storage order of the target dense matrix
579  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
580  {
582 
583  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
584  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
585 
586  smpAddAssign( ~lhs, rhs.dm_ );
587  }
589  //**********************************************************************************************
590 
591  //**SMP subtraction assignment to dense matrices************************************************
603  template< typename MT2 // Type of the target dense matrix
604  , bool SO2 > // Storage order of the target dense matrix
605  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
606  {
608 
609  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
610  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
611 
612  smpSubAssign( ~lhs, rhs.dm_ );
613  }
615  //**********************************************************************************************
616 
617  //**SMP subtraction assignment to sparse matrices***********************************************
629  template< typename MT2 // Type of the target sparse matrix
630  , bool SO2 > // Storage order of the target dense matrix
631  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
632  {
634 
635  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
636  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
637 
638  smpSubAssign( ~lhs, rhs.dm_ );
639  }
641  //**********************************************************************************************
642 
643  //**SMP Schur product assignment to dense matrices**********************************************
655  template< typename MT2 // Type of the target dense matrix
656  , bool SO2 > // Storage order of the target dense matrix
657  friend inline void smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
658  {
660 
661  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
662  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
663 
664  smpSchurAssign( ~lhs, rhs.dm_ );
665  }
667  //**********************************************************************************************
668 
669  //**SMP Schur product assignment to sparse matrices*********************************************
681  template< typename MT2 // Type of the target sparse matrix
682  , bool SO2 > // Storage order of the target dense matrix
683  friend inline void smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
684  {
686 
687  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
688  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
689 
690  smpSchurAssign( ~lhs, rhs.dm_ );
691  }
693  //**********************************************************************************************
694 
695  //**SMP multiplication assignment to dense matrices*********************************************
708  template< typename MT2 // Type of the target dense matrix
709  , bool SO2 > // Storage order of the target dense matrix
710  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
711  {
713 
714  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
715  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
716 
717  smpMultAssign( ~lhs, rhs.dm_ );
718  }
720  //**********************************************************************************************
721 
722  //**SMP multiplication assignment to sparse matrices********************************************
735  template< typename MT2 // Type of the target sparse matrix
736  , bool SO2 > // Storage order of the target dense matrix
737  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatEvalExpr& rhs )
738  {
740 
741  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
742  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
743 
744  smpMultAssign( ~lhs, rhs.dm_ );
745  }
747  //**********************************************************************************************
748 
749  //**Compile time checks*************************************************************************
754  //**********************************************************************************************
755 };
756 //*************************************************************************************************
757 
758 
759 
760 
761 //=================================================================================================
762 //
763 // GLOBAL FUNCTIONS
764 //
765 //=================================================================================================
766 
767 //*************************************************************************************************
784 template< typename MT // Type of the dense matrix
785  , bool SO > // Storage order
786 inline decltype(auto) eval( const DenseMatrix<MT,SO>& dm )
787 {
789 
790  using ReturnType = const DMatEvalExpr<MT,SO>;
791  return ReturnType( ~dm );
792 }
793 //*************************************************************************************************
794 
795 
796 
797 
798 //=================================================================================================
799 //
800 // GLOBAL RESTRUCTURING FUNCTIONS
801 //
802 //=================================================================================================
803 
804 //*************************************************************************************************
815 template< typename MT // Type of the dense matrix
816  , bool SO > // Storage order
817 inline decltype(auto) eval( const DMatEvalExpr<MT,SO>& dm )
818 {
819  return dm;
820 }
822 //*************************************************************************************************
823 
824 
825 
826 
827 //=================================================================================================
828 //
829 // ISALIGNED SPECIALIZATIONS
830 //
831 //=================================================================================================
832 
833 //*************************************************************************************************
835 template< typename MT, bool SO >
836 struct IsAligned< DMatEvalExpr<MT,SO> >
837  : public IsAligned<MT>
838 {};
840 //*************************************************************************************************
841 
842 } // namespace blaze
843 
844 #endif
DMatEvalExpr(const MT &dm) noexcept
Constructor for the DMatEvalExpr class.
Definition: DMatEvalExpr.h:110
Header file for auxiliary alias declarations.
Header file for basic type definitions.
typename If< Condition, T1, T2 >::Type If_t
Auxiliary alias declaration for the If class template.The If_t alias declaration provides a convenien...
Definition: If.h:109
ElementType_t< MT > ElementType
Resulting element type.
Definition: DMatEvalExpr.h:87
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.The ResultType_t alias declaration provides ...
Definition: Aliases.h:390
#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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatEvalExpr.h:137
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatEvalExpr.h:88
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: CompressedMatrix.h:3113
Header file for the MatEvalExpr base class.
If_t< IsExpression_v< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatEvalExpr.h:94
Header file for the Computation base class.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatEvalExpr.h:217
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatEvalExpr.h:173
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.The ReturnType_t alias declaration provides ...
Definition: Aliases.h:410
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:137
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provide...
Definition: Aliases.h:170
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DMatEvalExpr.h:99
Constraint on the data type.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatEvalExpr.h:207
Header file for the If class template.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatEvalExpr.h:122
#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.
TransposeType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatEvalExpr.h:86
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatEvalExpr.h:185
Header file for the IsAligned type trait.
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:786
Constraints on the storage order of matrix types.
Header file for the exception macros of the math module.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatEvalExpr.h:153
Header file for all forward declarations for expression class templates.
Operand dm_
Dense matrix of the evaluation expression.
Definition: DMatEvalExpr.h:224
OppositeType_t< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatEvalExpr.h:85
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.The OppositeType_t alias declaration provi...
Definition: Aliases.h:270
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatEvalExpr.h:163
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.
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DMatEvalExpr.h:102
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
Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for a...
Definition: MatEvalExpr.h:66
#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
ResultType_t< MT > ResultType
Result type for expression template evaluations.
Definition: DMatEvalExpr.h:84
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
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
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3081
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatEvalExpr.h:197
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
Expression object for the forced evaluation of dense matrices.The DMatEvalExpr class represents the c...
Definition: DMatEvalExpr.h:76
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:66
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatEvalExpr.h:91
#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
auto smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:191
Header file for the IsExpression type trait class.
Header file for the function trace functionality.