35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATSVECMULTEXPR_H_ 36 #define _BLAZE_MATH_EXPRESSIONS_SMATSVECMULTEXPR_H_ 96 class SMatSVecMultExpr
97 :
public MatVecMultExpr< SparseVector< SMatSVecMultExpr<MT,VT>, false > >
115 static constexpr
bool evaluateVector = ( RequiresEvaluation_v<VT> || IsComputation_v<VT> );
124 template<
typename T1 >
194 if( index >=
mat_.rows() ) {
197 return (*
this)[index];
206 inline size_t size() const noexcept {
247 template<
typename T >
248 inline bool canAlias(
const T* alias )
const noexcept {
249 return (
mat_.isAliased( alias ) ||
vec_.isAliased( alias ) );
259 template<
typename T >
260 inline bool isAliased(
const T* alias )
const noexcept {
261 return (
mat_.isAliased( alias ) ||
vec_.isAliased( alias ) );
271 return (
size() > SMP_SMATSVECMULT_THRESHOLD );
293 template<
typename VT1 >
305 if( x.nonZeros() == 0UL )
return;
317 SMatSVecMultExpr::selectAssignKernel( ~lhs, A, x );
336 template<
typename VT1
339 static inline void selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
341 const auto vend( x.end() );
343 for(
size_t i=0UL; i<y.size(); ++i )
345 const auto mend ( A.end(i) );
346 auto melem( A.begin(i) );
348 if( melem == mend )
continue;
350 auto velem( x.begin() );
353 if( melem->index() < velem->index() ) {
355 if( melem == mend )
break;
357 else if( velem->index() < melem->index() ) {
359 if( velem == vend )
break;
362 y[i] = melem->value() * velem->value();
369 if( melem != mend && velem != vend )
372 if( melem->index() < velem->index() ) {
374 if( melem == mend )
break;
376 else if( velem->index() < melem->index() ) {
378 if( velem == vend )
break;
381 y[i] += melem->value() * velem->value();
383 if( melem == mend )
break;
385 if( velem == vend )
break;
406 template<
typename VT1 >
407 friend inline void assign( SparseVector<VT1,false>& lhs,
const SMatSVecMultExpr& rhs )
414 if( x.nonZeros() == 0UL )
return;
424 const auto vend( x.end() );
426 for(
size_t i=0UL; i<(~lhs).
size(); ++i )
428 const auto mend ( A.end(i) );
429 auto melem( A.begin(i) );
431 if( melem == mend )
continue;
433 auto velem( x.begin() );
438 if( melem->index() < velem->index() ) {
440 if( melem == mend )
break;
442 else if( velem->index() < melem->index() ) {
444 if( velem == vend )
break;
447 accu = melem->value() * velem->value();
454 if( melem != mend && velem != vend )
457 if( melem->index() < velem->index() ) {
459 if( melem == mend )
break;
461 else if( velem->index() < melem->index() ) {
463 if( velem == vend )
break;
466 accu += melem->value() * velem->value();
468 if( melem == mend )
break;
470 if( velem == vend )
break;
476 (~lhs).insert( i, accu );
494 template<
typename VT1 >
495 friend inline void addAssign( DenseVector<VT1,false>& lhs,
const SMatSVecMultExpr& rhs )
503 if( x.nonZeros() == 0UL )
return;
515 SMatSVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
534 template<
typename VT1
537 static inline void selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
539 const auto vend( x.end() );
541 for(
size_t i=0UL; i<y.size(); ++i )
543 const auto mend ( A.end(i) );
544 auto melem( A.begin(i) );
546 if( melem == mend )
continue;
548 auto velem( x.begin() );
551 if( melem->index() < velem->index() ) {
553 if( melem == mend )
break;
555 else if( velem->index() < melem->index() ) {
557 if( velem == vend )
break;
560 y[i] += melem->value() * velem->value();
562 if( melem == mend )
break;
564 if( velem == vend )
break;
588 template<
typename VT1 >
589 friend inline void subAssign( DenseVector<VT1,false>& lhs,
const SMatSVecMultExpr& rhs )
597 if( x.nonZeros() == 0UL )
return;
609 SMatSVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
628 template<
typename VT1
631 static inline void selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
633 const auto vend( x.end() );
635 for(
size_t i=0UL; i<y.size(); ++i )
637 const auto mend ( A.end(i) );
638 auto melem( A.begin(i) );
640 if( melem == mend )
continue;
642 auto velem( x.begin() );
645 if( melem->index() < velem->index() ) {
647 if( melem == mend )
break;
649 else if( velem->index() < melem->index() ) {
651 if( velem == vend )
break;
654 y[i] -= melem->value() * velem->value();
656 if( melem == mend )
break;
658 if( velem == vend )
break;
682 template<
typename VT1 >
683 friend inline void multAssign( DenseVector<VT1,false>& lhs,
const SMatSVecMultExpr& rhs )
694 multAssign( ~lhs, tmp );
717 template<
typename VT1 >
719 -> EnableIf_t< UseSMPAssign_v<VT1> >
730 if( x.nonZeros() == 0UL )
return;
766 template<
typename VT1 >
768 -> EnableIf_t< UseSMPAssign_v<VT1> >
776 if( x.nonZeros() == 0UL )
return;
812 template<
typename VT1 >
814 -> EnableIf_t< UseSMPAssign_v<VT1> >
822 if( x.nonZeros() == 0UL )
return;
858 template<
typename VT1 >
860 -> EnableIf_t< UseSMPAssign_v<VT1> >
917 template<
typename MT
919 , DisableIf_t< IsSymmetric_v<MT> ||
920 ( IsIdentity_v<MT> &&
921 IsSame_v< ElementType_t<MT>, ElementType_t<VT> > ) ||
922 ( IsZero_v<MT> || IsZero_v<VT> ) >* =
nullptr >
923 inline const SMatSVecMultExpr<MT,VT>
924 smatsvecmult(
const SparseMatrix<MT,false>& mat,
const SparseVector<VT,false>& vec )
930 return SMatSVecMultExpr<MT,VT>( ~mat, ~vec );
950 template<
typename MT
952 , EnableIf_t< IsSymmetric_v<MT> &&
953 !( IsIdentity_v<MT> &&
954 IsSame_v< ElementType_t<MT>, ElementType_t<VT> > ) &&
955 !( IsZero_v<MT> || IsZero_v<VT> ) >* =
nullptr >
956 inline decltype(
auto)
957 smatsvecmult( const SparseMatrix<MT,false>& mat, const SparseVector<VT,false>& vec )
963 return trans( ~mat ) * (~vec);
983 template<
typename MT
986 IsSame_v< ElementType_t<MT>, ElementType_t<VT> > ) &&
987 !IsZero_v<VT> >* =
nullptr >
989 smatsvecmult(
const SparseMatrix<MT,false>& mat,
const SparseVector<VT,false>& vec )
1016 template<
typename MT
1018 , EnableIf_t< IsZero_v<MT> || IsZero_v<VT> >* =
nullptr >
1019 inline decltype(
auto)
1020 smatsvecmult( const SparseMatrix<MT,false>& mat, const SparseVector<VT,false>& vec )
1028 using ReturnType =
const MultTrait_t< ResultType_t<MT>, ResultType_t<VT> >;
1033 return ReturnType( (~mat).
rows() );
1070 template<
typename MT
1072 inline decltype(
auto)
1083 return smatsvecmult( ~mat, ~vec );
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
Header file for the blaze::checked and blaze::unchecked instances.
LeftOperand mat_
Left-hand side sparse matrix of the multiplication expression.
Definition: SMatSVecMultExpr.h:277
Header file for basic type definitions.
Header file for the SparseVector base class.
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
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: SMatSVecMultExpr.h:156
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_COLUMN_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a column dense or sparse vector type...
Definition: ColumnVector.h:61
Header file for the serial shim.
size_t nonZeros() const
Returns an estimation for the number of non-zero elements in the sparse vector.
Definition: SMatSVecMultExpr.h:216
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: SMatSVecMultExpr.h:193
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:595
constexpr Unchecked unchecked
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of view...
Definition: Check.h:138
Constraint on the data type.
Header file for the MAYBE_UNUSED function template.
Header file for the IsIdentity type trait.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatSVecMultExpr.h:260
Header file for the Computation base class.
Header file for the reset shim.
CompositeType_t< MT > MCT
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSVecMultExpr.h:104
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
Base class for 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 transpose flag of vector types.
Constraint on the data type.
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.The EnableIf_t alias declaration provides a convenient...
Definition: EnableIf.h:138
ResultType_t< VT > VRT
Result type of the right-hand side sparse vector expression.
Definition: SMatSVecMultExpr.h:103
Header file for the DisableIf class template.
const ElementType ReturnType
Return type for expression template evaluations.
Definition: SMatSVecMultExpr.h:136
Header file for the multiplication trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
If_t< IsExpression_v< MT >, const MT, const MT & > LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSVecMultExpr.h:142
Expression object for sparse matrix-sparse vector multiplications.The SMatSVecMultExpr class represen...
Definition: Forward.h:135
Header file for the If class template.
#define BLAZE_CONSTRAINT_MUST_BE_ZERO_TYPE(T)
Constraint on the data type.In case the given data type T is not a zero vector or matrix type,...
Definition: Zero.h:61
#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
CompositeType_t< VT > VCT
Composite type of the right-hand side sparse vector expression.
Definition: SMatSVecMultExpr.h:105
ElementType_t< ResultType > ElementType
Resulting element type.
Definition: SMatSVecMultExpr.h:135
MultTrait_t< MRT, VRT > ResultType
Result type for expression template evaluations.
Definition: SMatSVecMultExpr.h:133
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:76
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type,...
Definition: SparseVector.h:61
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatSVecMultExpr.h:270
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: SMatSVecMultExpr.h:180
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMULTEXPR_TYPE(T)
Constraint on the data type.In case the given data type T is a matrix/matrix multiplication expressio...
Definition: MatMatMultExpr.h:83
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/vector ...
Definition: MatVecMultExpr.h:104
Header file for the exception macros of the math module.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatSVecMultExpr.h:139
ResultType_t< MT > MRT
Result type of the left-hand side sparse matrix expression.
Definition: SMatSVecMultExpr.h:102
Constraint on the data type.
Constraint on the data type.
Header file for the EnableIf class template.
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse matrix operand.
Definition: SMatSVecMultExpr.h:226
typename MultTrait< T1, T2 >::Type MultTrait_t
Auxiliary alias declaration for the MultTrait class template.The MultTrait_t alias declaration provid...
Definition: MultTrait.h:240
If_t< IsExpression_v< VT >, const VT, const VT & > RightOperand
Composite type of the right-hand side sparse vector expression.
Definition: SMatSVecMultExpr.h:145
RightOperand vec_
Right-hand side sparse vector of the multiplication expression.
Definition: SMatSVecMultExpr.h:278
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type,...
Definition: Symmetric.h:79
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: RowMajorMatrix.h:61
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.
typename T::CompositeType CompositeType_t
Alias declaration for nested CompositeType type definitions.The CompositeType_t alias declaration pro...
Definition: Aliases.h:90
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
If_t< evaluateMatrix, const MRT, MCT > LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: SMatSVecMultExpr.h:148
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:133
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: SMatSVecMultExpr.h:206
Header file for the IsZero type trait.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Header file for all forward declarations for expression class templates.
TransposeType_t< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: SMatSVecMultExpr.h:134
Header file for the isDefault shim.
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:530
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
Constraint on the data type.
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse vector operand.
Definition: SMatSVecMultExpr.h:236
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:808
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatSVecMultExpr.h:248
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:765
Header file for the IsComputation type trait class.
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 sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:146
Constraint on the data type.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:635
static constexpr bool evaluateMatrix
Compilation switch for the composite type of the left-hand side sparse matrix expression.
Definition: SMatSVecMultExpr.h:110
If_t< evaluateVector, const VRT, VCT > RT
Type for the assignment of the right-hand side sparse vector operand.
Definition: SMatSVecMultExpr.h:151
SMatSVecMultExpr(const MT &mat, const VT &vec) noexcept
Constructor for the SMatSVecMultExpr class.
Definition: SMatSVecMultExpr.h:166
Header file for the MatVecMultExpr base class.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ZERO_TYPE(T)
Constraint on the data type.In case the given data type T is a zero vector or matrix type,...
Definition: Zero.h:81
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#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
static constexpr bool evaluateVector
Compilation switch for the composite type of the right-hand side sparse vector expression.
Definition: SMatSVecMultExpr.h:115
#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.