From f1d98aad1bf8590d9bb1f1126303417710dae759 Mon Sep 17 00:00:00 2001 From: Gael Guennebaud Date: Mon, 5 Sep 2011 17:47:58 +0200 Subject: [PATCH] add atan2 support in AutoDiff and remove superfluous std:: specializations --- .../Eigen/src/AutoDiff/AutoDiffScalar.h | 100 +++++++----------- unsupported/test/autodiff.cpp | 33 +++++- 2 files changed, 69 insertions(+), 64 deletions(-) diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h index 371160c24..323bac764 100644 --- a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h +++ b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h @@ -503,8 +503,6 @@ struct scalar_product_traits,T> } // end namespace internal -} // end namespace Eigen - #define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC,CODE) \ template \ inline const Eigen::AutoDiffScalar::type>::Scalar>, const typename Eigen::internal::remove_all::type> > \ @@ -515,94 +513,78 @@ struct scalar_product_traits,T> CODE; \ } -namespace std -{ - EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs, - return ReturnType(std::abs(x.value()), x.derivatives() * (sign(x.value())));) - - EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sqrt, - Scalar sqrtx = std::sqrt(x.value()); - return ReturnType(sqrtx,x.derivatives() * (Scalar(0.5) / sqrtx));) - - EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos, - return ReturnType(std::cos(x.value()), x.derivatives() * (-std::sin(x.value())));) - - EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sin, - return ReturnType(std::sin(x.value()),x.derivatives() * std::cos(x.value()));) - - EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp, - Scalar expx = std::exp(x.value()); - return ReturnType(expx,x.derivatives() * expx);) - - EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(log, - return ReturnType(std::log(x.value()),x.derivatives() * (Scalar(1)/x.value()));) - - template - inline const Eigen::AutoDiffScalar::Scalar>, const DerType> > - pow(const Eigen::AutoDiffScalar& x, typename Eigen::internal::traits::Scalar y) - { - using namespace Eigen; - typedef typename Eigen::internal::traits::Scalar Scalar; - return AutoDiffScalar, const DerType> >( - std::pow(x.value(),y), - x.derivatives() * (y * std::pow(x.value(),y-1))); - } - -} - -#undef EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY -#define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC,CODE) \ - template \ - struct FUNC##_impl > \ - { \ - static inline const Eigen::AutoDiffScalar::type>::Scalar>, const typename Eigen::internal::remove_all::type> > \ - run(const Eigen::AutoDiffScalar& x) { \ - using namespace Eigen; \ - typedef typename Eigen::internal::traits::type>::Scalar Scalar; \ - typedef AutoDiffScalar, const typename Eigen::internal::remove_all::type> > ReturnType; \ - CODE; \ - } }; - -namespace Eigen { - -namespace internal { - template inline const AutoDiffScalar& conj(const AutoDiffScalar& x) { return x; } template inline const AutoDiffScalar& real(const AutoDiffScalar& x) { return x; } template inline typename DerType::Scalar imag(const AutoDiffScalar&) { return 0.; } - + EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs, + using std::abs; return ReturnType(abs(x.value()), x.derivatives() * (sign(x.value())));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2, + using internal::abs2; return ReturnType(abs2(x.value()), x.derivatives() * (Scalar(2)*x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sqrt, + using std::sqrt; Scalar sqrtx = sqrt(x.value()); return ReturnType(sqrtx,x.derivatives() * (Scalar(0.5) / sqrtx));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos, + using std::cos; + using std::sin; return ReturnType(cos(x.value()), x.derivatives() * (-sin(x.value())));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sin, + using std::sin; + using std::cos; return ReturnType(sin(x.value()),x.derivatives() * cos(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp, + using std::exp; Scalar expx = exp(x.value()); return ReturnType(expx,x.derivatives() * expx);) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(log, + using std::log; return ReturnType(log(x.value()),x.derivatives() * (Scalar(1)/x.value()));) template -inline const AutoDiffScalar::Scalar>, DerType> > -pow(const AutoDiffScalar& x, typename traits::Scalar y) -{ return std::pow(x,y);} +inline const Eigen::AutoDiffScalar::Scalar>, const DerType> > +pow(const Eigen::AutoDiffScalar& x, typename Eigen::internal::traits::Scalar y) +{ + using namespace Eigen; + typedef typename Eigen::internal::traits::Scalar Scalar; + return AutoDiffScalar, const DerType> >( + std::pow(x.value(),y), + x.derivatives() * (y * std::pow(x.value(),y-1))); +} -} // end namespace internal + +template +inline const AutoDiffScalar::Scalar,Dynamic,1> > +atan2(const AutoDiffScalar& a, const AutoDiffScalar& b) +{ + using std::atan2; + typedef typename internal::traits::Scalar Scalar; + typedef AutoDiffScalar > PlainADS; + PlainADS ret; + ret.value() = atan2(a.value(), b.value()); + + Scalar tmp2 = a.value() * a.value(); + Scalar tmp3 = b.value() * b.value(); + Scalar tmp4 = tmp3/(tmp2+tmp3); + + if (tmp4!=0) + ret.derivatives() = (a.derivatives() * b.value() - a.value() * b.derivatives()) * (tmp2+tmp3); + else + ret.derivatives().setZero(); + + return ret; +} #undef EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY diff --git a/unsupported/test/autodiff.cpp b/unsupported/test/autodiff.cpp index a32d85829..3bc360548 100644 --- a/unsupported/test/autodiff.cpp +++ b/unsupported/test/autodiff.cpp @@ -28,13 +28,21 @@ template EIGEN_DONT_INLINE Scalar foo(const Scalar& x, const Scalar& y) { + using namespace std; // return x+std::sin(y); EIGEN_ASM_COMMENT("mybegin"); - return static_cast(x*2 - std::pow(x,2) + 2*std::sqrt(y*y) - 4 * std::sin(x) + 2 * std::cos(y) - std::exp(-0.5*x*x)); + return static_cast(x*2 - pow(x,2) + 2*sqrt(y*y) - 4 * sin(x) + 2 * cos(y) - exp(-0.5*x*x)); //return x+2*y*x;//x*2 -std::pow(x,2);//(2*y/x);// - y*2; EIGEN_ASM_COMMENT("myend"); } +template +EIGEN_DONT_INLINE typename Vector::Scalar foo(const Vector& p) +{ + typedef typename Vector::Scalar Scalar; + return (p-Vector(Scalar(-1),Scalar(1.))).norm(); +} + template struct TestFunc1 { @@ -140,9 +148,23 @@ void test_autodiff_scalar() typedef AutoDiffScalar AD; AD ax(1,Vector2f::UnitX()); AD ay(2,Vector2f::UnitY()); - foo(ax,ay); - std::cerr << foo(ax,ay).value() << " <> " - << foo(ax,ay).derivatives().transpose() << "\n\n"; + AD res = foo(ax,ay); + std::cerr << res.value() << " <> " + << res.derivatives().transpose() << "\n\n"; +} + +void test_autodiff_vector() +{ + std::cerr << foo(Vector2f(1,2)) << "\n"; + typedef AutoDiffScalar AD; + typedef Matrix VectorAD; + VectorAD p(AD(1),AD(-1)); + p.x().derivatives() = Vector2f::UnitX(); + p.y().derivatives() = Vector2f::UnitY(); + + AD res = foo(p); + std::cerr << res.value() << " <> " + << res.derivatives().transpose() << "\n\n"; } void test_autodiff_jacobian() @@ -159,6 +181,7 @@ void test_autodiff_jacobian() void test_autodiff() { test_autodiff_scalar(); - test_autodiff_jacobian(); + test_autodiff_vector(); +// test_autodiff_jacobian(); }