mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-08-11 11:19:02 +08:00
Use copyCoeff/copyPacket in copy_using_evaluator.
This commit is contained in:
Jitse Niesen
parent
3457965bf5
commit
2d11041e24
@ -147,165 +147,132 @@ public:
|
||||
* Part 2 : meta-unrollers
|
||||
***************************************************************************/
|
||||
|
||||
// TODO:`Ideally, we want to use only the evaluator objects here, not the expression objects
|
||||
// However, we need to access .rowIndexByOuterInner() which is in the expression object
|
||||
|
||||
/************************
|
||||
*** Default traversal ***
|
||||
************************/
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Index, int Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Index, int Stop>
|
||||
struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling
|
||||
{
|
||||
typedef typename DstEvaluatorType::XprType DstXprType;
|
||||
|
||||
enum {
|
||||
outer = Index / DstXprType::InnerSizeAtCompileTime,
|
||||
inner = Index % DstXprType::InnerSizeAtCompileTime
|
||||
};
|
||||
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType &dstEvaluator,
|
||||
SrcEvaluatorType &srcEvaluator,
|
||||
const DstXprType &dst)
|
||||
SrcEvaluatorType &srcEvaluator)
|
||||
{
|
||||
// TODO: Use copyCoeffByOuterInner ?
|
||||
typename DstXprType::Index row = dst.rowIndexByOuterInner(outer, inner);
|
||||
typename DstXprType::Index col = dst.colIndexByOuterInner(outer, inner);
|
||||
dstEvaluator.coeffRef(row, col) = srcEvaluator.coeff(row, col);
|
||||
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<DstXprType, SrcXprType, Index+1, Stop>
|
||||
::run(dstEvaluator, srcEvaluator, dst);
|
||||
dstEvaluator.copyCoeffByOuterInner(outer, inner, srcEvaluator);
|
||||
copy_using_evaluator_DefaultTraversal_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, Index+1, Stop>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Stop>
|
||||
struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<DstXprType, SrcXprType, Stop, Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Stop>
|
||||
struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<DstEvaluatorType, SrcEvaluatorType, Stop, Stop>
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&, const DstXprType&) { }
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&) { }
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Index, int Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Index, int Stop>
|
||||
struct copy_using_evaluator_DefaultTraversal_InnerUnrolling
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType &dstEvaluator,
|
||||
SrcEvaluatorType &srcEvaluator,
|
||||
const DstXprType &dst,
|
||||
int outer)
|
||||
{
|
||||
// TODO: Use copyCoeffByOuterInner ?
|
||||
typename DstXprType::Index row = dst.rowIndexByOuterInner(outer, Index);
|
||||
typename DstXprType::Index col = dst.colIndexByOuterInner(outer, Index);
|
||||
dstEvaluator.coeffRef(row, col) = srcEvaluator.coeff(row, col);
|
||||
copy_using_evaluator_DefaultTraversal_InnerUnrolling<DstXprType, SrcXprType, Index+1, Stop>
|
||||
::run(dstEvaluator, srcEvaluator, dst, outer);
|
||||
dstEvaluator.copyCoeffByOuterInner(outer, Index, srcEvaluator);
|
||||
copy_using_evaluator_DefaultTraversal_InnerUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, Index+1, Stop>
|
||||
::run(dstEvaluator, srcEvaluator, outer);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Stop>
|
||||
struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<DstXprType, SrcXprType, Stop, Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Stop>
|
||||
struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<DstEvaluatorType, SrcEvaluatorType, Stop, Stop>
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&, const DstXprType&, int) { }
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&, int) { }
|
||||
};
|
||||
|
||||
/***********************
|
||||
*** Linear traversal ***
|
||||
***********************/
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Index, int Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Index, int Stop>
|
||||
struct copy_using_evaluator_LinearTraversal_CompleteUnrolling
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType &dstEvaluator,
|
||||
SrcEvaluatorType &srcEvaluator,
|
||||
const DstXprType &dst)
|
||||
SrcEvaluatorType &srcEvaluator)
|
||||
{
|
||||
// use copyCoeff ?
|
||||
dstEvaluator.coeffRef(Index) = srcEvaluator.coeff(Index);
|
||||
copy_using_evaluator_LinearTraversal_CompleteUnrolling<DstXprType, SrcXprType, Index+1, Stop>
|
||||
::run(dstEvaluator, srcEvaluator, dst);
|
||||
dstEvaluator.copyCoeff(Index, srcEvaluator);
|
||||
copy_using_evaluator_LinearTraversal_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, Index+1, Stop>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Stop>
|
||||
struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<DstXprType, SrcXprType, Stop, Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Stop>
|
||||
struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<DstEvaluatorType, SrcEvaluatorType, Stop, Stop>
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&, const DstXprType&) { }
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&) { }
|
||||
};
|
||||
|
||||
/**************************
|
||||
*** Inner vectorization ***
|
||||
**************************/
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Index, int Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Index, int Stop>
|
||||
struct copy_using_evaluator_innervec_CompleteUnrolling
|
||||
{
|
||||
typedef typename DstEvaluatorType::XprType DstXprType;
|
||||
typedef typename SrcEvaluatorType::XprType SrcXprType;
|
||||
|
||||
enum {
|
||||
outer = Index / DstXprType::InnerSizeAtCompileTime,
|
||||
inner = Index % DstXprType::InnerSizeAtCompileTime,
|
||||
JointAlignment = copy_using_evaluator_traits<DstXprType,SrcXprType>::JointAlignment
|
||||
};
|
||||
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType &dstEvaluator,
|
||||
SrcEvaluatorType &srcEvaluator,
|
||||
const DstXprType &dst)
|
||||
SrcEvaluatorType &srcEvaluator)
|
||||
{
|
||||
// TODO: Use copyPacketByOuterInner ?
|
||||
typename DstXprType::Index row = dst.rowIndexByOuterInner(outer, inner);
|
||||
typename DstXprType::Index col = dst.colIndexByOuterInner(outer, inner);
|
||||
dstEvaluator.template writePacket<Aligned>(row, col, srcEvaluator.template packet<JointAlignment>(row, col));
|
||||
copy_using_evaluator_innervec_CompleteUnrolling<DstXprType, SrcXprType,
|
||||
Index+packet_traits<typename DstXprType::Scalar>::size, Stop>::run(dstEvaluator, srcEvaluator, dst);
|
||||
dstEvaluator.template copyPacketByOuterInner<Aligned, JointAlignment>(outer, inner, srcEvaluator);
|
||||
enum { NextIndex = Index + packet_traits<typename DstXprType::Scalar>::size };
|
||||
copy_using_evaluator_innervec_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, NextIndex, Stop>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Stop>
|
||||
struct copy_using_evaluator_innervec_CompleteUnrolling<DstXprType, SrcXprType, Stop, Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Stop>
|
||||
struct copy_using_evaluator_innervec_CompleteUnrolling<DstEvaluatorType, SrcEvaluatorType, Stop, Stop>
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&, const DstXprType&) { }
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&) { }
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Index, int Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Index, int Stop>
|
||||
struct copy_using_evaluator_innervec_InnerUnrolling
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType &dstEvaluator,
|
||||
SrcEvaluatorType &srcEvaluator,
|
||||
const DstXprType &dst,
|
||||
int outer)
|
||||
{
|
||||
// TODO: Use copyPacketByOuterInner ?
|
||||
typename DstXprType::Index row = dst.rowIndexByOuterInner(outer, Index);
|
||||
typename DstXprType::Index col = dst.colIndexByOuterInner(outer, Index);
|
||||
dstEvaluator.template writePacket<Aligned>(row, col, srcEvaluator.template packet<Aligned>(row, col));
|
||||
copy_using_evaluator_innervec_InnerUnrolling<DstXprType, SrcXprType,
|
||||
Index+packet_traits<typename DstXprType::Scalar>::size, Stop>::run(dstEvaluator, srcEvaluator, dst, outer);
|
||||
dstEvaluator.template copyPacketByOuterInner<Aligned, Aligned>(outer, Index, srcEvaluator);
|
||||
typedef typename DstEvaluatorType::XprType DstXprType;
|
||||
enum { NextIndex = Index + packet_traits<typename DstXprType::Scalar>::size };
|
||||
copy_using_evaluator_innervec_InnerUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, NextIndex, Stop>
|
||||
::run(dstEvaluator, srcEvaluator, outer);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType, int Stop>
|
||||
struct copy_using_evaluator_innervec_InnerUnrolling<DstXprType, SrcXprType, Stop, Stop>
|
||||
template<typename DstEvaluatorType, typename SrcEvaluatorType, int Stop>
|
||||
struct copy_using_evaluator_innervec_InnerUnrolling<DstEvaluatorType, SrcEvaluatorType, Stop, Stop>
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&, const DstXprType&, int) { }
|
||||
EIGEN_STRONG_INLINE static void run(DstEvaluatorType&, SrcEvaluatorType&, int) { }
|
||||
};
|
||||
|
||||
/***************************************************************************
|
||||
@ -326,20 +293,18 @@ struct copy_using_evaluator_impl;
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, DefaultTraversal, NoUnrolling>
|
||||
{
|
||||
static void run(const DstXprType& dst, const SrcXprType& src)
|
||||
static void run(DstXprType& dst, const SrcXprType& src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
typedef typename DstXprType::Index Index;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
for(Index outer = 0; outer < dst.outerSize(); ++outer) {
|
||||
for(Index inner = 0; inner < dst.innerSize(); ++inner) {
|
||||
Index row = dst.rowIndexByOuterInner(outer, inner);
|
||||
Index col = dst.colIndexByOuterInner(outer, inner);
|
||||
dstEvaluator.coeffRef(row, col) = srcEvaluator.coeff(row, col); // TODO: use copyCoeff ?
|
||||
dstEvaluator.copyCoeffByOuterInner(outer, inner, srcEvaluator);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -348,16 +313,17 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, DefaultTraversal, NoUnr
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, DefaultTraversal, CompleteUnrolling>
|
||||
{
|
||||
EIGEN_STRONG_INLINE static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
EIGEN_STRONG_INLINE static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<DstXprType, SrcXprType, 0, DstXprType::SizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator, dst);
|
||||
copy_using_evaluator_DefaultTraversal_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, 0, DstXprType::SizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
@ -365,18 +331,19 @@ template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, DefaultTraversal, InnerUnrolling>
|
||||
{
|
||||
typedef typename DstXprType::Index Index;
|
||||
EIGEN_STRONG_INLINE static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
EIGEN_STRONG_INLINE static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
const Index outerSize = dst.outerSize();
|
||||
for(Index outer = 0; outer < outerSize; ++outer)
|
||||
copy_using_evaluator_DefaultTraversal_InnerUnrolling<DstXprType, SrcXprType, 0, DstXprType::InnerSizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator, dst, outer);
|
||||
copy_using_evaluator_DefaultTraversal_InnerUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, 0, DstXprType::InnerSizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator, outer);
|
||||
}
|
||||
};
|
||||
|
||||
@ -387,43 +354,46 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, DefaultTraversal, Inner
|
||||
template <bool IsAligned = false>
|
||||
struct unaligned_copy_using_evaluator_impl
|
||||
{
|
||||
// if IsAligned = true, then do nothing
|
||||
template <typename SrcEvaluatorType, typename DstEvaluatorType>
|
||||
static EIGEN_STRONG_INLINE void run(const SrcEvaluatorType&, DstEvaluatorType&,
|
||||
typename SrcEvaluatorType::Index, typename SrcEvaluatorType::Index) {}
|
||||
};
|
||||
|
||||
// TODO: check why no ...<true> ????
|
||||
|
||||
template <>
|
||||
struct unaligned_copy_using_evaluator_impl<false>
|
||||
{
|
||||
// MSVC must not inline this functions. If it does, it fails to optimize the
|
||||
// packet access path.
|
||||
#ifdef _MSC_VER
|
||||
template <typename SrcEvaluatorType, typename DstEvaluatorType>
|
||||
static EIGEN_DONT_INLINE void run(const SrcEvaluatorType& src, DstEvaluatorType& dst,
|
||||
typename SrcEvaluatorType::Index start, typename SrcEvaluatorType::Index end)
|
||||
template <typename DstEvaluatorType, typename SrcEvaluatorType>
|
||||
static EIGEN_DONT_INLINE void run(DstEvaluatorType &dstEvaluator,
|
||||
const SrcEvaluatorType &srcEvaluator,
|
||||
typename DstEvaluatorType::Index start,
|
||||
typename DstEvaluatorType::Index end)
|
||||
#else
|
||||
template <typename SrcEvaluatorType, typename DstEvaluatorType>
|
||||
static EIGEN_STRONG_INLINE void run(const SrcEvaluatorType& src, DstEvaluatorType& dst,
|
||||
typename SrcEvaluatorType::Index start, typename SrcEvaluatorType::Index end)
|
||||
template <typename DstEvaluatorType, typename SrcEvaluatorType>
|
||||
static EIGEN_STRONG_INLINE void run(DstEvaluatorType &dstEvaluator,
|
||||
const SrcEvaluatorType &srcEvaluator,
|
||||
typename DstEvaluatorType::Index start,
|
||||
typename DstEvaluatorType::Index end)
|
||||
#endif
|
||||
{
|
||||
for (typename SrcEvaluatorType::Index index = start; index < end; ++index)
|
||||
dst.copyCoeff(index, src);
|
||||
for (typename DstEvaluatorType::Index index = start; index < end; ++index)
|
||||
dstEvaluator.copyCoeff(index, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, LinearVectorizedTraversal, NoUnrolling>
|
||||
{
|
||||
EIGEN_STRONG_INLINE static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
EIGEN_STRONG_INLINE static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
typedef typename DstXprType::Index Index;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
const Index size = dst.size();
|
||||
@ -437,14 +407,14 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, LinearVectorizedTravers
|
||||
const Index alignedStart = dstIsAligned ? 0 : first_aligned(&dst.coeffRef(0), size);
|
||||
const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
|
||||
|
||||
unaligned_copy_using_evaluator_impl<dstIsAligned!=0>::run(src,dst.const_cast_derived(),0,alignedStart);
|
||||
unaligned_copy_using_evaluator_impl<dstIsAligned!=0>::run(dstEvaluator, srcEvaluator, 0, alignedStart);
|
||||
|
||||
for(Index index = alignedStart; index < alignedEnd; index += packetSize)
|
||||
{
|
||||
dstEvaluator.template writePacket<dstAlignment>(index, srcEvaluator.template packet<srcAlignment>(index));
|
||||
dstEvaluator.template copyPacket<dstAlignment, srcAlignment>(index, srcEvaluator);
|
||||
}
|
||||
|
||||
unaligned_copy_using_evaluator_impl<>::run(src,dst.const_cast_derived(),alignedEnd,size);
|
||||
unaligned_copy_using_evaluator_impl<>::run(dstEvaluator, srcEvaluator, alignedEnd, size);
|
||||
}
|
||||
};
|
||||
|
||||
@ -452,22 +422,24 @@ template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, LinearVectorizedTraversal, CompleteUnrolling>
|
||||
{
|
||||
typedef typename DstXprType::Index Index;
|
||||
EIGEN_STRONG_INLINE static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
EIGEN_STRONG_INLINE static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
enum { size = DstXprType::SizeAtCompileTime,
|
||||
packetSize = packet_traits<typename DstXprType::Scalar>::size,
|
||||
alignedSize = (size/packetSize)*packetSize };
|
||||
|
||||
copy_using_evaluator_innervec_CompleteUnrolling<DstXprType, SrcXprType, 0, alignedSize>
|
||||
::run(dstEvaluator, srcEvaluator, dst);
|
||||
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<DstXprType, SrcXprType, alignedSize, size>
|
||||
::run(dstEvaluator, srcEvaluator, dst);
|
||||
copy_using_evaluator_innervec_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, 0, alignedSize>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
copy_using_evaluator_DefaultTraversal_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, alignedSize, size>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
@ -478,13 +450,13 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, LinearVectorizedTravers
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, InnerVectorizedTraversal, NoUnrolling>
|
||||
{
|
||||
inline static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
inline static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
typedef typename DstXprType::Index Index;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
const Index innerSize = dst.innerSize();
|
||||
@ -492,10 +464,7 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, InnerVectorizedTraversa
|
||||
const Index packetSize = packet_traits<typename DstXprType::Scalar>::size;
|
||||
for(Index outer = 0; outer < outerSize; ++outer)
|
||||
for(Index inner = 0; inner < innerSize; inner+=packetSize) {
|
||||
// TODO: Use copyPacketByOuterInner ?
|
||||
Index row = dst.rowIndexByOuterInner(outer, inner);
|
||||
Index col = dst.colIndexByOuterInner(outer, inner);
|
||||
dstEvaluator.template writePacket<Aligned>(row, col, srcEvaluator.template packet<Aligned>(row, col));
|
||||
dstEvaluator.template copyPacketByOuterInner<Aligned, Aligned>(outer, inner, srcEvaluator);
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -503,16 +472,17 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, InnerVectorizedTraversa
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, InnerVectorizedTraversal, CompleteUnrolling>
|
||||
{
|
||||
EIGEN_STRONG_INLINE static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
EIGEN_STRONG_INLINE static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
copy_using_evaluator_innervec_CompleteUnrolling<DstXprType, SrcXprType, 0, DstXprType::SizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator, dst);
|
||||
copy_using_evaluator_innervec_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, 0, DstXprType::SizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
@ -520,18 +490,19 @@ template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, InnerVectorizedTraversal, InnerUnrolling>
|
||||
{
|
||||
typedef typename DstXprType::Index Index;
|
||||
EIGEN_STRONG_INLINE static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
EIGEN_STRONG_INLINE static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
const Index outerSize = dst.outerSize();
|
||||
for(Index outer = 0; outer < outerSize; ++outer)
|
||||
copy_using_evaluator_innervec_InnerUnrolling<DstXprType, SrcXprType, 0, DstXprType::InnerSizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator, dst, outer);
|
||||
copy_using_evaluator_innervec_InnerUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, 0, DstXprType::InnerSizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator, outer);
|
||||
}
|
||||
};
|
||||
|
||||
@ -542,34 +513,35 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, InnerVectorizedTraversa
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, LinearTraversal, NoUnrolling>
|
||||
{
|
||||
inline static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
inline static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
typedef typename DstXprType::Index Index;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
const Index size = dst.size();
|
||||
for(Index i = 0; i < size; ++i)
|
||||
dstEvaluator.coeffRef(i) = srcEvaluator.coeff(i); // TODO: use copyCoeff ?
|
||||
dstEvaluator.copyCoeff(i, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, LinearTraversal, CompleteUnrolling>
|
||||
{
|
||||
EIGEN_STRONG_INLINE static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
EIGEN_STRONG_INLINE static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
copy_using_evaluator_LinearTraversal_CompleteUnrolling<DstXprType, SrcXprType, 0, DstXprType::SizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator, dst);
|
||||
copy_using_evaluator_LinearTraversal_CompleteUnrolling
|
||||
<DstEvaluatorType, SrcEvaluatorType, 0, DstXprType::SizeAtCompileTime>
|
||||
::run(dstEvaluator, srcEvaluator);
|
||||
}
|
||||
};
|
||||
|
||||
@ -580,13 +552,13 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, LinearTraversal, Comple
|
||||
template<typename DstXprType, typename SrcXprType>
|
||||
struct copy_using_evaluator_impl<DstXprType, SrcXprType, SliceVectorizedTraversal, NoUnrolling>
|
||||
{
|
||||
inline static void run(const DstXprType &dst, const SrcXprType &src)
|
||||
inline static void run(DstXprType &dst, const SrcXprType &src)
|
||||
{
|
||||
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
|
||||
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
|
||||
typedef typename DstXprType::Index Index;
|
||||
|
||||
DstEvaluatorType dstEvaluator(dst.const_cast_derived());
|
||||
DstEvaluatorType dstEvaluator(dst);
|
||||
SrcEvaluatorType srcEvaluator(src);
|
||||
|
||||
typedef packet_traits<typename DstXprType::Scalar> PacketTraits;
|
||||
@ -608,23 +580,17 @@ struct copy_using_evaluator_impl<DstXprType, SrcXprType, SliceVectorizedTraversa
|
||||
const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
|
||||
// do the non-vectorizable part of the assignment
|
||||
for(Index inner = 0; inner<alignedStart ; ++inner) {
|
||||
Index row = dst.rowIndexByOuterInner(outer, inner);
|
||||
Index col = dst.colIndexByOuterInner(outer, inner);
|
||||
dstEvaluator.coeffRef(row, col) = srcEvaluator.coeff(row, col);
|
||||
dstEvaluator.copyCoeffByOuterInner(outer, inner, srcEvaluator);
|
||||
}
|
||||
|
||||
// do the vectorizable part of the assignment
|
||||
for(Index inner = alignedStart; inner<alignedEnd; inner+=packetSize) {
|
||||
Index row = dst.rowIndexByOuterInner(outer, inner);
|
||||
Index col = dst.colIndexByOuterInner(outer, inner);
|
||||
dstEvaluator.template writePacket<dstAlignment>(row, col, srcEvaluator.template packet<srcAlignment>(row, col));
|
||||
dstEvaluator.template copyPacketByOuterInner<dstAlignment, srcAlignment>(outer, inner, srcEvaluator);
|
||||
}
|
||||
|
||||
// do the non-vectorizable part of the assignment
|
||||
for(Index inner = alignedEnd; inner<innerSize ; ++inner) {
|
||||
Index row = dst.rowIndexByOuterInner(outer, inner);
|
||||
Index col = dst.colIndexByOuterInner(outer, inner);
|
||||
dstEvaluator.coeffRef(row, col) = srcEvaluator.coeff(row, col);
|
||||
dstEvaluator.copyCoeffByOuterInner(outer, inner, srcEvaluator);
|
||||
}
|
||||
|
||||
alignedStart = std::min<Index>((alignedStart+alignedStep)%packetSize, innerSize);
|
||||
@ -644,7 +610,7 @@ const DstXprType& copy_using_evaluator(const DstXprType& dst, const SrcXprType&
|
||||
#ifdef EIGEN_DEBUG_ASSIGN
|
||||
internal::copy_using_evaluator_traits<DstXprType, SrcXprType>::debug();
|
||||
#endif
|
||||
copy_using_evaluator_impl<DstXprType, SrcXprType>::run(dst, src);
|
||||
copy_using_evaluator_impl<DstXprType, SrcXprType>::run(const_cast<DstXprType&>(dst), src);
|
||||
return dst;
|
||||
}
|
||||
|
||||
|
||||
@ -47,63 +47,140 @@ struct evaluator<const T>
|
||||
typedef evaluator_impl<T> type;
|
||||
};
|
||||
|
||||
// -------------------- Transpose --------------------
|
||||
// ---------- base class for all writable evaluators ----------
|
||||
|
||||
template<typename ExpressionType>
|
||||
struct evaluator_impl<Transpose<ExpressionType> >
|
||||
struct evaluator_impl_base
|
||||
{
|
||||
typedef Transpose<ExpressionType> TransposeType;
|
||||
evaluator_impl(const TransposeType& t) : m_argImpl(t.nestedExpression()) {}
|
||||
typedef typename ExpressionType::Index Index;
|
||||
|
||||
typedef typename TransposeType::Index Index;
|
||||
|
||||
typename TransposeType::CoeffReturnType coeff(Index i, Index j) const
|
||||
template<typename OtherEvaluatorType>
|
||||
void copyCoeff(Index row, Index col, const OtherEvaluatorType& other)
|
||||
{
|
||||
return m_argImpl.coeff(j, i);
|
||||
derived().coeffRef(row, col) = other.coeff(row, col);
|
||||
}
|
||||
|
||||
typename TransposeType::CoeffReturnType coeff(Index index) const
|
||||
template<typename OtherEvaluatorType>
|
||||
void copyCoeffByOuterInner(Index outer, Index inner, const OtherEvaluatorType& other)
|
||||
{
|
||||
Index row = rowIndexByOuterInner(outer, inner);
|
||||
Index col = colIndexByOuterInner(outer, inner);
|
||||
derived().coeffRef(row, col) = other.coeff(row, col);
|
||||
}
|
||||
|
||||
template<typename OtherEvaluatorType>
|
||||
void copyCoeff(Index index, const OtherEvaluatorType& other)
|
||||
{
|
||||
derived().coeffRef(index) = other.coeff(index);
|
||||
}
|
||||
|
||||
template<int StoreMode, int LoadMode, typename OtherEvaluatorType>
|
||||
void copyPacket(Index row, Index col, const OtherEvaluatorType& other)
|
||||
{
|
||||
derived().template writePacket<StoreMode>(row, col,
|
||||
other.template packet<LoadMode>(row, col));
|
||||
}
|
||||
|
||||
template<int StoreMode, int LoadMode, typename OtherEvaluatorType>
|
||||
void copyPacketByOuterInner(Index outer, Index inner, const OtherEvaluatorType& other)
|
||||
{
|
||||
Index row = rowIndexByOuterInner(outer, inner);
|
||||
Index col = colIndexByOuterInner(outer, inner);
|
||||
derived().template writePacket<StoreMode>(row, col,
|
||||
other.template packet<LoadMode>(row, col));
|
||||
}
|
||||
|
||||
template<int StoreMode, int LoadMode, typename OtherEvaluatorType>
|
||||
void copyPacket(Index index, const OtherEvaluatorType& other)
|
||||
{
|
||||
derived().template writePacket<StoreMode>(index,
|
||||
other.template packet<LoadMode>(index));
|
||||
}
|
||||
|
||||
Index rowIndexByOuterInner(Index outer, Index inner) const
|
||||
{
|
||||
return int(ExpressionType::RowsAtCompileTime) == 1 ? 0
|
||||
: int(ExpressionType::ColsAtCompileTime) == 1 ? inner
|
||||
: int(ExpressionType::Flags)&RowMajorBit ? outer
|
||||
: inner;
|
||||
}
|
||||
|
||||
Index colIndexByOuterInner(Index outer, Index inner) const
|
||||
{
|
||||
return int(ExpressionType::ColsAtCompileTime) == 1 ? 0
|
||||
: int(ExpressionType::RowsAtCompileTime) == 1 ? inner
|
||||
: int(ExpressionType::Flags)&RowMajorBit ? inner
|
||||
: outer;
|
||||
}
|
||||
|
||||
evaluator_impl<ExpressionType>& derived()
|
||||
{
|
||||
return *static_cast<evaluator_impl<ExpressionType>*>(this);
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------- Transpose --------------------
|
||||
|
||||
template<typename ArgType>
|
||||
struct evaluator_impl<Transpose<ArgType> >
|
||||
: evaluator_impl_base<Transpose<ArgType> >
|
||||
{
|
||||
typedef Transpose<ArgType> XprType;
|
||||
|
||||
evaluator_impl(const XprType& t) : m_argImpl(t.nestedExpression()) {}
|
||||
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::Scalar Scalar;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketScalar PacketScalar;
|
||||
typedef typename XprType::PacketReturnType PacketReturnType;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
return m_argImpl.coeff(col, row);
|
||||
}
|
||||
|
||||
CoeffReturnType coeff(Index index) const
|
||||
{
|
||||
return m_argImpl.coeff(index);
|
||||
}
|
||||
|
||||
typename TransposeType::Scalar& coeffRef(Index i, Index j)
|
||||
Scalar& coeffRef(Index row, Index col)
|
||||
{
|
||||
return m_argImpl.coeffRef(j, i);
|
||||
return m_argImpl.coeffRef(col, row);
|
||||
}
|
||||
|
||||
typename TransposeType::Scalar& coeffRef(Index index)
|
||||
typename XprType::Scalar& coeffRef(Index index)
|
||||
{
|
||||
return m_argImpl.coeffRef(index);
|
||||
}
|
||||
|
||||
// TODO: Difference between PacketScalar and PacketReturnType?
|
||||
template<int LoadMode>
|
||||
const typename ExpressionType::PacketScalar packet(Index row, Index col) const
|
||||
PacketReturnType packet(Index row, Index col) const
|
||||
{
|
||||
return m_argImpl.template packet<LoadMode>(col, row);
|
||||
}
|
||||
|
||||
template<int LoadMode>
|
||||
const typename ExpressionType::PacketScalar packet(Index index) const
|
||||
PacketReturnType packet(Index index) const
|
||||
{
|
||||
return m_argImpl.template packet<LoadMode>(index);
|
||||
}
|
||||
|
||||
template<int StoreMode>
|
||||
void writePacket(Index row, Index col, const typename ExpressionType::PacketScalar& x)
|
||||
void writePacket(Index row, Index col, const PacketScalar& x)
|
||||
{
|
||||
m_argImpl.template writePacket<StoreMode>(col, row, x);
|
||||
}
|
||||
|
||||
template<int StoreMode>
|
||||
void writePacket(Index index, const typename ExpressionType::PacketScalar& x)
|
||||
void writePacket(Index index, const PacketScalar& x)
|
||||
{
|
||||
m_argImpl.template writePacket<StoreMode>(index, x);
|
||||
}
|
||||
|
||||
protected:
|
||||
typename evaluator<ExpressionType>::type m_argImpl;
|
||||
typename evaluator<ArgType>::type m_argImpl;
|
||||
};
|
||||
|
||||
// -------------------- Matrix and Array --------------------
|
||||
@ -113,6 +190,7 @@ protected:
|
||||
|
||||
template<typename Derived>
|
||||
struct evaluator_impl<PlainObjectBase<Derived> >
|
||||
: evaluator_impl_base<Derived>
|
||||
{
|
||||
typedef PlainObjectBase<Derived> PlainObjectType;
|
||||
|
||||
@ -176,10 +254,10 @@ template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxC
|
||||
struct evaluator_impl<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
|
||||
: evaluator_impl<PlainObjectBase<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
|
||||
{
|
||||
typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> MatrixType;
|
||||
typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
|
||||
|
||||
evaluator_impl(const MatrixType& m)
|
||||
: evaluator_impl<PlainObjectBase<MatrixType> >(m)
|
||||
evaluator_impl(const XprType& m)
|
||||
: evaluator_impl<PlainObjectBase<XprType> >(m)
|
||||
{ }
|
||||
};
|
||||
|
||||
@ -187,10 +265,10 @@ template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxC
|
||||
struct evaluator_impl<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
|
||||
: evaluator_impl<PlainObjectBase<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
|
||||
{
|
||||
typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> ArrayType;
|
||||
typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
|
||||
|
||||
evaluator_impl(const ArrayType& m)
|
||||
: evaluator_impl<PlainObjectBase<ArrayType> >(m)
|
||||
evaluator_impl(const XprType& m)
|
||||
: evaluator_impl<PlainObjectBase<XprType> >(m)
|
||||
{ }
|
||||
};
|
||||
|
||||
@ -199,15 +277,15 @@ struct evaluator_impl<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
|
||||
template<typename NullaryOp, typename PlainObjectType>
|
||||
struct evaluator_impl<CwiseNullaryOp<NullaryOp,PlainObjectType> >
|
||||
{
|
||||
typedef CwiseNullaryOp<NullaryOp,PlainObjectType> NullaryOpType;
|
||||
typedef CwiseNullaryOp<NullaryOp,PlainObjectType> XprType;
|
||||
|
||||
evaluator_impl(const NullaryOpType& n)
|
||||
evaluator_impl(const XprType& n)
|
||||
: m_functor(n.functor())
|
||||
{ }
|
||||
|
||||
typedef typename NullaryOpType::Index Index;
|
||||
typedef typename NullaryOpType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename NullaryOpType::PacketScalar PacketScalar;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketScalar PacketScalar;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
@ -240,16 +318,16 @@ protected:
|
||||
template<typename UnaryOp, typename ArgType>
|
||||
struct evaluator_impl<CwiseUnaryOp<UnaryOp, ArgType> >
|
||||
{
|
||||
typedef CwiseUnaryOp<UnaryOp, ArgType> UnaryOpType;
|
||||
typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
|
||||
|
||||
evaluator_impl(const UnaryOpType& op)
|
||||
evaluator_impl(const XprType& op)
|
||||
: m_functor(op.functor()),
|
||||
m_argImpl(op.nestedExpression())
|
||||
{ }
|
||||
|
||||
typedef typename UnaryOpType::Index Index;
|
||||
typedef typename UnaryOpType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename UnaryOpType::PacketScalar PacketScalar;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketScalar PacketScalar;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
@ -283,17 +361,17 @@ protected:
|
||||
template<typename BinaryOp, typename Lhs, typename Rhs>
|
||||
struct evaluator_impl<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
|
||||
{
|
||||
typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> BinaryOpType;
|
||||
typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
|
||||
|
||||
evaluator_impl(const BinaryOpType& xpr)
|
||||
evaluator_impl(const XprType& xpr)
|
||||
: m_functor(xpr.functor()),
|
||||
m_lhsImpl(xpr.lhs()),
|
||||
m_rhsImpl(xpr.rhs())
|
||||
{ }
|
||||
|
||||
typedef typename BinaryOpType::Index Index;
|
||||
typedef typename BinaryOpType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename BinaryOpType::PacketScalar PacketScalar;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketScalar PacketScalar;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
@ -329,17 +407,18 @@ protected:
|
||||
|
||||
template<typename UnaryOp, typename ArgType>
|
||||
struct evaluator_impl<CwiseUnaryView<UnaryOp, ArgType> >
|
||||
: evaluator_impl_base<CwiseUnaryView<UnaryOp, ArgType> >
|
||||
{
|
||||
typedef CwiseUnaryView<UnaryOp, ArgType> CwiseUnaryViewType;
|
||||
typedef CwiseUnaryView<UnaryOp, ArgType> XprType;
|
||||
|
||||
evaluator_impl(const CwiseUnaryViewType& op)
|
||||
evaluator_impl(const XprType& op)
|
||||
: m_unaryOp(op.functor()),
|
||||
m_argImpl(op.nestedExpression())
|
||||
{ }
|
||||
|
||||
typedef typename CwiseUnaryViewType::Index Index;
|
||||
typedef typename CwiseUnaryViewType::Scalar Scalar;
|
||||
typedef typename CwiseUnaryViewType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::Scalar Scalar;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
@ -400,23 +479,26 @@ protected:
|
||||
|
||||
template<typename Derived, int AccessorsType>
|
||||
struct evaluator_impl<MapBase<Derived, AccessorsType> >
|
||||
: evaluator_impl_base<Derived>
|
||||
{
|
||||
typedef MapBase<Derived, AccessorsType> MapType;
|
||||
typedef typename MapType::PointerType PointerType;
|
||||
typedef typename MapType::Index Index;
|
||||
typedef typename MapType::Scalar Scalar;
|
||||
typedef typename MapType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename MapType::PacketScalar PacketScalar;
|
||||
typedef typename MapType::PacketReturnType PacketReturnType;
|
||||
typedef Derived XprType;
|
||||
|
||||
typedef typename XprType::PointerType PointerType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::Scalar Scalar;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketScalar PacketScalar;
|
||||
typedef typename XprType::PacketReturnType PacketReturnType;
|
||||
|
||||
evaluator_impl(const MapType& map)
|
||||
evaluator_impl(const XprType& map)
|
||||
: m_data(const_cast<PointerType>(map.data())),
|
||||
m_rowStride(map.rowStride()),
|
||||
m_colStride(map.colStride())
|
||||
{ }
|
||||
|
||||
enum {
|
||||
RowsAtCompileTime = MapType::RowsAtCompileTime
|
||||
RowsAtCompileTime = XprType::RowsAtCompileTime
|
||||
};
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
@ -480,34 +562,35 @@ template<typename PlainObjectType, int MapOptions, typename StrideType>
|
||||
struct evaluator_impl<Map<PlainObjectType, MapOptions, StrideType> >
|
||||
: public evaluator_impl<MapBase<Map<PlainObjectType, MapOptions, StrideType> > >
|
||||
{
|
||||
typedef Map<PlainObjectType, MapOptions, StrideType> MapType;
|
||||
typedef Map<PlainObjectType, MapOptions, StrideType> XprType;
|
||||
|
||||
evaluator_impl(const MapType& map)
|
||||
: evaluator_impl<MapBase<MapType> >(map)
|
||||
evaluator_impl(const XprType& map)
|
||||
: evaluator_impl<MapBase<XprType> >(map)
|
||||
{ }
|
||||
};
|
||||
|
||||
// -------------------- Block --------------------
|
||||
|
||||
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
|
||||
struct evaluator_impl<Block<XprType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ false> >
|
||||
template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
|
||||
struct evaluator_impl<Block<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ false> >
|
||||
: evaluator_impl_base<Block<ArgType, BlockRows, BlockCols, InnerPanel, false> >
|
||||
{
|
||||
typedef Block<XprType, BlockRows, BlockCols, InnerPanel, false> BlockType;
|
||||
typedef Block<ArgType, BlockRows, BlockCols, InnerPanel, false> XprType;
|
||||
|
||||
evaluator_impl(const BlockType& block)
|
||||
evaluator_impl(const XprType& block)
|
||||
: m_argImpl(block.nestedExpression()),
|
||||
m_startRow(block.startRow()),
|
||||
m_startCol(block.startCol())
|
||||
{ }
|
||||
|
||||
typedef typename BlockType::Index Index;
|
||||
typedef typename BlockType::Scalar Scalar;
|
||||
typedef typename BlockType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename BlockType::PacketScalar PacketScalar;
|
||||
typedef typename BlockType::PacketReturnType PacketReturnType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::Scalar Scalar;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketScalar PacketScalar;
|
||||
typedef typename XprType::PacketReturnType PacketReturnType;
|
||||
|
||||
enum {
|
||||
RowsAtCompileTime = BlockType::RowsAtCompileTime
|
||||
RowsAtCompileTime = XprType::RowsAtCompileTime
|
||||
};
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
@ -560,7 +643,7 @@ struct evaluator_impl<Block<XprType, BlockRows, BlockCols, InnerPanel, /* HasDir
|
||||
}
|
||||
|
||||
protected:
|
||||
typename evaluator<XprType>::type m_argImpl;
|
||||
typename evaluator<ArgType>::type m_argImpl;
|
||||
|
||||
// TODO: Get rid of m_startRow, m_startCol if known at compile time
|
||||
Index m_startRow;
|
||||
@ -570,14 +653,14 @@ protected:
|
||||
// TODO: This evaluator does not actually use the child evaluator;
|
||||
// all action is via the data() as returned by the Block expression.
|
||||
|
||||
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
|
||||
struct evaluator_impl<Block<XprType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true> >
|
||||
: evaluator_impl<MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel, true> > >
|
||||
template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
|
||||
struct evaluator_impl<Block<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true> >
|
||||
: evaluator_impl<MapBase<Block<ArgType, BlockRows, BlockCols, InnerPanel, true> > >
|
||||
{
|
||||
typedef Block<XprType, BlockRows, BlockCols, InnerPanel, true> BlockType;
|
||||
typedef Block<ArgType, BlockRows, BlockCols, InnerPanel, true> XprType;
|
||||
|
||||
evaluator_impl(const BlockType& block)
|
||||
: evaluator_impl<MapBase<BlockType> >(block)
|
||||
evaluator_impl(const XprType& block)
|
||||
: evaluator_impl<MapBase<XprType> >(block)
|
||||
{ }
|
||||
};
|
||||
|
||||
@ -587,16 +670,16 @@ struct evaluator_impl<Block<XprType, BlockRows, BlockCols, InnerPanel, /* HasDir
|
||||
template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
|
||||
struct evaluator_impl<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
|
||||
{
|
||||
typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> SelectType;
|
||||
typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> XprType;
|
||||
|
||||
evaluator_impl(const SelectType& select)
|
||||
evaluator_impl(const XprType& select)
|
||||
: m_conditionImpl(select.conditionMatrix()),
|
||||
m_thenImpl(select.thenMatrix()),
|
||||
m_elseImpl(select.elseMatrix())
|
||||
{ }
|
||||
|
||||
typedef typename SelectType::Index Index;
|
||||
typedef typename SelectType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
@ -623,20 +706,20 @@ protected:
|
||||
|
||||
// -------------------- Replicate --------------------
|
||||
|
||||
template<typename XprType, int RowFactor, int ColFactor>
|
||||
struct evaluator_impl<Replicate<XprType, RowFactor, ColFactor> >
|
||||
template<typename ArgType, int RowFactor, int ColFactor>
|
||||
struct evaluator_impl<Replicate<ArgType, RowFactor, ColFactor> >
|
||||
{
|
||||
typedef Replicate<XprType, RowFactor, ColFactor> ReplicateType;
|
||||
typedef Replicate<ArgType, RowFactor, ColFactor> XprType;
|
||||
|
||||
evaluator_impl(const ReplicateType& replicate)
|
||||
evaluator_impl(const XprType& replicate)
|
||||
: m_argImpl(replicate.nestedExpression()),
|
||||
m_rows(replicate.nestedExpression().rows()),
|
||||
m_cols(replicate.nestedExpression().cols())
|
||||
{ }
|
||||
|
||||
typedef typename ReplicateType::Index Index;
|
||||
typedef typename ReplicateType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename ReplicateType::PacketReturnType PacketReturnType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketReturnType PacketReturnType;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
@ -665,7 +748,7 @@ struct evaluator_impl<Replicate<XprType, RowFactor, ColFactor> >
|
||||
}
|
||||
|
||||
protected:
|
||||
typename evaluator<XprType>::type m_argImpl;
|
||||
typename evaluator<ArgType>::type m_argImpl;
|
||||
Index m_rows; // TODO: Get rid of this if known at compile time
|
||||
Index m_cols;
|
||||
};
|
||||
@ -677,17 +760,17 @@ protected:
|
||||
// TODO: Find out how to write a proper evaluator without duplicating
|
||||
// the row() and col() member functions.
|
||||
|
||||
template< typename XprType, typename MemberOp, int Direction>
|
||||
struct evaluator_impl<PartialReduxExpr<XprType, MemberOp, Direction> >
|
||||
template< typename ArgType, typename MemberOp, int Direction>
|
||||
struct evaluator_impl<PartialReduxExpr<ArgType, MemberOp, Direction> >
|
||||
{
|
||||
typedef PartialReduxExpr<XprType, MemberOp, Direction> PartialReduxExprType;
|
||||
typedef PartialReduxExpr<ArgType, MemberOp, Direction> XprType;
|
||||
|
||||
evaluator_impl(const PartialReduxExprType expr)
|
||||
evaluator_impl(const XprType expr)
|
||||
: m_expr(expr)
|
||||
{ }
|
||||
|
||||
typedef typename PartialReduxExprType::Index Index;
|
||||
typedef typename PartialReduxExprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index col) const
|
||||
{
|
||||
@ -700,7 +783,7 @@ struct evaluator_impl<PartialReduxExpr<XprType, MemberOp, Direction> >
|
||||
}
|
||||
|
||||
protected:
|
||||
const PartialReduxExprType& m_expr;
|
||||
const XprType& m_expr;
|
||||
};
|
||||
|
||||
|
||||
@ -711,6 +794,7 @@ protected:
|
||||
|
||||
template<typename ArgType>
|
||||
struct evaluator_impl_wrapper_base
|
||||
: evaluator_impl_base<ArgType>
|
||||
{
|
||||
evaluator_impl_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}
|
||||
|
||||
@ -772,7 +856,9 @@ template<typename ArgType>
|
||||
struct evaluator_impl<MatrixWrapper<ArgType> >
|
||||
: evaluator_impl_wrapper_base<ArgType>
|
||||
{
|
||||
evaluator_impl(const MatrixWrapper<ArgType>& wrapper)
|
||||
typedef MatrixWrapper<ArgType> XprType;
|
||||
|
||||
evaluator_impl(const XprType& wrapper)
|
||||
: evaluator_impl_wrapper_base<ArgType>(wrapper.nestedExpression())
|
||||
{ }
|
||||
};
|
||||
@ -781,7 +867,9 @@ template<typename ArgType>
|
||||
struct evaluator_impl<ArrayWrapper<ArgType> >
|
||||
: evaluator_impl_wrapper_base<ArgType>
|
||||
{
|
||||
evaluator_impl(const ArrayWrapper<ArgType>& wrapper)
|
||||
typedef ArrayWrapper<ArgType> XprType;
|
||||
|
||||
evaluator_impl(const XprType& wrapper)
|
||||
: evaluator_impl_wrapper_base<ArgType>(wrapper.nestedExpression())
|
||||
{ }
|
||||
};
|
||||
@ -794,24 +882,25 @@ template<typename PacketScalar, bool ReversePacket> struct reverse_packet_cond;
|
||||
|
||||
template<typename ArgType, int Direction>
|
||||
struct evaluator_impl<Reverse<ArgType, Direction> >
|
||||
: evaluator_impl_base<Reverse<ArgType, Direction> >
|
||||
{
|
||||
typedef Reverse<ArgType, Direction> ReverseType;
|
||||
typedef Reverse<ArgType, Direction> XprType;
|
||||
|
||||
evaluator_impl(const ReverseType& reverse)
|
||||
evaluator_impl(const XprType& reverse)
|
||||
: m_argImpl(reverse.nestedExpression()),
|
||||
m_rows(reverse.nestedExpression().rows()),
|
||||
m_cols(reverse.nestedExpression().cols())
|
||||
{ }
|
||||
|
||||
typedef typename ReverseType::Index Index;
|
||||
typedef typename ReverseType::Scalar Scalar;
|
||||
typedef typename ReverseType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename ReverseType::PacketScalar PacketScalar;
|
||||
typedef typename ReverseType::PacketReturnType PacketReturnType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::Scalar Scalar;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::PacketScalar PacketScalar;
|
||||
typedef typename XprType::PacketReturnType PacketReturnType;
|
||||
|
||||
enum {
|
||||
PacketSize = internal::packet_traits<Scalar>::size,
|
||||
IsRowMajor = ReverseType::IsRowMajor,
|
||||
IsRowMajor = XprType::IsRowMajor,
|
||||
IsColMajor = !IsRowMajor,
|
||||
ReverseRow = (Direction == Vertical) || (Direction == BothDirections),
|
||||
ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
|
||||
@ -885,17 +974,18 @@ protected:
|
||||
|
||||
template<typename ArgType, int DiagIndex>
|
||||
struct evaluator_impl<Diagonal<ArgType, DiagIndex> >
|
||||
: evaluator_impl_base<Diagonal<ArgType, DiagIndex> >
|
||||
{
|
||||
typedef Diagonal<ArgType, DiagIndex> DiagonalType;
|
||||
typedef Diagonal<ArgType, DiagIndex> XprType;
|
||||
|
||||
evaluator_impl(const DiagonalType& diagonal)
|
||||
evaluator_impl(const XprType& diagonal)
|
||||
: m_argImpl(diagonal.nestedExpression()),
|
||||
m_index(diagonal.index())
|
||||
{ }
|
||||
|
||||
typedef typename DiagonalType::Index Index;
|
||||
typedef typename DiagonalType::Scalar Scalar;
|
||||
typedef typename DiagonalType::CoeffReturnType CoeffReturnType;
|
||||
typedef typename XprType::Index Index;
|
||||
typedef typename XprType::Scalar Scalar;
|
||||
typedef typename XprType::CoeffReturnType CoeffReturnType;
|
||||
|
||||
CoeffReturnType coeff(Index row, Index) const
|
||||
{
|
||||
|
||||
@ -214,5 +214,5 @@ void test_evaluators()
|
||||
|
||||
copy_using_evaluator(mat1.diagonal<-1>(), mat1.diagonal(1));
|
||||
mat2.diagonal<-1>() = mat2.diagonal(1);
|
||||
VERIFY_IS_APPROX(mat1, mat2);
|
||||
VERIFY_IS_APPROX(mat1, mat2);
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user