tpgMutator.h

 
#ifndef TPG_MUTATOR_H
#define TPG_MUTATOR_H
 
#include <thread>
 
#include "archive.h"
#include "mutator/mutationParameters.h"
#include "selector/selector.h"
#include "tpg/tpgGraph.h"
 
namespace Mutator {
    namespace TPGMutator {
 
        const TPG::TPGAction* initActionVertex(
            TPG::TPGGraph& graph, const Mutator::MutationParameters& params,
            Mutator::RNG& rng, uint64_t nbActionEdgeInit, uint64_t actionID);
 
        void initRandomTPG(TPG::TPGGraph& graph,
                           const MutationParameters& params, Mutator::RNG& rng,
                           uint64_t nbAction);
 
        void removeRandomActionEdge(TPG::TPGGraph& graph,
                                    const TPG::TPGAction& action,
                                    Mutator::RNG& rng);
 
        void addRandomActionEdge(TPG::TPGGraph& graph,
                                 const TPG::TPGAction& action,
                                 const Selector::SelectionContext* context,
                                 Mutator::RNG& rng);
 
        void swapActionEdges(TPG::TPGGraph& graph, const TPG::TPGAction& action,
                             Mutator::RNG& rng);
 
        void mutateTPGActionEdge(
            TPG::TPGGraph& graph, const TPG::TPGAction& action,
            TPG::TPGActionEdge* actionEdge,
            std::list<std::shared_ptr<Program::Program>>& newPrograms,
            const Mutator::MutationParameters& params, Mutator::RNG& rng);
 
        void mutateTPGAction(
            TPG::TPGGraph& graph, const TPG::TPGAction& action,
            const Selector::SelectionContext* context,
            std::list<std::shared_ptr<Program::Program>>& newPrograms,
            const Mutator::MutationParameters& params, Mutator::RNG& rng);
 
        void crossProgram(TPG::TPGGraph& graph,
                          std::vector<const TPG::TPGAction*> childs,
                          size_t actionID,
                          const Mutator::MutationParameters& params,
                          Mutator::RNG& rng);
 
        void crossEdges(TPG::TPGGraph& graph,
                        std::vector<const TPG::TPGAction*> childs,
                        size_t actionID,
                        const Mutator::MutationParameters& params,
                        Mutator::RNG& rng);
 
        void crossTPGAction(TPG::TPGGraph& graph,
                            std::vector<const TPG::TPGAction*> childs,
                            const Mutator::MutationParameters& params,
                            Mutator::RNG& rng);
 
        void removeRandomEdge(TPG::TPGGraph& graph, const TPG::TPGTeam& team,
                              Mutator::RNG& rng);
 
        void addRandomEdge(TPG::TPGGraph& graph, const TPG::TPGTeam& team,
                           const Selector::SelectionContext* context,
                           Mutator::RNG& rng);
 
        void mutateEdgeDestination(TPG::TPGGraph& graph,
                                   const TPG::TPGEdge* edge,
                                   const Selector::SelectionContext* context,
                                   const Mutator::MutationParameters& params,
                                   Mutator::RNG& rng);
 
        void mutateOutgoingEdge(
            TPG::TPGGraph& graph, const TPG::TPGEdge* edge,
            const Selector::SelectionContext* context,
            std::list<std::shared_ptr<Program::Program>>& newPrograms,
            const Mutator::MutationParameters& params, Mutator::RNG& rng);
 
        void mutateTPGTeam(
            TPG::TPGGraph& graph, const Archive& archive,
            const TPG::TPGTeam& team, const Selector::SelectionContext* context,
            std::list<std::shared_ptr<Program::Program>>& newPrograms,
            const Mutator::MutationParameters& params, Mutator::RNG& rng);
 
        void mutateProgramBehaviorAgainstArchive(
            std::shared_ptr<Program::Program>& newProg,
            const Mutator::MutationParameters& params, const Archive& archive,
            Mutator::RNG& rng);
 
        void mutateNewProgramBehaviors(
            const uint64_t& maxNbThreads,
            std::list<std::shared_ptr<Program::Program>>& newPrograms,
            Mutator::RNG& rng, const Mutator::MutationParameters& params,
            const Archive& archive);
 
        void populateTPG(
            TPG::TPGGraph& graph, Selector::Selector& selector,
            const Archive& archive, const Mutator::MutationParameters& params,
            Mutator::RNG& rng, uint64_t nbActions,
            uint64_t maxNbThreads = std::thread::hardware_concurrency());
    }; // namespace TPGMutator
}; // namespace Mutator
 
#endif