Distribution.h

Go to the documentation of this file.

#ifndef STORM_STORAGE_DISTRIBUTION_H_
#define STORM_STORAGE_DISTRIBUTION_H_
 
#include <boost/container/flat_map.hpp>
#include <iosfwd>
#include <vector>
 
#include "storm/storage/sparse/StateType.h"
#include "storm/utility/ConstantsComparator.h"
 
namespace storm {
 
namespace storage {
 
template<typename ValueType, typename StateType = uint32_t>
class Distribution {
   public:
    typedef boost::container::flat_map<StateType, ValueType> container_type;
    typedef typename container_type::iterator iterator;
    typedef typename container_type::const_iterator const_iterator;
 
    Distribution();
 
    Distribution(Distribution const& other) = default;
    Distribution& operator=(Distribution const& other) = default;
    Distribution(Distribution&& other) = default;
    Distribution& operator=(Distribution&& other) = default;
 
    /*
     * If the size of this distribution is known before adding probabilities,, this method can be used to reserve enough space.
     */
    void reserve(uint64_t size);
 
    void add(Distribution const& other);
 
    bool equals(Distribution<ValueType, StateType> const& other, storm::utility::ConstantsComparator<ValueType> const& comparator) const;
 
    void addProbability(StateType const& state, ValueType const& probability);
 
    void removeProbability(StateType const& state, ValueType const& probability, storm::utility::ConstantsComparator<ValueType> const& comparator);
 
    void shiftProbability(StateType const& fromState, StateType const& toState, ValueType const& probability,
                          storm::utility::ConstantsComparator<ValueType> const& comparator);
 
    iterator begin();
 
    const_iterator begin() const;
 
    const_iterator cbegin() const;
 
    iterator end();
 
    const_iterator end() const;
 
    const_iterator cend() const;
 
    void scale(StateType const& state);
 
    std::size_t size() const;
 
    bool less(Distribution<ValueType, StateType> const& other, storm::utility::ConstantsComparator<ValueType> const& comparator) const;
 
    ValueType getProbability(StateType const& state) const;
 
    void normalize();
 
    StateType sampleFromDistribution(ValueType const& quantile) const;
 
   private:
    // A list of states and the probabilities that are assigned to them.
    container_type distribution;
};
 
template<typename ValueType, typename StateType = uint32_t>
std::ostream& operator<<(std::ostream& out, Distribution<ValueType, StateType> const& distribution);
}  // namespace storage
}  // namespace storm
 
namespace std {
 
template<typename ValueType>
struct hash<storm::storage::Distribution<ValueType>> {
    std::size_t operator()(storm::storage::Distribution<ValueType> const& distribution) const {
        return (distribution.getHash());
    }
};
 
}  // namespace std
 
#endif /* STORM_STORAGE_DISTRIBUTION_H_ */