35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECTDVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECTDVECMULTEXPR_H_
92 template<
typename VT1
127 enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
141 enum { useAssign = ( evaluateLeft || evaluateRight ) };
144 template<
typename VT >
147 enum { value = useAssign };
158 template<
typename VT >
159 struct UseSMPAssign {
160 enum { value = evaluateRight };
170 template<
typename T1,
typename T2,
typename T3 >
171 struct UseVectorizedKernel {
172 enum { value = T1::vectorizable && T2::vectorizable && T3::vectorizable &&
185 template<
typename T1,
typename T2,
typename T3 >
186 struct UseDefaultKernel {
187 enum { value = !UseVectorizedKernel<T1,T2,T3>::value };
331 return (*
left_) * (*right_);
340 inline IntrinsicType
load()
const {
468 enum { vectorizable = VT1::vectorizable && VT2::vectorizable &&
473 enum { smpAssignable = VT1::smpAssignable && !evaluateRight };
510 inline IntrinsicType
load(
size_t i,
size_t j )
const {
515 const IntrinsicType xmm1(
set(
lhs_[i] ) );
516 const IntrinsicType xmm2(
rhs_.load( j ) );
591 template<
typename T >
593 return (
lhs_.canAlias( alias ) ||
rhs_.canAlias( alias ) );
603 template<
typename T >
605 return (
lhs_.isAliased( alias ) ||
rhs_.isAliased( alias ) );
615 return lhs_.isAligned() &&
rhs_.isAligned();
649 template<
typename MT >
666 DVecTDVecMultExpr::selectAssignKernel( ~lhs, x, y );
685 template<
typename MT
691 const size_t m( (~A).
rows() );
692 const size_t n( (~A).
columns() );
694 const size_t jend( n &
size_t(-2) );
697 for(
size_t i=0UL; i<m; ++i ) {
698 for(
size_t j=0UL; j<jend; j+=2UL ) {
699 (~A)(i,j ) = x[i] * y[j ];
700 (~A)(i,j+1UL) = x[i] * y[j+1];
703 (~A)(i,jend) = x[i] * y[jend];
724 template<
typename MT
727 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
728 selectAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
730 typedef IntrinsicTrait<ElementType> IT;
732 const size_t m( (~A).
rows() );
733 const size_t n( (~A).
columns() );
735 for(
size_t i=0UL; i<m; ++i )
737 const IntrinsicType x1(
set( x[i] ) );
739 for(
size_t j=0UL; j<n; j+=
IT::size ) {
740 (~A).
store( i, j, x1 * y.load(j) );
759 template<
typename MT >
769 LT x(
serial( rhs.lhs_ ) );
770 RT y(
serial( rhs.rhs_ ) );
777 DVecTDVecMultExpr::selectAssignKernel( ~lhs, x, y );
796 template<
typename MT
799 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
800 selectAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
802 const size_t m( (~A).
rows() );
803 const size_t n( (~A).
columns() );
805 const size_t iend( m &
size_t(-2) );
808 for(
size_t j=0UL; j<n; ++j ) {
809 for(
size_t i=0UL; i<iend; i+=2UL ) {
810 (~A)(i ,j) = x[i ] * y[j];
811 (~A)(i+1UL,j) = x[i+1] * y[j];
814 (~A)(iend,j) = x[iend] * y[j];
835 template<
typename MT
838 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
839 selectAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
841 typedef IntrinsicTrait<ElementType> IT;
843 const size_t m( (~A).
rows() );
844 const size_t n( (~A).
columns() );
846 for(
size_t j=0UL; j<n; ++j )
848 const IntrinsicType y1(
set( y[j] ) );
850 for(
size_t i=0UL; i<m; i+=
IT::size ) {
851 (~A).
store( i, j, x.load(i) * y1 );
870 template<
typename MT
876 typedef typename SelectType< SO, OppositeType, ResultType >::Type TmpType;
888 const TmpType tmp(
serial( rhs ) );
909 template<
typename MT >
910 friend inline typename EnableIf< UseAssign<MT> >::Type
918 LT x(
serial( rhs.lhs_ ) );
919 RT y(
serial( rhs.rhs_ ) );
926 DVecTDVecMultExpr::selectAddAssignKernel( ~lhs, x, y );
945 template<
typename MT
948 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
949 selectAddAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
951 const size_t m( (~A).
rows() );
952 const size_t n( (~A).
columns() );
954 const size_t jend( n &
size_t(-2) );
957 for(
size_t i=0UL; i<m; ++i ) {
958 for(
size_t j=0UL; j<jend; j+=2UL ) {
959 (~A)(i,j ) += x[i] * y[j ];
960 (~A)(i,j+1UL) += x[i] * y[j+1UL];
963 (~A)(i,jend) += x[i] * y[jend];
984 template<
typename MT
987 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
988 selectAddAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
990 typedef IntrinsicTrait<ElementType> IT;
992 const size_t m( (~A).
rows() );
993 const size_t n( (~A).
columns() );
995 for(
size_t i=0UL; i<m; ++i )
997 const IntrinsicType x1(
set( x[i] ) );
999 for(
size_t j=0UL; j<n; j+=
IT::size ) {
1000 (~A).
store( i, j, (~A).load(i,j) + x1 * y.load(j) );
1020 template<
typename MT >
1030 LT x(
serial( rhs.lhs_ ) );
1031 RT y(
serial( rhs.rhs_ ) );
1038 DVecTDVecMultExpr::selectAddAssignKernel( ~lhs, x, y );
1057 template<
typename MT
1060 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
1061 selectAddAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1063 const size_t m( (~A).
rows() );
1064 const size_t n( (~A).
columns() );
1066 const size_t iend( m &
size_t(-2) );
1069 for(
size_t j=0UL; j<n; ++j ) {
1070 for(
size_t i=0UL; i<iend; i+=2UL ) {
1071 (~A)(i ,j) += x[i ] * y[j];
1072 (~A)(i+1UL,j) += x[i+1UL] * y[j];
1075 (~A)(iend,j) += x[iend] * y[j];
1096 template<
typename MT
1099 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
1100 selectAddAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1102 typedef IntrinsicTrait<ElementType> IT;
1104 const size_t m( (~A).
rows() );
1105 const size_t n( (~A).
columns() );
1107 for(
size_t j=0UL; j<n; ++j )
1109 const IntrinsicType y1(
set( y[j] ) );
1111 for(
size_t i=0UL; i<m; i+=
IT::size ) {
1112 (~A).
store( i, j, (~A).load(i,j) + x.load(i) * y1 );
1138 template<
typename MT >
1139 friend inline typename EnableIf< UseAssign<MT> >::Type
1147 LT x(
serial( rhs.lhs_ ) );
1148 RT y(
serial( rhs.rhs_ ) );
1155 DVecTDVecMultExpr::selectSubAssignKernel( ~lhs, x, y );
1174 template<
typename MT
1177 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
1178 selectSubAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1180 const size_t m( (~A).
rows() );
1181 const size_t n( (~A).
columns() );
1183 const size_t jend( n &
size_t(-2) );
1186 for(
size_t i=0UL; i<m; ++i ) {
1187 for(
size_t j=0UL; j<jend; j+=2UL ) {
1188 (~A)(i,j ) -= x[i] * y[j ];
1189 (~A)(i,j+1UL) -= x[i] * y[j+1UL];
1192 (~A)(i,jend) -= x[i] * y[jend];
1213 template<
typename MT
1216 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
1217 selectSubAssignKernel( DenseMatrix<MT,false>& A,
const VT3& x,
const VT4& y )
1219 typedef IntrinsicTrait<ElementType> IT;
1221 const size_t m( (~A).
rows() );
1222 const size_t n( (~A).
columns() );
1224 for(
size_t i=0UL; i<m; ++i )
1226 const IntrinsicType x1(
set( x[i] ) );
1228 for(
size_t j=0UL; j<n; j+=
IT::size ) {
1229 (~A).
store( i, j, (~A).load(i,j) - x1 * y.load(j) );
1249 template<
typename MT >
1259 LT x(
serial( rhs.lhs_ ) );
1260 RT y(
serial( rhs.rhs_ ) );
1267 DVecTDVecMultExpr::selectSubAssignKernel( ~lhs, x, y );
1286 template<
typename MT
1289 static inline typename EnableIf< UseDefaultKernel<MT,VT3,VT4> >::Type
1290 selectSubAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1292 const size_t m( (~A).
rows() );
1293 const size_t n( (~A).
columns() );
1295 const size_t iend( m &
size_t(-2) );
1298 for(
size_t j=0UL; j<n; ++j ) {
1299 for(
size_t i=0UL; i<iend; i+=2UL ) {
1300 (~A)(i ,j) -= x[i ] * y[j];
1301 (~A)(i+1UL,j) -= x[i+1UL] * y[j];
1304 (~A)(iend,j) -= x[iend] * y[j];
1325 template<
typename MT
1328 static inline typename EnableIf< UseVectorizedKernel<MT,VT3,VT4> >::Type
1329 selectSubAssignKernel( DenseMatrix<MT,true>& A,
const VT3& x,
const VT4& y )
1331 typedef IntrinsicTrait<ElementType> IT;
1333 const size_t m( (~A).
rows() );
1334 const size_t n( (~A).
columns() );
1336 for(
size_t j=0UL; j<n; ++j )
1338 const IntrinsicType y1(
set( y[j] ) );
1340 for(
size_t i=0UL; i<m; i+=
IT::size ) {
1341 (~A).
store( i, j, (~A).load(i,j) - x.load(i) * y1 );
1374 template<
typename MT
1376 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1411 template<
typename MT
1413 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1418 typedef typename SelectType< SO, OppositeType, ResultType >::Type TmpType;
1430 const TmpType tmp( rhs );
1450 template<
typename MT >
1451 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1491 template<
typename MT >
1492 friend inline typename EnableIf< UseSMPAssign<MT> >::Type
1573 template<
typename T1
1575 inline const DVecTDVecMultExpr<T1,T2>
1595 template<
typename VT1,
typename VT2 >
1612 template<
typename VT1,
typename VT2 >
1629 template<
typename VT1,
typename VT2,
bool AF >
1634 typedef typename MultExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
1635 ,
typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
1644 template<
typename VT1,
typename VT2 >
1649 typedef typename MultExprTrait< typename VT1::ReturnType, VT2 >::Type Type;
1658 template<
typename VT1,
typename VT2 >
1663 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:102
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:194
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DVecTDVecMultExpr.h:231
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:4838
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:258
const ConstIterator operator++(int)
Post-increment operator.
Definition: DVecTDVecMultExpr.h:299
#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:205
ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DVecTDVecMultExpr.h:277
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: DVecTDVecMultExpr.h:539
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DVecTDVecMultExpr.h:453
#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:195
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DVecTDVecMultExpr.h:592
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DVecTDVecMultExpr.h:417
ElementType * PointerType
Pointer return type.
Definition: DVecTDVecMultExpr.h:229
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2478
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:257
DVecTDVecMultExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the DVecTDVecMultExpr class.
Definition: DVecTDVecMultExpr.h:482
LeftIteratorType left_
Iterator to the current left-hand side element.
Definition: DVecTDVecMultExpr.h:460
VT2::ConstIterator RightIteratorType
ConstIterator type of the right-hand side dense matrix expression.
Definition: DVecTDVecMultExpr.h:244
Expression object for outer products between two dense vectors.The DVecTDVecMultExpr class represents...
Definition: DVecTDVecMultExpr.h:94
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:695
Header file for the Computation base class.
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:406
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
SelectType< evaluateLeft, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:214
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:241
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:373
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DVecTDVecMultExpr.h:604
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:235
VT1::CompositeType CT1
Composite type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:106
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:429
VT2::ReturnType RN2
Return type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:105
#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
ConstIterator & operator--()
Pre-decrement operator.
Definition: DVecTDVecMultExpr.h:309
SelectType< useAssign, const ResultType, const DVecTDVecMultExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: DVecTDVecMultExpr.h:205
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2482
#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:351
LeftOperand leftOperand() const
Returns the left-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:570
Header file for the DenseMatrix base class.
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
Header file for the Columns type trait.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DVecTDVecMultExpr.h:196
IntrinsicTrait< ElementType >::Type IntrinsicType
Resulting intrinsic element type.
Definition: DVecTDVecMultExpr.h:199
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DVecTDVecMultExpr.h:550
ReferenceType reference
Reference return type.
Definition: DVecTDVecMultExpr.h:237
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:253
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:362
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DVecTDVecMultExpr.h:614
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:202
Constraint on the data type.
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:211
#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:238
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:217
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DVecTDVecMultExpr.h:441
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2476
VT1::ReturnType RN1
Return type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:104
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:101
Header file for the EnableIf class template.
ConstIterator & operator++()
Pre-increment operator.
Definition: DVecTDVecMultExpr.h:288
Header file for the serial shim.
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DVecTDVecMultExpr.h:227
IteratorCategory iterator_category
The iterator category.
Definition: DVecTDVecMultExpr.h:234
BLAZE_ALWAYS_INLINE EnableIf< IsIntegral< T >, Set< T, sizeof(T)> >::Type::Type set(T value)
Sets all values in the vector to the given integral value.
Definition: Set.h:211
VT1::ResultType RT1
Result type of the left-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:100
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:631
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: StorageOrder.h:81
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2477
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:749
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Base template for the MultTrait class.
Definition: MultTrait.h:142
BLAZE_ALWAYS_INLINE 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:742
RightOperand rightOperand() const
Returns the right-hand side dense vector operand.
Definition: DVecTDVecMultExpr.h:580
IntrinsicType load(size_t i, size_t j) const
Access to the intrinsic elements of the matrix.
Definition: DVecTDVecMultExpr.h:510
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: DVecTDVecMultExpr.h:527
RightIteratorType right_
Iterator to the current right-hand side element.
Definition: DVecTDVecMultExpr.h:461
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DVecTDVecMultExpr.h:197
RT2::ElementType ET2
Element type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:103
RightOperand rhs_
Right-hand side dense vector of the multiplication expression.
Definition: DVecTDVecMultExpr.h:632
IntrinsicType load() const
Access to the intrinsic elements of the matrix.
Definition: DVecTDVecMultExpr.h:340
VT2::CompositeType CT2
Composite type of the right-hand side dense vector expression.
Definition: DVecTDVecMultExpr.h:107
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DVecTDVecMultExpr.h:624
Constraint on the data type.
const size_t SMP_DVECTDVECMULT_THRESHOLD
SMP dense vector/dense vector outer product threshold.This threshold specifies when a dense vector/de...
Definition: Thresholds.h:1202
ElementType & ReferenceType
Reference return type.
Definition: DVecTDVecMultExpr.h:230
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DVecTDVecMultExpr.h:495
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:283
Header file for all intrinsic functionality.
ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DVecTDVecMultExpr.h:265
ResultType::ElementType ElementType
Resulting element type.
Definition: DVecTDVecMultExpr.h:198
#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:560
ElementType ValueType
Type of the underlying elements.
Definition: DVecTDVecMultExpr.h:228
Header file for the IsComputation type trait class.
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DVecTDVecMultExpr.h:330
Iterator over the elements of the dense matrix.
Definition: DVecTDVecMultExpr.h:223
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:2473
PointerType pointer
Pointer return type.
Definition: DVecTDVecMultExpr.h:236
Header file for basic type definitions.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a row dense or sparse vector type (i...
Definition: TransposeFlag.h:81
Header file for the SubvectorExprTrait class template.
MultExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DVecTDVecMultExpr.h:130
BLAZE_ALWAYS_INLINE EnableIf< IsIntegral< T > >::Type store(T *address, const typename Store< T, sizeof(T)>::Type &value)
Aligned store of a vector of integral values.
Definition: Store.h:225
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecTDVecMultExpr.h:395
const ConstIterator operator--(int)
Post-decrement operator.
Definition: DVecTDVecMultExpr.h:320
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:384
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:208
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE 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:849