Blaze  3.6
SMatEvalExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATEVALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATEVALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
46 #include <blaze/math/Exception.h>
52 #include <blaze/util/Assert.h>
54 #include <blaze/util/mpl/If.h>
55 #include <blaze/util/Types.h>
56 
57 
58 namespace blaze {
59 
60 //=================================================================================================
61 //
62 // CLASS SMATEVALEXPR
63 //
64 //=================================================================================================
65 
66 //*************************************************************************************************
73 template< typename MT // Type of the sparse matrix
74  , bool SO > // Storage order
75 class SMatEvalExpr
76  : public MatEvalExpr< SparseMatrix< SMatEvalExpr<MT,SO>, SO > >
77  , private Computation
78 {
79  public:
80  //**Type definitions****************************************************************************
88 
90  using CompositeType = const ResultType;
91 
93  using Operand = If_t< IsExpression_v<MT>, const MT, const MT& >;
94  //**********************************************************************************************
95 
96  //**Compilation flags***************************************************************************
98  static constexpr bool smpAssignable = MT::smpAssignable;
99  //**********************************************************************************************
100 
101  //**Constructor*********************************************************************************
106  explicit inline SMatEvalExpr( const MT& sm ) noexcept
107  : sm_( sm ) // Sparse matrix of the evaluation expression
108  {}
109  //**********************************************************************************************
110 
111  //**Access operator*****************************************************************************
118  inline ReturnType operator()( size_t i, size_t j ) const {
119  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
120  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
121  return sm_(i,j);
122  }
123  //**********************************************************************************************
124 
125  //**At function*********************************************************************************
133  inline ReturnType at( size_t i, size_t j ) const {
134  if( i >= sm_.rows() ) {
135  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
136  }
137  if( j >= sm_.columns() ) {
138  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
139  }
140  return (*this)(i,j);
141  }
142  //**********************************************************************************************
143 
144  //**Rows function*******************************************************************************
149  inline size_t rows() const noexcept {
150  return sm_.rows();
151  }
152  //**********************************************************************************************
153 
154  //**Columns function****************************************************************************
159  inline size_t columns() const noexcept {
160  return sm_.columns();
161  }
162  //**********************************************************************************************
163 
164  //**NonZeros function***************************************************************************
169  inline size_t nonZeros() const {
170  return sm_.nonZeros();
171  }
172  //**********************************************************************************************
173 
174  //**NonZeros function***************************************************************************
180  inline size_t nonZeros( size_t i ) const {
181  return sm_.nonZeros(i);
182  }
183  //**********************************************************************************************
184 
185  //**Operand access******************************************************************************
190  inline Operand operand() const noexcept {
191  return sm_;
192  }
193  //**********************************************************************************************
194 
195  //**********************************************************************************************
201  template< typename T >
202  inline bool canAlias( const T* alias ) const noexcept {
203  return sm_.canAlias( alias );
204  }
205  //**********************************************************************************************
206 
207  //**********************************************************************************************
213  template< typename T >
214  inline bool isAliased( const T* alias ) const noexcept {
215  return sm_.isAliased( alias );
216  }
217  //**********************************************************************************************
218 
219  //**********************************************************************************************
224  inline bool canSMPAssign() const noexcept {
225  return sm_.canSMPAssign();
226  }
227  //**********************************************************************************************
228 
229  private:
230  //**Member variables****************************************************************************
232  //**********************************************************************************************
233 
234  //**Assignment to dense matrices****************************************************************
246  template< typename MT2 // Type of the target dense matrix
247  , bool SO2 > // Storage order of the target dense matrix
248  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
249  {
251 
252  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
253  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
254 
255  assign( ~lhs, rhs.sm_ );
256  }
258  //**********************************************************************************************
259 
260  //**Assignment to sparse matrices***************************************************************
272  template< typename MT2 // Type of the target sparse matrix
273  , bool SO2 > // Storage order of the target sparse matrix
274  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
275  {
277 
278  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
279  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
280 
281  assign( ~lhs, rhs.sm_ );
282  }
284  //**********************************************************************************************
285 
286  //**Addition assignment to dense matrices*******************************************************
298  template< typename MT2 // Type of the target dense matrix
299  , bool SO2 > // Storage order of the target dense matrix
300  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
301  {
303 
304  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
305  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
306 
307  addAssign( ~lhs, rhs.sm_ );
308  }
310  //**********************************************************************************************
311 
312  //**Addition assignment to sparse matrices******************************************************
324  template< typename MT2 // Type of the target sparse matrix
325  , bool SO2 > // Storage order of the target sparse matrix
326  friend inline void addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
327  {
329 
330  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
331  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
332 
333  addAssign( ~lhs, rhs.sm_ );
334  }
336  //**********************************************************************************************
337 
338  //**Subtraction assignment to dense matrices****************************************************
350  template< typename MT2 // Type of the target dense matrix
351  , bool SO2 > // Storage order of the target dense matrix
352  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
353  {
355 
356  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
357  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
358 
359  subAssign( ~lhs, rhs.sm_ );
360  }
362  //**********************************************************************************************
363 
364  //**Subtraction assignment to sparse matrices***************************************************
376  template< typename MT2 // Type of the target sparse matrix
377  , bool SO2 > // Storage order of the target sparse matrix
378  friend inline void subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
379  {
381 
382  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
383  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
384 
385  subAssign( ~lhs, rhs.sm_ );
386  }
388  //**********************************************************************************************
389 
390  //**Schur product assignment to dense matrices**************************************************
402  template< typename MT2 // Type of the target dense matrix
403  , bool SO2 > // Storage order of the target dense matrix
404  friend inline void schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
405  {
407 
408  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
409  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
410 
411  schurAssign( ~lhs, rhs.sm_ );
412  }
414  //**********************************************************************************************
415 
416  //**Schur product assignment to sparse matrices*************************************************
428  template< typename MT2 // Type of the target sparse matrix
429  , bool SO2 > // Storage order of the target sparse matrix
430  friend inline void schurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
431  {
433 
434  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
435  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
436 
437  schurAssign( ~lhs, rhs.sm_ );
438  }
440  //**********************************************************************************************
441 
442  //**Multiplication assignment to dense matrices*************************************************
454  template< typename MT2 // Type of the target dense matrix
455  , bool SO2 > // Storage order of the target dense matrix
456  friend inline void multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
457  {
459 
460  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
461  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
462 
463  multAssign( ~lhs, rhs.sm_ );
464  }
466  //**********************************************************************************************
467 
468  //**Multiplication assignment to sparse matrices************************************************
480  template< typename MT2 // Type of the target sparse matrix
481  , bool SO2 > // Storage order of the target sparse matrix
482  friend inline void multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
483  {
485 
486  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
487  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
488 
489  multAssign( ~lhs, rhs.sm_ );
490  }
492  //**********************************************************************************************
493 
494  //**SMP assignment to dense matrices************************************************************
506  template< typename MT2 // Type of the target dense matrix
507  , bool SO2 > // Storage order of the target dense matrix
508  friend inline void smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
509  {
511 
512  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
513  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
514 
515  smpAssign( ~lhs, rhs.sm_ );
516  }
518  //**********************************************************************************************
519 
520  //**SMP assignment to sparse matrices***********************************************************
532  template< typename MT2 // Type of the target sparse matrix
533  , bool SO2 > // Storage order of the target sparse matrix
534  friend inline void smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
535  {
537 
538  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
539  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
540 
541  smpAssign( ~lhs, rhs.sm_ );
542  }
544  //**********************************************************************************************
545 
546  //**SMP addition assignment to dense matrices***************************************************
558  template< typename MT2 // Type of the target dense matrix
559  , bool SO2 > // Storage order of the target dense matrix
560  friend inline void smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
561  {
563 
564  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
565  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
566 
567  smpAddAssign( ~lhs, rhs.sm_ );
568  }
570  //**********************************************************************************************
571 
572  //**SMP addition assignment to sparse matrices**************************************************
584  template< typename MT2 // Type of the target sparse matrix
585  , bool SO2 > // Storage order of the target sparse matrix
586  friend inline void smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
587  {
589 
590  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
591  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
592 
593  smpAddAssign( ~lhs, rhs.sm_ );
594  }
596  //**********************************************************************************************
597 
598  //**SMP subtraction assignment to dense matrices************************************************
610  template< typename MT2 // Type of the target dense matrix
611  , bool SO2 > // Storage order of the target dense matrix
612  friend inline void smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
613  {
615 
616  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
617  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
618 
619  smpSubAssign( ~lhs, rhs.sm_ );
620  }
622  //**********************************************************************************************
623 
624  //**SMP subtraction assignment to sparse matrices***********************************************
636  template< typename MT2 // Type of the target sparse matrix
637  , bool SO2 > // Storage order of the target sparse matrix
638  friend inline void smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
639  {
641 
642  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
643  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
644 
645  smpSubAssign( ~lhs, rhs.sm_ );
646  }
648  //**********************************************************************************************
649 
650  //**SMP Schur product assignment to dense matrices**********************************************
663  template< typename MT2 // Type of the target dense matrix
664  , bool SO2 > // Storage order of the target dense matrix
665  friend inline void smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
666  {
668 
669  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
670  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
671 
672  smpSchurAssign( ~lhs, rhs.sm_ );
673  }
675  //**********************************************************************************************
676 
677  //**SMP Schur product assignment to sparse matrices*********************************************
690  template< typename MT2 // Type of the target sparse matrix
691  , bool SO2 > // Storage order of the target sparse matrix
692  friend inline void smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
693  {
695 
696  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
697  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
698 
699  smpSchurAssign( ~lhs, rhs.sm_ );
700  }
702  //**********************************************************************************************
703 
704  //**SMP multiplication assignment to dense matrices*********************************************
717  template< typename MT2 // Type of the target dense matrix
718  , bool SO2 > // Storage order of the target dense matrix
719  friend inline void smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
720  {
722 
723  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
724  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
725 
726  smpMultAssign( ~lhs, rhs.sm_ );
727  }
729  //**********************************************************************************************
730 
731  //**SMP multiplication assignment to sparse matrices********************************************
744  template< typename MT2 // Type of the target sparse matrix
745  , bool SO2 > // Storage order of the target sparse matrix
746  friend inline void smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatEvalExpr& rhs )
747  {
749 
750  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
751  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
752 
753  smpMultAssign( ~lhs, rhs.sm_ );
754  }
756  //**********************************************************************************************
757 
758  //**Compile time checks*************************************************************************
763  //**********************************************************************************************
764 };
765 //*************************************************************************************************
766 
767 
768 
769 
770 //=================================================================================================
771 //
772 // GLOBAL FUNCTIONS
773 //
774 //=================================================================================================
775 
776 //*************************************************************************************************
793 template< typename MT // Type of the sparse matrix
794  , bool SO > // Storage order
795 inline decltype(auto) eval( const SparseMatrix<MT,SO>& sm )
796 {
798 
799  using ReturnType = const SMatEvalExpr<MT,SO>;
800  return ReturnType( ~sm );
801 }
802 //*************************************************************************************************
803 
804 
805 
806 
807 //=================================================================================================
808 //
809 // GLOBAL RESTRUCTURING FUNCTIONS
810 //
811 //=================================================================================================
812 
813 //*************************************************************************************************
824 template< typename MT // Type of the sparse matrix
825  , bool SO > // Storage order
826 inline decltype(auto) eval( const SMatEvalExpr<MT,SO>& sm )
827 {
828  return sm;
829 }
831 //*************************************************************************************************
832 
833 } // namespace blaze
834 
835 #endif
If_t< IsExpression_v< MT >, const MT, const MT & > Operand
Composite data type of the sparse matrix expression.
Definition: SMatEvalExpr.h:93
Header file for auxiliary alias declarations.
Header file for basic type definitions.
TransposeType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition: SMatEvalExpr.h:85
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
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatEvalExpr.h:90
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatEvalExpr.h:159
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
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: SMatEvalExpr.h:98
Header file for the MatEvalExpr base class.
Header file for the Computation base class.
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: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
Header file for the SparseMatrix base class.
SMatEvalExpr(const MT &sm) noexcept
Constructor for the SMatEvalExpr class.
Definition: SMatEvalExpr.h:106
Constraint on the data type.
ElementType_t< MT > ElementType
Resulting element type.
Definition: SMatEvalExpr.h:86
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Header file for the If class template.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatEvalExpr.h:202
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatEvalExpr.h:214
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatEvalExpr.h:133
#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
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatEvalExpr.h:87
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatEvalExpr.h:224
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatEvalExpr.h:190
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 nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatEvalExpr.h:180
Operand sm_
Sparse matrix of the evaluation expression.
Definition: SMatEvalExpr.h:231
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.The OppositeType_t alias declaration provi...
Definition: Aliases.h:270
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatEvalExpr.h:169
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.
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatEvalExpr.h:118
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
OppositeType_t< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatEvalExpr.h:84
ResultType_t< MT > ResultType
Result type for expression template evaluations.
Definition: SMatEvalExpr.h:83
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 sparse matrices.The SMatEvalExpr class represents the ...
Definition: Forward.h:125
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatEvalExpr.h:149
#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
#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.