35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDMATSVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDMATSVECMULTEXPR_H_
97 class TDMatSVecMultExpr :
public DenseVector< TDMatSVecMultExpr<MT,VT>, false >
98 ,
private MatVecMultExpr
128 template<
typename T1 >
129 struct UseSMPAssign {
130 enum { value = ( evaluateMatrix || evaluateVector ) };
141 template<
typename T1,
typename T2,
typename T3 >
142 struct UseVectorizedKernel {
143 enum { value = T1::vectorizable && T2::vectorizable &&
158 template<
typename T1,
typename T2,
typename T3 >
159 struct UseOptimizedKernel {
160 enum { value = !UseVectorizedKernel<T1,T2,T3>::value &&
172 template<
typename T1,
typename T2,
typename T3 >
173 struct UseDefaultKernel {
174 enum { value = !UseVectorizedKernel<T1,T2,T3>::value &&
175 !UseOptimizedKernel<T1,T2,T3>::value };
205 enum { vectorizable = MT::vectorizable &&
211 enum { smpAssignable = !evaluateMatrix && MT::smpAssignable &&
212 !evaluateVector && VT::smpAssignable };
244 ConstIterator element( x.begin() );
247 if( element != x.end() ) {
248 res =
mat_( index, element->index() ) * element->value();
250 for( ; element!=x.end(); ++element ) {
251 res +=
mat_( index, element->index() ) * element->value();
298 template<
typename T >
300 return mat_.isAliased( alias ) ||
vec_.isAliased( alias );
310 template<
typename T >
312 return mat_.isAliased( alias ) ||
vec_.isAliased( alias );
322 return mat_.isAligned();
355 template<
typename VT1 >
364 if( x.nonZeros() == 0UL ) {
379 TDMatSVecMultExpr::selectAssignKernel( ~lhs, A, x );
398 template<
typename VT1
402 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
408 const size_t M( A.rows() );
410 ConstIterator element( x.begin() );
411 const ConstIterator
end( x.end() );
413 for(
size_t i=0UL; i<M; ++i ) {
414 y[i] = A(i,element->index()) * element->value();
419 for( ; element!=
end; ++element ) {
420 for(
size_t i=0UL; i<M; ++i ) {
421 y[i] += A(i,element->index()) * element->value();
442 template<
typename VT1
445 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
446 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
452 const size_t M( A.rows() );
454 ConstIterator element( x.begin() );
455 const ConstIterator
end( x.end() );
457 const size_t jend( x.nonZeros() & size_t(-4) );
458 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
462 const size_t j1( element->index() );
463 const VET v1( element->value() );
465 const size_t j2( element->index() );
466 const VET v2( element->value() );
468 const size_t j3( element->index() );
469 const VET v3( element->value() );
471 const size_t j4( element->index() );
472 const VET v4( element->value() );
475 for(
size_t i=0UL; i<M; ++i ) {
476 y[i] = A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
481 const size_t j1( element->index() );
482 const VET v1( element->value() );
485 for(
size_t i=0UL; i<M; ++i ) {
490 for(
size_t j=(jend>3UL)?(4UL):(1UL); (j+4UL)<=jend; j+=4UL )
492 const size_t j1( element->index() );
493 const VET v1( element->value() );
495 const size_t j2( element->index() );
496 const VET v2( element->value() );
498 const size_t j3( element->index() );
499 const VET v3( element->value() );
501 const size_t j4( element->index() );
502 const VET v4( element->value() );
505 for(
size_t i=0UL; i<M; ++i ) {
506 y[i] += A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
509 for( ; element!=
end; ++element )
511 const size_t j1( element->index() );
512 const VET v1( element->value() );
514 for(
size_t i=0UL; i<M; ++i ) {
515 y[i] += A(i,j1) * v1;
536 template<
typename VT1
539 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
540 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
542 typedef IntrinsicTrait<ElementType> IT;
547 const size_t M( A.rows() );
549 ConstIterator element( x.begin() );
550 const ConstIterator
end( x.end() );
552 const size_t jend( x.nonZeros() & size_t(-4) );
553 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
557 const size_t j1( element->index() );
560 const size_t j2( element->index() );
563 const size_t j3( element->index() );
566 const size_t j4( element->index() );
570 for(
size_t i=0UL; i<M; i+=
IT::size ) {
571 y.store( i, A.load(i,j1) * v1 + A.load(i,j2) * v2 + A.load(i,j3) * v3 + A.load(i,j4) * v4 );
576 const size_t j1( element->index() );
580 for(
size_t i=0UL; i<M; i+=
IT::size ) {
581 y.store( i, A.load(i,j1) * v1 );
585 for(
size_t j=(jend>3UL)?(4UL):(1UL); (j+4UL)<=jend; j+=4UL )
587 const size_t j1( element->index() );
590 const size_t j2( element->index() );
593 const size_t j3( element->index() );
596 const size_t j4( element->index() );
600 for(
size_t i=0UL; i<M; i+=
IT::size ) {
601 y.store( i, y.load(i) + A.load(i,j1) * v1 + A.load(i,j2) * v2 + A.load(i,j3) * v3 + A.load(i,j4) * v4 );
604 for( ; element!=
end; ++element )
606 const size_t j1( element->index() );
609 for(
size_t i=0UL; i<M; i+=
IT::size ) {
610 y.store( i, y.load(i) + A.load(i,j1) * v1 );
630 template<
typename VT1 >
660 template<
typename VT1 >
671 if( x.nonZeros() == 0UL )
return;
683 TDMatSVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
702 template<
typename VT1
705 static inline typename EnableIf< UseDefaultKernel<VT1,MT1,VT2> >::Type
706 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
712 const size_t M( A.rows() );
714 ConstIterator element( x.begin() );
715 const ConstIterator
end( x.end() );
717 for( ; element!=
end; ++element ) {
718 for(
size_t i=0UL; i<M; ++i ) {
719 y[i] += A(i,element->index()) * element->value();
740 template<
typename VT1
743 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
744 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
750 const size_t M( A.rows() );
752 ConstIterator element( x.begin() );
753 const ConstIterator
end( x.end() );
755 const size_t jend( x.nonZeros() & size_t(-4) );
756 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
758 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
760 const size_t j1( element->index() );
761 const VET v1( element->value() );
763 const size_t j2( element->index() );
764 const VET v2( element->value() );
766 const size_t j3( element->index() );
767 const VET v3( element->value() );
769 const size_t j4( element->index() );
770 const VET v4( element->value() );
773 for(
size_t i=0UL; i<M; ++i ) {
774 y[i] += A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
777 for( ; element!=
end; ++element )
779 const size_t j1( element->index() );
780 const VET v1( element->value() );
782 for(
size_t i=0UL; i<M; ++i ) {
783 y[i] += A(i,j1) * v1;
804 template<
typename VT1
807 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
808 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
810 typedef IntrinsicTrait<ElementType> IT;
815 const size_t M( A.rows() );
817 ConstIterator element( x.begin() );
818 const ConstIterator
end( x.end() );
820 const size_t jend( x.nonZeros() & size_t(-4) );
821 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
823 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
825 const size_t j1( element->index() );
828 const size_t j2( element->index() );
831 const size_t j3( element->index() );
834 const size_t j4( element->index() );
838 for(
size_t i=0UL; i<M; i+=
IT::size ) {
839 y.store( i, y.load(i) + A.load(i,j1) * v1 + A.load(i,j2) * v2 + A.load(i,j3) * v3 + A.load(i,j4) * v4 );
842 for( ; element!=
end; ++element )
844 const size_t j1( element->index() );
847 for(
size_t i=0UL; i<M; i+=
IT::size ) {
848 y.store( i, y.load(i) + A.load(i,j1) * v1 );
872 template<
typename VT1 >
883 if( x.nonZeros() == 0UL )
return;
895 TDMatSVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
914 template<
typename VT1
917 static inline typename EnableIf< UseDefaultKernel<VT1,MT1,VT2> >::Type
918 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
924 const size_t M( A.rows() );
926 ConstIterator element( x.begin() );
927 const ConstIterator
end( x.end() );
929 for( ; element!=
end; ++element ) {
930 for(
size_t i=0UL; i<M; ++i ) {
931 y[i] -= A(i,element->index()) * element->value();
952 template<
typename VT1
955 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
956 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
962 const size_t M( A.rows() );
964 ConstIterator element( x.begin() );
965 const ConstIterator
end( x.end() );
967 const size_t jend( x.nonZeros() & size_t(-4) );
968 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
970 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
972 const size_t j1( element->index() );
973 const VET v1( element->value() );
975 const size_t j2( element->index() );
976 const VET v2( element->value() );
978 const size_t j3( element->index() );
979 const VET v3( element->value() );
981 const size_t j4( element->index() );
982 const VET v4( element->value() );
985 for(
size_t i=0UL; i<M; ++i ) {
986 y[i] -= A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
989 for( ; element!=
end; ++element )
991 const size_t j1( element->index() );
992 const VET v1( element->value() );
994 for(
size_t i=0UL; i<M; ++i ) {
995 y[i] -= A(i,j1) * v1;
1016 template<
typename VT1
1019 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
1020 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
1022 typedef IntrinsicTrait<ElementType> IT;
1027 const size_t M( A.rows() );
1029 ConstIterator element( x.begin() );
1030 const ConstIterator
end( x.end() );
1032 const size_t jend( x.nonZeros() & size_t(-4) );
1033 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
1035 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
1037 const size_t j1( element->index() );
1040 const size_t j2( element->index() );
1043 const size_t j3( element->index() );
1046 const size_t j4( element->index() );
1050 for(
size_t i=0UL; i<M; i+=
IT::size ) {
1051 y.store( i, y.load(i) - A.load(i,j1) * v1 - A.load(i,j2) * v2 - A.load(i,j3) * v3 - A.load(i,j4) * v4 );
1054 for( ; element!=
end; ++element )
1056 const size_t j1( element->index() );
1059 for(
size_t i=0UL; i<M; i+=
IT::size ) {
1060 y.store( i, y.load(i) - A.load(i,j1) * v1 );
1084 template<
typename VT1 >
1120 template<
typename VT1 >
1121 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1130 if( x.nonZeros() == 0UL ) {
1165 template<
typename VT1 >
1166 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1198 template<
typename VT1 >
1199 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1210 if( x.nonZeros() == 0UL )
return;
1246 template<
typename VT1 >
1247 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1258 if( x.nonZeros() == 0UL )
return;
1294 template<
typename VT1 >
1295 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1369 template<
typename T1
1371 inline const typename DisableIf< IsMatMatMultExpr<T1>, TDMatSVecMultExpr<T1,T2> >::Type
1377 throw std::invalid_argument(
"Matrix and vector sizes do not match" );
1394 template<
typename MT,
typename VT >
1412 template<
typename MT,
typename VT,
bool AF >
1417 typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type, VT >::Type Type;
ResultType::ElementType ElementType
Resulting element type.
Definition: TDMatSVecMultExpr.h:185
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
size_t size() const
Returns the current size/dimension of the vector.
Definition: TDMatSVecMultExpr.h:267
BLAZE_ALWAYS_INLINE void multAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the multiplication assignment of a matrix to a matrix.
Definition: Matrix.h:879
Header file for the Rows type trait.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:4838
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:258
VT::ResultType VRT
Result type of the right-hand side sparse vector expression.
Definition: TDMatSVecMultExpr.h:104
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:258
#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: TransposeFlag.h:159
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:205
#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:79
RightOperand vec_
Right-hand side sparse vector of the multiplication expression.
Definition: TDMatSVecMultExpr.h:339
Header file for the IsSame and IsStrictlySame type traits.
VRT::ElementType VET
Element type of the right-hand side sparse vector expression.
Definition: TDMatSVecMultExpr.h:106
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TDMatSVecMultExpr.h:321
const size_t SMP_TDMATSVECMULT_THRESHOLD
SMP column-major dense matrix/sparse vector multiplication threshold.This threshold specifies when a ...
Definition: Thresholds.h:437
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2478
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:257
Header file for the DenseVector base class.
MRT::ElementType MET
Element type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:105
TDMatSVecMultExpr< MT, VT > This
Type of this TDMatSVecMultExpr instance.
Definition: TDMatSVecMultExpr.h:182
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:695
MultTrait< MRT, VRT >::Type ResultType
Result type for expression template evaluations.
Definition: TDMatSVecMultExpr.h:183
Header file for the Computation base class.
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType.
Definition: IsSame.h:158
Header file for the RequiresEvaluation type trait.
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: TDMatSVecMultExpr.h:194
Constraint on the data type.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TDMatSVecMultExpr.h:235
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSVecMultExpr.h:311
Constraint on the data type.
Header file for the MultExprTrait class template.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:259
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the DisableIf class template.
Header file for the multiplication trait.
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TDMatSVecMultExpr.h:187
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TDMatSVecMultExpr.h:331
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: StorageOrder.h:161
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2482
Header file for the IsMatMatMultExpr type trait class.
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
LeftOperand mat_
Left-hand side dense matrix of the multiplication expression.
Definition: TDMatSVecMultExpr.h:338
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
IntrinsicTrait< ElementType >::Type IntrinsicType
Resulting intrinsic element type.
Definition: TDMatSVecMultExpr.h:186
#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:79
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:78
#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:166
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSVecMultExpr.h:188
Constraints on the storage order of matrix types.
Constraint on the data type.
TDMatSVecMultExpr(const MT &mat, const VT &vec)
Constructor for the TDMatSVecMultExpr class.
Definition: TDMatSVecMultExpr.h:221
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2476
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the serial shim.
SelectType< evaluateVector, const VRT, typename VT::CompositeType >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TDMatSVecMultExpr.h:200
Expression object for transpose dense matrix-sparse vector multiplications.The TDMatSVecMultExpr clas...
Definition: Forward.h:130
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
BLAZE_ALWAYS_INLINE EnableIf< IsIntegral< T >, Set< T, sizeof(T)> >::Type::Type set(T value)
Sets all values in the vector to the given integral value.
Definition: Set.h:211
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the SubmatrixExprTrait class template.
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:749
LeftOperand leftOperand() const
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSVecMultExpr.h:277
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Base template for the MultTrait class.
Definition: MultTrait.h:142
BLAZE_ALWAYS_INLINE void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:742
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
VT::CompositeType VCT
Composite type of the right-hand side sparse vector expression.
Definition: TDMatSVecMultExpr.h:108
Header file for the reset shim.
Compile time check for data types.This type trait tests whether or not the given template parameter i...
Definition: IsBlasCompatible.h:99
BLAZE_ALWAYS_INLINE void reset(const NonNumericProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: NonNumericProxy.h:833
MT::ResultType MRT
Result type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:103
SelectType< evaluateMatrix, const MRT, MCT >::Type LT
Type for the assignment of the left-hand side dense matrix operand.
Definition: TDMatSVecMultExpr.h:197
Header file for the RemoveReference type trait.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TDMatSVecMultExpr.h:299
Header file for all intrinsic functionality.
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type...
Definition: DenseVector.h:79
RightOperand rightOperand() const
Returns the right-hand side sparse vector operand.
Definition: TDMatSVecMultExpr.h:287
Header file for the IsComputation type trait class.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSVecMultExpr.h:184
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:108
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2473
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
Header file for basic type definitions.
Header file for the SubvectorExprTrait class template.
Constraint on the data type.
Header file for the MatVecMultExpr base class.
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:191
Header file for the IsResizable type trait.
EnableIf< IsDenseVector< VT1 > >::Type smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:189
Header file for the Size type trait.
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, 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
MT::CompositeType MCT
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:107
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:849