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

makes evaluator test use VERIFY_IS_APPROX

Browse Source
This commit is contained in:
Gael Guennebaud 2011-03-23 17:23:56 +01:00
parent 4ada45bc76
commit abc8c0821c
2 changed files with 34 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -170,9 +170,10 @@ struct copy_using_evaluator_impl<LhsXprType, RhsXprType, DefaultTraversal, NoUnr
// Based on DenseBase::LazyAssign()
template<typename LhsXprType, typename RhsXprType>
void copy_using_evaluator(const LhsXprType& lhs, const RhsXprType& rhs)
const LhsXprType& copy_using_evaluator(const LhsXprType& lhs, const RhsXprType& rhs)
{
copy_using_evaluator_impl<LhsXprType, RhsXprType>::run(lhs, rhs);
return lhs;
}
} // namespace internal

86
test/evaluators.cpp
View File

@ -5,32 +5,29 @@
using internal::copy_using_evaluator;
using namespace std;
#define VERIFY_IS_APPROX_EVALUATOR(DEST,EXPR) VERIFY_IS_APPROX(copy_using_evaluator(DEST,(EXPR)), (EXPR).eval());
#define VERIFY_IS_APPROX_EVALUATOR2(DEST,EXPR,REF) VERIFY_IS_APPROX(copy_using_evaluator(DEST,(EXPR)), (REF).eval());
void test_evaluators()
{
// Testing Matrix evaluator and Transpose
Vector2d v(1,2);
Vector2d v = Vector2d::Random();
const Vector2d v_const(v);
Vector2d v2;
RowVector2d w;
copy_using_evaluator(v2, v);
assert(v2.isApprox((Vector2d() << 1,2).finished()));
copy_using_evaluator(v2, v_const);
assert(v2.isApprox((Vector2d() << 1,2).finished()));
VERIFY_IS_APPROX_EVALUATOR(v2, v);
VERIFY_IS_APPROX_EVALUATOR(v2, v_const);
// Testing Transpose
copy_using_evaluator(w, v.transpose()); // Transpose as rvalue
assert(w.isApprox((RowVector2d() << 1,2).finished()));
copy_using_evaluator(w, v_const.transpose());
assert(w.isApprox((RowVector2d() << 1,2).finished()));
VERIFY_IS_APPROX_EVALUATOR(w, v.transpose()); // Transpose as rvalue
VERIFY_IS_APPROX_EVALUATOR(w, v_const.transpose());
copy_using_evaluator(w.transpose(), v); // Transpose as lvalue
assert(w.isApprox((RowVector2d() << 1,2).finished()));
VERIFY_IS_APPROX(w,v.transpose().eval());
copy_using_evaluator(w.transpose(), v_const);
assert(w.isApprox((RowVector2d() << 1,2).finished()));
VERIFY_IS_APPROX(w,v_const.transpose().eval());
// Testing Array evaluator
ArrayXXf a(2,3);
@ -38,39 +35,32 @@ void test_evaluators()
a << 1,2,3, 4,5,6;
const ArrayXXf a_const(a);
ArrayXXf b_expected(3,2);
b_expected << 1,4, 2,5, 3,6;
copy_using_evaluator(b, a.transpose());
assert(b.isApprox(b_expected));
VERIFY_IS_APPROX_EVALUATOR(b, a.transpose());
copy_using_evaluator(b, a_const.transpose());
assert(b.isApprox(b_expected));
VERIFY_IS_APPROX_EVALUATOR(b, a_const.transpose());
// Testing CwiseNullaryOp evaluator
copy_using_evaluator(w, RowVector2d::Random());
assert((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ...
VERIFY((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ...
copy_using_evaluator(w, RowVector2d::Zero());
assert(w.isApprox((RowVector2d() << 0,0).finished()));
VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Zero());
copy_using_evaluator(w, RowVector2d::Constant(3));
assert(w.isApprox((RowVector2d() << 3,3).finished()));
VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Constant(3));
// mix CwiseNullaryOp and transpose
copy_using_evaluator(w, Vector2d::Zero().transpose());
assert(w.isApprox((RowVector2d() << 0,0).finished()));
VERIFY_IS_APPROX_EVALUATOR(w, Vector2d::Zero().transpose());
{
MatrixXf a(2,2), b(2,2), c(2,2), d(2,2);
a << 1, 2, 3, 4; b << 5, 6, 7, 8; c << 9, 10, 11, 12;
copy_using_evaluator(d, (a + b));
cout << d << endl;
copy_using_evaluator(d, (a + b).transpose());
cout << d << endl;
copy_using_evaluator(d, prod(a,b).transpose());
cout << d << endl;
int s = internal::random<int>(1,100);
MatrixXf a(s,s), b(s,s), c(s,s), d(s,s);
a.setRandom();
b.setRandom();
c.setRandom();
d.setRandom();
VERIFY_IS_APPROX_EVALUATOR(d, (a + b));
VERIFY_IS_APPROX_EVALUATOR(d, (a + b).transpose());
VERIFY_IS_APPROX_EVALUATOR2(d, prod(a,b).transpose(), (a*b).transpose());
VERIFY_IS_APPROX_EVALUATOR2(d, prod(a,b) + prod(b,c), a*b + b*c);
// copy_using_evaluator(d, a.transpose() + (a.transpose() * (b+b)));
// cout << d << endl;
@ -80,24 +70,12 @@ void test_evaluators()
// copy_using_evaluator(w, Vector2d::Random().transpose());
// test CwiseUnaryOp
copy_using_evaluator(v2, 3 * v);
assert(v2.isApprox((Vector2d() << 3,6).finished()));
copy_using_evaluator(w, (3 * v).transpose());
assert(w.isApprox((RowVector2d() << 3,6).finished()));
copy_using_evaluator(b, (a + 3).transpose());
b_expected << 4,7, 5,8, 6,9;
assert(b.isApprox(b_expected));
copy_using_evaluator(b, (2 * a_const + 3).transpose());
b_expected << 5,11, 7,13, 9,15;
assert(b.isApprox(b_expected));
VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v);
VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose());
VERIFY_IS_APPROX_EVALUATOR(b, (a + 3).transpose());
VERIFY_IS_APPROX_EVALUATOR(b, (2 * a_const + 3).transpose());
// test CwiseBinaryOp
copy_using_evaluator(v2, v + Vector2d::Ones());
assert(v2.isApprox((Vector2d() << 2,3).finished()));
copy_using_evaluator(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3)));
assert(w.isApprox((RowVector2d() << 6,9).finished()));
VERIFY_IS_APPROX_EVALUATOR(v2, v + Vector2d::Ones());
VERIFY_IS_APPROX_EVALUATOR(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3)));
}