selector.h

 
#ifndef SELECTOR_H
#define SELECTOR_H
 
#include "learn/evaluationResult.h"
#include "mutator/rng.h"
#include "selector/selectionContext.h"
#include "selector/selectionMetrics.h"
#include "selector/selectionParameters.h"
#include "tpg/tpgGraph.h"
 
namespace Selector {
 
    class Selector
    {
      protected:
        std::shared_ptr<TPG::TPGGraph> graph;
 
        const Learn::LearningParameters& params;
 
        std::pair<const TPG::TPGVertex*,
                  std::shared_ptr<Learn::EvaluationResult>>
            bestRoot{nullptr, nullptr};
 
        std::map<const TPG::TPGVertex*,
                 std::shared_ptr<Learn::EvaluationResult>>
            resultsPerRoot;
 
        SelectionContext context;
 
      public:
        Selector(std::shared_ptr<TPG::TPGGraph> graph,
                 const Learn::LearningParameters& params)
            : graph{graph}, params{params}
        {
        }
 
        virtual void launchSelection(
            std::multimap<std::shared_ptr<Learn::EvaluationResult>,
                          const TPG::TPGVertex*>& results,
            Mutator::RNG& rng);
 
        virtual void doSelection(
            std::multimap<std::shared_ptr<Learn::EvaluationResult>,
                          const TPG::TPGVertex*>& results,
            Mutator::RNG& rng);
 
        virtual std::shared_ptr<SelectionMetrics> createSelectionMetrics();
 
        virtual void keepBestPolicy();
 
        virtual void updateEvaluationRecords(
            const std::multimap<std::shared_ptr<Learn::EvaluationResult>,
                                const TPG::TPGVertex*>& results);
 
        virtual void updateResultsPerRoot(
            const std::multimap<std::shared_ptr<Learn::EvaluationResult>,
                                const TPG::TPGVertex*>& results);
 
        virtual void updateBestRoot(
            const std::multimap<std::shared_ptr<Learn::EvaluationResult>,
                                const TPG::TPGVertex*>& results);
 
        virtual const std::pair<const TPG::TPGVertex*,
                                std::shared_ptr<Learn::EvaluationResult>>&
        getBestRoot() const;
 
        virtual std::shared_ptr<TPG::TPGGraph> getGraph();
 
        virtual void forgetPreviousResults();
 
        virtual const std::map<const TPG::TPGVertex*,
                               std::shared_ptr<Learn::EvaluationResult>>&
        getResultsPerRoot() const;
 
        virtual const SelectionContext& updateContext();
 
        virtual void updateAfterPopulate() {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
    };
}; // namespace Selector
 
#endif // SELECTION_H