setter.hpp

Go to the documentation of this file.

#pragma once
#include "sigma/uncertain.hpp"

 
namespace sigma::detail_ {

template<typename UncertainType>
class Setter {
public:
    using my_t = Setter<UncertainType>;

    using uncertain_t = UncertainType;

    using value_t = typename uncertain_t::value_t;

    using dep_sd_t = typename uncertain_t::dep_sd_t;

    using dep_sd_ptr = typename uncertain_t::dep_sd_ptr;

    using deps_map_t = typename uncertain_t::deps_map_t;

    Setter(uncertain_t& u) : m_x_(u) {}

    void update_mean(value_t mean) { m_x_.m_mean_ = mean; }

    void update_sd() {
        m_x_.m_sd_ = 0.0;
        std::vector<dep_sd_ptr> zero_contributions{};
        for(const auto& [dep, deriv] : m_x_.m_deps_) {
            if(deriv == 0.0) {
                zero_contributions.emplace_back(dep);
                continue;
            }
            m_x_.m_sd_ += std::pow(*dep.get() * deriv, 2.0);
        }
        for(const auto& dep : zero_contributions) { m_x_.m_deps_.erase(dep); }
        m_x_.m_sd_ = std::sqrt(m_x_.m_sd_);
    }

    void update_derivatives(value_t dxda, bool call_update_std = true) {
        if(dxda != 1.0) {
            for(const auto& [dep, deriv] : m_x_.m_deps_) {
                m_x_.m_deps_[dep] *= dxda;
            }
        }
        if(call_update_std) update_sd();
    }

    void update_derivatives(const deps_map_t& deps, value_t dxda,
                            bool call_update_std = true) {
        for(const auto& [dep, deriv] : deps) {
            auto new_deriv = dxda * deriv;
            if(m_x_.m_deps_.count(dep) != 0) {
                m_x_.m_deps_[dep] += new_deriv;
            } else {
                m_x_.m_deps_.emplace(std::make_pair(std::move(dep), new_deriv));
            }
        }
        if(call_update_std) update_sd();
    }
 
private:
    uncertain_t& m_x_;
};
 
} // namespace sigma::detail_