dual_functions.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_DUAL_FUNCTIONS_H
#define THEORETICA_DUAL_FUNCTIONS_H
 
#include "./dual.h"
#include "../core/real_analysis.h"
 
 
namespace theoretica {
 

    inline dual square(dual x) {
        return x * x;
    }
 

    inline dual cube(dual x) {
        return x * x * x;
    }
 

    inline dual conjugate(dual x) {
        return x.conjugate();
    }
 

    inline dual pow(dual x, int n) {
 
        const real pow_n_1_x = pow(x.Re(), n - 1);
        return dual(pow_n_1_x * x.Re(), pow_n_1_x * n * x.Dual());
    }
 

    inline dual sqrt(dual x) {
 
        const real sqrt_x = sqrt(x.Re());
 
        if(sqrt_x == 0) {
            TH_MATH_ERROR("sqrt(dual)", sqrt_x, MathError::DivByZero);
            return dual(nan(), nan());
        }
 
        return dual(sqrt_x, 0.5 / sqrt_x * x.Dual());
    }
 

    inline dual sin(dual x) {
        return dual(sin(x.Re()), cos(x.Re()) * x.Dual());
    }
 

    inline dual cos(dual x) {
        return dual(cos(x.Re()), -sin(x.Re()) * x.Dual());
    }
 

    inline dual tan(dual x) {
 
        const real cos_x = cos(x.Re());
 
        if(cos_x == 0) {
            TH_MATH_ERROR("tan(dual)", cos_x, MathError::DivByZero);
            return dual(nan(), nan());
        }
 
        return dual(tan(x.Re()), x.Dual() / square(cos_x));
    }
 

    inline dual cot(dual x) {
 
        const real sin_x = sin(x.Re());
 
        if(sin_x == 0) {
            TH_MATH_ERROR("cot(dual)", sin_x, MathError::DivByZero);
            return dual(nan(), nan());
        }
 
        return dual(cot(x.Re()), -x.Dual() / square(sin_x));
    }
 

    inline dual exp(dual x) {
 
        const real exp_x = exp(x.Re());
        return dual(exp_x, x.Dual() * exp_x);
    }
 

    inline dual ln(dual x) {
 
        if(x.Re() <= 0) {
            TH_MATH_ERROR("ln(dual)", x.Re(), MathError::OutOfDomain);
            return dual(nan(), nan());
        }
 
        return dual(ln(x.Re()), x.Dual() / x.Re());
    }
 

    inline dual log2(dual x) {
 
        if(x.Re() <= 0) {
            TH_MATH_ERROR("log2(dual)", x.Re(), MathError::OutOfDomain);
            return dual(nan(), nan());
        }
 
        return dual(log2(x.Re()), x.Dual() * LOG2E / x.Re());
    }
 

    inline dual log10(dual x) {
 
        if(x.Re() <= 0) {
            TH_MATH_ERROR("log10(dual)", x.Re(), MathError::OutOfDomain);
            return dual(nan(), nan());
        }
 
        return dual(log10(x.Re()), x.Dual() * LOG10E / x.Re());
    }
 

    inline dual abs(dual x) {
        return dual(abs(x.Re()), x.Dual() * sgn(x.Re()));
    }
 

    inline dual asin(dual x) {
 
        if(x.Re() >= 1) {
            TH_MATH_ERROR("asin(dual)", x.Re(), MathError::OutOfDomain);
            return dual(nan(), nan());
        }
 
        return dual(asin(x.Re()), x.Dual() / sqrt(1 - square(x.Re())));
    }
 

    inline dual acos(dual x) {
 
        if(x.Re() >= 1) {
            TH_MATH_ERROR("acos(dual)", x.Re(), MathError::OutOfDomain);
            return dual(nan(), nan());
        }
 
        return dual(
            acos(x.Re()),
            -x.Dual() / sqrt(1 - square(x.Re()))
        );
    }
 

    inline dual atan(dual x) {
        return dual(
            atan(x.Re()),
            x.Dual() / (1 + square(x.Re()))
        );
    }
 

    inline dual sinh(dual x) {
 
        const real exp_x = exp(x.Re());
        return dual(
            (exp_x - 1.0 / exp_x) / 2.0,
            x.Dual() * (exp_x + 1.0 / exp_x) / 2.0
        );
    }
 

    inline dual cosh(dual x) {
 
        const real exp_x = exp(x.Re());
        return dual(
            (exp_x + 1.0 / exp_x) / 2.0,
            x.Dual() * (exp_x - 1.0 / exp_x) / 2.0
        );
    }
 

    inline dual tanh(dual x) {
 
        const real exp_2x = exp(-2.0 * abs(x.Re()));
 
        real t;
        if (x.Re() >= 0.0)
            t = (1.0 - exp_2x) / (1.0 + exp_2x);
        else
            t = (exp_2x - 1.0) / (1.0 + exp_2x);
 
        const real dt = (4.0 * exp_2x) / square(1.0 + exp_2x);
 
        return dual(t, x.Dual() * dt);
    }
 
}
 
 
#endif