initial commit
This commit is contained in:
Jérôme
parent
8a7a27370b
commit
92beeb07cd
9 changed files with 2161 additions and 0 deletions
390
AutomaticDifferentiation.hpp
Normal file
390
AutomaticDifferentiation.hpp
Normal file
|
|
@ -0,0 +1,390 @@
|
|||
#ifndef DEF_AUTOMATIC_DIFFERENTIATION
|
||||
#define DEF_AUTOMATIC_DIFFERENTIATION
|
||||
|
||||
#include <cmath>
|
||||
#include <ostream>
|
||||
|
||||
/// Implementation of dual numbers for automatic differentiation
|
||||
/// reference : http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.89.7749&rep=rep1&type=pdf
|
||||
template<typename Scalar>
|
||||
class Dual
|
||||
{
|
||||
public:
|
||||
Dual(const Scalar & _a, const Scalar & _b = Scalar(0.0))
|
||||
: a(_a),
|
||||
b(_b)
|
||||
{}
|
||||
|
||||
static Dual d() {
|
||||
return Dual(Scalar(0.), Scalar(1.));
|
||||
}
|
||||
|
||||
Dual & operator+=(const Dual & x) {
|
||||
a += x.a;
|
||||
b += x.b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Dual & operator-=(const Dual & x) {
|
||||
a -= x.a;
|
||||
b -= x.b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Dual & operator*=(const Dual & x) {
|
||||
b = a*x.b + b*x.a;
|
||||
a *= x.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Dual & operator/=(const Dual & x) {
|
||||
b = (x.a*b - a*x.b)/(x.a*x.a);
|
||||
a /= x.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Dual & operator++() { // ++x
|
||||
return ((*this) += Scalar(1.));
|
||||
}
|
||||
|
||||
Dual & operator--() { // --x
|
||||
return ((*this) -= Scalar(1.));
|
||||
}
|
||||
|
||||
Dual operator++(int) { // x++
|
||||
Dual copy = *this;
|
||||
(*this) += Scalar(1.);
|
||||
return copy;
|
||||
}
|
||||
|
||||
Dual operator--(int) { // x--
|
||||
Dual copy = *this;
|
||||
(*this) -= Scalar(1.);
|
||||
return copy;
|
||||
}
|
||||
|
||||
Dual operator+(const Dual & x) const {
|
||||
Dual res(*this);
|
||||
return (res += x);
|
||||
}
|
||||
|
||||
Dual operator+(void) const { // +x
|
||||
return (*this);
|
||||
}
|
||||
|
||||
Dual operator-(const Dual & x) const {
|
||||
Dual res(*this);
|
||||
return (res -= x);
|
||||
}
|
||||
|
||||
Dual operator-(void) const { // -x
|
||||
return Dual(-a, -b);
|
||||
}
|
||||
|
||||
Dual operator*(const Dual & x) const {
|
||||
Dual res(*this);
|
||||
return (res *= x);
|
||||
}
|
||||
|
||||
Dual operator/(const Dual & x) const {
|
||||
Dual res(*this);
|
||||
return (res /= x);
|
||||
}
|
||||
|
||||
bool operator==(const Dual & x) const {
|
||||
return (a == x.a);
|
||||
}
|
||||
|
||||
bool operator!=(const Dual & x) const {
|
||||
return (a != x.a);
|
||||
}
|
||||
|
||||
bool operator<(const Dual & x) const {
|
||||
return (a < x.a);
|
||||
}
|
||||
|
||||
bool operator<=(const Dual & x) const {
|
||||
return (a <= x.a);
|
||||
}
|
||||
|
||||
bool operator>(const Dual & x) const {
|
||||
return (a > x.a);
|
||||
}
|
||||
|
||||
bool operator>=(const Dual & x) const {
|
||||
return (a >= x.a);
|
||||
}
|
||||
|
||||
Scalar a; /// Real part
|
||||
Scalar b; /// Infinitesimal part
|
||||
};
|
||||
|
||||
// Basic mathematical functions for Scalar numbers
|
||||
|
||||
// Trigonometric functions
|
||||
template<typename Scalar> Scalar sec(const Scalar & x) {
|
||||
return Scalar(1.)/cos(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar cot(const Scalar & x) {
|
||||
return cos(x)/sin(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar csc(const Scalar & x) {
|
||||
return Scalar(1.)/sin(x);
|
||||
}
|
||||
|
||||
// Inverse trigonometric functions
|
||||
template<typename Scalar> Scalar asec(const Scalar & x) {
|
||||
return acos(Scalar(1.)/x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acot(const Scalar & x) {
|
||||
return atan(Scalar(1.)/x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acsc(const Scalar & x) {
|
||||
return asin(Scalar(1.)/x);
|
||||
}
|
||||
|
||||
// Hyperbolic trigonometric functions
|
||||
template<typename Scalar> Scalar sech(const Scalar & x) {
|
||||
return Scalar(1.)/cosh(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar coth(const Scalar & x) {
|
||||
return cosh(x)/sinh(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar csch(const Scalar & x) {
|
||||
return Scalar(1.)/sinh(x);
|
||||
}
|
||||
|
||||
// Inverse hyperbolic trigonometric functions
|
||||
template<typename Scalar> Scalar asech(const Scalar & x) {
|
||||
return log((Scalar(1.) + sqrt(Scalar(1.) - x*x))/x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acoth(const Scalar & x) {
|
||||
return Scalar(0.5)*log((x + Scalar(1.))/(x - Scalar(1.)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acsch(const Scalar & x) {
|
||||
return (x >= Scalar(0.)) ? log((Scalar(1.) + sqrt(Scalar(1.) + x*x))/x) : log((Scalar(1.) - sqrt(Scalar(1.) + x*x))/x);
|
||||
}
|
||||
|
||||
// Other functions
|
||||
template<typename Scalar> Scalar exp10(const Scalar & x) {
|
||||
return exp(x*log(Scalar(10.)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar sign(const Scalar & x) {
|
||||
return (x >= Scalar(0.)) ? ((x > Scalar(0.)) ? Scalar(1.) : Scalar(0.)) : Scalar(-1.);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar heaviside(const Scalar & x) {
|
||||
return Scalar(x >= Scalar(0.));
|
||||
}
|
||||
|
||||
// Basic mathematical functions for Dual numbers
|
||||
// f(a + b*d) = f(a) + b*f'(a)*d
|
||||
|
||||
// Trigonometric functions
|
||||
template<typename Scalar> Dual<Scalar> cos(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(cos(x.a), -x.b*sin(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> sin(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(sin(x.a), x.b*cos(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> tan(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(tan(x.a), x.b*sec(x.a)*sec(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> sec(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(sec(x.a), x.b*sec(x.a)*tan(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> cot(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(cot(x.a), x.b*(-csc(x.a)*csc(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> csc(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(csc(x.a), x.b*(-cot(x.a)*csc(x.a)));
|
||||
}
|
||||
|
||||
// Inverse trigonometric functions
|
||||
template<typename Scalar> Dual<Scalar> acos(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(acos(x.a), x.b*(-Scalar(1.)/sqrt(Scalar(1.)-x.a*x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> asin(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(asin(x.a), x.b*(Scalar(1.)/sqrt(Scalar(1.)-x.a*x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> atan(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(atan(x.a), x.b*(Scalar(1.)/(x.a*x.a + Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> asec(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(asec(x.a), x.b*(Scalar(1.)/(sqrt(Scalar(1.)-Scalar(1.)/(x.a*x.a))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> acot(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(acot(x.a), x.b*(-Scalar(1.)/((x.a*x.a)+Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> acsc(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(acsc(x.a), x.b*(-Scalar(1.)/(sqrt(Scalar(1.)-Scalar(1.)/(x.a*x.a))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
// Hyperbolic trigonometric functions
|
||||
template<typename Scalar> Dual<Scalar> cosh(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(cosh(x.a), x.b*sinh(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> sinh(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(sinh(x.a), x.b*cosh(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> tanh(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(tanh(x.a), x.b*sech(x.a)*sech(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> sech(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(sech(x.a), x.b*(-sech(x.a)*tanh(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> coth(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(coth(x.a), x.b*(-csch(x.a)*csch(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> csch(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(csch(x.a), x.b*(-coth(x.a)*csch(x.a)));
|
||||
}
|
||||
|
||||
// Inverse hyperbolic trigonometric functions
|
||||
template<typename Scalar> Dual<Scalar> acosh(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(acosh(x.a), x.b*(Scalar(1.)/sqrt((x.a*x.a)-Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> asinh(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(asinh(x.a), x.b*(Scalar(1.)/sqrt((x.a*x.a)+Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> atanh(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(atanh(x.a), x.b*(Scalar(1.)/(Scalar(1.)-(x.a*x.a))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> asech(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(asech(x.a), x.b*(Scalar(-1.)/(sqrt(Scalar(1.)/(x.a*x.a)-Scalar(1.))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> acoth(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(acoth(x.a), x.b*(-Scalar(1.)/((x.a*x.a)-Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> acsch(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(acsch(x.a), x.b*(-Scalar(1.)/(sqrt(Scalar(1.)/(x.a*x.a)+Scalar(1.))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
// Exponential functions
|
||||
template<typename Scalar> Dual<Scalar> exp(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(exp(x.a), x.b*exp(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> log(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(log(x.a), x.b/x.a);
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> exp10(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(exp10(x.a), x.b*(log(Scalar(10.))*exp10(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> log10(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(log10(x.a), x.b/(log(Scalar(10.))*x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> exp2(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(exp2(x.a), x.b*(log(Scalar(2.))*exp2(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> log2(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(log2(x.a), x.b/(log(Scalar(2.))*x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> pow(const Dual<Scalar> & x, const Dual<Scalar> & n) {
|
||||
return exp(n*log(x));
|
||||
}
|
||||
|
||||
// Other functions
|
||||
template<typename Scalar> Dual<Scalar> sqrt(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(sqrt(x.a), x.b/(Scalar(2.)*sqrt(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> sign(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(sign(x.a), Scalar(0.));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> abs(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(fabs(x.a), x.b*sign(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> fabs(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(fabs(x.a), x.b*sign(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> heaviside(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(heaviside(x.a), Scalar(0.));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> floor(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(floor(x.a), Scalar(0.));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> ceil(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(ceil(x.a), Scalar(0.));
|
||||
}
|
||||
|
||||
template<typename Scalar> Dual<Scalar> round(const Dual<Scalar> & x) {
|
||||
return Dual<Scalar>(round(x.a), Scalar(0.));
|
||||
}
|
||||
|
||||
template<typename Scalar> std::ostream & operator<<(std::ostream & s, const Dual<Scalar> & x)
|
||||
{
|
||||
return (s << x.a);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
367
AutomaticDifferentiationVector.hpp
Normal file
367
AutomaticDifferentiationVector.hpp
Normal file
|
|
@ -0,0 +1,367 @@
|
|||
#ifndef DEF_AUTOMATIC_DIFFERENTIATION
|
||||
#define DEF_AUTOMATIC_DIFFERENTIATION
|
||||
|
||||
#include <cmath>
|
||||
#include <ostream>
|
||||
|
||||
#include <Eigen/Dense>
|
||||
|
||||
/// Implementation of dual numbers for automatic differentiation.
|
||||
/// This implementation uses vectors for b so that function gradients can be computed in one function call.
|
||||
/// Set the index of every variable with the ::d(int i) function and call the function to be computed : f(x+DualVector::d(0), y+DualVector::d(1), z+DualVector::d(2), ...)
|
||||
/// reference : http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.89.7749&rep=rep1&type=pdf
|
||||
template<typename Scalar, int N>
|
||||
class DualVector
|
||||
{
|
||||
public:
|
||||
using VectorT = Eigen::Matrix<Scalar, N, 1>;
|
||||
|
||||
DualVector(const Scalar & _a, const VectorT & _b = VectorT::Zero())
|
||||
: a(_a),
|
||||
b(_b)
|
||||
{}
|
||||
|
||||
DualVector(const Scalar & _a, const Scalar & _b)
|
||||
: a(_a)
|
||||
{
|
||||
b.fill(_b);
|
||||
}
|
||||
|
||||
static DualVector d(int i = 0)
|
||||
{
|
||||
assert(i >= 0);
|
||||
assert(i < N);
|
||||
VectorT _d = VectorT::Zero();
|
||||
_d[i] = Scalar(1.);
|
||||
return DualVector(Scalar(0.), _d);
|
||||
}
|
||||
|
||||
DualVector & operator+=(const DualVector & x)
|
||||
{
|
||||
a += x.a;
|
||||
b += x.b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
DualVector & operator-=(const DualVector & x)
|
||||
{
|
||||
a -= x.a;
|
||||
b -= x.b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
DualVector & operator*=(const DualVector & x)
|
||||
{
|
||||
b = a*x.b + b*x.a;
|
||||
a *= x.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
DualVector & operator/=(const DualVector & x)
|
||||
{
|
||||
b = (x.a*b - a*x.b)/(x.a*x.a);
|
||||
a /= x.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
DualVector operator+(const DualVector & x) const
|
||||
{
|
||||
DualVector res(*this);
|
||||
return (res += x);
|
||||
}
|
||||
|
||||
DualVector operator+(void) const // +x
|
||||
{
|
||||
return (*this);
|
||||
}
|
||||
|
||||
DualVector operator-(const DualVector & x) const {
|
||||
DualVector res(*this);
|
||||
return (res -= x);
|
||||
}
|
||||
|
||||
DualVector operator-(void) const // -x
|
||||
{
|
||||
return DualVector(-a, -b);
|
||||
}
|
||||
|
||||
DualVector operator*(const DualVector & x) const
|
||||
{
|
||||
DualVector res(*this);
|
||||
return (res *= x);
|
||||
}
|
||||
|
||||
DualVector operator/(const DualVector & x) const
|
||||
{
|
||||
DualVector res(*this);
|
||||
return (res /= x);
|
||||
}
|
||||
|
||||
Scalar a; /// Real part
|
||||
VectorT b; /// Infinitesimal parts
|
||||
};
|
||||
|
||||
// Basic mathematical functions for Scalar numbers
|
||||
|
||||
// Trigonometric functions
|
||||
template<typename Scalar> Scalar sec(const Scalar & x) {
|
||||
return Scalar(1.)/cos(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar cot(const Scalar & x) {
|
||||
return cos(x)/sin(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar csc(const Scalar & x) {
|
||||
return Scalar(1.)/sin(x);
|
||||
}
|
||||
|
||||
// Inverse trigonometric functions
|
||||
template<typename Scalar> Scalar asec(const Scalar & x) {
|
||||
return acos(Scalar(1.)/x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acot(const Scalar & x) {
|
||||
return atan(Scalar(1.)/x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acsc(const Scalar & x) {
|
||||
return asin(Scalar(1.)/x);
|
||||
}
|
||||
|
||||
// Hyperbolic trigonometric functions
|
||||
template<typename Scalar> Scalar sech(const Scalar & x) {
|
||||
return Scalar(1.)/cosh(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar coth(const Scalar & x) {
|
||||
return cosh(x)/sinh(x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar csch(const Scalar & x) {
|
||||
return Scalar(1.)/sinh(x);
|
||||
}
|
||||
|
||||
// Inverse hyperbolic trigonometric functions
|
||||
template<typename Scalar> Scalar asech(const Scalar & x) {
|
||||
return log((Scalar(1.) + sqrt(Scalar(1.) - x*x))/x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acoth(const Scalar & x) {
|
||||
return Scalar(0.5)*log((x + Scalar(1.))/(x - Scalar(1.)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar acsch(const Scalar & x) {
|
||||
return (x >= Scalar(0.)) ? log((Scalar(1.) + sqrt(Scalar(1.) + x*x))/x) : log((Scalar(1.) - sqrt(Scalar(1.) + x*x))/x);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar exp10(const Scalar & x) {
|
||||
return exp(x*log(Scalar(10.)));
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar sign(const Scalar & x) {
|
||||
return (x >= Scalar(0.)) ? ((x > Scalar(0.)) ? Scalar(1.) : Scalar(0.)) : Scalar(-1.);
|
||||
}
|
||||
|
||||
template<typename Scalar> Scalar heaviside(const Scalar & x) {
|
||||
return Scalar(x >= Scalar(0.));
|
||||
}
|
||||
|
||||
// Basic mathematical functions for DualVector numbers
|
||||
// f(a + b*d) = f(a) + b*f'(a)*d
|
||||
|
||||
// Trigonometric functions
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> cos(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(cos(x.a), -x.b*sin(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> sin(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(sin(x.a), x.b*cos(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> tan(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(tan(x.a), x.b*sec(x.a)*sec(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> sec(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(sec(x.a), x.b*sec(x.a)*tan(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> cot(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(cot(x.a), x.b*(-csc(x.a)*csc(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> csc(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(csc(x.a), x.b*(-cot(x.a)*csc(x.a)));
|
||||
}
|
||||
|
||||
// Inverse trigonometric functions
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> acos(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(acos(x.a), x.b*(-Scalar(1.)/sqrt(Scalar(1.)-x.a*x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> asin(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(asin(x.a), x.b*(Scalar(1.)/sqrt(Scalar(1.)-x.a*x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> atan(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(atan(x.a), x.b*(Scalar(1.)/(x.a*x.a + Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> asec(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(asec(x.a), x.b*(Scalar(1.)/(sqrt(Scalar(1.)-Scalar(1.)/(x.a*x.a))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> acot(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(acot(x.a), x.b*(-Scalar(1.)/((x.a*x.a)+Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> acsc(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(acsc(x.a), x.b*(-Scalar(1.)/(sqrt(Scalar(1.)-Scalar(1.)/(x.a*x.a))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
// Hyperbolic trigonometric functions
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> cosh(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(cosh(x.a), x.b*sinh(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> sinh(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(sinh(x.a), x.b*cosh(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> tanh(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(tanh(x.a), x.b*sech(x.a)*sech(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> sech(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(sech(x.a), x.b*(-sech(x.a)*tanh(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> coth(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(coth(x.a), x.b*(-csch(x.a)*csch(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> csch(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(csch(x.a), x.b*(-coth(x.a)*csch(x.a)));
|
||||
}
|
||||
|
||||
// Inverse hyperbolic trigonometric functions
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> acosh(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(acosh(x.a), x.b*(Scalar(1.)/sqrt((x.a*x.a)-Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> asinh(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(asinh(x.a), x.b*(Scalar(1.)/sqrt((x.a*x.a)+Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> atanh(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(atanh(x.a), x.b*(Scalar(1.)/(Scalar(1.)-(x.a*x.a))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> asech(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(asech(x.a), x.b*(Scalar(-1.)/(sqrt(Scalar(1.)/(x.a*x.a)-Scalar(1.))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> acoth(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(acoth(x.a), x.b*(-Scalar(1.)/((x.a*x.a)-Scalar(1.))));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> acsch(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(acsch(x.a), x.b*(-Scalar(1.)/(sqrt(Scalar(1.)/(x.a*x.a)+Scalar(1.))*(x.a*x.a))));
|
||||
}
|
||||
|
||||
// Exponential functions
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> exp(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(exp(x.a), x.b*exp(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> log(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(log(x.a), x.b/x.a);
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> exp10(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(exp10(x.a), x.b*(log(Scalar(10.))*exp10(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> log10(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(log10(x.a), x.b/(log(Scalar(10.))*x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> exp2(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(exp2(x.a), x.b*(log(Scalar(2.))*exp2(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> log2(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(log2(x.a), x.b/(log(Scalar(2.))*x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> pow(const DualVector<Scalar, N> & x, const DualVector<Scalar, N> & n) {
|
||||
return exp(n*log(x));
|
||||
}
|
||||
|
||||
// Other functions
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> sqrt(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(sqrt(x.a), x.b/(Scalar(2.)*sqrt(x.a)));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> sign(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(sign(x.a), DualVector<Scalar, N>::VectorT::Zero());
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> abs(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(fabs(x.a), x.b*sign(x.a));
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> heaviside(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(heaviside(x.a), DualVector<Scalar, N>::VectorT::Zero());
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> floor(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(floor(x.a), DualVector<Scalar, N>::VectorT::Zero());
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> ceil(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(ceil(x.a), DualVector<Scalar, N>::VectorT::Zero());
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> DualVector<Scalar, N> round(const DualVector<Scalar, N> & x) {
|
||||
return DualVector<Scalar, N>(round(x.a), DualVector<Scalar, N>::VectorT::Zero());
|
||||
}
|
||||
|
||||
template<typename Scalar, int N> std::ostream & operator<<(std::ostream & s, const DualVector<Scalar, N> & x)
|
||||
{
|
||||
return (s << x.a);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
36
Makefile.linux
Normal file
36
Makefile.linux
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
CXX = g++
|
||||
INCLUDE = -I../third_party_libs/Catch2-master/single_include
|
||||
CFLAGS = -Wall -std=c++11 -O0 -fprofile-arcs -ftest-coverage $(INCLUDE)
|
||||
LDFLAGS = -lgcov
|
||||
LDFLAGS_ALL = $(LDFLAGS)
|
||||
OUTPUT_NAME = test_AutomaticDifferentiation
|
||||
|
||||
# scalar version
|
||||
test_AutomaticDifferentiation:test_AutomaticDifferentiation.o test_AutomaticDifferentiation_main.o
|
||||
$(CXX) -o $(OUTPUT_NAME) test_AutomaticDifferentiation.o test_AutomaticDifferentiation_main.o $(LDFLAGS_ALL)
|
||||
|
||||
test_AutomaticDifferentiation_manual:test_AutomaticDifferentiation_manual.o
|
||||
$(CXX) -o $(OUTPUT_NAME) test_AutomaticDifferentiation_manual.o $(LDFLAGS_ALL)
|
||||
|
||||
test_AutomaticDifferentiation_main.o: test_AutomaticDifferentiation_main.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation_main.cpp
|
||||
|
||||
test_AutomaticDifferentiation.o: test_AutomaticDifferentiation.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation.cpp
|
||||
|
||||
test_AutomaticDifferentiation_manual.o: test_AutomaticDifferentiation_manual.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation_manual.cpp
|
||||
|
||||
# Vector version
|
||||
test_AutomaticDifferentiation_vector:test_AutomaticDifferentiation_vector.o
|
||||
$(CXX) -o test_AutomaticDifferentiation_vector.exe test_AutomaticDifferentiation_vector.o $(LDFLAGS_ALL)
|
||||
|
||||
test_AutomaticDifferentiation_vector.o: test_AutomaticDifferentiation_vector.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation_vector.cpp
|
||||
|
||||
clean:
|
||||
rm *.o
|
||||
|
||||
cleaner:
|
||||
rm *.o
|
||||
rm $(OUTPUT_NAME)
|
||||
36
Makefile.windows
Normal file
36
Makefile.windows
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
CXX = g++
|
||||
INCLUDE = -I D:/Users/jerome/Documents/Programmation/third_party_libs/Eigen3 -ID:/Users/jerome/Documents/Programmation/third_party_libs/Catch2-master/single_include
|
||||
CFLAGS = -Wall -std=c++11 $(INCLUDE)
|
||||
LDFLAGS =
|
||||
LDFLAGS_ALL = $(LDFLAGS)
|
||||
OUTPUT_NAME = test_AutomaticDifferentiation
|
||||
|
||||
# scalar version
|
||||
test_AutomaticDifferentiation:test_AutomaticDifferentiation.o test_AutomaticDifferentiation_main.o
|
||||
$(CXX) -o $(OUTPUT_NAME) test_AutomaticDifferentiation.o test_AutomaticDifferentiation_main.o $(LDFLAGS_ALL)
|
||||
|
||||
test_AutomaticDifferentiation_manual:test_AutomaticDifferentiation_manual.o
|
||||
$(CXX) -o $(OUTPUT_NAME) test_AutomaticDifferentiation_manual.o $(LDFLAGS_ALL)
|
||||
|
||||
test_AutomaticDifferentiation_main.o: test_AutomaticDifferentiation_main.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation_main.cpp
|
||||
|
||||
test_AutomaticDifferentiation.o: test_AutomaticDifferentiation.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation.cpp
|
||||
|
||||
test_AutomaticDifferentiation_manual.o: test_AutomaticDifferentiation_manual.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation_manual.cpp
|
||||
|
||||
# Vector version
|
||||
test_AutomaticDifferentiation_vector:test_AutomaticDifferentiation_vector.o
|
||||
$(CXX) -o test_AutomaticDifferentiation_vector.exe test_AutomaticDifferentiation_vector.o $(LDFLAGS_ALL)
|
||||
|
||||
test_AutomaticDifferentiation_vector.o: test_AutomaticDifferentiation_vector.cpp
|
||||
$(CXX) $(CFLAGS) $(LDFLAGS) -c test_AutomaticDifferentiation_vector.cpp
|
||||
|
||||
clean:
|
||||
rm *.o
|
||||
|
||||
cleaner:
|
||||
rm *.o
|
||||
rm $(OUTPUT_NAME)
|
||||
11
coverage_test.txt
Normal file
11
coverage_test.txt
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
To help the next person with a similar question, here's what I ended up doing (thanks to /u/flyingcaribou):
|
||||
1- I'm using cmake to build my project and Catch for unit tests.
|
||||
2- In the root CMakeLists.txt I create multiple targets, including a test executable (tests.exe)which will run all unit tests. The compile flags are -O0 -g --coverage -std=c++14.
|
||||
3- ./tests.exe
|
||||
4- In the build directory under ./CMakeFiles/, each target has its own subdirectory. In there (e.g. under build/CMakeFiles/targetName/src) a file with gcno extension will be created as the result of running tests. I used lcov to parse these coverage files.
|
||||
5- brew install lcov
|
||||
6- lcov -c -d CMakeFiles -o cov.info
|
||||
7- genhtml cov.info -o out
|
||||
8- open out/index.html
|
||||
|
||||
https://medium.com/@naveen.maltesh/generating-code-coverage-report-using-gnu-gcov-lcov-ee54a4de3f11
|
||||
353
test_AutomaticDifferentiation.cpp
Normal file
353
test_AutomaticDifferentiation.cpp
Normal file
|
|
@ -0,0 +1,353 @@
|
|||
#include <catch2/catch.hpp>
|
||||
#include "AutomaticDifferentiation.hpp"
|
||||
|
||||
#define TEST_EQ_TOL 1e-9
|
||||
#define EQ_DOUBLE(a, b) (fabs((a) - (b)) <= TEST_EQ_TOL)
|
||||
#define EQ_DOUBLE_TOL(a, b, tol) (fabs((a) - (b)) <= (tol))
|
||||
#define CHECK_FUNCTION_ON_DUAL_DOUBLE(fct, x) CHECK( EQ_DOUBLE((fct(Dual<double>((x))).a), fct((x))) )
|
||||
|
||||
#define TEST_DERIVATIVE_NUM(fct, x, DX_NUM_DIFF, tol) \
|
||||
CHECK( fabs(fct((Dual<double>((x))+Dual<double>::d())).b - (((fct((x)+DX_NUM_DIFF)) - (fct((x)-DX_NUM_DIFF)))/(2*DX_NUM_DIFF))) <= tol )
|
||||
|
||||
// Test function for nth derivative
|
||||
template<typename Scalar>
|
||||
Scalar testFunction1(const Scalar & x)
|
||||
{
|
||||
return Scalar(1.)/atan(Scalar(1.) - pow(x, Scalar(2.)));
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar dtestFunction1(const Scalar & x)
|
||||
{
|
||||
return testFunction1(Dual<Scalar>(x) + Dual<Scalar>::d()).b;
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar ddtestFunction1(const Scalar & x)
|
||||
{
|
||||
return dtestFunction1(Dual<Scalar>(x) + Dual<Scalar>::d()).b;
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar dtestFunction1_sym(const Scalar & x)
|
||||
{
|
||||
return (Scalar(2.)*x)/((Scalar(1.) + pow(Scalar(1.) - pow(x,Scalar(2.)),Scalar(2.)))*pow(atan(Scalar(1.) - pow(x,Scalar(2.))),Scalar(2.)));
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar ddtestFunction1_sym(const Scalar & x)
|
||||
{
|
||||
return (Scalar(8.)*pow(x,Scalar(2.)))/(pow(Scalar(1.) + pow(Scalar(1.) - pow(x,Scalar(2.)),Scalar(2.)),Scalar(2.))* pow(atan(Scalar(1.) - pow(x,Scalar(2.))),Scalar(3.))) + (Scalar(8.)*pow(x,Scalar(2.))*(Scalar(1.) - pow(x,Scalar(2.))))/(pow(Scalar(1.) + pow(Scalar(1.) - pow(x,Scalar(2.)),Scalar(2.)),Scalar(2.))* pow(atan(Scalar(1.) - pow(x,Scalar(2.))),Scalar(2.))) + Scalar(2.)/((Scalar(1.) + pow(Scalar(1.) - pow(x,Scalar(2.)),Scalar(2.)))*pow(atan(Scalar(1.) - pow(x,Scalar(2.))),Scalar(2.)));
|
||||
}
|
||||
|
||||
// Length of vector from coordinates
|
||||
template<typename Scalar>
|
||||
Scalar f3(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3x(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return x/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3y(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return y/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3z(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return z/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
TEST_CASE( "Basic Dual class tests", "[basic]" ) {
|
||||
|
||||
// For each section, these variables are anew
|
||||
double x1 = 1.62, x2 = 0.62, x3 = 3.14, x4 = 2.71;
|
||||
using D = Dual<double>;
|
||||
|
||||
SECTION( "Constructors" ) {
|
||||
// REQUIRE( D().a == 0. );
|
||||
// REQUIRE( D().b == 0. );
|
||||
REQUIRE( D(x1).a == x1 );
|
||||
REQUIRE( D(x1).b == 0. );
|
||||
REQUIRE( D(x1, x2).a == x1 );
|
||||
REQUIRE( D(x1, x2).b == x2 );
|
||||
|
||||
// copy constructor
|
||||
D X(x1, x2);
|
||||
D Y(X);
|
||||
REQUIRE( X.a == Y.a );
|
||||
REQUIRE( X.b == Y.b );
|
||||
|
||||
// d() function
|
||||
REQUIRE( D::d().a == 0. );
|
||||
REQUIRE( D::d().b == 1. );
|
||||
}
|
||||
|
||||
SECTION( "Comparison operators" ) {
|
||||
D X(x1, x2);
|
||||
D Y(x3, x4);
|
||||
|
||||
// equal
|
||||
REQUIRE( (X == X) );
|
||||
REQUIRE_FALSE( (X == Y) );
|
||||
|
||||
// different
|
||||
REQUIRE_FALSE( (X != X) );
|
||||
REQUIRE( (X != Y) );
|
||||
|
||||
// lower than
|
||||
REQUIRE( (X < Y) == (X.a < Y.a) );
|
||||
REQUIRE( (X < X) == (X.a < X.a) );
|
||||
REQUIRE( (X <= Y) == (X.a <= Y.a) );
|
||||
REQUIRE( (X <= X) == (X.a <= X.a) );
|
||||
|
||||
// greater than
|
||||
REQUIRE( (X > Y) == (X.a > Y.a) );
|
||||
REQUIRE( (X > X) == (X.a > X.a) );
|
||||
REQUIRE( (X >= Y) == (X.a >= Y.a) );
|
||||
REQUIRE( (X >= X) == (X.a >= X.a) );
|
||||
}
|
||||
|
||||
SECTION( "Operators for operations" ) {
|
||||
D X(x1, x2);
|
||||
D Y(x3, x4);
|
||||
|
||||
REQUIRE( (X+Y).a == X.a+Y.a );
|
||||
REQUIRE( (X-Y).a == X.a-Y.a );
|
||||
REQUIRE( (X*Y).a == X.a*Y.a );
|
||||
REQUIRE( (X/Y).a == X.a/Y.a );
|
||||
|
||||
REQUIRE( (X+Y).b == X.b+Y.b );
|
||||
REQUIRE( (X-Y).b == X.b-Y.b );
|
||||
REQUIRE( (X*Y).b == X.a*Y.b+X.b*Y.a );
|
||||
REQUIRE( (X/Y).b == (Y.a*X.b - X.a*Y.b)/(Y.a*Y.a) );
|
||||
|
||||
// increment and decrement operators
|
||||
double aValue = X.a;
|
||||
REQUIRE( (++X).a == ++aValue);
|
||||
REQUIRE( (--X).a == --aValue);
|
||||
REQUIRE( (X++).a == aValue++);
|
||||
REQUIRE( (X).a == aValue);// check that it was incremented properly
|
||||
REQUIRE( (X--).a == aValue--);
|
||||
REQUIRE( (X).a == aValue);// check that it was decremented properly
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Scalar functions tests", "[scalarFunctions]" ) {
|
||||
SECTION( "Scalar functions" ) {
|
||||
REQUIRE( fabs(-5.) == 5. );
|
||||
REQUIRE( fabs(5.) == 5. );
|
||||
|
||||
CHECK( EQ_DOUBLE(cos(1.62), -0.04918382191417056) );
|
||||
CHECK( EQ_DOUBLE(sin(1.62), 0.998789743470524) );
|
||||
CHECK( EQ_DOUBLE(tan(1.62), -20.30728204110463) );
|
||||
CHECK( EQ_DOUBLE(sec(1.62), -20.33188884233264) );
|
||||
CHECK( EQ_DOUBLE(cot(1.62), -0.04924341908365026) );
|
||||
CHECK( EQ_DOUBLE(csc(1.62), 1.001211723025179) );
|
||||
|
||||
// inverse trigonometric functions
|
||||
CHECK( EQ_DOUBLE(acos(0.62), 0.902053623592525) );
|
||||
CHECK( EQ_DOUBLE(asin(0.62), 0.6687427032023717) );
|
||||
CHECK( EQ_DOUBLE(atan(0.62), 0.5549957273385867) );
|
||||
CHECK( EQ_DOUBLE(asec(1.62), 0.905510600165641) );
|
||||
CHECK( EQ_DOUBLE(acot(0.62), 1.01580059945631) );
|
||||
CHECK( EQ_DOUBLE(acsc(1.62), 0.6652857266292561) );
|
||||
|
||||
// hyperbolic trigonometric functions
|
||||
CHECK( EQ_DOUBLE(cosh(1.62), 2.625494507823741) );
|
||||
CHECK( EQ_DOUBLE(sinh(1.62), 2.427595808740127) );
|
||||
CHECK( EQ_DOUBLE(tanh(1.62), 0.924624218982788) );
|
||||
CHECK( EQ_DOUBLE(sech(1.62), 0.3808806291615117) );
|
||||
CHECK( EQ_DOUBLE(coth(1.62), 1.081520448491102) );
|
||||
CHECK( EQ_DOUBLE(csch(1.62), 0.4119301888723312) );
|
||||
|
||||
// inverse hyperbolic trigonometric functions
|
||||
CHECK( EQ_DOUBLE(acosh(1.62), 1.062819127408777) );
|
||||
CHECK( EQ_DOUBLE(asinh(1.62), 1.259535895278778) );
|
||||
CHECK( EQ_DOUBLE(atanh(0.62), 0.7250050877529992) );
|
||||
CHECK( EQ_DOUBLE(asech(0.62), 1.057231115568124) );
|
||||
CHECK( EQ_DOUBLE(acoth(1.62), 0.7206050593580027) );
|
||||
CHECK( EQ_DOUBLE(acsch(1.62), 0.5835891509960214) );
|
||||
|
||||
// other functions
|
||||
CHECK( EQ_DOUBLE(exp10(1.62), pow(10., 1.62)) );
|
||||
CHECK( EQ_DOUBLE(sign(1.62), 1.) );
|
||||
CHECK( EQ_DOUBLE(sign(-1.62), -1.) );
|
||||
CHECK( EQ_DOUBLE(sign(0.), 0.) );
|
||||
CHECK( EQ_DOUBLE(heaviside(-1.62), 0.) );
|
||||
CHECK( EQ_DOUBLE(heaviside(0.), 1.) );
|
||||
CHECK( EQ_DOUBLE(heaviside(1.62), 1.) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Functions on dual numbers", "[FunctionsOnDualNumbers]" ) {
|
||||
SECTION( "Functions on Dual numbers" ) {
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(cos, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sin, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(tan, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sec, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(cot, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(csc, 1.62);
|
||||
|
||||
// inverse trigonometric functions
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(acos, 0.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(asin, 0.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(atan, 0.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(asec, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(acot, 0.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(acsc, 1.62);
|
||||
|
||||
// exponential functions
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(exp, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(log, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(exp10, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(log10, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(exp2, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(log2, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sqrt, 1.62);
|
||||
|
||||
// hyperbolic trigonometric functions
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(cosh, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sinh, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(tanh, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sech, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(coth, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(csch, 1.62);
|
||||
|
||||
// inverse hyperbolic trigonometric functions
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(acosh, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(asinh, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(atanh, 0.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(asech, 0.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(acoth, 1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(acsch, 1.62);
|
||||
|
||||
// other functions
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sign, -1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sign, 0.00);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(sign, 1.62);
|
||||
|
||||
CHECK( abs(Dual<double>(-1.62)) == fabs(-1.62) );
|
||||
CHECK( fabs(Dual<double>(-1.62)) == fabs(-1.62) );
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(fabs, -1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(fabs, 1.62);
|
||||
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(heaviside, -1.62);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(heaviside, 0.00);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(heaviside, 1.62);
|
||||
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(floor, 1.2);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(ceil, 1.2);
|
||||
CHECK_FUNCTION_ON_DUAL_DOUBLE(round, 1.2);
|
||||
}
|
||||
|
||||
SECTION( "Function derivatives checked numerically" ) {
|
||||
double x = 0.5, x2 = 1.5, x3 = -x, dx = 1e-6, tol = 1e-9;
|
||||
TEST_DERIVATIVE_NUM(cos, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sin, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(tan, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sec, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(cot, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(csc, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(acos, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asin, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(atan, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asec, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acot, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acsc, x2, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(cosh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sinh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(tanh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sech, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(coth, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(csch, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(acosh, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asinh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(atanh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asech, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acoth, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acsch, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(exp, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(exp10, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log10, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(exp2, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log2, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(sqrt, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sign, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sign, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(fabs, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(fabs, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(heaviside, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(heaviside, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(floor, 1.6, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(ceil, 1.6, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(round, 1.6, dx, tol);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Nth derivative", "[NthDerivative]" ) {
|
||||
double x = 0.7;
|
||||
double dx = 1e-6;
|
||||
double fx = testFunction1(x);
|
||||
double dfdx = (testFunction1(x+dx) - testFunction1(x-dx))/(2*dx);
|
||||
double d2fdx2 = (testFunction1(x-dx) - 2*fx + testFunction1(x+dx))/(dx*dx);
|
||||
|
||||
CHECK( testFunction1(Dual<double>(x)).a == fx );
|
||||
CHECK( EQ_DOUBLE_TOL(dtestFunction1_sym(x), dfdx, 1e-6) );
|
||||
CHECK( EQ_DOUBLE_TOL(ddtestFunction1_sym(x), d2fdx2, 1e-4) );
|
||||
|
||||
CHECK( testFunction1(Dual<double>(x) + Dual<double>::d()).b == dtestFunction1_sym(x) );
|
||||
CHECK( dtestFunction1(x) == dtestFunction1_sym(x) );
|
||||
CHECK( EQ_DOUBLE(ddtestFunction1(x), ddtestFunction1_sym(x)) );
|
||||
}
|
||||
|
||||
TEST_CASE( "Partial derivatives", "[PartialDerivatives]" ) {
|
||||
double x = 0.7, y = -2., z = 1.5;
|
||||
|
||||
CHECK( f3(Dual<double>(x), Dual<double>(y), Dual<double>(z)) == f3(x,y,z) );
|
||||
CHECK( f3(Dual<double>(x)+Dual<double>::d(), Dual<double>(y), Dual<double>(z)).b == df3x(x,y,z) );
|
||||
CHECK( f3(Dual<double>(x), Dual<double>(y)+Dual<double>::d(), Dual<double>(z)).b == df3y(x,y,z) );
|
||||
CHECK( f3(Dual<double>(x), Dual<double>(y), Dual<double>(z)+Dual<double>::d()).b == df3z(x,y,z) );
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
4
test_AutomaticDifferentiation_main.cpp
Normal file
4
test_AutomaticDifferentiation_main.cpp
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
// Let Catch provide main()
|
||||
#define CATCH_CONFIG_MAIN
|
||||
|
||||
#include <catch2/catch.hpp>
|
||||
503
test_AutomaticDifferentiation_manual.cpp
Normal file
503
test_AutomaticDifferentiation_manual.cpp
Normal file
|
|
@ -0,0 +1,503 @@
|
|||
#include "AutomaticDifferentiation.hpp"
|
||||
|
||||
#include <vector>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
using std::cout;
|
||||
using std::cout;
|
||||
using std::setw;
|
||||
#define PRINT_VAR(x) std::cout << #x << "\t= " << std::setprecision(16) << (x) << std::endl
|
||||
#define PRINT_DUAL(x) std::cout << #x << "\t= " << std::fixed << std::setprecision(4) << std::setw(10) << (x).a << ", " << std::setw(10) << (x).b << std::endl
|
||||
|
||||
#define TEST_EQ_TOL 1e-9
|
||||
// #define TEST_FUNCTION_ON_DUAL_DOUBLE(fct, x) assert(fct(Dual<double>(x)).a == fct(x))
|
||||
// #define TEST_FUNCTION_ON_DUAL_DOUBLE(fct, x) assert(abs((fct(Dual<double>((x))).a) - (fct((x)))) <= TEST_EQ_TOL)
|
||||
#define TEST_EQ_DOUBLE(a, b) assert(abs((a) - (b)) <= TEST_EQ_TOL)
|
||||
|
||||
#define TEST_FUNCTION_ON_DUAL_DOUBLE(fct, x) \
|
||||
if(abs((fct(Dual<double>((x))).a) - fct((x))) > TEST_EQ_TOL) { \
|
||||
std::cerr << "Assertion failed at " << __FILE__ << ":" << __LINE__ << " : " << #fct << "<Dual<double>>(" << (x) << ") != " << #fct << "(" << (x) << ")" << "\n";\
|
||||
std::cerr << "Got " << (fct(Dual<double>(x)).a) << " ; expected " << (fct((x))) << "\n";\
|
||||
exit(1);\
|
||||
}
|
||||
|
||||
template<typename T> void print_T() { std::cout << __PRETTY_FUNCTION__ << '\n'; }
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar f1(const Scalar & x)
|
||||
{
|
||||
return Scalar(5.)*x*x*x + Scalar(3.)*x*x - Scalar(2.)*x + Scalar(4.);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df1(const Scalar & x)
|
||||
{
|
||||
return Scalar(15.)*x*x + Scalar(6.)*x - Scalar(2.);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar ddf1(const Scalar & x)
|
||||
{
|
||||
return Scalar(30.)*x + Scalar(6.);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar g1(Scalar x) {
|
||||
return f1(Dual<Scalar>(x) + Dual<Scalar>::d()).b;
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar h1(Scalar x) {
|
||||
return g1(Dual<Scalar>(x) + Dual<Scalar>::d()).b;
|
||||
}
|
||||
|
||||
template<class D> D f2(D x) {
|
||||
return (x + D(2.0)) * (x + D(1.0));
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar f3(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3x(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return x/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3y(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return y/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3z(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return z/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
void test_basic();
|
||||
void test_scalar_functions();
|
||||
void test_derivative_all();
|
||||
void test_derivative_pow();
|
||||
void test_derivative_simple();
|
||||
void test_derivative_simple_2();
|
||||
void test_derivative_simple_3();
|
||||
void test_derivative_nested();
|
||||
|
||||
int main()
|
||||
{
|
||||
test_scalar_functions();
|
||||
test_basic();
|
||||
test_derivative_all();
|
||||
test_derivative_pow();
|
||||
// test_derivative_simple();
|
||||
// test_derivative_simple_2();
|
||||
// test_derivative_simple_3();
|
||||
// test_derivative_nested();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void test_basic()
|
||||
{
|
||||
cout << "\ntest_basic()\n";
|
||||
using D = Dual<double>;
|
||||
cout.precision(16);
|
||||
|
||||
double x = 2;
|
||||
double y = 5;
|
||||
|
||||
D X(x), Y(y), Z(x, y);
|
||||
|
||||
D W = Z;
|
||||
|
||||
assert(X.a == x);
|
||||
assert(X.b == 0.);
|
||||
assert(Y.a == y);
|
||||
assert(Y.b == 0.);
|
||||
assert((X+Y).a == (x+y));
|
||||
assert((X-Y).a == (x-y));
|
||||
assert((X*Y).a == (x*y));
|
||||
assert((X/Y).a == (x/y));
|
||||
assert(-X.a == -x);
|
||||
|
||||
assert(D(1., 2.).a == 1.);
|
||||
assert(D(1., 2.).b == 2.);
|
||||
assert(W.a == Z.a);
|
||||
assert(W.b == Z.b);
|
||||
|
||||
assert((D(1., 2.)+D(4., 7.)).a == 5.);
|
||||
assert((D(1., 2.)+D(4., 7.)).b == 9.);
|
||||
|
||||
// test all the value returned by non-linear functions
|
||||
assert(heaviside(-1.) == 0.);
|
||||
assert(heaviside(0.) == 1.);
|
||||
assert(heaviside(1.) == 1.);
|
||||
|
||||
assert(sign(-10.) == -1.);
|
||||
assert(sign(0.) == 0.);
|
||||
assert(sign(10.) == 1.);
|
||||
|
||||
PRINT_VAR(abs(-10.));
|
||||
PRINT_VAR(abs(10.));
|
||||
PRINT_VAR(abs(Dual<double>(-10.)).a);
|
||||
PRINT_VAR(abs(Dual<double>(10.)).a);
|
||||
PRINT_VAR(abs(Dual<double>(-1.62)).a);
|
||||
PRINT_VAR(abs(-1.62));
|
||||
|
||||
PRINT_VAR(exp10(-3.));
|
||||
PRINT_VAR(exp10(-2.));
|
||||
PRINT_VAR(exp10(-1.));
|
||||
PRINT_VAR(exp10(0.));
|
||||
PRINT_VAR(exp10(1.));
|
||||
PRINT_VAR(exp10(2.));
|
||||
PRINT_VAR(exp10(3.));
|
||||
|
||||
x = -1.5;
|
||||
PRINT_VAR((x >= (0.)) ? pow((10.), x) : (1.)/pow((10.), -x));
|
||||
|
||||
PRINT_VAR(pow(10., -3.));
|
||||
PRINT_VAR(pow(10., 3.));
|
||||
PRINT_VAR(1./pow(10., 3.));
|
||||
|
||||
PRINT_VAR(exp2(-3.));
|
||||
PRINT_VAR(exp2(3.));
|
||||
|
||||
TEST_EQ_DOUBLE(exp10(-3.), 1./exp10(3.));
|
||||
TEST_EQ_DOUBLE(exp10(-3.), 0.001);
|
||||
TEST_EQ_DOUBLE(exp10( 3.), 1000.);
|
||||
|
||||
PRINT_VAR(atanh(0.62));
|
||||
PRINT_VAR(atanh(Dual<double>(0.62)).a);
|
||||
|
||||
PRINT_VAR(acsc(Dual<double>(1.62)).a);
|
||||
PRINT_VAR(acsc(1.62));
|
||||
|
||||
TEST_EQ_DOUBLE(pow(Dual<double>(1.62), Dual<double>(1.5)).a, pow(1.62, 1.5));
|
||||
|
||||
// trigonometric functions
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(cos, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sin, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(tan, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sec, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(cot, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(csc, 1.62);
|
||||
|
||||
// inverse trigonometric functions
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(acos, 0.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(asin, 0.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(atan, 0.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(asec, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(acot, 0.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(acsc, 1.62);
|
||||
|
||||
// exponential functions
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(exp, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(log, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(exp10, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(log10, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(exp2, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(log2, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sqrt, 1.62);
|
||||
|
||||
// hyperbolic trigonometric functions
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(cosh, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sinh, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(tanh, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sech, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(coth, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(csch, 1.62);
|
||||
|
||||
// inverse hyperbolic trigonometric functions
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(acosh, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(asinh, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(atanh, 0.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(asech, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(acoth, 1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(acsch, 1.62);
|
||||
|
||||
// other functions
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sign, -1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sign, 0.00);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(sign, 1.62);
|
||||
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(abs, -1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(abs, 1.62);
|
||||
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(heaviside, -1.62);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(heaviside, 0.00);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(heaviside, 1.62);
|
||||
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(floor, 1.2);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(ceil, 1.2);
|
||||
TEST_FUNCTION_ON_DUAL_DOUBLE(round, 1.2);
|
||||
}
|
||||
|
||||
void test_scalar_functions()
|
||||
{
|
||||
// test basic scalar functions numerically with values from mathematica
|
||||
cout << "\ntest_scalar_functions()\n";
|
||||
|
||||
// trigonometric functions
|
||||
//{-0.04918382191417056,0.998789743470524,-20.30728204110463,-20.33188884233264,-0.04924341908365026,1.001211723025179}
|
||||
TEST_EQ_DOUBLE(cos(1.62), -0.04918382191417056);
|
||||
TEST_EQ_DOUBLE(sin(1.62), 0.998789743470524);
|
||||
TEST_EQ_DOUBLE(tan(1.62), -20.30728204110463);
|
||||
TEST_EQ_DOUBLE(sec(1.62), -20.33188884233264);
|
||||
TEST_EQ_DOUBLE(cot(1.62), -0.04924341908365026);
|
||||
TEST_EQ_DOUBLE(csc(1.62), 1.001211723025179);
|
||||
|
||||
// inverse trigonometric functions
|
||||
// {0.902053623592525,0.6687427032023717,0.5549957273385867,0.905510600165641,1.01580059945631,0.6652857266292561}
|
||||
TEST_EQ_DOUBLE(acos(0.62), 0.902053623592525);
|
||||
TEST_EQ_DOUBLE(asin(0.62), 0.6687427032023717);
|
||||
TEST_EQ_DOUBLE(atan(0.62), 0.5549957273385867);
|
||||
TEST_EQ_DOUBLE(asec(1.62), 0.905510600165641);
|
||||
TEST_EQ_DOUBLE(acot(0.62), 1.01580059945631);
|
||||
TEST_EQ_DOUBLE(acsc(1.62), 0.6652857266292561);
|
||||
|
||||
// hyperbolic trigonometric functions
|
||||
// {2.625494507823741,2.427595808740127,0.924624218982788,0.3808806291615117,1.081520448491102,0.4119301888723312}
|
||||
TEST_EQ_DOUBLE(cosh(1.62), 2.625494507823741);
|
||||
TEST_EQ_DOUBLE(sinh(1.62), 2.427595808740127);
|
||||
TEST_EQ_DOUBLE(tanh(1.62), 0.924624218982788);
|
||||
TEST_EQ_DOUBLE(sech(1.62), 0.3808806291615117);
|
||||
TEST_EQ_DOUBLE(coth(1.62), 1.081520448491102);
|
||||
TEST_EQ_DOUBLE(csch(1.62), 0.4119301888723312);
|
||||
|
||||
// inverse hyperbolic trigonometric functions
|
||||
// {1.062819127408777,1.259535895278778,0.7250050877529992,1.057231115568124,0.7206050593580027,0.5835891509960214}
|
||||
TEST_EQ_DOUBLE(acosh(1.62), 1.062819127408777);
|
||||
TEST_EQ_DOUBLE(asinh(1.62), 1.259535895278778);
|
||||
TEST_EQ_DOUBLE(atanh(0.62), 0.7250050877529992);
|
||||
TEST_EQ_DOUBLE(asech(0.62), 1.057231115568124);
|
||||
TEST_EQ_DOUBLE(acoth(1.62), 0.7206050593580027);
|
||||
TEST_EQ_DOUBLE(acsch(1.62), 0.5835891509960214);
|
||||
}
|
||||
|
||||
#define TEST_DERIVATIVE_NUM(fct, x, DX_NUM_DIFF, tol); \
|
||||
{\
|
||||
double dfdx = fct((Dual<double>((x))+Dual<double>::d())).b;\
|
||||
double dfdx_num = ((fct((x)+DX_NUM_DIFF)) - (fct((x)-DX_NUM_DIFF)))/(2*DX_NUM_DIFF);\
|
||||
bool ok = (abs(dfdx - dfdx_num) <= tol) ? true : false;\
|
||||
cout << setw(10) << #fct << "(" << (x) << ") : " << setw(25) << dfdx << " " << setw(25) << dfdx_num << " " << setw(25) << (dfdx-dfdx_num) << "\t" << ok << "\n";\
|
||||
}
|
||||
|
||||
void test_derivative_all()
|
||||
{
|
||||
cout << "\ntest_derivative_all()\n";
|
||||
// test all derivatives numerically and check that they add up
|
||||
double x = 0.5, x2 = 1.5, x3 = -x, dx = 1e-6, tol = 1e-9;
|
||||
TEST_DERIVATIVE_NUM(cos, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sin, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(tan, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sec, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(cot, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(csc, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(acos, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asin, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(atan, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asec, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acot, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acsc, x2, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(cosh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sinh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(tanh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sech, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(coth, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(csch, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(acosh, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asinh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(atanh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asech, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acoth, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acsch, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(exp, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(exp10, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log10, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(exp2, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log2, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(sqrt, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sign, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sign, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(abs, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(abs, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(heaviside, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(heaviside, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(floor, 1.6, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(ceil, 1.6, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(round, 1.6, dx, tol);
|
||||
}
|
||||
void test_derivative_pow()
|
||||
{
|
||||
// test the derivatives of the power function
|
||||
cout << "\ntest_derivative_pow()\n";
|
||||
using D = Dual<double>;
|
||||
|
||||
double a = 1.5, b = 5.4;
|
||||
double c = pow(a, b);
|
||||
double dcda = b*pow(a, b-1);
|
||||
double dcdb = pow(a, b)*log(a);
|
||||
D A(a), B(b);
|
||||
|
||||
PRINT_VAR(a);
|
||||
PRINT_VAR(b);
|
||||
PRINT_VAR(c);
|
||||
PRINT_VAR(dcda);
|
||||
PRINT_VAR(dcdb);
|
||||
|
||||
PRINT_DUAL(pow(A, B));
|
||||
|
||||
PRINT_DUAL(pow(A+D::d(), B));
|
||||
PRINT_DUAL(pow(A, B+D::d()));
|
||||
|
||||
double dcda_AD = pow(A+D::d(), B).b;
|
||||
double dcdb_AD = pow(A, B+D::d()).b;
|
||||
|
||||
TEST_EQ_DOUBLE(pow(A, B).a, c);
|
||||
TEST_EQ_DOUBLE(dcda_AD, dcda);
|
||||
TEST_EQ_DOUBLE(dcdb_AD, dcdb);
|
||||
}
|
||||
|
||||
void test_derivative_simple()
|
||||
{
|
||||
cout << "\ntest_derivative_simple()\n";
|
||||
using D = Dual<double>;
|
||||
|
||||
D d(0., 1.);
|
||||
D x = 3.5;
|
||||
D y = f1(x+d);
|
||||
D dy = df1(x);
|
||||
D ddy = ddf1(x);
|
||||
|
||||
PRINT_DUAL(x);
|
||||
PRINT_DUAL(x+d);
|
||||
PRINT_DUAL(y);
|
||||
PRINT_DUAL(dy);
|
||||
PRINT_VAR(g1(x));
|
||||
PRINT_VAR(h1(x.a));
|
||||
PRINT_VAR(ddy);
|
||||
|
||||
assert(y.b == dy.a);
|
||||
}
|
||||
|
||||
void test_derivative_simple_2()
|
||||
{
|
||||
cout << "\ntest_derivative_simple_2()\n";
|
||||
using D = Dual<double>;
|
||||
|
||||
D d(0., 1.);
|
||||
D x = 3.;
|
||||
D x2 = x+d;
|
||||
D y = f2(x);
|
||||
D y2 = f2(x2);
|
||||
D y3 = f2(D(3.0)+d);
|
||||
|
||||
PRINT_DUAL(x);
|
||||
PRINT_DUAL(x+d);
|
||||
PRINT_DUAL(y);
|
||||
PRINT_DUAL(y2);
|
||||
PRINT_DUAL(y3);
|
||||
|
||||
assert(y.a == 20.);
|
||||
assert(y2.a == 20.);
|
||||
assert(y3.a == 20.);
|
||||
assert(y2.b == 9.);
|
||||
assert(y3.b == 9.);
|
||||
}
|
||||
|
||||
void test_derivative_simple_3()
|
||||
{
|
||||
// partial derivatives using scalar implementation
|
||||
cout << "\ntest_derivative_simple_3()\n";
|
||||
using D = Dual<double>;
|
||||
|
||||
D x(2.), y(4.), z(-7.);
|
||||
D L = f3(x, y, z);
|
||||
|
||||
PRINT_DUAL(L);
|
||||
PRINT_VAR(f3(x+D::d(), y, z).b);
|
||||
PRINT_VAR(f3(x, y+D::d(), z).b);
|
||||
PRINT_VAR(f3(x, y, z+D::d()).b);
|
||||
|
||||
PRINT_VAR(df3x(x.a, y.a, z.a));
|
||||
PRINT_VAR(df3y(x.a, y.a, z.a));
|
||||
PRINT_VAR(df3z(x.a, y.a, z.a));
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar testFunctionNesting(const Scalar & x)
|
||||
{
|
||||
return Scalar(1.)/atan(Scalar(1.) - pow(x, Scalar(2.)));
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
struct TestFunctionNestingFunctor
|
||||
{
|
||||
Scalar operator()(const Scalar & x)
|
||||
{
|
||||
return Scalar(1.)/atan(Scalar(1.) - pow(x, Scalar(2.)));
|
||||
}
|
||||
};
|
||||
|
||||
/* template<typename Scalar, typename FunctorType>
|
||||
std::vector<Scalar> computeNfirstDerivatives(FunctorType & functor, const Scalar & x, const int & n, int depth = 0)
|
||||
{
|
||||
// compute the n first derivatives using the recursive, nested approach
|
||||
std::vector<Scalar> derivatives;
|
||||
|
||||
if(depth < n)
|
||||
derivatives.push_back(computeNfirstDerivatives(functor, Dual<Scalar>(x) + Dual<Scalar>::d(), n, ++depth)[0].b);
|
||||
|
||||
return derivatives;
|
||||
}
|
||||
|
||||
void test_derivative_nested()
|
||||
{
|
||||
// nested function to compute the first nth derivatives using scalar implementation
|
||||
cout << "\ntest_derivative_nested()\n";
|
||||
using D = Dual<double>;
|
||||
|
||||
double x = 0.7;
|
||||
TestFunctionNestingFunctor<double> ffun;
|
||||
|
||||
std::vector<double> derivatives = computeNfirstDerivatives<double, TestFunctionNestingFunctor<double> >(ffun, x, 1);
|
||||
|
||||
|
||||
} */
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
461
test_AutomaticDifferentiation_vector.cpp
Normal file
461
test_AutomaticDifferentiation_vector.cpp
Normal file
|
|
@ -0,0 +1,461 @@
|
|||
#include "AutomaticDifferentiationVector.hpp"
|
||||
|
||||
#include <assert.h>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
using std::cout;
|
||||
using std::cout;
|
||||
using std::setw;
|
||||
#define PRINT_VAR(x) std::cout << #x << "\t= " << std::setprecision(16) << (x) << std::endl
|
||||
#define PRINT_DUALVECTOR(x) std::cout << #x << "\t= " << std::fixed << std::setprecision(4) << std::setw(10) << (x).a << ", " << std::setw(10) << (x).b.transpose() << std::endl
|
||||
|
||||
#define TEST_EQ_TOL 1e-9
|
||||
// #define TEST_FUNCTION_ON_DualVector_DOUBLE(fct, x) assert(fct(DualVector<double,1>(x)).a == fct(x))
|
||||
// #define TEST_FUNCTION_ON_DualVector_DOUBLE(fct, x) assert(abs((fct(DualVector<double,1>((x))).a) - (fct((x)))) <= TEST_EQ_TOL)
|
||||
#define TEST_EQ_DOUBLE(a, b) assert(abs((a) - (b)) <= TEST_EQ_TOL)
|
||||
|
||||
#define TEST_FUNCTION_ON_DualVector_DOUBLE(fct, x) \
|
||||
if(abs((fct(DualVector<double,1>((x))).a) - fct((x))) > TEST_EQ_TOL) { \
|
||||
std::cerr << "Assertion failed at " << __FILE__ << ":" << __LINE__ << " : " << #fct << "<DualVector<double,1>>(" << (x) << ") != " << #fct << "(" << (x) << ")" << "\n";\
|
||||
std::cerr << "Got " << (fct(DualVector<double,1>(x)).a) << " ; expected " << (fct((x))) << "\n";\
|
||||
exit(1);\
|
||||
}
|
||||
|
||||
template<typename T> void print_T() { std::cout << __PRETTY_FUNCTION__ << '\n'; }
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar f1(const Scalar & x)
|
||||
{
|
||||
return Scalar(5.)*x*x*x + Scalar(3.)*x*x - Scalar(2.)*x + Scalar(4.);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df1(const Scalar & x)
|
||||
{
|
||||
return Scalar(15.)*x*x + Scalar(6.)*x - Scalar(2.);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar ddf1(const Scalar & x)
|
||||
{
|
||||
return Scalar(30.)*x + Scalar(6.);
|
||||
}
|
||||
|
||||
template<typename Scalar, typename Vector>
|
||||
Vector g1(Scalar x) {
|
||||
return f1(DualVector<Scalar,1>(x) + DualVector<Scalar,1>::d()).b;
|
||||
}
|
||||
|
||||
template<typename Scalar, typename Vector>
|
||||
Vector h1(Scalar x) {
|
||||
return g1(DualVector<Scalar,1>(x) + DualVector<Scalar,1>::d()).b;
|
||||
}
|
||||
|
||||
template<class D> D f2(D x) {
|
||||
return (x + D(2.0)) * (x + D(1.0));
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar f3(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3x(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return x/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3y(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return y/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
template<typename Scalar>
|
||||
Scalar df3z(const Scalar & x, const Scalar & y, const Scalar & z)
|
||||
{
|
||||
return z/sqrt(z*z+y*y+x*x);
|
||||
}
|
||||
|
||||
void test_basic();
|
||||
void test_scalar_functions();
|
||||
void test_derivative_all();
|
||||
void test_derivative_pow();
|
||||
void test_derivative_simple();
|
||||
void test_derivative_simple_2();
|
||||
void test_derivative_simple_3();
|
||||
|
||||
int main()
|
||||
{
|
||||
test_scalar_functions();
|
||||
test_basic();
|
||||
test_derivative_all();
|
||||
test_derivative_pow();
|
||||
// test_derivative_simple();
|
||||
test_derivative_simple_2();
|
||||
test_derivative_simple_3();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void test_basic()
|
||||
{
|
||||
cout << "\ntest_basic()\n";
|
||||
using D = DualVector<double, 3>;
|
||||
cout.precision(16);
|
||||
|
||||
double x = 2;
|
||||
double y = 5;
|
||||
|
||||
D X(x), Y(y);
|
||||
|
||||
assert(X.a == x);
|
||||
assert(X.b == D::VectorT::Zero());
|
||||
assert(Y.a == y);
|
||||
assert(Y.b == D::VectorT::Zero());
|
||||
assert((X+Y).a == (x+y));
|
||||
assert((X-Y).a == (x-y));
|
||||
assert((X*Y).a == (x*y));
|
||||
assert((X/Y).a == (x/y));
|
||||
assert(-X.a == -x);
|
||||
|
||||
PRINT_DUALVECTOR(X+Y);
|
||||
PRINT_DUALVECTOR(X-Y);
|
||||
PRINT_DUALVECTOR(X*Y);
|
||||
PRINT_DUALVECTOR(X/Y);
|
||||
|
||||
assert(D(1., 2.).a == 1.);
|
||||
// assert(D(1., 2.).b == 2.);
|
||||
|
||||
assert((D(1., 2.)+D(4., 7.)).a == 5.);
|
||||
// assert((D(1., 2.)+D(4., 7.)).b == 9.);
|
||||
|
||||
// test all the value returned by non-linear functions
|
||||
assert(heaviside(-1.) == 0.);
|
||||
assert(heaviside(0.) == 1.);
|
||||
assert(heaviside(1.) == 1.);
|
||||
|
||||
assert(sign(-10.) == -1.);
|
||||
assert(sign(0.) == 0.);
|
||||
assert(sign(10.) == 1.);
|
||||
|
||||
PRINT_VAR(abs(-10.));
|
||||
PRINT_VAR(abs(10.));
|
||||
PRINT_VAR(abs(DualVector<double,1>(-10.)).a);
|
||||
PRINT_VAR(abs(DualVector<double,1>(10.)).a);
|
||||
PRINT_VAR(abs(DualVector<double,1>(-1.62)).a);
|
||||
PRINT_VAR(abs(-1.62));
|
||||
|
||||
PRINT_VAR(exp10(-3.));
|
||||
PRINT_VAR(exp10(-2.));
|
||||
PRINT_VAR(exp10(-1.));
|
||||
PRINT_VAR(exp10(0.));
|
||||
PRINT_VAR(exp10(1.));
|
||||
PRINT_VAR(exp10(2.));
|
||||
PRINT_VAR(exp10(3.));
|
||||
|
||||
x = -1.5;
|
||||
PRINT_VAR((x >= (0.)) ? pow((10.), x) : (1.)/pow((10.), -x));
|
||||
|
||||
PRINT_VAR(pow(10., -3.));
|
||||
PRINT_VAR(pow(10., 3.));
|
||||
PRINT_VAR(1./pow(10., 3.));
|
||||
|
||||
PRINT_VAR(exp2(-3.));
|
||||
PRINT_VAR(exp2(3.));
|
||||
|
||||
TEST_EQ_DOUBLE(exp10(-3.), 1./exp10(3.));
|
||||
TEST_EQ_DOUBLE(exp10(-3.), 0.001);
|
||||
TEST_EQ_DOUBLE(exp10( 3.), 1000.);
|
||||
|
||||
PRINT_VAR(atanh(0.62));
|
||||
PRINT_VAR(atanh(DualVector<double,1>(0.62)).a);
|
||||
|
||||
PRINT_VAR(acsc(DualVector<double,1>(1.62)).a);
|
||||
PRINT_VAR(acsc(1.62));
|
||||
|
||||
TEST_EQ_DOUBLE(pow(DualVector<double,1>(1.62), DualVector<double,1>(1.5)).a, pow(1.62, 1.5));
|
||||
|
||||
// trigonometric functions
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(cos, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sin, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(tan, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sec, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(cot, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(csc, 1.62);
|
||||
|
||||
// inverse trigonometric functions
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(acos, 0.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(asin, 0.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(atan, 0.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(asec, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(acot, 0.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(acsc, 1.62);
|
||||
|
||||
// exponential functions
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(exp, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(log, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(exp10, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(log10, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(exp2, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(log2, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sqrt, 1.62);
|
||||
|
||||
// hyperbolic trigonometric functions
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(cosh, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sinh, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(tanh, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sech, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(coth, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(csch, 1.62);
|
||||
|
||||
// inverse hyperbolic trigonometric functions
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(acosh, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(asinh, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(atanh, 0.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(asech, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(acoth, 1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(acsch, 1.62);
|
||||
|
||||
// other functions
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sign, -1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sign, 0.00);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(sign, 1.62);
|
||||
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(abs, -1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(abs, 1.62);
|
||||
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(heaviside, -1.62);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(heaviside, 0.00);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(heaviside, 1.62);
|
||||
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(floor, 1.2);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(ceil, 1.2);
|
||||
TEST_FUNCTION_ON_DualVector_DOUBLE(round, 1.2);
|
||||
}
|
||||
|
||||
void test_scalar_functions()
|
||||
{
|
||||
// test basic scalar functions numerically with values from mathematica
|
||||
cout << "\ntest_scalar_functions()\n";
|
||||
|
||||
// trigonometric functions
|
||||
//{-0.04918382191417056,0.998789743470524,-20.30728204110463,-20.33188884233264,-0.04924341908365026,1.001211723025179}
|
||||
TEST_EQ_DOUBLE(cos(1.62), -0.04918382191417056);
|
||||
TEST_EQ_DOUBLE(sin(1.62), 0.998789743470524);
|
||||
TEST_EQ_DOUBLE(tan(1.62), -20.30728204110463);
|
||||
TEST_EQ_DOUBLE(sec(1.62), -20.33188884233264);
|
||||
TEST_EQ_DOUBLE(cot(1.62), -0.04924341908365026);
|
||||
TEST_EQ_DOUBLE(csc(1.62), 1.001211723025179);
|
||||
|
||||
// inverse trigonometric functions
|
||||
// {0.902053623592525,0.6687427032023717,0.5549957273385867,0.905510600165641,1.01580059945631,0.6652857266292561}
|
||||
TEST_EQ_DOUBLE(acos(0.62), 0.902053623592525);
|
||||
TEST_EQ_DOUBLE(asin(0.62), 0.6687427032023717);
|
||||
TEST_EQ_DOUBLE(atan(0.62), 0.5549957273385867);
|
||||
TEST_EQ_DOUBLE(asec(1.62), 0.905510600165641);
|
||||
TEST_EQ_DOUBLE(acot(0.62), 1.01580059945631);
|
||||
TEST_EQ_DOUBLE(acsc(1.62), 0.6652857266292561);
|
||||
|
||||
// hyperbolic trigonometric functions
|
||||
// {2.625494507823741,2.427595808740127,0.924624218982788,0.3808806291615117,1.081520448491102,0.4119301888723312}
|
||||
TEST_EQ_DOUBLE(cosh(1.62), 2.625494507823741);
|
||||
TEST_EQ_DOUBLE(sinh(1.62), 2.427595808740127);
|
||||
TEST_EQ_DOUBLE(tanh(1.62), 0.924624218982788);
|
||||
TEST_EQ_DOUBLE(sech(1.62), 0.3808806291615117);
|
||||
TEST_EQ_DOUBLE(coth(1.62), 1.081520448491102);
|
||||
TEST_EQ_DOUBLE(csch(1.62), 0.4119301888723312);
|
||||
|
||||
// inverse hyperbolic trigonometric functions
|
||||
// {1.062819127408777,1.259535895278778,0.7250050877529992,1.057231115568124,0.7206050593580027,0.5835891509960214}
|
||||
TEST_EQ_DOUBLE(acosh(1.62), 1.062819127408777);
|
||||
TEST_EQ_DOUBLE(asinh(1.62), 1.259535895278778);
|
||||
TEST_EQ_DOUBLE(atanh(0.62), 0.7250050877529992);
|
||||
TEST_EQ_DOUBLE(asech(0.62), 1.057231115568124);
|
||||
TEST_EQ_DOUBLE(acoth(1.62), 0.7206050593580027);
|
||||
TEST_EQ_DOUBLE(acsch(1.62), 0.5835891509960214);
|
||||
}
|
||||
|
||||
#define TEST_DERIVATIVE_NUM(fct, x, DX_NUM_DIFF, tol); \
|
||||
{\
|
||||
double dfdx = fct((DualVector<double,1>((x))+DualVector<double,1>::d())).b[0];\
|
||||
double dfdx_num = ((fct((x)+DX_NUM_DIFF)) - (fct((x)-DX_NUM_DIFF)))/(2*DX_NUM_DIFF);\
|
||||
bool ok = (abs(dfdx - dfdx_num) <= tol) ? true : false;\
|
||||
cout << setw(10) << #fct << "(" << (x) << ") : " << setw(25) << dfdx << " " << setw(25) << dfdx_num << " " << setw(25) << (dfdx-dfdx_num) << "\t" << ok << "\n";\
|
||||
}
|
||||
|
||||
void test_derivative_all()
|
||||
{
|
||||
cout << "\ntest_derivative_all()\n";
|
||||
// test all derivatives numerically and check that they add up
|
||||
double x = 0.5, x2 = 1.5, x3 = -x, dx = 1e-6, tol = 1e-9;
|
||||
TEST_DERIVATIVE_NUM(cos, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sin, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(tan, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sec, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(cot, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(csc, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(acos, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asin, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(atan, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asec, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acot, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acsc, x2, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(cosh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sinh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(tanh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sech, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(coth, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(csch, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(acosh, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asinh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(atanh, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(asech, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acoth, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(acsch, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(exp, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(exp10, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log10, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(exp2, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(log2, x, dx, tol);
|
||||
|
||||
TEST_DERIVATIVE_NUM(sqrt, x2, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sign, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(sign, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(abs, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(abs, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(heaviside, x3, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(heaviside, x, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(floor, 1.6, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(ceil, 1.6, dx, tol);
|
||||
TEST_DERIVATIVE_NUM(round, 1.6, dx, tol);
|
||||
}
|
||||
|
||||
void test_derivative_pow()
|
||||
{
|
||||
// test the derivatives of the power function
|
||||
cout << "\ntest_derivative_pow()\n";
|
||||
using D = DualVector<double,2>;
|
||||
|
||||
double a = 1.5, b = 5.4;
|
||||
double c = pow(a, b);
|
||||
double dcda = b*pow(a, b-1);
|
||||
double dcdb = pow(a, b)*log(a);
|
||||
D A(a), B(b);
|
||||
|
||||
PRINT_VAR(a);
|
||||
PRINT_VAR(b);
|
||||
PRINT_VAR(c);
|
||||
PRINT_VAR(dcda);
|
||||
PRINT_VAR(dcdb);
|
||||
|
||||
PRINT_DUALVECTOR(pow(A, B));
|
||||
|
||||
PRINT_DUALVECTOR(pow(A+D::d(0), B+D::d(1)));
|
||||
|
||||
D A1(A+D::d(0)), B1(B+D::d(1)), C(0.);
|
||||
PRINT_DUALVECTOR(exp(B1*log(A1)));
|
||||
|
||||
C = pow(A1, B1);
|
||||
TEST_EQ_DOUBLE(C.a , c);
|
||||
TEST_EQ_DOUBLE(C.b[0], dcda);
|
||||
TEST_EQ_DOUBLE(C.b[1], dcdb);
|
||||
}
|
||||
|
||||
void test_derivative_simple()
|
||||
{
|
||||
cout << "\ntest_derivative_simple()\n";
|
||||
/*using D = DualVector<double,1>;
|
||||
|
||||
D d = D::d();
|
||||
D x = 3.5;
|
||||
D y = f1(x+D::d());
|
||||
D dy = df1(x);
|
||||
D ddy = ddf1(x);
|
||||
|
||||
PRINT_DUALVECTOR(x);
|
||||
PRINT_DUALVECTOR(x+d);
|
||||
PRINT_DUALVECTOR(y);
|
||||
PRINT_DUALVECTOR(dy);
|
||||
PRINT_VAR((g1<double, D::VectorT>(x)));
|
||||
// PRINT_VAR(h1(x.a));
|
||||
PRINT_VAR(ddy);
|
||||
|
||||
assert(y.b[0] == dy.a);//*/
|
||||
}
|
||||
|
||||
void test_derivative_simple_2()
|
||||
{
|
||||
cout << "\ntest_derivative_simple_2()\n";
|
||||
using D = DualVector<double,1>;
|
||||
|
||||
D d(0., 1.);
|
||||
D x = 3.;
|
||||
D x2 = x+d;
|
||||
D y = f2(x);
|
||||
D y2 = f2(x2);
|
||||
D y3 = f2(D(3.0)+d);
|
||||
|
||||
PRINT_DUALVECTOR(x);
|
||||
PRINT_DUALVECTOR(x+d);
|
||||
PRINT_DUALVECTOR(y);
|
||||
PRINT_DUALVECTOR(y2);
|
||||
PRINT_DUALVECTOR(y3);
|
||||
|
||||
assert(y.a == 20.);
|
||||
assert(y2.a == 20.);
|
||||
assert(y3.a == 20.);
|
||||
assert(y2.b[0] == 9.);
|
||||
assert(y3.b[0] == 9.);
|
||||
}
|
||||
|
||||
void test_derivative_simple_3()
|
||||
{
|
||||
// partial derivatives using scalar implementation
|
||||
cout << "\ntest_derivative_simple_3()\n";
|
||||
using D = DualVector<double,3>;
|
||||
|
||||
D x(2.), y(4.), z(-7.);
|
||||
D L = f3(x, y, z);
|
||||
|
||||
PRINT_DUALVECTOR(L);
|
||||
PRINT_VAR(f3(x+D::d(0), y+D::d(1), z+D::d(2)).b.transpose());
|
||||
|
||||
PRINT_VAR(df3x(x.a, y.a, z.a));
|
||||
PRINT_VAR(df3y(x.a, y.a, z.a));
|
||||
PRINT_VAR(df3z(x.a, y.a, z.a));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Add table
Reference in a new issue