search_engine.h

Go to the documentation of this file.

/*
 * search_engine.h
 *
 * LICENSE HERE
 *
 *  Created on: 2016-08-24
 *      Author: Rick Valenzano
 */

#ifndef SEARCHENGINE_H_
#define SEARCHENGINE_H_

#include <vector>
#include <cstdint>

#include "goal_test_function.h"
#include "transition_system.h"

//TODO Are these enums really the best way to do this? Have classes like an Exception?
//TODO Add time and time limits
//TODO Add debug modes for state-checking?

enum class SearchStatus
{
    not_ready, ready, active, terminated
};

enum class SearchTermType
{
    completed, engine_not_ready, res_limit
};

template<class state_t, class action_t>
class SearchEngine
{
public:
    SearchEngine();

    virtual ~SearchEngine();

    void setGoalTest(const GoalTestFunction<state_t> *g);

    void setTransitionSystem(const TransitionSystem<state_t, action_t> *o);

    SearchStatus getStatus() const;

    SearchTermType getPlan(const state_t &init_state, std::vector<action_t> &sol_plan);

    bool foundSolution() const;

    std::vector<action_t> getLastPlan();

    double getLastPlanCost();

    void setStorageLimit(uint64_t limit);

    bool hitStorageLimit();

    void setHComputeLimit(uint64_t limit);

    bool hitHCompLimit();

    void setSuccCallLimit(uint64_t limit);

    bool hitSuccFuncLimit();

    void setGoalTestLimit(uint64_t limit);

    bool hitGoalTestLimit();

    uint64_t getStorageCount() const;

    uint64_t getHCompCount() const;

    uint64_t getSuccFuncCount() const;

    uint64_t getStateGenCount() const;

    uint64_t getActionGenCount() const;

    uint64_t getGoalTestCount() const;

    virtual void resetStatistics();

    virtual void resetEngine();

    virtual bool isConfigured() const;

protected:

    virtual SearchTermType searchForPlan(const state_t &init_state) = 0;

    virtual void incrementGoalTestCount();

    virtual void incrementHCompCount();

    virtual void incrementSuccFuccCalls();

    virtual void incrementStateGenCount();

    virtual void increaseActionGenCount(double new_gens);

    const GoalTestFunction<state_t> *goal_test; 
    const TransitionSystem<state_t, action_t> *op_system; 

    SearchStatus alg_status; 

    bool have_incumbent; 
    std::vector<action_t> incumbent_plan; 
    double incumbent_cost; 

    uint64_t storage_limit; 
    uint64_t storage_count; 

    uint64_t h_comp_limit; 
    uint64_t h_comp_count; 

    uint64_t succ_func_limit; 
    uint64_t succ_func_count; 

    uint64_t goal_test_limit; 
    uint64_t goal_test_count; 

    uint64_t state_gen_count; 
    uint64_t action_gen_count; 
};

template<class state_t, class action_t>
SearchEngine<state_t, action_t>::SearchEngine()
        : goal_test(0), op_system(0), alg_status(SearchStatus::not_ready), have_incumbent(false), incumbent_cost(0.0),
                storage_limit(0), storage_count(0), h_comp_limit(0), h_comp_count(0), succ_func_limit(0),
                succ_func_count(0), goal_test_limit(0), goal_test_count(0), state_gen_count(0), action_gen_count(0)
{
}

