EIGBuilder.h

//
// Created by amarrero on 23/6/21.
//
 
#ifndef DIGNEA_EIGBUILDER_H
#define DIGNEA_EIGBUILDER_H
 
#include <dignea/factories/CXFactory.h>
#include <dignea/factories/MutFactory.h>
#include <dignea/factories/NSFactory.h>
#include <dignea/factories/RepFactory.h>
#include <dignea/factories/SelFactory.h>
#include <dignea/generator/AbstractDomain.h>
#include <dignea/generator/EIG.h>
// #include <dignea/generator/MOEIG.h>
#include <dignea/generator/MapElites.h>
#include <dignea/searches/NSFeatures.h>
#include <dignea/searches/NSPerformance.h>
 
enum class GeneratorType { LinearScaled, MultiObjective, MapElites };
 
template <typename IP, typename IS, typename OP, typename S>
class EIGBuilder {
    using EA = unique_ptr<AbstractEA<S>>;
 
   public:
    static EIGBuilder<IP, IS, OP, S> create(GeneratorType type);
 
    virtual ~EIGBuilder() = default;
 
    operator unique_ptr<EIG<IP, IS, OP, S>>();
 
    EIGBuilder<IP, IS, OP, S> &toSolve(unique_ptr<IP> problem);
 
    EIGBuilder<IP, IS, OP, S> &weights(const float &fW, const float &mW);
 
    EIGBuilder<IP, IS, OP, S> &with() { return *this; };
 
    EIGBuilder<IP, IS, OP, S> &portfolio(vector<EA> &configs);
 
    EIGBuilder<IP, IS, OP, S> &withSearch(NSType nsType,
                                          unique_ptr<Distance<float>> dist,
                                          const float &thres,
                                          const float &finalThresh, const int k,
                                          bool warmUp = false);
 
    EIGBuilder<IP, IS, OP, S> &evalWith(unique_ptr<InstanceFitness> evalMethod);
 
    EIGBuilder<IP, IS, OP, S> &repeating(const int &reps);
 
    EIGBuilder<IP, IS, OP, S> &crossover(CXType cxType);
 
    EIGBuilder<IP, IS, OP, S> &withCrossRate(const float &crSsRate);
 
    EIGBuilder<IP, IS, OP, S> &mutation(MutType mutation);
 
    EIGBuilder<IP, IS, OP, S> &withMutRate(const float &mutRate);
 
    EIGBuilder<IP, IS, OP, S> &selection(SelType selType);
 
    EIGBuilder<IP, IS, OP, S> &replacement(ReplacementTypes reType);
 
    EIGBuilder<IP, IS, OP, S> &populationOf(const int &popsize);
 
    EIGBuilder<IP, IS, OP, S> &runDuring(const int &generations);
 
    EIGBuilder<IP, IS, OP, S> &setFeatures(const Features &f);
 
   private:
    EIGBuilder(GeneratorType t);
 
    void newCompSet() { compSet++; }
 
   private:
    unique_ptr<EIG<IP, IS, OP, S>> generator;
    int compSet;
    bool problemSet;
    GeneratorType type;
    static int MUST_COMPS;
};
 
template <typename IP, typename IS, typename OP, typename S>
int EIGBuilder<IP, IS, OP, S>::MUST_COMPS = 12;
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> EIGBuilder<IP, IS, OP, S>::create(GeneratorType t) {
    return EIGBuilder<IP, IS, OP, S>(t);
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S>::EIGBuilder(GeneratorType t)
    : compSet(0), problemSet(false), type(t) {
    this->type = t;  // Saves the type we're building
    switch (type) {
        case GeneratorType::LinearScaled:
            this->generator = make_unique<EIG<IP, IS, OP, S>>();
            break;
        // case GeneratorType::MultiObjective:
        //     this->generator = make_unique<MOEIG<IP, IS, OP, S>>();
        //     break;
        case GeneratorType::MapElites:
            MUST_COMPS = 10;  // MapElites does not need NS parameters
            this->generator = make_unique<MapElites<IP, IS, OP, S>>();
            break;
        default:
            std::cerr << "Unknown type in EIGBuilder. LinearScaled algorithm "
                         "created by default"
                      << std::endl;
            this->generator = make_unique<EIG<IP, IS, OP, S>>();
 
            break;
    }
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S>::operator unique_ptr<EIG<IP, IS, OP, S>>() {
    if (!this->problemSet) {
        std::cerr << "EIG created but not problem set. "
                     "Remember to set a problem before calling run"
                  << std::endl;
    }
    if (compSet >= MUST_COMPS) {
        return move(this->generator);
    } else {
        throw runtime_error(
            "No all the components are set. EIG requires: "
            "configurations, evaluation method,"
            "Novelty Search configuration, "
            "mutation operator, crSsover operator, "
            "selection operator, mutation rate, "
            "crSsover rate, population size, "
            "max generations and repetitions");
    }
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::toSolve(
    unique_ptr<IP> problem) {
    this->generator->setInstanceProblem(move(problem));
    newCompSet();
    this->problemSet = true;
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::weights(const float &fW,
                                                              const float &nW) {
    this->generator->setWeightedFunction(fW, nW);
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::portfolio(
    vector<EA> &configs) {
    this->generator->setPortfolio(configs);
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::withSearch(
    NSType nsType, unique_ptr<Distance<float>> dist, const float &thres,
    const float &finalThresh, const int k, bool warmUp) {
    NSFactory<IS> factory;
    auto ns = factory.create(nsType, move(dist), thres, finalThresh, k, warmUp);
    this->generator->setNoveltySearch(move(ns));
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::evalWith(
    unique_ptr<InstanceFitness> evalMethod) {
    this->generator->setInstanceFitness(move(evalMethod));
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::repeating(
    const int &reps) {
    this->generator->setRepetitions(reps);
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::crossover(CXType cxType) {
    CXFactory<IS> factory;
    auto cx = factory.create(cxType);
    this->generator->setCrossover(move(cx));
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::withCrossRate(
    const float &crSsRate) {
    this->generator->setCrossoverRate(crSsRate);
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::mutation(
    MutType mutation) {
    MutFactory<IS> factory;
    auto mut = factory.create(mutation);
    this->generator->setMutation(move(mut));
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::withMutRate(
    const float &mutRate) {
    this->generator->setMutationRate(mutRate);
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::selection(
    SelType selType) {
    SelFactory<IS> factory;
    auto sel = factory.create(selType);
    this->generator->setSelection(move(sel));
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::replacement(
    ReplacementTypes repType) {
    RepFactory<IS> factory;
    auto rep = factory.create(repType);
    this->generator->setReplacement(move(rep));
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::populationOf(
    const int &popsize) {
    this->generator->setPopulationSize(popsize);
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::runDuring(
    const int &generations) {
    this->generator->setMaxEvaluations(generations);
    newCompSet();
    return *this;
}
 
template <typename IP, typename IS, typename OP, typename S>
EIGBuilder<IP, IS, OP, S> &EIGBuilder<IP, IS, OP, S>::setFeatures(
    const Features &f) {
    if (this->type == GeneratorType::MapElites) {
        static_cast<MapElites<IP, IS, OP, S> *>(this->generator.get())
            ->setFeaturesInfo(f);
        newCompSet();
        return *this;
    }
    return *this;
}
 
#endif  // DIGNEA_EIGBUILDER_H