35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDMATSVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDMATSVECMULTEXPR_H_
93 class TDMatSVecMultExpr :
public DenseVector< TDMatSVecMultExpr<MT,VT>, false >
94 ,
private MatVecMultExpr
124 template<
typename T1 >
125 struct UseSMPAssign {
126 enum { value = ( evaluateMatrix || evaluateVector ) };
137 template<
typename T1,
typename T2,
typename T3 >
138 struct UseVectorizedKernel {
139 enum { value = T1::vectorizable && T2::vectorizable &&
154 template<
typename T1,
typename T2,
typename T3 >
155 struct UseOptimizedKernel {
156 enum { value = !UseVectorizedKernel<T1,T2,T3>::value &&
168 template<
typename T1,
typename T2,
typename T3 >
169 struct UseDefaultKernel {
170 enum { value = !UseVectorizedKernel<T1,T2,T3>::value &&
171 !UseOptimizedKernel<T1,T2,T3>::value };
201 enum { vectorizable = MT::vectorizable &&
207 enum { smpAssignable = !evaluateMatrix && MT::smpAssignable &&
208 !evaluateVector && VT::smpAssignable };
240 ConstIterator element( x.begin() );
243 if( element != x.end() ) {
244 res =
mat_( index, element->index() ) * element->value();
246 for( ; element!=x.end(); ++element ) {
247 res +=
mat_( index, element->index() ) * element->value();
294 template<
typename T >
296 return mat_.isAliased( alias ) ||
vec_.isAliased( alias );
306 template<
typename T >
308 return mat_.isAliased( alias ) ||
vec_.isAliased( alias );
318 return mat_.isAligned();
351 template<
typename VT1 >
360 if( x.nonZeros() == 0UL ) {
375 TDMatSVecMultExpr::selectAssignKernel( ~lhs, A, x );
394 template<
typename VT1
398 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
404 const size_t M( A.rows() );
406 ConstIterator element( x.begin() );
407 const ConstIterator end( x.end() );
409 for(
size_t i=0UL; i<M; ++i ) {
410 y[i] = A(i,element->index()) * element->value();
415 for( ; element!=end; ++element ) {
416 for(
size_t i=0UL; i<M; ++i ) {
417 y[i] += A(i,element->index()) * element->value();
438 template<
typename VT1
441 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
442 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
448 const size_t M( A.rows() );
450 ConstIterator element( x.begin() );
451 const ConstIterator end( x.end() );
453 const size_t jend( x.nonZeros() & size_t(-4) );
454 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
458 const size_t j1( element->index() );
459 const VET v1( element->value() );
461 const size_t j2( element->index() );
462 const VET v2( element->value() );
464 const size_t j3( element->index() );
465 const VET v3( element->value() );
467 const size_t j4( element->index() );
468 const VET v4( element->value() );
471 for(
size_t i=0UL; i<M; ++i ) {
472 y[i] = A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
477 const size_t j1( element->index() );
478 const VET v1( element->value() );
481 for(
size_t i=0UL; i<M; ++i ) {
486 for(
size_t j=(jend>3UL)?(4UL):(1UL); (j+4UL)<=jend; j+=4UL )
488 const size_t j1( element->index() );
489 const VET v1( element->value() );
491 const size_t j2( element->index() );
492 const VET v2( element->value() );
494 const size_t j3( element->index() );
495 const VET v3( element->value() );
497 const size_t j4( element->index() );
498 const VET v4( element->value() );
501 for(
size_t i=0UL; i<M; ++i ) {
502 y[i] += A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
505 for( ; element!=end; ++element )
507 const size_t j1( element->index() );
508 const VET v1( element->value() );
510 for(
size_t i=0UL; i<M; ++i ) {
511 y[i] += A(i,j1) * v1;
532 template<
typename VT1
535 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
536 selectAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
538 typedef IntrinsicTrait<ElementType> IT;
543 const size_t M( A.rows() );
545 ConstIterator element( x.begin() );
546 const ConstIterator end( x.end() );
548 const size_t jend( x.nonZeros() & size_t(-4) );
549 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
553 const size_t j1( element->index() );
556 const size_t j2( element->index() );
559 const size_t j3( element->index() );
562 const size_t j4( element->index() );
566 for(
size_t i=0UL; i<M; i+=IT::size ) {
567 y.store( i, A.load(i,j1) * v1 + A.load(i,j2) * v2 + A.load(i,j3) * v3 + A.load(i,j4) * v4 );
572 const size_t j1( element->index() );
576 for(
size_t i=0UL; i<M; i+=IT::size ) {
577 y.store( i, A.load(i,j1) * v1 );
581 for(
size_t j=(jend>3UL)?(4UL):(1UL); (j+4UL)<=jend; j+=4UL )
583 const size_t j1( element->index() );
586 const size_t j2( element->index() );
589 const size_t j3( element->index() );
592 const size_t j4( element->index() );
596 for(
size_t i=0UL; i<M; i+=IT::size ) {
597 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 );
600 for( ; element!=end; ++element )
602 const size_t j1( element->index() );
605 for(
size_t i=0UL; i<M; i+=IT::size ) {
606 y.store( i, y.load(i) + A.load(i,j1) * v1 );
626 template<
typename VT1 >
656 template<
typename VT1 >
667 if( x.nonZeros() == 0UL )
return;
679 TDMatSVecMultExpr::selectAddAssignKernel( ~lhs, A, x );
698 template<
typename VT1
701 static inline typename EnableIf< UseDefaultKernel<VT1,MT1,VT2> >::Type
702 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
708 const size_t M( A.rows() );
710 ConstIterator element( x.begin() );
711 const ConstIterator end( x.end() );
713 for( ; element!=end; ++element ) {
714 for(
size_t i=0UL; i<M; ++i ) {
715 y[i] += A(i,element->index()) * element->value();
736 template<
typename VT1
739 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
740 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
746 const size_t M( A.rows() );
748 ConstIterator element( x.begin() );
749 const ConstIterator end( x.end() );
751 const size_t jend( x.nonZeros() & size_t(-4) );
752 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
754 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
756 const size_t j1( element->index() );
757 const VET v1( element->value() );
759 const size_t j2( element->index() );
760 const VET v2( element->value() );
762 const size_t j3( element->index() );
763 const VET v3( element->value() );
765 const size_t j4( element->index() );
766 const VET v4( element->value() );
769 for(
size_t i=0UL; i<M; ++i ) {
770 y[i] += A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
773 for( ; element!=end; ++element )
775 const size_t j1( element->index() );
776 const VET v1( element->value() );
778 for(
size_t i=0UL; i<M; ++i ) {
779 y[i] += A(i,j1) * v1;
800 template<
typename VT1
803 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
804 selectAddAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
806 typedef IntrinsicTrait<ElementType> IT;
811 const size_t M( A.rows() );
813 ConstIterator element( x.begin() );
814 const ConstIterator end( x.end() );
816 const size_t jend( x.nonZeros() & size_t(-4) );
817 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
819 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
821 const size_t j1( element->index() );
824 const size_t j2( element->index() );
827 const size_t j3( element->index() );
830 const size_t j4( element->index() );
834 for(
size_t i=0UL; i<M; i+=IT::size ) {
835 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 );
838 for( ; element!=end; ++element )
840 const size_t j1( element->index() );
843 for(
size_t i=0UL; i<M; i+=IT::size ) {
844 y.store( i, y.load(i) + A.load(i,j1) * v1 );
868 template<
typename VT1 >
879 if( x.nonZeros() == 0UL )
return;
891 TDMatSVecMultExpr::selectSubAssignKernel( ~lhs, A, x );
910 template<
typename VT1
913 static inline typename EnableIf< UseDefaultKernel<VT1,MT1,VT2> >::Type
914 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
920 const size_t M( A.rows() );
922 ConstIterator element( x.begin() );
923 const ConstIterator end( x.end() );
925 for( ; element!=end; ++element ) {
926 for(
size_t i=0UL; i<M; ++i ) {
927 y[i] -= A(i,element->index()) * element->value();
948 template<
typename VT1
951 static inline typename EnableIf< UseOptimizedKernel<VT1,MT1,VT2> >::Type
952 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
958 const size_t M( A.rows() );
960 ConstIterator element( x.begin() );
961 const ConstIterator end( x.end() );
963 const size_t jend( x.nonZeros() & size_t(-4) );
964 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
966 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
968 const size_t j1( element->index() );
969 const VET v1( element->value() );
971 const size_t j2( element->index() );
972 const VET v2( element->value() );
974 const size_t j3( element->index() );
975 const VET v3( element->value() );
977 const size_t j4( element->index() );
978 const VET v4( element->value() );
981 for(
size_t i=0UL; i<M; ++i ) {
982 y[i] -= A(i,j1) * v1 + A(i,j2) * v2 + A(i,j3) * v3 + A(i,j4) * v4;
985 for( ; element!=end; ++element )
987 const size_t j1( element->index() );
988 const VET v1( element->value() );
990 for(
size_t i=0UL; i<M; ++i ) {
991 y[i] -= A(i,j1) * v1;
1012 template<
typename VT1
1015 static inline typename EnableIf< UseVectorizedKernel<VT1,MT1,VT2> >::Type
1016 selectSubAssignKernel( VT1& y,
const MT1& A,
const VT2& x )
1018 typedef IntrinsicTrait<ElementType> IT;
1023 const size_t M( A.rows() );
1025 ConstIterator element( x.begin() );
1026 const ConstIterator end( x.end() );
1028 const size_t jend( x.nonZeros() & size_t(-4) );
1029 BLAZE_INTERNAL_ASSERT( ( x.nonZeros() - ( x.nonZeros() % 4UL ) ) == jend,
"Invalid end calculation" );
1031 for(
size_t j=0UL; (j+4UL)<=jend; j+=4UL )
1033 const size_t j1( element->index() );
1036 const size_t j2( element->index() );
1039 const size_t j3( element->index() );
1042 const size_t j4( element->index() );
1046 for(
size_t i=0UL; i<M; i+=IT::size ) {
1047 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 );
1050 for( ; element!=end; ++element )
1052 const size_t j1( element->index() );
1055 for(
size_t i=0UL; i<M; i+=IT::size ) {
1056 y.store( i, y.load(i) - A.load(i,j1) * v1 );
1080 template<
typename VT1 >
1116 template<
typename VT1 >
1117 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1126 if( x.nonZeros() == 0UL ) {
1161 template<
typename VT1 >
1162 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1194 template<
typename VT1 >
1195 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1206 if( x.nonZeros() == 0UL )
return;
1242 template<
typename VT1 >
1243 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1254 if( x.nonZeros() == 0UL )
return;
1290 template<
typename VT1 >
1291 friend inline typename EnableIf< UseSMPAssign<VT1> >::Type
1364 template<
typename T1
1366 inline const typename DisableIf< IsMatMatMultExpr<T1>, TDMatSVecMultExpr<T1,T2> >::Type
1372 throw std::invalid_argument(
"Matrix and vector sizes do not match" );
1389 template<
typename MT,
typename VT,
bool AF >
1394 typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT,AF>::Type, VT >::Type Type;
ResultType::ElementType ElementType
Resulting element type.
Definition: TDMatSVecMultExpr.h:181
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:263
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4599
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:4329
VT::ResultType VRT
Result type of the right-hand side sparse vector expression.
Definition: TDMatSVecMultExpr.h:100
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:152
#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:199
#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:179
RightOperand vec_
Right-hand side sparse vector of the multiplication expression.
Definition: TDMatSVecMultExpr.h:335
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:102
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: TDMatSVecMultExpr.h:317
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:2408
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:251
Header file for the DenseVector base class.
MRT::ElementType MET
Element type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:101
TDMatSVecMultExpr< MT, VT > This
Type of this TDMatSVecMultExpr instance.
Definition: TDMatSVecMultExpr.h:178
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:690
MultTrait< MRT, VRT >::Type ResultType
Result type for expression template evaluations.
Definition: TDMatSVecMultExpr.h:179
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:190
Constraint on the data type.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: TDMatSVecMultExpr.h:231
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSVecMultExpr.h:307
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:122
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:253
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:183
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: TDMatSVecMultExpr.h:327
#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:2412
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:271
LeftOperand mat_
Left-hand side dense matrix of the multiplication expression.
Definition: TDMatSVecMultExpr.h:334
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:182
#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:184
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:217
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2406
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:361
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 serial shim.
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:92
SelectType< evaluateVector, const VRT, typename VT::CompositeType >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TDMatSVecMultExpr.h:196
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
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:273
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:301
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:104
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:331
MT::ResultType MRT
Result type of the left-hand side dense matrix expression.
Definition: TDMatSVecMultExpr.h:99
SelectType< evaluateMatrix, const MRT, MCT >::Type LT
Type for the assignment of the left-hand side dense matrix operand.
Definition: TDMatSVecMultExpr.h:193
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:295
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:283
Header file for the IsComputation type trait class.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSVecMultExpr.h:180
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:2403
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:170
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:187
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:103
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.