35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECTDVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECTDVECMULTEXPR_H_
103 template<
typename VT1
138 enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
152 enum { useAssign = ( evaluateLeft || evaluateRight ) };
155 template<
typename VT >
158 enum { value = useAssign };
169 template<
typename VT >
170 struct UseSMPAssign {
171 enum { value = evaluateRight };
181 template<
typename T1,
typename T2,
typename T3 >
182 struct UseVectorizedKernel {
184 T1::vectorizable && T2::vectorizable && T3::vectorizable &&
197 template<
typename T1,
typename T2,
typename T3 >
198 struct UseDefaultKernel {
199 enum { value = !UseVectorizedKernel<T1,T2,T3>::value };
265 explicit inline ConstIterator( LeftIteratorType left, RightIteratorType right )
343 return (*
left_) * (*right_);
352 inline IntrinsicType
load()
const {
480 enum { vectorizable = VT1::vectorizable && VT2::vectorizable &&
485 enum { smpAssignable = VT1::smpAssignable && !evaluateRight };
523 inline ReturnType
at(
size_t i,
size_t j )
const {
524 if( i >=
lhs_.size() ) {
527 if( j >=
rhs_.size() ) {
546 const IntrinsicType xmm1(
set(
lhs_[i] ) );
547 const IntrinsicType xmm2(
rhs_.load( j ) );
622 template<
typename T >
624 return (
lhs_.canAlias( alias ) ||
rhs_.canAlias( alias ) );
634 template<
typename T >
636 return (
lhs_.isAliased( alias ) ||
rhs_.isAliased( alias ) );
646 return lhs_.isAligned() &&
rhs_.isAligned();
656 return (
rows() > SMP_DVECTDVECMULT_THRESHOLD );
680 template<
typename MT >
697 DVecTDVecMultExpr::selectAssignKernel( ~lhs, x, y );
716 template<
typename MT
722 const size_t M( (~A).
rows() );
723 const size_t N( (~A).
columns() );
725 const size_t jpos( N &
size_t(-2) );
728 for(
size_t i=0UL; i<M; ++i ) {
729 for(
size_t j=0UL; j<jpos; j+=2UL ) {
730 (~A)(i,j ) = x[i] * y[j ];
731 (~A)(i,j+1UL) = x[i] * y[j+1];
734 (~A)(i,jpos) = x[i] * y[jpos];
755 template<
typename MT
758 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
759 selectAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
761 typedef IntrinsicTrait<ElementType> IT;
763 const size_t M( (~A).
rows() );
764 const size_t N( (~A).
columns() );
766 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT4>::value );
768 const size_t jpos( remainder ? ( N &
size_t(-
IT::size) ) : N );
771 for(
size_t i=0UL; i<M; ++i )
773 const IntrinsicType x1(
set( x[i] ) );
778 (~A).store( i, j, x1 * y.load(j) );
780 for( ; remainder && j<N; ++j ) {
781 (~A)(i,j) = x[i] * y[j];
800 template<
typename MT >
801 friend inline void assign( DenseMatrix<MT,true>& lhs,
const DVecTDVecMultExpr& rhs )
810 LT x(
serial( rhs.lhs_ ) );
811 RT y(
serial( rhs.rhs_ ) );
818 DVecTDVecMultExpr::selectAssignKernel( ~lhs, x, y );
837 template<
typename MT
840 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
841 selectAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
843 const size_t M( (~A).
rows() );
844 const size_t N( (~A).
columns() );
846 const size_t ipos( M &
size_t(-2) );
849 for(
size_t j=0UL; j<N; ++j ) {
850 for(
size_t i=0UL; i<ipos; i+=2UL ) {
851 (~A)(i ,j) = x[i ] * y[j];
852 (~A)(i+1UL,j) = x[i+1] * y[j];
855 (~A)(ipos,j) = x[ipos] * y[j];
876 template<
typename MT
879 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
880 selectAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
882 typedef IntrinsicTrait<ElementType> IT;
884 const size_t M( (~A).
rows() );
885 const size_t N( (~A).
columns() );
887 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT3>::value );
889 const size_t ipos( remainder ? ( M &
size_t(-
IT::size) ) : M );
892 for(
size_t j=0UL; j<N; ++j )
894 const IntrinsicType y1(
set( y[j] ) );
899 (~A).store( i, j, x.load(i) * y1 );
901 for( ; remainder && i<M; ++i ) {
902 (~A)(i,j) = x[i] * y[j];
921 template<
typename MT
923 friend inline void assign( SparseMatrix<MT,SO>& lhs,
const DVecTDVecMultExpr& rhs )
927 typedef typename SelectType< SO, OppositeType, ResultType >::Type TmpType;
939 const TmpType tmp(
serial( rhs ) );
960 template<
typename MT >
961 friend inline typename EnableIf< UseAssign<MT> >::Type
969 LT x(
serial( rhs.lhs_ ) );
970 RT y(
serial( rhs.rhs_ ) );
977 DVecTDVecMultExpr::selectAddAssignKernel( ~lhs, x, y );
996 template<
typename MT
999 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
1000 selectAddAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1002 const size_t M( (~A).
rows() );
1003 const size_t N( (~A).
columns() );
1005 const size_t jpos( N &
size_t(-2) );
1008 for(
size_t i=0UL; i<M; ++i ) {
1009 for(
size_t j=0UL; j<jpos; j+=2UL ) {
1010 (~A)(i,j ) += x[i] * y[j ];
1011 (~A)(i,j+1UL) += x[i] * y[j+1UL];
1014 (~A)(i,jpos) += x[i] * y[jpos];
1035 template<
typename MT
1038 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
1039 selectAddAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1041 typedef IntrinsicTrait<ElementType> IT;
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(-
IT::size) ) : N );
1051 for(
size_t i=0UL; i<M; ++i )
1053 const IntrinsicType x1(
set( x[i] ) );
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 typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
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 typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
1161 selectAddAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1163 typedef IntrinsicTrait<ElementType> IT;
1165 const size_t M( (~A).
rows() );
1166 const size_t N( (~A).
columns() );
1168 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT3>::value );
1170 const size_t ipos( remainder ? ( M &
size_t(-
IT::size) ) : M );
1173 for(
size_t j=0UL; j<N; ++j )
1175 const IntrinsicType y1(
set( y[j] ) );
1180 (~A).store( i, j, (~A).load(i,j) + x.load(i) * y1 );
1182 for( ; remainder && i<M; ++i ) {
1183 (~A)(i,j) += x[i] * y[j];
1209 template<
typename MT >
1210 friend inline typename EnableIf< UseAssign<MT> >::Type
1218 LT x(
serial( rhs.lhs_ ) );
1219 RT y(
serial( rhs.rhs_ ) );
1226 DVecTDVecMultExpr::selectSubAssignKernel( ~lhs, x, y );
1245 template<
typename MT
1248 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
1249 selectSubAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1251 const size_t M( (~A).
rows() );
1252 const size_t N( (~A).
columns() );
1254 const size_t jpos( N &
size_t(-2) );
1257 for(
size_t i=0UL; i<M; ++i ) {
1258 for(
size_t j=0UL; j<jpos; j+=2UL ) {
1259 (~A)(i,j ) -= x[i] * y[j ];
1260 (~A)(i,j+1UL) -= x[i] * y[j+1UL];
1263 (~A)(i,jpos) -= x[i] * y[jpos];
1284 template<
typename MT
1287 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
1288 selectSubAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1290 typedef IntrinsicTrait<ElementType> IT;
1292 const size_t M( (~A).
rows() );
1293 const size_t N( (~A).
columns() );
1295 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT4>::value );
1297 const size_t jpos( remainder ? ( N &
size_t(-
IT::size) ) : N );
1300 for(
size_t i=0UL; i<M; ++i )
1302 const IntrinsicType x1(
set( x[i] ) );
1307 (~A).store( i, j, (~A).load(i,j) - x1 * y.load(j) );
1309 for( ; remainder && j<N; ++j ) {
1310 (~A)(i,j) -= x[i] * y[j];
1330 template<
typename MT >
1331 friend inline void subAssign( DenseMatrix<MT,true>& lhs,
const DVecTDVecMultExpr& rhs )
1340 LT x(
serial( rhs.lhs_ ) );
1341 RT y(
serial( rhs.rhs_ ) );
1348 DVecTDVecMultExpr::selectSubAssignKernel( ~lhs, x, y );
1367 template<
typename MT
1370 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
1371 selectSubAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1373 const size_t M( (~A).
rows() );
1374 const size_t N( (~A).
columns() );
1376 const size_t ipos( M &
size_t(-2) );
1379 for(
size_t j=0UL; j<N; ++j ) {
1380 for(
size_t i=0UL; i<ipos; i+=2UL ) {
1381 (~A)(i ,j) -= x[i ] * y[j];
1382 (~A)(i+1UL,j) -= x[i+1UL] * y[j];
1385 (~A)(ipos,j) -= x[ipos] * y[j];
1406 template<
typename MT
1409 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
1410 selectSubAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1412 typedef IntrinsicTrait<ElementType> IT;
1414 const size_t M( (~A).
rows() );
1415 const size_t N( (~A).
columns() );
1417 const bool remainder( !IsPadded<MT>::value || !IsPadded<VT3>::value );
1419 const size_t ipos( remainder ? ( M &
size_t(-
IT::size) ) : M );
1422 for(
size_t j=0UL; j<N; ++j )
1424 const IntrinsicType y1(
set( y[j] ) );
1429 (~A).store( i, j, (~A).load(i,j) - x.load(i) * y1 );
1431 for( ; remainder && i<M; ++i ) {
1432 (~A)(i,j) -= x[i] * y[j];
1465 template<
typename MT
1467 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1502 template<
typename MT
1504 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1509 typedef typename SelectType< SO, OppositeType, ResultType >::Type TmpType;
1521 const TmpType tmp( rhs );
1541 template<
typename MT >
1542 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1582 template<
typename MT >
1583 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1664 template<
typename T1
1666 inline const DVecTDVecMultExpr<T1,T2>
1686 template<
typename VT1,
typename VT2 >
1703 template<
typename VT1,
typename VT2 >
1720 template<
typename VT1,
typename VT2 >
1722 :
public IsTrue< And< IsAligned<VT1>, IsAligned<VT2> >::value >
1738 template<
typename VT1,
typename VT2 >
1739 struct IsPadded<
DVecTDVecMultExpr<VT1,VT2> > :
public IsTrue< IsPadded<VT2>::value >
1755 template<
typename VT1,
typename VT2,
bool AF >
1760 typedef typename MultExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
1761 ,
typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
1770 template<
typename VT1,
typename VT2 >
1775 typedef typename MultExprTrait< typename VT1::ReturnType, VT2 >::Type Type;
1784 template<
typename VT1,
typename VT2 >
1789 typedef typename MultExprTrait< VT1, typename VT2::ReturnType >::Type Type;
Pointer difference type of the Blaze library.
RT1::ElementType ET1
Element type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:113
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type set(T value)
Sets all values in the vector to the given 2-byte integral value.
Definition: Set.h:73
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
DVecTDVecMultExpr< VT1, VT2 > This
Type of this DVecTDVecMultExpr instance.
Definition: DVecTDVecMultExpr.h:206
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DVecTDVecMultExpr.h:243
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:7820
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:252
const ConstIterator operator++(int)
Post-increment operator.
Definition: DVecTDVecMultExpr.h:311
#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:79
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DVecTDVecMultExpr.h:289
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: DVecTDVecMultExpr.h:570
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DVecTDVecMultExpr.h:465
#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 ColumnExprTrait class template.
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:207
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DVecTDVecMultExpr.h:623
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DVecTDVecMultExpr.h:429
ElementType * PointerType
Pointer return type.
Definition: DVecTDVecMultExpr.h:241
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:259
DVecTDVecMultExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the DVecTDVecMultExpr class.
Definition: DVecTDVecMultExpr.h:494
LeftIteratorType left_
Iterator to the current left-hand side element.
Definition: DVecTDVecMultExpr.h:472
VT2::ConstIterator RightIteratorType
ConstIterator type of the right-hand side dense matrix expression.
Definition: DVecTDVecMultExpr.h:256
Expression object for outer products between two dense vectors.The DVecTDVecMultExpr class represents...
Definition: DVecTDVecMultExpr.h:105
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
Header file for the Computation base class.
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:418
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
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
System settings for performance optimizations.
SelectType< evaluateLeft, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:226
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.
VT1::ConstIterator LeftIteratorType
ConstIterator type of the left-hand side dense matrix expression.
Definition: DVecTDVecMultExpr.h:253
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:385
Constraint on the transpose flag of vector types.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DVecTDVecMultExpr.h:635
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
ValueType value_type
Type of the underlying elements.
Definition: DVecTDVecMultExpr.h:247
VT1::CompositeType CT1
Composite type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:117
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 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:441
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
VT2::ReturnType RN2
Return type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:116
#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:79
ConstIterator & operator--()
Pre-decrement operator.
Definition: DVecTDVecMultExpr.h:321
SelectType< useAssign, const ResultType, const DVecTDVecMultExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: DVecTDVecMultExpr.h:217
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
#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:161
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:363
LeftOperand leftOperand() const
Returns the left-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:601
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DVecTDVecMultExpr.h:208
IntrinsicTrait< ElementType >::Type IntrinsicType
Resulting intrinsic element type.
Definition: DVecTDVecMultExpr.h:211
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DVecTDVecMultExpr.h:581
ReferenceType reference
Reference return type.
Definition: DVecTDVecMultExpr.h:249
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:265
Header file for the IsAligned type trait.
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:374
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DVecTDVecMultExpr.h:645
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:214
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:223
#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
DifferenceType difference_type
Difference between two iterators.
Definition: DVecTDVecMultExpr.h:250
Constraints on the storage order of matrix types.
Constraint on the data type.
SelectType< evaluateRight, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:229
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DVecTDVecMultExpr.h:453
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
VT1::ReturnType RN1
Return type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:115
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the VecTVecMultExpr base class.
VT2::ResultType RT2
Result type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:112
Header file for the EnableIf class template.
Header file for the IsPadded type trait.
ConstIterator & operator++()
Pre-increment operator.
Definition: DVecTDVecMultExpr.h:300
Header file for the serial shim.
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DVecTDVecMultExpr.h:239
IteratorCategory iterator_category
The iterator category.
Definition: DVecTDVecMultExpr.h:246
VT1::ResultType RT1
Result type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:111
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
LeftOperand lhs_
Left-hand side dense vector of the multiplication expression.
Definition: DVecTDVecMultExpr.h:662
#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: RowMajorMatrix.h:79
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:1232
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:138
RightOperand rightOperand() const
Returns the right-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:611
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
const bool useOptimizedKernels
Configuration switch for optimized kernels.This configuration switch enables/disables all optimized c...
Definition: Optimizations.h:84
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: DVecTDVecMultExpr.h:558
RightIteratorType right_
Iterator to the current right-hand side element.
Definition: DVecTDVecMultExpr.h:473
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:209
RT2::ElementType ET2
Element type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:114
RightOperand rhs_
Right-hand side dense vector of the multiplication expression.
Definition: DVecTDVecMultExpr.h:663
IntrinsicType load() const
Access to the intrinsic elements of the matrix.
Definition: DVecTDVecMultExpr.h:352
VT2::CompositeType CT2
Composite type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:118
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DVecTDVecMultExpr.h:655
Constraint on the data type.
Constraints on the storage order of matrix types.
ElementType & ReferenceType
Reference return type.
Definition: DVecTDVecMultExpr.h:242
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DVecTDVecMultExpr.h:507
Constraint on the data type.
Header file for the IsReference type trait.
Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for a...
Definition: VecTVecMultExpr.h:66
#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:122
Header file for all intrinsic functionality.
ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DVecTDVecMultExpr.h:277
ResultType::ElementType ElementType
Resulting element type.
Definition: DVecTDVecMultExpr.h:210
#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
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DVecTDVecMultExpr.h:591
ElementType ValueType
Type of the underlying elements.
Definition: DVecTDVecMultExpr.h:240
Header file for the IsComputation type trait class.
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DVecTDVecMultExpr.h:342
Iterator over the elements of the dense matrix.
Definition: DVecTDVecMultExpr.h:235
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#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:2583
Header file for the IsTrue value trait.
PointerType pointer
Pointer return type.
Definition: DVecTDVecMultExpr.h:248
#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:79
Header file for the SubvectorExprTrait class template.
MultExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DVecTDVecMultExpr.h:141
Header file for exception macros.
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:407
BLAZE_ALWAYS_INLINE IntrinsicType load(size_t i, size_t j) const
Access to the intrinsic elements of the matrix.
Definition: DVecTDVecMultExpr.h:541
const ConstIterator operator--(int)
Post-decrement operator.
Definition: DVecTDVecMultExpr.h:332
System settings for the inline keywords.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DVecTDVecMultExpr.h:523
Header file for the Size type trait.
Evaluation of the resulting expression type of a multiplication.Via this type trait it is possible to...
Definition: MultExprTrait.h:137
bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:396
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
SelectType< IsExpression< VT1 >::value, const VT1, const VT1 & >::Type LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:220
Constraint on the transpose flag of vector types.
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.