35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDMATSVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDMATSVECMULTEXPR_H_
94 class TDMatSVecMultExpr :
public DenseVector< TDMatSVecMultExpr<MT,VT>, false >
95 ,
private MatVecMultExpr
124 template<
typename T1,
typename T2,
typename T3 >
125 struct UseSMPAssignKernel {
126 enum { value = evaluateMatrix || evaluateVector };
137 template<
typename T1,
typename T2,
typename T3 >
138 struct UseVectorizedKernel {
139 enum { value = !UseSMPAssignKernel<T1,T2,T3>::value &&
140 T1::vectorizable && T2::vectorizable &&
155 template<
typename T1,
typename T2,
typename T3 >
156 struct UseOptimizedKernel {
157 enum { value = !UseSMPAssignKernel<T1,T2,T3>::value &&
158 !UseVectorizedKernel<T1,T2,T3>::value &&
170 template<
typename T1,
typename T2,
typename T3 >
171 struct UseDefaultKernel {
172 enum { value = !UseSMPAssignKernel<T1,T2,T3>::value &&
173 !UseVectorizedKernel<T1,T2,T3>::value &&
174 !UseOptimizedKernel<T1,T2,T3>::value };
204 enum { vectorizable = MT::vectorizable &&
210 enum { smpAssignable = !evaluateMatrix && !evaluateVector };
242 ConstIterator element( x.begin() );
245 if( element != x.end() ) {
246 res =
mat_( index, element->index() ) * element->value();
248 for( ; element!=x.end(); ++element ) {
249 res +=
mat_( index, element->index() ) * element->value();
296 template<
typename T >
298 return mat_.isAliased( alias ) ||
vec_.isAliased( alias );
308 template<
typename T >
310 return mat_.isAliased( alias ) ||
vec_.isAliased( alias );
320 return mat_.isAligned();
353 template<
typename VT1 >
362 if( x.nonZeros() == 0UL ) {
377 TDMatSVecMultExpr::selectAssignKernel( ~lhs, A, x );
396 template<
typename VT1
400 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
406 const size_t M( A.rows() );
408 ConstIterator element( x.begin() );
409 const ConstIterator end( x.end() );
411 for(
size_t i=0UL; i<M; ++i ) {
412 y[i] = A(i,element->index()) * element->value();
417 for( ; element!=end; ++element ) {
418 for(
size_t i=0UL; i<M; ++i ) {
419 y[i] += A(i,element->index()) * element->value();
440 template<
typename VT1
443 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
444 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
450 const size_t M( A.rows() );
452 ConstIterator element( x.begin() );
453 const ConstIterator end( x.end() );
455 const size_t jend( x.nonZeros() & size_t(-4) );
456 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
460 const size_t j1( element->index() );
461 const VET v1( element->value() );
463 const size_t j2( element->index() );
464 const VET v2( element->value() );
466 const size_t j3( element->index() );
467 const VET v3( element->value() );
469 const size_t j4( element->index() );
470 const VET v4( element->value() );
473 for(
size_t i=0UL; i<M; ++i ) {
474 y[i] = A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
479 const size_t j1( element->index() );
480 const VET v1( element->value() );
483 for(
size_t i=0UL; i<M; ++i ) {
488 for(
size_t j=(jend>3UL)?(4UL):(1UL); (j+4UL)<=jend; j+=4UL )
490 const size_t j1( element->index() );
491 const VET v1( element->value() );
493 const size_t j2( element->index() );
494 const VET v2( element->value() );
496 const size_t j3( element->index() );
497 const VET v3( element->value() );
499 const size_t j4( element->index() );
500 const VET v4( element->value() );
503 for(
size_t i=0UL; i<M; ++i ) {
504 y[i] += A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
507 for( ; element!=end; ++element )
509 const size_t j1( element->index() );
510 const VET v1( element->value() );
512 for(
size_t i=0UL; i<M; ++i ) {
513 y[i] += A(i,j1) * v1;
534 template<
typename VT1
537 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
538 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
540 typedef IntrinsicTrait<ElementType> IT;
545 const size_t M( A.rows() );
547 ConstIterator element( x.begin() );
548 const ConstIterator end( x.end() );
550 const size_t jend( x.nonZeros() & size_t(-4) );
551 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
555 const size_t j1( element->index() );
556 const IntrinsicType v1(
set( element->value() ) );
558 const size_t j2( element->index() );
559 const IntrinsicType v2(
set( element->value() ) );
561 const size_t j3( element->index() );
562 const IntrinsicType v3(
set( element->value() ) );
564 const size_t j4( element->index() );
565 const IntrinsicType v4(
set( element->value() ) );
568 for(
size_t i=0UL; i<M; i+=IT::size ) {
569 y.store( i, A.load(i,j1) * v1 + A.load(i,j2) * v2 + A.load(i,j3) * v3 + A.load(i,j4) * v4 );
574 const size_t j1( element->index() );
575 const IntrinsicType v1(
set( element->value() ) );
578 for(
size_t i=0UL; i<M; i+=IT::size ) {
579 y.store( i, A.load(i,j1) * v1 );
583 for(
size_t j=(jend>3UL)?(4UL):(1UL); (j+4UL)<=jend; j+=4UL )
585 const size_t j1( element->index() );
586 const IntrinsicType v1(
set( element->value() ) );
588 const size_t j2( element->index() );
589 const IntrinsicType v2(
set( element->value() ) );
591 const size_t j3( element->index() );
592 const IntrinsicType v3(
set( element->value() ) );
594 const size_t j4( element->index() );
595 const IntrinsicType v4(
set( element->value() ) );
598 for(
size_t i=0UL; i<M; i+=IT::size ) {
599 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 );
602 for( ; element!=end; ++element )
604 const size_t j1( element->index() );
605 const IntrinsicType v1(
set( element->value() ) );
607 for(
size_t i=0UL; i<M; i+=IT::size ) {
608 y.store( i, y.load(i) + A.load(i,j1) * v1 );
629 template<
typename VT1
632 static inline typename EnableIf< UseSMPAssignKernel<VT1,MT1,VT2> >::Type
633 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
653 template<
typename VT1 >
664 const ResultType tmp( rhs );
683 template<
typename VT1 >
694 if( x.nonZeros() == 0UL )
return;
706 TDMatSVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
725 template<
typename VT1
728 static inline typename EnableIf< UseDefaultKernel<VT1,MT1,VT2> >::Type
729 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
735 const size_t M( A.rows() );
737 ConstIterator element( x.begin() );
738 const ConstIterator end( x.end() );
740 for( ; element!=end; ++element ) {
741 for(
size_t i=0UL; i<M; ++i ) {
742 y[i] += A(i,element->index()) * element->value();
763 template<
typename VT1
766 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
767 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
773 const size_t M( A.rows() );
775 ConstIterator element( x.begin() );
776 const ConstIterator end( x.end() );
778 const size_t jend( x.nonZeros() & size_t(-4) );
779 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
781 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
783 const size_t j1( element->index() );
784 const VET v1( element->value() );
786 const size_t j2( element->index() );
787 const VET v2( element->value() );
789 const size_t j3( element->index() );
790 const VET v3( element->value() );
792 const size_t j4( element->index() );
793 const VET v4( element->value() );
796 for(
size_t i=0UL; i<M; ++i ) {
797 y[i] += A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
800 for( ; element!=end; ++element )
802 const size_t j1( element->index() );
803 const VET v1( element->value() );
805 for(
size_t i=0UL; i<M; ++i ) {
806 y[i] += A(i,j1) * v1;
827 template<
typename VT1
830 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
831 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
833 typedef IntrinsicTrait<ElementType> IT;
838 const size_t M( A.rows() );
840 ConstIterator element( x.begin() );
841 const ConstIterator end( x.end() );
843 const size_t jend( x.nonZeros() & size_t(-4) );
844 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
846 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
848 const size_t j1( element->index() );
849 const IntrinsicType v1(
set( element->value() ) );
851 const size_t j2( element->index() );
852 const IntrinsicType v2(
set( element->value() ) );
854 const size_t j3( element->index() );
855 const IntrinsicType v3(
set( element->value() ) );
857 const size_t j4( element->index() );
858 const IntrinsicType v4(
set( element->value() ) );
861 for(
size_t i=0UL; i<M; i+=IT::size ) {
862 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 );
865 for( ; element!=end; ++element )
867 const size_t j1( element->index() );
868 const IntrinsicType v1(
set( element->value() ) );
870 for(
size_t i=0UL; i<M; i+=IT::size ) {
871 y.store( i, y.load(i) + A.load(i,j1) * v1 );
892 template<
typename VT1
895 static inline typename EnableIf< UseSMPAssignKernel<VT1,MT1,VT2> >::Type
896 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
920 template<
typename VT1 >
931 if( x.nonZeros() == 0UL )
return;
943 TDMatSVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
962 template<
typename VT1
965 static inline typename EnableIf< UseDefaultKernel<VT1,MT1,VT2> >::Type
966 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
972 const size_t M( A.rows() );
974 ConstIterator element( x.begin() );
975 const ConstIterator end( x.end() );
977 for( ; element!=end; ++element ) {
978 for(
size_t i=0UL; i<M; ++i ) {
979 y[i] -= A(i,element->index()) * element->value();
1000 template<
typename VT1
1003 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
1004 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
1010 const size_t M( A.rows() );
1012 ConstIterator element( x.begin() );
1013 const ConstIterator end( x.end() );
1015 const size_t jend( x.nonZeros() & size_t(-4) );
1016 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
1018 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
1020 const size_t j1( element->index() );
1021 const VET v1( element->value() );
1023 const size_t j2( element->index() );
1024 const VET v2( element->value() );
1026 const size_t j3( element->index() );
1027 const VET v3( element->value() );
1029 const size_t j4( element->index() );
1030 const VET v4( element->value() );
1033 for(
size_t i=0UL; i<M; ++i ) {
1034 y[i] -= A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
1037 for( ; element!=end; ++element )
1039 const size_t j1( element->index() );
1040 const VET v1( element->value() );
1042 for(
size_t i=0UL; i<M; ++i ) {
1043 y[i] -= A(i,j1) * v1;
1064 template<
typename VT1
1067 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
1068 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
1070 typedef IntrinsicTrait<ElementType> IT;
1075 const size_t M( A.rows() );
1077 ConstIterator element( x.begin() );
1078 const ConstIterator end( x.end() );
1080 const size_t jend( x.nonZeros() & size_t(-4) );
1081 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
1083 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
1085 const size_t j1( element->index() );
1086 const IntrinsicType v1(
set( element->value() ) );
1088 const size_t j2( element->index() );
1089 const IntrinsicType v2(
set( element->value() ) );
1091 const size_t j3( element->index() );
1092 const IntrinsicType v3(
set( element->value() ) );
1094 const size_t j4( element->index() );
1095 const IntrinsicType v4(
set( element->value() ) );
1098 for(
size_t i=0UL; i<M; i+=IT::size ) {
1099 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 );
1102 for( ; element!=end; ++element )
1104 const size_t j1( element->index() );
1105 const IntrinsicType v1(
set( element->value() ) );
1107 for(
size_t i=0UL; i<M; i+=IT::size ) {
1108 y.store( i, y.load(i) - A.load(i,j1) * v1 );
1129 template<
typename VT1
1132 static inline typename EnableIf< UseSMPAssignKernel<VT1,MT1,VT2> >::Type
1133 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
1157 template<
typename VT1 >
1168 const ResultType tmp( rhs );
1230 template<
typename T1
1232 inline const typename DisableIf< IsMatMatMultExpr<T1>, TDMatSVecMultExpr<T1,T2> >::Type
1238 throw std::invalid_argument(
"Matrix and vector sizes do not match" );
1255 template<
typename MT,
typename VT,
bool AF >
1260 typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type, VT >::Type Type;
ResultType::ElementType ElementType
Resulting element type.
Definition: TDMatSVecMultExpr.h:184
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:265
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4579
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:4075
VT::ResultType VRT
Result type of the right-hand side sparse vector expression.
Definition: TDMatSVecMultExpr.h:101
void smpSubAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:151
#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:197
#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
void smpMultAssign(DenseVector< 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:178
RightOperand vec_
Right-hand side sparse vector of the multiplication expression.
Definition: TDMatSVecMultExpr.h:337
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:103
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TDMatSVecMultExpr.h:319
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
const size_t SMP_TDMATSVECMULT_THRESHOLD
SMP column-major dense matrix/sparse vector multiplication threshold.This threshold represents the sy...
Definition: Thresholds.h:204
Header file for the DenseVector base class.
MRT::ElementType MET
Element type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:102
TDMatSVecMultExpr< MT, VT > This
Type of this TDMatSVecMultExpr instance.
Definition: TDMatSVecMultExpr.h:181
MultTrait< MRT, VRT >::Type ResultType
Result type for expression template evaluations.
Definition: TDMatSVecMultExpr.h:182
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:193
Constraint on the data type.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TDMatSVecMultExpr.h:233
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSVecMultExpr.h:309
Constraint on the data type.
Header file for the MultExprTrait class template.
void smpAddAssign(DenseMatrix< 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:121
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:251
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:186
Header file for the dense vector SMP implementation.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TDMatSVecMultExpr.h:329
#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:2388
Header file for the IsMatMatMultExpr type trait class.
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:179
LeftOperand mat_
Left-hand side dense matrix of the multiplication expression.
Definition: TDMatSVecMultExpr.h:336
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:185
#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
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSVecMultExpr.h:187
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:219
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2382
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:269
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
void smpAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:91
SelectType< evaluateVector, const VRT, typename VT::CompositeType >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TDMatSVecMultExpr.h:199
Expression object for transpose dense matrix-sparse vector multiplications.The TDMatSVecMultExpr clas...
Definition: Forward.h:126
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
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:748
LeftOperand leftOperand() const
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSVecMultExpr.h:275
Header file for run time assertion macros.
Base template for the MultTrait class.
Definition: MultTrait.h:141
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:209
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:105
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
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:239
MT::ResultType MRT
Result type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:100
SelectType< evaluateMatrix, const MRT, MCT >::Type LT
Type for the assignment of the left-hand side dense matrix operand.
Definition: TDMatSVecMultExpr.h:196
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:297
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:285
Header file for the IsComputation type trait class.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSVecMultExpr.h:183
Header file for the sparse vector SMP implementation.
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:105
#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:2379
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
Header file for basic type definitions.
Header file for the SubvectorExprTrait class template.
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:190
Header file for the IsResizable 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
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:209
MT::CompositeType MCT
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:104
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.