Blaze  3.6
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 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
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
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: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
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 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
Header file for all forward declarations for expression class templates.
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
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,...
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.