uncertain.hpp

Go to the documentation of this file.

#pragma once
#include <cmath>
#include <iostream>
#include <memory>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <utility>

 
namespace sigma {
 
// Foward Declaration
namespace detail_ {
template<typename T>
class Setter; // Class to alter values inside Uncertain
} // namespace detail_

template<typename ValueType>
class Uncertain {
public:
    using my_t = Uncertain<ValueType>;

    using value_t = ValueType;

    using dep_sd_t = value_t;

    using dep_sd_ptr = std::shared_ptr<dep_sd_t>;

    using deps_map_t = std::unordered_map<dep_sd_ptr, value_t>;

    Uncertain(value_t mean = 0.0, value_t sd = 0.0,
              value_t threshold = std::numeric_limits<value_t>::epsilon());

    value_t mean() const { return m_mean_; }

    value_t sd() const { return m_sd_; }

    const deps_map_t& deps() const { return m_deps_; }

    value_t threshold() const { return m_threshold_; }
 
private:
    value_t m_mean_;

    value_t m_sd_;

    value_t m_threshold_;

    deps_map_t m_deps_ = {};

    template<typename T>
    friend class detail_::Setter;
 
}; // class Uncertain
 
// -- Out-of-line Definitions --------------------------------------------------
 
template<typename ValueType>
Uncertain<ValueType>::Uncertain(value_t mean, value_t sd, value_t threshold) :
  m_mean_(std::abs(mean) < threshold ? 0 : mean),
  m_sd_(std::abs(sd) < threshold ? 0 : std::abs(sd)),
  m_threshold_(threshold) {
    if(m_sd_ > 0.0) {
        m_deps_.emplace(std::make_shared<dep_sd_t>(m_sd_), value_t{1.0});
    }
}
 
// -- Utility functions --------------------------------------------------------

template<typename ValueType>
std::ostream& operator<<(std::ostream& os, const Uncertain<ValueType>& u) {
    os << u.mean() << "+/-" << u.sd();
    return os;
}

template<typename ValueType1, typename ValueType2>
bool operator==(const Uncertain<ValueType1>& lhs,
                const Uncertain<ValueType2>& rhs) {
    if constexpr(!std::is_same_v<ValueType1, ValueType2>) {
        return false;
    } else {
        if(lhs.mean() != rhs.mean()) return false;
        if(lhs.sd() != rhs.sd()) return false;
        if(lhs.deps() != rhs.deps()) return false;
        if(lhs.threshold() != rhs.threshold()) return false;
        return true;
    }
}

template<typename ValueType1, typename ValueType2>
bool operator!=(const Uncertain<ValueType1>& lhs,
                const Uncertain<ValueType2>& rhs) {
    return !(lhs == rhs);
}

template<typename ValueType1, typename ValueType2>
bool operator<(const Uncertain<ValueType1>& lhs,
               const Uncertain<ValueType2>& rhs) {
    return lhs.mean() < rhs.mean();
}

template<typename ValueType1, typename ValueType2>
bool operator>(const Uncertain<ValueType1>& lhs,
               const Uncertain<ValueType2>& rhs) {
    return rhs < lhs;
}

template<typename ValueType1, typename ValueType2>
bool operator<=(const Uncertain<ValueType1>& lhs,
                const Uncertain<ValueType2>& rhs) {
    return (lhs == rhs) || (lhs < rhs);
}

template<typename ValueType1, typename ValueType2>
bool operator>=(const Uncertain<ValueType1>& lhs,
                const Uncertain<ValueType2>& rhs) {
    return (lhs == rhs) || (lhs > rhs);
}

using UFloat = Uncertain<float>;

using UDouble = Uncertain<double>;
 
} // namespace sigma
 
#include "sigma/uncertain/eigen_compat.hpp"
#include "sigma/uncertain/operations/operations.hpp"