DMatSerialExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSERIALEXPR_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 DMATSERIALEXPR
64 //
65 //=================================================================================================
66 
67 //*************************************************************************************************
74 template< typename MT // Type of the dense matrix
75  , bool SO > // Storage order
77  : public MatSerialExpr< DenseMatrix< DMatSerialExpr<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 DMatSerialExpr( const MT& dm ) noexcept
111  : dm_( dm ) // Dense matrix of the serial 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  //**Conversion operator*************************************************************************
183  inline operator Operand() const noexcept {
184  return dm_;
185  }
186  //**********************************************************************************************
187 
188  //**********************************************************************************************
194  template< typename T >
195  inline bool canAlias( const T* alias ) const noexcept {
196  return dm_.canAlias( alias );
197  }
198  //**********************************************************************************************
199 
200  //**********************************************************************************************
206  template< typename T >
207  inline bool isAliased( const T* alias ) const noexcept {
208  return dm_.isAliased( alias );
209  }
210  //**********************************************************************************************
211 
212  //**********************************************************************************************
217  inline bool isAligned() const noexcept {
218  return dm_.isAligned();
219  }
220  //**********************************************************************************************
221 
222  //**********************************************************************************************
227  inline bool canSMPAssign() const noexcept {
228  return dm_.canSMPAssign();
229  }
230  //**********************************************************************************************
231 
232  private:
233  //**Member variables****************************************************************************
235  //**********************************************************************************************
236 
237  //**Assignment to dense matrices****************************************************************
249  template< typename MT2 // Type of the target dense matrix
250  , bool SO2 > // Storage order of the target dense matrix
251  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
252  {
254 
255  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
256  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
257 
258  assign( ~lhs, rhs.dm_ );
259  }
261  //**********************************************************************************************
262 
263  //**Assignment to sparse matrices***************************************************************
275  template< typename MT2 // Type of the target sparse matrix
276  , bool SO2 > // Storage order of the target dense matrix
277  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
278  {
280 
281  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
282  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
283 
284  assign( ~lhs, rhs.dm_ );
285  }
287  //**********************************************************************************************
288 
289  //**Addition assignment to dense matrices*******************************************************
301  template< typename MT2 // Type of the target dense matrix
302  , bool SO2 > // Storage order of the target dense matrix
303  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
304  {
306 
307  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
308  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
309 
310  addAssign( ~lhs, rhs.dm_ );
311  }
313  //**********************************************************************************************
314 
315  //**Addition assignment to sparse matrices******************************************************
327  template< typename MT2 // Type of the target sparse matrix
328  , bool SO2 > // Storage order of the target dense matrix
329  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
330  {
332 
333  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
334  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
335 
336  addAssign( ~lhs, rhs.dm_ );
337  }
339  //**********************************************************************************************
340 
341  //**Subtraction assignment to dense matrices****************************************************
354  template< typename MT2 // Type of the target dense matrix
355  , bool SO2 > // Storage order of the target dense matrix
356  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
357  {
359 
360  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
361  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
362 
363  subAssign( ~lhs, rhs.dm_ );
364  }
366  //**********************************************************************************************
367 
368  //**Subtraction assignment to sparse matrices***************************************************
381  template< typename MT2 // Type of the target sparse matrix
382  , bool SO2 > // Storage order of the target dense matrix
383  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
384  {
386 
387  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
388  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
389 
390  subAssign( ~lhs, rhs.dm_ );
391  }
393  //**********************************************************************************************
394 
395  //**Schur product assignment to dense matrices**************************************************
408  template< typename MT2 // Type of the target dense matrix
409  , bool SO2 > // Storage order of the target dense matrix
410  friend inline void schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
411  {
413 
414  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
415  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
416 
417  schurAssign( ~lhs, rhs.dm_ );
418  }
420  //**********************************************************************************************
421 
422  //**Schur product assignment to sparse matrices*************************************************
435  template< typename MT2 // Type of the target sparse matrix
436  , bool SO2 > // Storage order of the target dense matrix
437  friend inline void schurAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
438  {
440 
441  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
442  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
443 
444  schurAssign( ~lhs, rhs.dm_ );
445  }
447  //**********************************************************************************************
448 
449  //**Multiplication assignment to dense matrices*************************************************
462  template< typename MT2 // Type of the target dense matrix
463  , bool SO2 > // Storage order of the target dense matrix
464  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
465  {
467 
468  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
469  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
470 
471  multAssign( ~lhs, rhs.sm_ );
472  }
474  //**********************************************************************************************
475 
476  //**Multiplication assignment to sparse matrices************************************************
489  template< typename MT2 // Type of the target sparse matrix
490  , bool SO2 > // Storage order of the target sparse matrix
491  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
492  {
494 
495  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
496  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
497 
498  multAssign( ~lhs, rhs.sm_ );
499  }
501  //**********************************************************************************************
502 
503  //**SMP assignment to dense matrices************************************************************
515  template< typename MT2 // Type of the target dense matrix
516  , bool SO2 > // Storage order of the target dense matrix
517  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
518  {
520 
521  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
522  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
523 
524  assign( ~lhs, rhs.dm_ );
525  }
527  //**********************************************************************************************
528 
529  //**SMP assignment to sparse matrices***********************************************************
541  template< typename MT2 // Type of the target sparse matrix
542  , bool SO2 > // Storage order of the target dense matrix
543  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
544  {
546 
547  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
548  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
549 
550  assign( ~lhs, rhs.dm_ );
551  }
553  //**********************************************************************************************
554 
555  //**SMP addition assignment to dense matrices***************************************************
568  template< typename MT2 // Type of the target dense matrix
569  , bool SO2 > // Storage order of the target dense matrix
570  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
571  {
573 
574  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
575  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
576 
577  addAssign( ~lhs, rhs.dm_ );
578  }
580  //**********************************************************************************************
581 
582  //**SMP addition assignment to sparse matrices**************************************************
595  template< typename MT2 // Type of the target sparse matrix
596  , bool SO2 > // Storage order of the target dense matrix
597  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
598  {
600 
601  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
602  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
603 
604  addAssign( ~lhs, rhs.dm_ );
605  }
607  //**********************************************************************************************
608 
609  //**SMP subtraction assignment to dense matrices************************************************
622  template< typename MT2 // Type of the target dense matrix
623  , bool SO2 > // Storage order of the target dense matrix
624  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
625  {
627 
628  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
629  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
630 
631  subAssign( ~lhs, rhs.dm_ );
632  }
634  //**********************************************************************************************
635 
636  //**SMP subtraction assignment to sparse matrices***********************************************
649  template< typename MT2 // Type of the target sparse matrix
650  , bool SO2 > // Storage order of the target dense matrix
651  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
652  {
654 
655  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
656  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
657 
658  subAssign( ~lhs, rhs.dm_ );
659  }
661  //**********************************************************************************************
662 
663  //**SMP Schur product assignment to dense matrices**********************************************
676  template< typename MT2 // Type of the target dense matrix
677  , bool SO2 > // Storage order of the target dense matrix
678  friend inline void smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
679  {
681 
682  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
683  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
684 
685  schurAssign( ~lhs, rhs.dm_ );
686  }
688  //**********************************************************************************************
689 
690  //**SMP Schur product assignment to sparse matrices*********************************************
703  template< typename MT2 // Type of the target sparse matrix
704  , bool SO2 > // Storage order of the target dense matrix
705  friend inline void smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
706  {
708 
709  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
710  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
711 
712  schurAssign( ~lhs, rhs.dm_ );
713  }
715  //**********************************************************************************************
716 
717  //**SMP multiplication assignment to dense matrices*********************************************
730  template< typename MT2 // Type of the target dense matrix
731  , bool SO2 > // Storage order of the target dense matrix
732  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
733  {
735 
736  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
737  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
738 
739  multAssign( ~lhs, rhs.sm_ );
740  }
742  //**********************************************************************************************
743 
744  //**SMP multiplication assignment to sparse matrices********************************************
757  template< typename MT2 // Type of the target sparse matrix
758  , bool SO2 > // Storage order of the target sparse matrix
759  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const DMatSerialExpr& rhs )
760  {
762 
763  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
764  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
765 
766  multAssign( ~lhs, rhs.sm_ );
767  }
769  //**********************************************************************************************
770 
771  //**Compile time checks*************************************************************************
776  //**********************************************************************************************
777 };
778 //*************************************************************************************************
779 
780 
781 
782 
783 //=================================================================================================
784 //
785 // GLOBAL FUNCTIONS
786 //
787 //=================================================================================================
788 
789 //*************************************************************************************************
806 template< typename MT // Type of the dense matrix
807  , bool SO > // Storage order
808 inline decltype(auto) serial( const DenseMatrix<MT,SO>& dm )
809 {
811 
812  using ReturnType = const DMatSerialExpr<MT,SO>;
813  return ReturnType( ~dm );
814 }
815 //*************************************************************************************************
816 
817 
818 
819 
820 //=================================================================================================
821 //
822 // GLOBAL RESTRUCTURING FUNCTIONS
823 //
824 //=================================================================================================
825 
826 //*************************************************************************************************
837 template< typename MT // Type of the dense matrix
838  , bool SO > // Storage order
839 inline decltype(auto) serial( const DMatSerialExpr<MT,SO>& dm )
840 {
841  return dm;
842 }
844 //*************************************************************************************************
845 
846 
847 
848 
849 //=================================================================================================
850 //
851 // ISALIGNED SPECIALIZATIONS
852 //
853 //=================================================================================================
854 
855 //*************************************************************************************************
857 template< typename MT, bool SO >
858 struct IsAligned< DMatSerialExpr<MT,SO> >
859  : public IsAligned<MT>
860 {};
862 //*************************************************************************************************
863 
864 } // namespace blaze
865 
866 #endif
Header file for auxiliary alias declarations.
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DMatSerialExpr.h:99
DMatSerialExpr(const MT &dm) noexcept
Constructor for the DMatSerialExpr class.
Definition: DMatSerialExpr.h:110
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatSerialExpr.h:207
Header file for basic type definitions.
Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a ...
Definition: MatSerialExpr.h:67
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
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.The ResultType_t alias declaration provides ...
Definition: Aliases.h:390
OppositeType_t< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSerialExpr.h:85
#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
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatSerialExpr.h:217
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: CompressedMatrix.h:3113
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatSerialExpr.h:195
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatSerialExpr.h:88
Header file for the Computation base class.
ElementType_t< MT > ElementType
Resulting element type.
Definition: DMatSerialExpr.h:87
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.The ReturnType_t alias declaration provides ...
Definition: Aliases.h:410
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DMatSerialExpr.h:102
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
Constraint on the data type.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Header file for the If class template.
Expression object for the forced serial evaluation of dense matrices.The DMatSerialExpr class represe...
Definition: DMatSerialExpr.h:76
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSerialExpr.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.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatSerialExpr.h:153
Header file for the IsAligned type trait.
If_t< IsExpression_v< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatSerialExpr.h:94
Constraints on the storage order of matrix types.
Header file for the exception macros of the math module.
ResultType_t< MT > ResultType
Result type for expression template evaluations.
Definition: DMatSerialExpr.h:84
Header file for all forward declarations for expression class templates.
Header file for the MatSerialExpr base class.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatSerialExpr.h:227
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSerialExpr.h:91
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.The OppositeType_t alias declaration provi...
Definition: Aliases.h:270
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.
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
#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
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatSerialExpr.h:163
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
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:808
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
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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatSerialExpr.h:137
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatSerialExpr.h:173
Operand dm_
Dense matrix of the serial evaluation expression.
Definition: DMatSerialExpr.h:234
TransposeType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatSerialExpr.h:86
#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.