35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECTDVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECTDVECMULTEXPR_H_
107 template<
typename VT1
142 enum :
bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
156 enum :
bool { useAssign = ( evaluateLeft || evaluateRight ) };
159 template<
typename VT >
162 enum :
bool { value = useAssign };
173 template<
typename VT >
174 struct UseSMPAssign {
175 enum :
bool { value = evaluateRight };
185 template<
typename T1,
typename T2,
typename T3 >
186 struct UseVectorizedKernel {
188 T1::simdEnabled && T2::simdEnabled && T3::simdEnabled &&
202 template<
typename T1,
typename T2,
typename T3 >
203 struct UseDefaultKernel {
204 enum :
bool { value = !UseVectorizedKernel<T1,T2,T3>::value };
270 explicit inline ConstIterator( LeftIteratorType left, RightIteratorType right )
348 return (*
left_) * (*right_);
357 inline auto load() const noexcept {
485 enum :
bool { simdEnabled = VT1::simdEnabled && VT2::simdEnabled &&
489 enum :
bool { smpAssignable = VT1::smpAssignable && !evaluateRight };
532 inline ReturnType
at(
size_t i,
size_t j )
const {
533 if( i >=
lhs_.size() ) {
536 if( j >=
rhs_.size() ) {
587 inline size_t rows() const noexcept {
628 template<
typename T >
629 inline bool canAlias(
const T* alias )
const noexcept {
630 return (
lhs_.canAlias( alias ) ||
rhs_.canAlias( alias ) );
640 template<
typename T >
641 inline bool isAliased(
const T* alias )
const noexcept {
642 return (
lhs_.isAliased( alias ) ||
rhs_.isAliased( alias ) );
652 return lhs_.isAligned() &&
rhs_.isAligned();
662 return (
rows() *
columns() >= SMP_DVECTDVECMULT_THRESHOLD );
686 template<
typename MT >
703 DVecTDVecMultExpr::selectAssignKernel( ~lhs, x, y );
722 template<
typename MT
728 const size_t M( (~A).
rows() );
729 const size_t N( (~A).
columns() );
731 const size_t jpos( N &
size_t(-2) );
734 for(
size_t i=0UL; i<M; ++i ) {
735 for(
size_t j=0UL; j<jpos; j+=2UL ) {
736 (~A)(i,j ) = x[i] * y[j ];
737 (~A)(i,j+1UL) = x[i] * y[j+1];
740 (~A)(i,jpos) = x[i] * y[jpos];
761 template<
typename MT
764 static inline EnableIf_< UseVectorizedKernel<MT,VT3,VT4> >
765 selectAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
767 const size_t M( (~A).
rows() );
768 const size_t N( (~A).
columns() );
770 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT4>::value );
772 const size_t jpos( remainder ? ( N &
size_t(-SIMDSIZE) ) : N );
775 for(
size_t i=0UL; i<M; ++i )
777 const SIMDType x1(
set( x[i] ) );
781 for( ; j<jpos; j+=SIMDSIZE ) {
782 (~A).store( i, j, x1 * y.load(j) );
784 for( ; remainder && j<N; ++j ) {
785 (~A)(i,j) = x[i] * y[j];
804 template<
typename MT >
805 friend inline void assign( DenseMatrix<MT,true>& lhs,
const DVecTDVecMultExpr& rhs )
814 LT x(
serial( rhs.lhs_ ) );
815 RT y(
serial( rhs.rhs_ ) );
822 DVecTDVecMultExpr::selectAssignKernel( ~lhs, x, y );
841 template<
typename MT
844 static inline EnableIf_< UseDefaultKernel<MT,VT3,VT4> >
845 selectAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
847 const size_t M( (~A).
rows() );
848 const size_t N( (~A).
columns() );
850 const size_t ipos( M &
size_t(-2) );
853 for(
size_t j=0UL; j<N; ++j ) {
854 for(
size_t i=0UL; i<ipos; i+=2UL ) {
855 (~A)(i ,j) = x[i ] * y[j];
856 (~A)(i+1UL,j) = x[i+1] * y[j];
859 (~A)(ipos,j) = x[ipos] * y[j];
880 template<
typename MT
883 static inline EnableIf_< UseVectorizedKernel<MT,VT3,VT4> >
884 selectAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
886 const size_t M( (~A).
rows() );
887 const size_t N( (~A).
columns() );
889 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT3>::value );
891 const size_t ipos( remainder ? ( M &
size_t(-SIMDSIZE) ) : M );
894 for(
size_t j=0UL; j<N; ++j )
896 const SIMDType y1(
set( y[j] ) );
900 for( ; i<ipos; i+=SIMDSIZE ) {
901 (~A).store( i, j, x.load(i) * y1 );
903 for( ; remainder && i<M; ++i ) {
904 (~A)(i,j) = x[i] * y[j];
923 template<
typename MT
925 friend inline void assign( SparseMatrix<MT,SO>& lhs,
const DVecTDVecMultExpr& rhs )
929 typedef IfTrue_< SO, OppositeType, ResultType > TmpType;
941 const TmpType tmp(
serial( rhs ) );
962 template<
typename MT >
963 friend inline EnableIf_< UseAssign<MT> >
971 LT x(
serial( rhs.lhs_ ) );
972 RT y(
serial( rhs.rhs_ ) );
979 DVecTDVecMultExpr::selectAddAssignKernel( ~lhs, x, y );
998 template<
typename MT
1001 static inline EnableIf_< UseDefaultKernel<MT,VT3,VT4> >
1002 selectAddAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1004 const size_t M( (~A).
rows() );
1005 const size_t N( (~A).
columns() );
1007 const size_t jpos( N &
size_t(-2) );
1010 for(
size_t i=0UL; i<M; ++i ) {
1011 for(
size_t j=0UL; j<jpos; j+=2UL ) {
1012 (~A)(i,j ) += x[i] * y[j ];
1013 (~A)(i,j+1UL) += x[i] * y[j+1UL];
1016 (~A)(i,jpos) += x[i] * y[jpos];
1037 template<
typename MT
1040 static inline EnableIf_< UseVectorizedKernel<MT,VT3,VT4> >
1041 selectAddAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1043 const size_t M( (~A).
rows() );
1044 const size_t N( (~A).
columns() );
1046 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT4>::value );
1048 const size_t jpos( remainder ? ( N &
size_t(-SIMDSIZE) ) : N );
1051 for(
size_t i=0UL; i<M; ++i )
1053 const SIMDType x1(
set( x[i] ) );
1057 for( ; j<jpos; j+=SIMDSIZE ) {
1058 (~A).store( i, j, (~A).load(i,j) + x1 * y.load(j) );
1060 for( ; remainder && j<N; ++j ) {
1061 (~A)(i,j) += x[i] * y[j];
1081 template<
typename MT >
1082 friend inline void addAssign( DenseMatrix<MT,true>& lhs,
const DVecTDVecMultExpr& rhs )
1091 LT x(
serial( rhs.lhs_ ) );
1092 RT y(
serial( rhs.rhs_ ) );
1099 DVecTDVecMultExpr::selectAddAssignKernel( ~lhs, x, y );
1118 template<
typename MT
1121 static inline EnableIf_< UseDefaultKernel<MT,VT3,VT4> >
1122 selectAddAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1124 const size_t M( (~A).
rows() );
1125 const size_t N( (~A).
columns() );
1127 const size_t ipos( M &
size_t(-2) );
1130 for(
size_t j=0UL; j<N; ++j ) {
1131 for(
size_t i=0UL; i<ipos; i+=2UL ) {
1132 (~A)(i ,j) += x[i ] * y[j];
1133 (~A)(i+1UL,j) += x[i+1UL] * y[j];
1136 (~A)(ipos,j) += x[ipos] * y[j];
1157 template<
typename MT
1160 static inline EnableIf_< UseVectorizedKernel<MT,VT3,VT4> >
1161 selectAddAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1163 const size_t M( (~A).
rows() );
1164 const size_t N( (~A).
columns() );
1166 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT3>::value );
1168 const size_t ipos( remainder ? ( M &
size_t(-SIMDSIZE) ) : M );
1171 for(
size_t j=0UL; j<N; ++j )
1173 const SIMDType y1(
set( y[j] ) );
1177 for( ; i<ipos; i+=SIMDSIZE ) {
1178 (~A).store( i, j, (~A).load(i,j) + x.load(i) * y1 );
1180 for( ; remainder && i<M; ++i ) {
1181 (~A)(i,j) += x[i] * y[j];
1207 template<
typename MT >
1208 friend inline EnableIf_< UseAssign<MT> >
1216 LT x(
serial( rhs.lhs_ ) );
1217 RT y(
serial( rhs.rhs_ ) );
1224 DVecTDVecMultExpr::selectSubAssignKernel( ~lhs, x, y );
1243 template<
typename MT
1246 static inline EnableIf_< UseDefaultKernel<MT,VT3,VT4> >
1247 selectSubAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1249 const size_t M( (~A).
rows() );
1250 const size_t N( (~A).
columns() );
1252 const size_t jpos( N &
size_t(-2) );
1255 for(
size_t i=0UL; i<M; ++i ) {
1256 for(
size_t j=0UL; j<jpos; j+=2UL ) {
1257 (~A)(i,j ) -= x[i] * y[j ];
1258 (~A)(i,j+1UL) -= x[i] * y[j+1UL];
1261 (~A)(i,jpos) -= x[i] * y[jpos];
1282 template<
typename MT
1285 static inline EnableIf_< UseVectorizedKernel<MT,VT3,VT4> >
1286 selectSubAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1288 const size_t M( (~A).
rows() );
1289 const size_t N( (~A).
columns() );
1291 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT4>::value );
1293 const size_t jpos( remainder ? ( N &
size_t(-SIMDSIZE) ) : N );
1296 for(
size_t i=0UL; i<M; ++i )
1298 const SIMDType x1(
set( x[i] ) );
1302 for( ; j<jpos; j+=SIMDSIZE ) {
1303 (~A).store( i, j, (~A).load(i,j) - x1 * y.load(j) );
1305 for( ; remainder && j<N; ++j ) {
1306 (~A)(i,j) -= x[i] * y[j];
1326 template<
typename MT >
1327 friend inline void subAssign( DenseMatrix<MT,true>& lhs,
const DVecTDVecMultExpr& rhs )
1336 LT x(
serial( rhs.lhs_ ) );
1337 RT y(
serial( rhs.rhs_ ) );
1344 DVecTDVecMultExpr::selectSubAssignKernel( ~lhs, x, y );
1363 template<
typename MT
1366 static inline EnableIf_< UseDefaultKernel<MT,VT3,VT4> >
1367 selectSubAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1369 const size_t M( (~A).
rows() );
1370 const size_t N( (~A).
columns() );
1372 const size_t ipos( M &
size_t(-2) );
1375 for(
size_t j=0UL; j<N; ++j ) {
1376 for(
size_t i=0UL; i<ipos; i+=2UL ) {
1377 (~A)(i ,j) -= x[i ] * y[j];
1378 (~A)(i+1UL,j) -= x[i+1UL] * y[j];
1381 (~A)(ipos,j) -= x[ipos] * y[j];
1402 template<
typename MT
1405 static inline EnableIf_< UseVectorizedKernel<MT,VT3,VT4> >
1406 selectSubAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1408 const size_t M( (~A).
rows() );
1409 const size_t N( (~A).
columns() );
1411 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT3>::value );
1413 const size_t ipos( remainder ? ( M &
size_t(-SIMDSIZE) ) : M );
1416 for(
size_t j=0UL; j<N; ++j )
1418 const SIMDType y1(
set( y[j] ) );
1422 for( ; i<ipos; i+=SIMDSIZE ) {
1423 (~A).store( i, j, (~A).load(i,j) - x.load(i) * y1 );
1425 for( ; remainder && i<M; ++i ) {
1426 (~A)(i,j) -= x[i] * y[j];
1459 template<
typename MT
1461 friend inline EnableIf_< UseSMPAssign<MT> >
1496 template<
typename MT
1498 friend inline EnableIf_< UseSMPAssign<MT> >
1503 typedef IfTrue_< SO, OppositeType, ResultType > TmpType;
1515 const TmpType tmp( rhs );
1535 template<
typename MT >
1536 friend inline EnableIf_< UseSMPAssign<MT> >
1576 template<
typename MT >
1577 friend inline EnableIf_< UseSMPAssign<MT> >
1658 template<
typename T1
1660 inline const DVecTDVecMultExpr<T1,T2>
1680 template<
typename VT1,
typename VT2 >
1697 template<
typename VT1,
typename VT2 >
1714 template<
typename VT1,
typename VT2 >
1716 :
public BoolConstant< And< IsAligned<VT1>, IsAligned<VT2> >::value >
1732 template<
typename VT1,
typename VT2 >
1750 template<
typename VT1,
typename VT2,
bool AF >
1755 using Type = MultExprTrait_< SubvectorExprTrait_<const VT1,AF>
1756 , SubvectorExprTrait_<const VT2,AF> >;
1765 template<
typename VT1,
typename VT2 >
1770 using Type = MultExprTrait_< ReturnType_<VT1>, VT2 >;
1779 template<
typename VT1,
typename VT2 >
1784 using Type = MultExprTrait_< VT1, ReturnType_<VT2> >;
IfTrue_< evaluateRight, const RT2, CT2 > RT
Type for the assignment of the right-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:234
Pointer difference type of the Blaze library.
Header file for auxiliary alias declarations.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
constexpr bool useOptimizedKernels
Configuration switch for optimized kernels.This configuration switch enables/disables all optimized c...
Definition: Optimizations.h:84
DVecTDVecMultExpr< VT1, VT2 > This
Type of this DVecTDVecMultExpr instance.
Definition: DVecTDVecMultExpr.h:211
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DVecTDVecMultExpr.h:248
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:7800
Header file for basic type definitions.
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:607
MultExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: DVecTDVecMultExpr.h:145
auto load() const noexcept
Access to the SIMD elements of the matrix.
Definition: DVecTDVecMultExpr.h:357
const ConstIterator operator++(int)
Post-increment operator.
Definition: DVecTDVecMultExpr.h:316
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a column dense or sparse vector type...
Definition: ColumnVector.h:61
EnableIf_< IsDenseMatrix< MT1 > > 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
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DVecTDVecMultExpr.h:641
Header file for the serial shim.
ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DVecTDVecMultExpr.h:294
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:258
ResultType_< VT1 > RT1
Result type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:115
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: DVecTDVecMultExpr.h:576
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DVecTDVecMultExpr.h:470
#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:61
Header file for the ColumnExprTrait class template.
Availability of a SIMD multiplication for the given data types.Depending on the available instruction...
Definition: HasSIMDMult.h:162
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DVecTDVecMultExpr.h:434
typename SIMDTrait< T >::Type SIMDTrait_
Auxiliary alias declaration for the SIMDTrait class template.The SIMDTrait_ alias declaration provide...
Definition: SIMDTrait.h:315
ElementType * PointerType
Pointer return type.
Definition: DVecTDVecMultExpr.h:246
LeftIteratorType left_
Iterator to the current left-hand side element.
Definition: DVecTDVecMultExpr.h:477
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DVecTDVecMultExpr.h:587
Header file for the And class template.
Expression object for outer products between two dense vectors.The DVecTDVecMultExpr class represents...
Definition: DVecTDVecMultExpr.h:109
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:723
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:245
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DVecTDVecMultExpr.h:215
Header file for the Computation base class.
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:423
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DVecTDVecMultExpr.h:629
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
System settings for performance optimizations.
DVecTDVecMultExpr(const VT1 &lhs, const VT2 &rhs) noexcept
Constructor for the DVecTDVecMultExpr class.
Definition: DVecTDVecMultExpr.h:503
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
EnableIf_< IsDenseMatrix< MT1 > > 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 dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Constraint on the data type.
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
Compile time check for data types.This type trait tests whether or not the given types can be combine...
Definition: AreSIMDCombinable.h:121
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:390
Constraint on the transpose flag of vector types.
Constraint on the data type.
typename MultExprTrait< T1, T2 >::Type MultExprTrait_
Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration...
Definition: MultExprTrait.h:344
Header file for the MultExprTrait class template.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DVecTDVecMultExpr.h:597
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DVecTDVecMultExpr.h:651
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
ValueType value_type
Type of the underlying elements.
Definition: DVecTDVecMultExpr.h:252
Header file for the IsTemporary type trait class.
Header file for the multiplication trait.
friend const ConstIterator operator+(const ConstIterator &it, size_t inc)
Addition between a ConstIterator and an integral value.
Definition: DVecTDVecMultExpr.h:446
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for the If class template.
#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: ColumnMajorMatrix.h:61
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DVecTDVecMultExpr.h:550
ConstIterator & operator--()
Pre-decrement operator.
Definition: DVecTDVecMultExpr.h:326
ResultType_< VT2 > RT2
Result type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:116
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECTVECMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector ...
Definition: VecTVecMultExpr.h:105
EnableIf_< IsDenseMatrix< MT1 > > 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
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:368
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DVecTDVecMultExpr.h:661
Header file for the Columns type trait.
If_< IsExpression< VT1 >, const VT1, const VT1 & > LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:225
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Header file for all SIMD functionality.
ReferenceType reference
Reference return type.
Definition: DVecTDVecMultExpr.h:254
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
ConstIterator(LeftIteratorType left, RightIteratorType right)
Constructor for the ConstIterator class.
Definition: DVecTDVecMultExpr.h:270
CompositeType_< VT2 > CT2
Composite type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:122
Header file for the IsAligned type trait.
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:379
#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:60
DifferenceType difference_type
Difference between two iterators.
Definition: DVecTDVecMultExpr.h:255
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:214
Constraints on the storage order of matrix types.
Constraint on the data type.
Header file for the exception macros of the math module.
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DVecTDVecMultExpr.h:458
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the VecTVecMultExpr base class.
Header file for the EnableIf class template.
Header file for the IsPadded type trait.
ConstIterator_< VT1 > LeftIteratorType
ConstIterator type of the left-hand side dense matrix expression.
Definition: DVecTDVecMultExpr.h:258
ConstIterator & operator++()
Pre-increment operator.
Definition: DVecTDVecMultExpr.h:305
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DVecTDVecMultExpr.h:244
IteratorCategory iterator_category
The iterator category.
Definition: DVecTDVecMultExpr.h:251
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > set(T value) noexcept
Sets all values in the vector to the given 1-byte integral value.
Definition: Set.h:76
LeftOperand lhs_
Left-hand side dense vector of the multiplication expression.
Definition: DVecTDVecMultExpr.h:668
#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:79
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: RowMajorMatrix.h:61
Header file for the HasSIMDMult type trait.
Header file for run time assertion macros.
ReturnType_< VT1 > RN1
Return type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:119
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:219
If_< IsExpression< VT2 >, const VT2, const VT2 & > RightOperand
Composite type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:228
ElementType_< RT1 > ET1
Element type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:117
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: DVecTDVecMultExpr.h:564
RightIteratorType right_
Iterator to the current right-hand side element.
Definition: DVecTDVecMultExpr.h:478
SIMDTrait_< ElementType > SIMDType
Resulting SIMD element type.
Definition: DVecTDVecMultExpr.h:216
CompositeType_< VT1 > CT1
Composite type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:121
RightOperand rhs_
Right-hand side dense vector of the multiplication expression.
Definition: DVecTDVecMultExpr.h:669
Constraint on the data type.
Constraints on the storage order of matrix types.
ElementType & ReferenceType
Reference return type.
Definition: DVecTDVecMultExpr.h:247
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DVecTDVecMultExpr.h:516
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
Constraint on the data type.
Header file for the IsReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for a...
Definition: VecTVecMultExpr.h:66
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
ReturnType_< VT2 > RN2
Return type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:120
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DVecTDVecMultExpr.h:282
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
#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:61
Header file for the AreSIMDCombinable type trait.
ElementType ValueType
Type of the underlying elements.
Definition: DVecTDVecMultExpr.h:245
ConstIterator_< VT2 > RightIteratorType
ConstIterator type of the right-hand side dense matrix expression.
Definition: DVecTDVecMultExpr.h:261
Header file for the IsComputation type trait class.
RightOperand rightOperand() const noexcept
Returns the right-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:617
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DVecTDVecMultExpr.h:347
Iterator over the elements of the dense matrix.
Definition: DVecTDVecMultExpr.h:240
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
ElementType_< RT2 > ET2
Element type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:118
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DVecTDVecMultExpr.h:213
#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
PointerType pointer
Pointer return type.
Definition: DVecTDVecMultExpr.h:253
Header file for the IntegralConstant class template.
IfTrue_< useAssign, const ResultType, const DVecTDVecMultExpr & > CompositeType
Data type for composite expression templates.
Definition: DVecTDVecMultExpr.h:222
#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: RowVector.h:61
Header file for the SubvectorExprTrait class template.
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:412
const ConstIterator operator--(int)
Post-decrement operator.
Definition: DVecTDVecMultExpr.h:337
System settings for the inline keywords.
MultTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:212
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DVecTDVecMultExpr.h:532
Header file for the Size type trait.
bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:401
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
IfTrue_< evaluateLeft, const RT1, CT1 > LT
Type for the assignment of the left-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:231
Constraint on the transpose flag of vector types.
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.