35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSVECDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSVECDMATMULTEXPR_H_
98 class TSVecDMatMultExpr :
public DenseVector< TSVecDMatMultExpr<VT,MT>, true >
99 ,
private TVecMatMultExpr
100 ,
private Computation
129 template<
typename T1 >
130 struct UseSMPAssign {
131 enum { value = ( evaluateVector || evaluateMatrix ) };
142 template<
typename T1,
typename T2,
typename T3 >
143 struct UseVectorizedKernel {
144 enum { value = T1::vectorizable && T3::vectorizable &&
145 IsSame<typename T1::ElementType,typename T2::ElementType>::value &&
146 IsSame<typename T1::ElementType,typename T3::ElementType>::value &&
147 IntrinsicTrait<typename T1::ElementType>::addition &&
148 IntrinsicTrait<typename T1::ElementType>::multiplication };
159 template<
typename T1,
typename T2,
typename T3 >
160 struct UseOptimizedKernel {
161 enum { value = !UseVectorizedKernel<T1,T2,T3>::value &&
162 !IsResizable<typename T1::ElementType>::value &&
163 !IsResizable<VET>::value };
173 template<
typename T1,
typename T2,
typename T3 >
174 struct UseDefaultKernel {
175 enum { value = !UseVectorizedKernel<T1,T2,T3>::value &&
176 !UseOptimizedKernel<T1,T2,T3>::value };
206 enum { vectorizable = MT::vectorizable &&
212 enum { smpAssignable = !evaluateVector && VT::smpAssignable &&
213 !evaluateMatrix && MT::smpAssignable };
245 const ConstIterator
end( x.end() );
246 ConstIterator element( x.begin() );
249 if( element !=
end ) {
250 res = element->value() *
mat_( element->index(), index );
252 for( ; element!=
end; ++element )
253 res += element->value() *
mat_( element->index(), index );
269 return mat_.columns();
299 template<
typename T >
301 return vec_.isAliased( alias ) ||
mat_.isAliased( alias );
311 template<
typename T >
313 return vec_.isAliased( alias ) ||
mat_.isAliased( alias );
323 return mat_.isAligned();
356 template<
typename VT2 >
365 if( x.nonZeros() == 0UL ) {
380 TSVecDMatMultExpr::selectAssignKernel( ~lhs, x, A );
399 template<
typename VT1
403 selectAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
409 const size_t N( A.columns() );
411 ConstIterator element( x.begin() );
412 const ConstIterator
end( x.end() );
414 for(
size_t j=0UL; j<N; ++j ) {
415 y[j] = element->value() * A(element->index(),j);
420 for( ; element!=
end; ++element ) {
421 for(
size_t j=0UL; j<N; ++j ) {
422 y[j] += element->value() * A(element->index(),j);
443 template<
typename VT1
446 static inline typename EnableIf< UseOptimizedKernel<VT1,VT2,MT1> >::Type
447 selectAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
453 const size_t N( A.columns() );
455 ConstIterator element( x.begin() );
456 const ConstIterator
end( x.end() );
458 const size_t iend( x.nonZeros() & size_t(-4) );
459 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == iend,
"Invalid end calculation" );
463 const size_t i1( element->index() );
464 const VET v1( element->value() );
466 const size_t i2( element->index() );
467 const VET v2( element->value() );
469 const size_t i3( element->index() );
470 const VET v3( element->value() );
472 const size_t i4( element->index() );
473 const VET v4( element->value() );
476 for(
size_t j=0UL; j<N; ++j ) {
477 y[j] = v1 * A(i1,j) + v2 * A(i2,j) + v3 * A(i3,j) + v4 * A(i4,j);
482 const size_t i1( element->index() );
483 const VET v1( element->value() );
486 for(
size_t j=0UL; j<N; ++j ) {
491 for(
size_t i=(iend>3UL)?(4UL):(1UL); (i+4UL)<=iend; i+=4UL )
493 const size_t i1( element->index() );
494 const VET v1( element->value() );
496 const size_t i2( element->index() );
497 const VET v2( element->value() );
499 const size_t i3( element->index() );
500 const VET v3( element->value() );
502 const size_t i4( element->index() );
503 const VET v4( element->value() );
506 for(
size_t j=0UL; j<N; ++j ) {
507 y[j] += v1 * A(i1,j) + v2 * A(i2,j) + v3 * A(i3,j) + v4 * A(i4,j);
510 for( ; element!=
end; ++element )
512 const size_t i1( element->index() );
513 const VET v1( element->value() );
515 for(
size_t j=0UL; j<N; ++j ) {
516 y[j] += v1 * A(i1,j);
537 template<
typename VT1
540 static inline typename EnableIf< UseVectorizedKernel<VT1,VT2,MT1> >::Type
541 selectAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
543 typedef IntrinsicTrait<ElementType> IT;
548 const size_t N( A.columns() );
550 ConstIterator element( x.begin() );
551 const ConstIterator
end( x.end() );
553 const size_t iend( x.nonZeros() & size_t(-4) );
554 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == iend,
"Invalid end calculation" );
558 const size_t i1( element->index() );
561 const size_t i2( element->index() );
564 const size_t i3( element->index() );
567 const size_t i4( element->index() );
571 for(
size_t j=0UL; j<N; j+=
IT::size ) {
572 y.store( j, v1 * A.load(i1,j) + v2 * A.load(i2,j) + v3 * A.load(i3,j) + v4 * A.load(i4,j) );
577 const size_t i1( element->index() );
581 for(
size_t j=0UL; j<N; j+=
IT::size ) {
582 y.store( j, v1 * A.load(i1,j) );
586 for(
size_t i=(iend>3UL)?(4UL):(1UL); (i+4UL)<=iend; i+=4UL )
588 const size_t i1( element->index() );
591 const size_t i2( element->index() );
594 const size_t i3( element->index() );
597 const size_t i4( element->index() );
601 for(
size_t j=0UL; j<N; j+=
IT::size ) {
602 y.store( j, y.load(j) + v1 * A.load(i1,j) + v2 * A.load(i2,j) + v3 * A.load(i3,j) + v4 * A.load(i4,j) );
605 for( ; element!=
end; ++element )
607 const size_t i1( element->index() );
610 for(
size_t j=0UL; j<N; j+=
IT::size ) {
611 y.store( j, y.load(j) + v1 * A.load(i1,j) );
631 template<
typename VT2 >
660 template<
typename VT2 >
669 if( x.nonZeros() == 0UL )
return;
681 TSVecDMatMultExpr::selectAddAssignKernel( ~lhs, x, A );
699 template<
typename VT1
703 selectAddAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
709 const size_t N( A.columns() );
711 ConstIterator element( x.begin() );
712 const ConstIterator
end( x.end() );
714 for( ; element!=
end; ++element ) {
715 for(
size_t j=0UL; j<N; ++j ) {
716 y[j] += element->value() * A(element->index(),j);
737 template<
typename VT1
740 static inline typename EnableIf< UseOptimizedKernel<VT1,VT2,MT1> >::Type
741 selectAddAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
747 const size_t N( A.columns() );
749 ConstIterator element( x.begin() );
750 const ConstIterator
end( x.end() );
752 const size_t iend( x.nonZeros() & size_t(-4) );
753 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == iend,
"Invalid end calculation" );
755 for(
size_t i=0UL; (i+4UL)<=iend; i+=4UL )
757 const size_t i1( element->index() );
758 const VET v1( element->value() );
760 const size_t i2( element->index() );
761 const VET v2( element->value() );
763 const size_t i3( element->index() );
764 const VET v3( element->value() );
766 const size_t i4( element->index() );
767 const VET v4( element->value() );
770 for(
size_t j=0UL; j<N; ++j ) {
771 y[j] += v1 * A(i1,j) + v2 * A(i2,j) + v3 * A(i3,j) + v4 * A(i4,j);
774 for( ; element!=
end; ++element )
776 const size_t i1( element->index() );
777 const VET v1( element->value() );
779 for(
size_t j=0UL; j<N; ++j ) {
780 y[j] += v1 * A(i1,j);
801 template<
typename VT1
804 static inline typename EnableIf< UseVectorizedKernel<VT1,VT2,MT1> >::Type
805 selectAddAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
807 typedef IntrinsicTrait<ElementType> IT;
812 const size_t N( A.columns() );
814 ConstIterator element( x.begin() );
815 const ConstIterator
end( x.end() );
817 const size_t iend( x.nonZeros() & size_t(-4) );
818 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == iend,
"Invalid end calculation" );
820 for(
size_t i=0UL; (i+4UL)<=iend; i+=4UL )
822 const size_t i1( element->index() );
825 const size_t i2( element->index() );
828 const size_t i3( element->index() );
831 const size_t i4( element->index() );
835 for(
size_t j=0UL; j<N; j+=
IT::size ) {
836 y.store( j, y.load(j) + v1 * A.load(i1,j) + v2 * A.load(i2,j) + v3 * A.load(i3,j) + v4 * A.load(i4,j) );
839 for( ; element!=
end; ++element )
841 const size_t i1( element->index() );
844 for(
size_t j=0UL; j<N; j+=
IT::size ) {
845 y.store( j, y.load(j) + v1 * A.load(i1,j) );
868 template<
typename VT2 >
879 if( x.nonZeros() == 0UL )
return;
891 TSVecDMatMultExpr::selectSubAssignKernel( ~lhs, x, A );
909 template<
typename VT1
913 selectSubAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
919 const size_t N( A.columns() );
921 ConstIterator element( x.begin() );
922 const ConstIterator
end( x.end() );
924 for( ; element!=
end; ++element ) {
925 for(
size_t j=0UL; j<N; ++j ) {
926 y[j] -= element->value() * A(element->index(),j);
947 template<
typename VT1
950 static inline typename EnableIf< UseOptimizedKernel<VT1,VT2,MT1> >::Type
951 selectSubAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
957 const size_t N( A.columns() );
959 ConstIterator element( x.begin() );
960 const ConstIterator
end( x.end() );
962 const size_t iend( x.nonZeros() & size_t(-4) );
963 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == iend,
"Invalid end calculation" );
965 for(
size_t i=0UL; (i+4UL)<=iend; i+=4UL )
967 const size_t i1( element->index() );
968 const VET v1( element->value() );
970 const size_t i2( element->index() );
971 const VET v2( element->value() );
973 const size_t i3( element->index() );
974 const VET v3( element->value() );
976 const size_t i4( element->index() );
977 const VET v4( element->value() );
980 for(
size_t j=0UL; j<N; ++j ) {
981 y[j] -= v1 * A(i1,j) + v2 * A(i2,j) + v3 * A(i3,j) + v4 * A(i4,j);
984 for( ; element!=
end; ++element )
986 const size_t i1( element->index() );
987 const VET v1( element->value() );
989 for(
size_t j=0UL; j<N; ++j ) {
990 y[j] -= v1 * A(i1,j);
1011 template<
typename VT1
1014 static inline typename EnableIf< UseVectorizedKernel<VT1,VT2,MT1> >::Type
1015 selectSubAssignKernel( VT1& y,
const VT2& x,
const MT1& A )
1017 typedef IntrinsicTrait<ElementType> IT;
1022 const size_t N( A.columns() );
1024 ConstIterator element( x.begin() );
1025 const ConstIterator
end( x.end() );
1027 const size_t iend( x.nonZeros() & size_t(-4) );
1028 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == iend,
"Invalid end calculation" );
1030 for(
size_t i=0UL; (i+4UL)<=iend; i+=4UL )
1032 const size_t i1( element->index() );
1035 const size_t i2( element->index() );
1038 const size_t i3( element->index() );
1041 const size_t i4( element->index() );
1045 for(
size_t j=0UL; j<N; j+=
IT::size ) {
1046 y.store( j, y.load(j) - v1 * A.load(i1,j) - v2 * A.load(i2,j) - v3 * A.load(i3,j) - v4 * A.load(i4,j) );
1049 for( ; element!=x.end(); ++element )
1051 const size_t i1( element->index() );
1054 for(
size_t j=0UL; j<N; j+=
IT::size ) {
1055 y.store( j, y.load(j) - v1 * A.load(i1,j) );
1078 template<
typename VT2 >
1113 template<
typename VT2 >
1123 if( x.nonZeros() == 0UL ) {
1158 template<
typename VT2 >
1159 friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
1190 template<
typename VT2 >
1191 friend inline typename EnableIf< UseSMPAssign<VT2> >::Type
1200 if( x.nonZeros() == 0UL )
return;
1234 template<
typename VT2 >
1246 if( x.nonZeros() == 0UL )
return;
1280 template<
typename VT2 >
1353 template<
typename T1,
typename T2 >
1354 inline const typename DisableIf< IsMatMatMultExpr<T2>, TSVecDMatMultExpr<T1,T2> >::Type
1359 if( (~vec).
size() != (~mat).
rows() )
1360 throw std::invalid_argument(
"Vector and matrix sizes do not match" );
1388 template<
typename T1
1391 inline const typename EnableIf< IsMatMatMultExpr<T2>,
typename MultExprTrait<T1,T2>::Type >::Type
1413 template<
typename MT,
typename VT >
1415 :
public Columns<MT>
1431 template<
typename VT,
typename MT,
bool AF >
1436 typedef typename MultExprTrait< VT, typename SubmatrixExprTrait<const MT,AF>::Type >::Type Type;
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
friend void multAssign(DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
Multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ...
Definition: TSVecDMatMultExpr.h:1079
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
TSVecDMatMultExpr< VT, MT > This
Type of this TSVecDMatMultExpr instance.
Definition: TSVecDMatMultExpr.h:183
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSVecDMatMultExpr.h:185
Expression object for transpose sparse vector-dense matrix multiplications.The TSVecDMatMultExpr clas...
Definition: Forward.h:147
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:258
SelectType< evaluateMatrix, const MRT, MCT >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TSVecDMatMultExpr.h:201
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
SelectType< IsExpression< MT >::value, const MT, const MT & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSVecDMatMultExpr.h:195
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TSVecDMatMultExpr.h:236
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:205
VT::ResultType VRT
Result type of the left-hand side sparse vector expression.
Definition: TSVecDMatMultExpr.h:104
#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
Header file for the IsSame and IsStrictlySame type traits.
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
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
VT::CompositeType VCT
Composite type of the left-hand side sparse vector expression.
Definition: TSVecDMatMultExpr.h:108
Header file for the DenseVector base class.
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
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.
IntrinsicTrait< ElementType >::Type IntrinsicType
Resulting intrinsic element type.
Definition: TSVecDMatMultExpr.h:187
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSVecDMatMultExpr.h:322
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSVecDMatMultExpr.h:188
Constraint on the data type.
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
size_t size() const
Returns the current size/dimension of the vector.
Definition: TSVecDMatMultExpr.h:268
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.
friend void addAssign(DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
Addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( )...
Definition: TSVecDMatMultExpr.h:661
Header file for the multiplication trait.
MT::CompositeType MCT
Composite type of the right-hand side dense matrix expression.
Definition: TSVecDMatMultExpr.h:109
LeftOperand leftOperand() const
Returns the left-hand side sparse vector operand.
Definition: TSVecDMatMultExpr.h:278
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2482
TSVecDMatMultExpr(const VT &vec, const MT &mat)
Constructor for the TSVecDMatMultExpr class.
Definition: TSVecDMatMultExpr.h:222
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
Header file for the Columns type trait.
MT::ResultType MRT
Result type of the right-hand side dense matrix expression.
Definition: TSVecDMatMultExpr.h:105
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSVecDMatMultExpr.h:312
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
#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
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: TSVecDMatMultExpr.h:192
Constraints on the storage order of matrix types.
Constraint on the data type.
MRT::ElementType MET
Element type of the right-hand side dense matrix expression.
Definition: TSVecDMatMultExpr.h:107
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.
MultTrait< VRT, MRT >::Type ResultType
Result type for expression template evaluations.
Definition: TSVecDMatMultExpr.h:184
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the serial shim.
friend EnableIf< UseSMPAssign< VT2 > >::Type smpMultAssign(DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
SMP multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vec...
Definition: TSVecDMatMultExpr.h:1282
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
#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, a compilation error is created.
Definition: Symmetric.h:116
Header file for the SubmatrixExprTrait class template.
#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: StorageOrder.h:81
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
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
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSVecDMatMultExpr.h:189
friend EnableIf< UseSMPAssign< VT2 > >::Type smpAddAssign(DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
SMP addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ...
Definition: TSVecDMatMultExpr.h:1192
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
Header file for the reset shim.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSVecDMatMultExpr.h:300
Constraint on the data type.
Compile time check for data types.This type trait tests whether or not the given template parameter i...
Definition: IsBlasCompatible.h:99
SelectType< evaluateVector, const VRT, VCT >::Type LT
Type for the assignment of the left-hand side sparse vector operand.
Definition: TSVecDMatMultExpr.h:198
Header file for the TVecMatMultExpr base class.
Constraint on the data type.
BLAZE_ALWAYS_INLINE void reset(const NonNumericProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: NonNumericProxy.h:833
Header file for the RemoveReference type trait.
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
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/matrix ...
Definition: TVecMatMultExpr.h:166
const size_t SMP_TSVECDMATMULT_THRESHOLD
SMP sparse vector/row-major dense matrix multiplication threshold.This threshold specifies when a spa...
Definition: Thresholds.h:460
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TSVecDMatMultExpr.h:332
RightOperand mat_
Right-hand side dense matrix of the multiplication expression.
Definition: TSVecDMatMultExpr.h:340
LeftOperand vec_
Left-hand side sparse vector of the multiplication expression.
Definition: TSVecDMatMultExpr.h:339
Header file for the IsComputation type trait class.
friend EnableIf< UseSMPAssign< VT2 > >::Type smpSubAssign(DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
SMP subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector...
Definition: TSVecDMatMultExpr.h:1236
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
Header file for basic type definitions.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a row dense or sparse vector type (i...
Definition: TransposeFlag.h:81
Header file for the SubvectorExprTrait class template.
VRT::ElementType VET
Element type of the left-hand side sparse vector expression.
Definition: TSVecDMatMultExpr.h:106
friend void subAssign(DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
Subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( )...
Definition: TSVecDMatMultExpr.h:869
Header file for the IsResizable type trait.
Header file for the Size type trait.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: TSVecDMatMultExpr.h:288
#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
ResultType::ElementType ElementType
Resulting element type.
Definition: TSVecDMatMultExpr.h:186
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.