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, DIV_BY_ZERO);
            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, DIV_BY_ZERO);
            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, DIV_BY_ZERO);
            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(), OUT_OF_DOMAIN);
            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(), OUT_OF_DOMAIN);
            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(), OUT_OF_DOMAIN);
            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(), OUT_OF_DOMAIN);
            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(), OUT_OF_DOMAIN);
            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_x = exp(x.Re());
        return dual(
            (exp_x - 1.0 / exp_x) / (exp_x + 1.0 / exp_x),
            x.Dual() / square(exp_x + 1.0 / exp_x)
        );
    }
 
}
 
 
#endif