ao_star.h

#ifndef PROBFD_ALGORITHMS_AO_STAR_H
#define PROBFD_ALGORITHMS_AO_STAR_H
 
#include "probfd/algorithms/ao_search.h"
 
#include <vector>
 
// Forward Declarations
namespace probfd::algorithms {
template <typename>
class SuccessorSampler;
}
 
namespace probfd::algorithms::ao_search::ao_star {
 
template <typename State, typename Action, bool UseInterval>
class AOStar
    : public AOBase<
          State,
          Action,
          PerStateInformation<Action, UseInterval, true>> {
    using Base = typename AOStar::AOBase;
 
    friend Base;
 
    using AlgorithmValueType = Base::AlgorithmValueType;
 
    using MDPType = typename Base::MDPType;
    using EvaluatorType = typename Base::EvaluatorType;
    using PolicyPickerType = typename Base::PolicyPickerType;
    using StateInfo = typename Base::StateInfo;
 
    using SuccessorSamplerType = SuccessorSampler<Action>;
 
    // Algorithm parameters
    const std::shared_ptr<SuccessorSamplerType> outcome_selection_;
 
    // Re-used buffers
    std::vector<Transition<Action>> transitions_;
    std::vector<AlgorithmValueType> qvalues_;
    Distribution<StateID> successor_dist_;
 
public:
    AOStar(
        std::shared_ptr<PolicyPickerType> policy_chooser,
        std::shared_ptr<SuccessorSamplerType> outcome_selection);
 
protected:
    Interval do_solve(
        MDPType& mdp,
        EvaluatorType& heuristic,
        param_type<State> initial_state,
        ProgressReport& progress,
        double max_time) override;
 
private:
    bool update_value_check_solved(
        MDPType& mdp,
        param_type<State> state,
        std::vector<Transition<Action>> transitions,
        StateInfo& info);
};
 
} // namespace probfd::algorithms::ao_search::ao_star
 
#define GUARD_INCLUDE_PROBFD_ALGORITHMS_AO_STAR_H
#include "probfd/algorithms/ao_star_impl.h"
#undef GUARD_INCLUDE_PROBFD_ALGORITHMS_AO_STAR_H
 
#endif // PROBFD_ALGORITHMS_AO_STAR_H