Belief.h

Go to the documentation of this file.

#pragma once
 
#include "storm/utility/constants.h"
#include "storm/utility/macros.h"
 
#include "storm-pomdp/beliefs/utility/types.h"
 
namespace storm::pomdp::beliefs {
 
template<typename ValueType>
class BeliefBuilder;

template<typename ValueTypeArg>
class Belief {
   public:
    using ValueType = ValueTypeArg;
    friend class BeliefBuilder<Belief<ValueType>>;
 
    Belief() = delete;
    Belief(Belief const& other) = default;
    Belief(Belief&& other) = default;
    Belief<ValueType>& operator=(Belief const& other) = delete;
    Belief<ValueType>& operator=(Belief&& other) = delete;

    std::size_t size() const;

    BeliefStateType representativeState() const;

    BeliefObservationType const& observation() const;

    bool operator==(Belief const& other) const;

    std::string toString(bool convertToDouble = true, bool fullPrecision = false) const;

    template<typename SummandsType>
    SummandsType getWeightedSum(std::vector<SummandsType> const& summands) const {
        auto sum = storm::utility::zero<SummandsType>();
        forEach([&sum, &summands](auto const& state, auto const& val) {
            STORM_LOG_ASSERT(state < summands.size(), "State " << state << " is out of range for the given summands.");
            // If SummandsType is the same as ValueType, we can directly multiply the value, otherwise convert
            if constexpr (std::is_same_v<SummandsType, ValueType>) {
                sum += summands[state] * val;
            } else {
                sum += summands[state] * storm::utility::convertNumber<SummandsType>(val);
            }
        });
        return sum;
    }

    template<typename FunctionType>
    void forEach(FunctionType const& f) const {
        for (auto const& [state, value] : data) {
            f(state, value);
        }
    }

    template<typename FunctionType>
    bool allOf(FunctionType const& f) const {
        for (auto const& [state, value] : data) {
            if (!f(state, value)) {
                return false;
            }
        }
        return true;
    }

    template<typename FunctionType>
    void forEachStateInSupport(FunctionType const& f) const {
        for (auto const& [state, value] : data) {
            f(state);
        }
    }

    template<typename FunctionType>
    void forEachCombine(Belief<ValueType> const& other, FunctionType const& f, bool considerOnlyThisSupport = false) const {
        static_assert(BeliefFlatMapIsOrdered);
        auto const zero = storm::utility::zero<ValueType>();
        auto it2 = other.data.cbegin();
        auto const it2End = other.data.cend();
        if (considerOnlyThisSupport) {
            for (auto const& [state1, value1] : data) {
                while (it2 != it2End && it2->first < state1) {
                    ++it2;
                }
                if (it2 == it2End || it2->first > state1) {
                    f(state1, value1, zero);
                } else {
                    STORM_LOG_ASSERT(state1 == it2->first, "Unexpected state.");
                    f(state1, value1, it2->second);
                }
            }
        } else {
            auto it1 = data.cbegin();
            auto const it1End = data.cend();
            while (it1 != it1End && it2 != it2End) {
                auto const state1 = it1->first;
                auto const state2 = it2->first;
                if (state1 == state2) {
                    f(state1, it1->second, it2->second);
                    ++it1;
                    ++it2;
                } else if (state1 < state2) {
                    f(state1, it1->second, zero);
                    ++it1;
                } else {
                    STORM_LOG_ASSERT(state2 < state1, "unexpected states.");
                    f(state2, zero, it2->second);
                    ++it2;
                }
            }
            for (; it1 != it1End; ++it1) {
                f(it1->first, it1->second, zero);
            }
            for (; it2 != it2End; ++it2) {
                f(it2->first, zero, it2->second);
            }
        }
    }

    struct BeliefHash {
        std::size_t operator()(Belief const& belief) const;
    };
 
   private:
    Belief(BeliefFlatMap<ValueType>&& data, BeliefObservationType&& obs);
 
    BeliefFlatMap<ValueType> data;
    BeliefObservationType obs;
};
 
}  // namespace storm::pomdp::beliefs