StandardRewardModel.h

Go to the documentation of this file.

#pragma once
 
#include <optional>
#include <set>
#include <vector>
 
#include "storm/adapters/RationalFunctionForward.h"
#include "storm/storage/SparseMatrix.h"
#include "storm/utility/OptionalRef.h"
#include "storm/utility/OsDetection.h"
#include "storm/utility/constants.h"
 
namespace storm {
namespace models {
namespace sparse {
template<typename CValueType>
class StandardRewardModel {
   public:
    typedef CValueType ValueType;
 
    StandardRewardModel(std::optional<std::vector<ValueType>> const& optionalStateRewardVector = std::nullopt,
                        std::optional<std::vector<ValueType>> const& optionalStateActionRewardVector = std::nullopt,
                        std::optional<storm::storage::SparseMatrix<ValueType>> const& optionalTransitionRewardMatrix = std::nullopt);
 
    StandardRewardModel(std::optional<std::vector<ValueType>>&& optionalStateRewardVector,
                        std::optional<std::vector<ValueType>>&& optionalStateActionRewardVector = std::nullopt,
                        std::optional<storm::storage::SparseMatrix<ValueType>>&& optionalTransitionRewardMatrix = std::nullopt);
 
    StandardRewardModel(StandardRewardModel<ValueType> const& other) = default;
    StandardRewardModel& operator=(StandardRewardModel<ValueType> const& other) = default;
 
    StandardRewardModel(StandardRewardModel<ValueType>&& other) = default;
    StandardRewardModel& operator=(StandardRewardModel<ValueType>&& other) = default;
 
    bool hasStateRewards() const;
 
    bool hasOnlyStateRewards() const;
 
    std::vector<ValueType> const& getStateRewardVector() const;
 
    std::vector<ValueType>& getStateRewardVector();
 
    ValueType const& getStateReward(uint_fast64_t state) const;
 
    template<typename T>
    void setStateReward(uint_fast64_t state, T const& newReward);
 
    // template<typename T=ValueType, EnableIf<hasTotalOrder<T>>>
    // ValueType maximalStateReward(uint_fast64_t state) const;
 
    std::optional<std::vector<ValueType>> const& getOptionalStateRewardVector() const;
 
    bool hasStateActionRewards() const;
 
    std::vector<ValueType> const& getStateActionRewardVector() const;
 
    std::vector<ValueType>& getStateActionRewardVector();
 
    ValueType const& getStateActionReward(uint_fast64_t choiceIndex) const;
 
    template<typename T>
    void setStateActionReward(uint_fast64_t choiceIndex, T const& newValue);
 
    template<typename MatrixValueType>
    void clearRewardAtState(uint_fast64_t state, storm::storage::SparseMatrix<MatrixValueType> const& transitions);
 
    std::optional<std::vector<ValueType>> const& getOptionalStateActionRewardVector() const;
 
    bool hasTransitionRewards() const;
 
    storm::storage::SparseMatrix<ValueType> const& getTransitionRewardMatrix() const;
 
    storm::storage::SparseMatrix<ValueType>& getTransitionRewardMatrix();
 
    std::optional<storm::storage::SparseMatrix<ValueType>> const& getOptionalTransitionRewardMatrix() const;
 
    template<typename MatrixValueType>
    ValueType getStateActionAndTransitionReward(uint_fast64_t choiceIndex, storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix) const;
 
    template<typename MatrixValueType>
    ValueType getTotalStateActionReward(uint_fast64_t stateIndex, uint_fast64_t choiceIndex,
                                        storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix,
                                        MatrixValueType const& stateRewardWeight = storm::utility::one<MatrixValueType>(),
                                        MatrixValueType const& actionRewardWeight = storm::utility::one<MatrixValueType>()) const;
 
    StandardRewardModel<ValueType> restrictActions(storm::storage::BitVector const& enabledActions) const;
 
    StandardRewardModel<ValueType> permuteActions(std::vector<uint64_t> const& inversePermutation) const;
 
    StandardRewardModel<ValueType> permuteStates(std::vector<uint64_t> const& inversePermutation,
                                                 storm::OptionalRef<std::vector<uint64_t> const> rowGroupIndices = storm::NullRef,
                                                 storm::OptionalRef<std::vector<uint64_t> const> permutation = storm::NullRef) const;
 
    template<typename MatrixValueType>
    void reduceToStateBasedRewards(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix, bool reduceToStateRewards = false,
                                   std::vector<MatrixValueType> const* weights = nullptr);
 
    template<typename MatrixValueType>
    std::vector<ValueType> getTotalRewardVector(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix) const;
 
    template<typename MatrixValueType>
    std::vector<ValueType> getTotalRewardVector(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix,
                                                std::vector<MatrixValueType> const& weights) const;
 
    template<typename MatrixValueType>
    std::vector<ValueType> getTotalRewardVector(uint_fast64_t numberOfRows, storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix,
                                                storm::storage::BitVector const& filter) const;
 
    template<typename MatrixValueType>
    std::vector<ValueType> getTotalActionRewardVector(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix,
                                                      std::vector<MatrixValueType> const& stateRewardWeights) const;
 
    template<typename MatrixValueType>
    storm::storage::BitVector getStatesWithZeroReward(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix) const;
 
    template<typename MatrixValueType>
    storm::storage::BitVector getStatesWithFilter(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix,
                                                  std::function<bool(ValueType const&)> const& filter) const;
 
    template<typename MatrixValueType>
    storm::storage::BitVector getChoicesWithZeroReward(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix) const;
 
    template<typename MatrixValueType>
    storm::storage::BitVector getChoicesWithFilter(storm::storage::SparseMatrix<MatrixValueType> const& transitionMatrix,
                                                   std::function<bool(ValueType const&)> const& filter) const;
 
    bool empty() const;
 
    bool isAllZero() const;
 
    bool hasNegativeRewards() const;
 
    bool hasPositiveRewards() const;
 
    bool isCompatible(uint_fast64_t nrStates, uint_fast64_t nrChoices) const;
 
    std::size_t hash() const;
 
    template<typename ValueTypePrime>
    friend std::ostream& operator<<(std::ostream& out, StandardRewardModel<ValueTypePrime> const& rewardModel);
 
   private:
    // An (optional) vector representing the state rewards.
    std::optional<std::vector<ValueType>> optionalStateRewardVector;
 
    // An (optional) vector representing the state-action rewards.
    std::optional<std::vector<ValueType>> optionalStateActionRewardVector;
 
    // An (optional) matrix representing the transition rewards.
    std::optional<storm::storage::SparseMatrix<ValueType>> optionalTransitionRewardMatrix;
};
 
template<typename ValueType>
std::ostream& operator<<(std::ostream& out, StandardRewardModel<ValueType> const& rewardModel);
 
std::set<storm::RationalFunctionVariable> getRewardModelParameters(StandardRewardModel<storm::RationalFunction> const& rewModel);
}  // namespace sparse
}  // namespace models
}  // namespace storm