template<class state_t, class action_t>
SearchEngine<state_t, action_t>::~SearchEngine()
{
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::setGoalTest(const GoalTestFunction<state_t>* g)
{
    goal_test = g;

    resetEngine();
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::setTransitionSystem(const TransitionSystem<state_t, action_t>* o)
{
    op_system = o;

    resetEngine();
}

template<class state_t, class action_t>
inline SearchStatus SearchEngine<state_t, action_t>::getStatus() const
{
    return alg_status;
}

template<class state_t, class action_t>
SearchTermType SearchEngine<state_t, action_t>::getPlan(const state_t& init_state, std::vector<action_t>& sol_plan)
{
    resetEngine();

    if(alg_status == SearchStatus::not_ready)
        return SearchTermType::engine_not_ready;

    alg_status = SearchStatus::active;
    SearchTermType term = searchForPlan(init_state);

    alg_status = SearchStatus::terminated;

    sol_plan.clear();
    if(incumbent_plan.size() > 0) {
        for(unsigned i = 0; i < incumbent_plan.size(); i++) {
            sol_plan.push_back(incumbent_plan[i]);
        }
    }

    return term;
}

template<class state_t, class action_t>
inline void SearchEngine<state_t, action_t>::setStorageLimit(uint64_t limit)
{
    storage_limit = limit;
}

template<class state_t, class action_t>
inline void SearchEngine<state_t, action_t>::setHComputeLimit(uint64_t limit)
{
    h_comp_limit = limit;
}

template<class state_t, class action_t>
inline void SearchEngine<state_t, action_t>::setSuccCallLimit(uint64_t limit)
{
    succ_func_limit = limit;
}

template<class state_t, class action_t>
inline uint64_t SearchEngine<state_t, action_t>::getStorageCount() const
{
    return storage_count;
}

template<class state_t, class action_t>
inline uint64_t SearchEngine<state_t, action_t>::getHCompCount() const
{
    return h_comp_count;
}

template<class state_t, class action_t>
inline uint64_t SearchEngine<state_t, action_t>::getSuccFuncCount() const
{
    return succ_func_count;
}

template<class state_t, class action_t>
inline uint64_t SearchEngine<state_t, action_t>::getStateGenCount() const
{
    return state_gen_count;
}

template<class state_t, class action_t>
inline uint64_t SearchEngine<state_t, action_t>::getActionGenCount() const
{
    return action_gen_count;
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::resetStatistics()
{
    storage_count = 0;
    h_comp_count = 0;
    succ_func_count = 0;
    state_gen_count = 0;
    action_gen_count = 0;
    goal_test_count = 0;
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::resetEngine()
{
    resetStatistics();

    have_incumbent = false;
    incumbent_cost = -1.0;
    incumbent_plan.clear();

    alg_status = SearchStatus::not_ready;
    if(isConfigured())
        alg_status = SearchStatus::ready;
}

template<class state_t, class action_t>
inline uint64_t SearchEngine<state_t, action_t>::getGoalTestCount() const
{
    return goal_test_count;
}

template<class state_t, class action_t>
bool SearchEngine<state_t, action_t>::isConfigured() const
{
    if(!goal_test || !op_system) {
        return false;
    }
    return true;
}

template<class state_t, class action_t>
bool SearchEngine<state_t, action_t>::hitStorageLimit()
{
    if(storage_limit > 0 && storage_count >= storage_limit)
        return true;
    return false;
}

template<class state_t, class action_t>
bool SearchEngine<state_t, action_t>::hitHCompLimit()
{
    if(h_comp_limit > 0 && h_comp_count >= h_comp_limit)
        return true;
    return false;
}

template<class state_t, class action_t>
inline std::vector<action_t> SearchEngine<state_t, action_t>::getLastPlan()
{
    return incumbent_plan;
}

template<class state_t, class action_t>
inline double SearchEngine<state_t, action_t>::getLastPlanCost()
{
    return incumbent_cost;
}

template<class state_t, class action_t>
inline bool SearchEngine<state_t, action_t>::foundSolution() const
{
    return have_incumbent;
}

template<class state_t, class action_t>
bool SearchEngine<state_t, action_t>::hitSuccFuncLimit()
{
    if(succ_func_limit > 0 && succ_func_count >= succ_func_limit)
        return true;
    return false;
}

template<class state_t, class action_t>
inline void SearchEngine<state_t, action_t>::setGoalTestLimit(uint64_t limit)
{
    goal_test_limit = limit;
}

template<class state_t, class action_t>
bool SearchEngine<state_t, action_t>::hitGoalTestLimit()
{
    if(goal_test_limit > 0 && goal_test_count >= goal_test_limit)
        return true;
    return false;
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::increaseActionGenCount(double new_gens)
{
    action_gen_count += new_gens;
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::incrementStateGenCount()
{
    state_gen_count++;
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::incrementGoalTestCount()
{
    goal_test_count++;
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::incrementSuccFuccCalls()
{
    succ_func_count++;
}

template<class state_t, class action_t>
void SearchEngine<state_t, action_t>::incrementHCompCount()
{
    h_comp_count++;
}

#endif /* SEARCHENGINE_H_ */