GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-07-30 16:52:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

Get rid of call_dense_swap_loop

Browse Source
This commit is contained in:
Gael Guennebaud 2013-12-02 14:44:13 +01:00
parent 626821b0e3
commit c6f7337032
3 changed files with 13 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Eigen/src/Core/AssignEvaluator.h
View File

@ -504,7 +504,7 @@ struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, NoUnrolling>
// This abstraction level permits to keep the evaluation loops as simple and as generic as possible. // This abstraction level permits to keep the evaluation loops as simple and as generic as possible.
// One can customize the assignment using this generic dense_assignment_kernel with different // One can customize the assignment using this generic dense_assignment_kernel with different
// functors, or by completely overloading it, by-passing a functor. // functors, or by completely overloading it, by-passing a functor.
template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor> template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
class generic_dense_assignment_kernel class generic_dense_assignment_kernel
{ {
protected: protected:

31
Eigen/src/Core/Swap.h
View File

@ -139,15 +139,16 @@ template<typename ExpressionType> class SwapWrapper
// #endif // #endif
#ifdef EIGEN_TEST_EVALUATORS #ifdef EIGEN_ENABLE_EVALUATORS
namespace internal { namespace internal {
// Overload default assignPacket behavior for swapping them // Overload default assignPacket behavior for swapping them
template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT> template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT>
class dense_swap_kernel : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar> > class generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, Specialized>
: public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn>
{ {
typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar> > Base; typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn> Base;
typedef typename DstEvaluatorTypeT::PacketScalar PacketScalar; typedef typename DstEvaluatorTypeT::PacketScalar PacketScalar;
using Base::m_dst; using Base::m_dst;
using Base::m_src; using Base::m_src;
@ -157,9 +158,10 @@ public:
typedef typename Base::Scalar Scalar; typedef typename Base::Scalar Scalar;
typedef typename Base::Index Index; typedef typename Base::Index Index;
typedef typename Base::DstXprType DstXprType; typedef typename Base::DstXprType DstXprType;
typedef swap_assign_op<Scalar> Functor;
dense_swap_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, DstXprType& dstExpr) generic_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr)
: Base(dst, src, swap_assign_op<Scalar>(), dstExpr) : Base(dst, src, func, dstExpr)
{} {}
template<int StoreMode, int LoadMode> template<int StoreMode, int LoadMode>
@ -183,25 +185,6 @@ public:
assignPacket<StoreMode,LoadMode>(row, col); assignPacket<StoreMode,LoadMode>(row, col);
} }
}; };
template<typename DstXprType, typename SrcXprType>
void call_dense_swap_loop(const DstXprType& dst, const SrcXprType& src)
{
// TODO there is too much redundancy with call_dense_assignment_loop
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
typedef typename evaluator<DstXprType>::type DstEvaluatorType;
typedef typename evaluator<SrcXprType>::type SrcEvaluatorType;
DstEvaluatorType dstEvaluator(dst);
SrcEvaluatorType srcEvaluator(src);
typedef dense_swap_kernel<DstEvaluatorType,SrcEvaluatorType> Kernel;
Kernel kernel(dstEvaluator, srcEvaluator, dst.const_cast_derived());
dense_assignment_loop<Kernel>::run(kernel);
}
} // namespace internal } // namespace internal

9
test/evaluators.cpp
View File

@ -74,7 +74,8 @@ namespace Eigen {
template<typename DstXprType, typename SrcXprType> template<typename DstXprType, typename SrcXprType>
void swap_using_evaluator(const DstXprType& dst, const SrcXprType& src) void swap_using_evaluator(const DstXprType& dst, const SrcXprType& src)
{ {
call_dense_swap_loop(dst.const_cast_derived(), src.const_cast_derived()); typedef typename DstXprType::Scalar Scalar;
call_assignment(dst.const_cast_derived(), src.const_cast_derived(), internal::swap_assign_op<Scalar>());
} }
} }
@ -193,7 +194,7 @@ void test_evaluators()
VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mX4,m4X), mX4*m4X); VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mX4,m4X), mX4*m4X);
VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mXX,mXX), mXX*mXX); VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mXX,mXX), mXX*mXX);
} }
#endif
{ {
ArrayXXf a(2,3); ArrayXXf a(2,3);
ArrayXXf b(3,2); ArrayXXf b(3,2);
@ -202,7 +203,7 @@ void test_evaluators()
// this does not work because Random is eval-before-nested: // this does not work because Random is eval-before-nested:
// copy_using_evaluator(w, Vector2d::Random().transpose()); // copy_using_evaluator(w, Vector2d::Random().transpose());
// test CwiseUnaryOp // test CwiseUnaryOp
VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v); VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v);
VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose()); VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose());
@ -405,7 +406,7 @@ void test_evaluators()
arr_ref.row(1) /= (arr_ref.row(2) + 1); arr_ref.row(1) /= (arr_ref.row(2) + 1);
VERIFY_IS_APPROX(arr, arr_ref); VERIFY_IS_APPROX(arr, arr_ref);
} }
#endif
{ {
// test triangular shapes // test triangular shapes
MatrixXd A = MatrixXd::Random(6,6), B(6,6), C(6,6); MatrixXd A = MatrixXd::Random(6,6), B(6,6), C(6,6);