operation_common.hpp

Go to the documentation of this file.

#pragma once
 
#include "sigma/detail_/setter.hpp"
#include "sigma/uncertain.hpp"
 
 
namespace sigma::detail_ {

constexpr double pi = 3.14159265358979323846;

template<typename T>
void inplace_unary(Uncertain<T>& c, T mean, T dcda) {
    detail_::Setter<Uncertain<T>> c_setter(c);
    c_setter.update_mean(mean);
    c_setter.update_derivatives(dcda);
}

template<typename T>
Uncertain<T> unary_result(const Uncertain<T>& a, T mean, T dcda) {
    Uncertain<T> c(a);
    detail_::inplace_unary(c, mean, dcda);
    return c;
}

template<typename T>
void inplace_binary(Uncertain<T>& c, const Uncertain<T>& b, T mean, T dcda,
                    T dcdb) {
    detail_::Setter<Uncertain<T>> c_setter(c);
    c_setter.update_mean(mean);
    c_setter.update_derivatives(dcda, false);
    c_setter.update_derivatives(b.deps(), dcdb);
}

template<typename T>
Uncertain<T> binary_result(const Uncertain<T>& a, const Uncertain<T>& b, T mean,
                           T dcda, T dcdb) {
    Uncertain<T> c(a);
    detail_::inplace_binary(c, b, mean, dcda, dcdb);
    return c;
}

template<typename FunctionType, typename NumericType>
NumericType numeric_derivative(FunctionType f, NumericType a) {
    // Step and step size chosen for consistency with uncertainties package
    auto step_size = std::sqrt(std::numeric_limits<float>::epsilon());
    auto step      = step_size * std::abs(a);
    auto a_plus    = f(a + step);
    auto a_minus   = f(a - step);
    auto dcda      = (a_plus - a_minus) / (2 * step);
    return dcda;
}
 
} // namespace sigma::detail_