AbstractSolver.h

Go to the documentation of this file.

 
#ifndef DIGNEA_ABSTRACTEA_H
#define DIGNEA_ABSTRACTEA_H
 
#include <dignea/core/Front.h>
#include <dignea/core/Problem.h>
#include <dignea/core/Solution.h>
#include <dignea/evaluators/PopulationEvaluator.h>
#include <dignea/evolution/AvgEvolution.h>
#include <dignea/evolution/Evolution.h>
#include <dignea/utilities/Sorter.h>
#include <dignea/utilities/exceptions/NotImplemented.h>
 
#include <algorithm>
#include <array>
#include <chrono>
#include <cstdio>
#include <ctime>
#include <iomanip>
#include <nlohmann/json.hpp>
#include <utility>
 
using json = nlohmann::json;
 
template <class S>
class AbstractSolver {
   public:
    AbstractSolver();
 
    AbstractSolver(const int &maxEvals, const int &popsize);
 
    AbstractSolver(unique_ptr<PopulationEvaluator<S>>, const int &maxEvals,
               const int &popsize);
 
    virtual ~AbstractSolver();
 
    virtual void run() = 0;
 
    virtual string getName() const = 0;
 
    virtual string getID() const = 0;
 
    virtual json to_json() const;
 
    virtual Front<S> getResults() const = 0;
 
    inline int getPopulationSize() const { return populationSize; };
 
    void setPopulationSize(int pSize);
 
    inline double getElapsedTime() const { return elapsedTime; };
 
    inline const vector<S> &getPopulation() const { return population; };
 
    int getMaxEvaluations() const { return maxEvaluations; }
 
    void setMaxEvaluations(int maxEval) {
        AbstractSolver::maxEvaluations = maxEval;
    }
 
    const Problem<S> *getProblem() const { return problem.get(); }
 
    virtual void setProblem(shared_ptr<Problem<S>> prob) {
        this->problem = prob;
    }
 
    virtual void setProblem(Problem<S> *prob) { this->problem.reset(prob); }
 
    PopulationEvaluator<S> *getEvaluator() const { return evaluator.get(); }
 
    void setEvaluator(unique_ptr<PopulationEvaluator<S>> eval) {
        this->evaluator = move(eval);
    }
 
    int getPerformedEvaluations() const { return performedEvaluations; }
 
    void setPerformedEvaluations(int pEvals) {
        this->performedEvaluations = pEvals;
    }
 
    void setPopulation(const vector<S> &pop);
 
    virtual Evolution<S> getEvolution() const;
 
    int getPrintingInterval() const { return evolutionInterval; }
 
   protected:
    virtual void initProgress() = 0;
 
    virtual void updateProgress() = 0;
 
    virtual void finishProgress() = 0;
 
    virtual bool isStoppingConditionReached() = 0;
 
    virtual void createInitialPopulation() = 0;
 
    virtual void evaluatePopulation(vector<S> &pop) = 0;
 
    virtual void updateEvolution(vector<S> &pop);
 
    virtual void updateEvolution(const int &checkpoint, vector<S> &);
 
   protected:
    int maxEvaluations; 
    int performedEvaluations;
    int populationSize; 
    // Population of individuals --> Solutions
    vector<S> population;
    // Problem to solve
    shared_ptr<Problem<S>> problem;
    // Evaluation class
    unique_ptr<PopulationEvaluator<S>> evaluator;
    // Evolution data
    Evolution<S> evolution;
    AvgEvolution<S> avgEvolution;
 
    // Execution time
    std::chrono::system_clock::time_point startTime;
    std::chrono::system_clock::time_point endTime;
    double elapsedTime;
 
    // Checkpoints to collect evolution data
    int nextCheckpoint;
    int evolutionInterval;
 
   public:
    static const int DEFAULT_POPULATION_SIZE;
    static const int DEFAULT_EVALUATIONS_LIMIT;
    static const std::string NAME;
    static const std::string MAX_EVALUATIONS;
    static const std::string POP_SIZE;
    static const std::string ELAPSED_TIME;
    static const std::string EVALUATOR;
    static const int EVOLUTION_SIZE;
};
 
template <class S>
const int AbstractSolver<S>::DEFAULT_POPULATION_SIZE = 100;
template <class S>
const int AbstractSolver<S>::DEFAULT_EVALUATIONS_LIMIT = 100000;
template <class S>
const std::string AbstractSolver<S>::NAME = "Algorithm";
template <class S>
const std::string AbstractSolver<S>::MAX_EVALUATIONS = "Max Evaluations";
template <class S>
const std::string AbstractSolver<S>::POP_SIZE = "Population Size";
template <class S>
const std::string AbstractSolver<S>::ELAPSED_TIME = "Elapsed Time";
template <class S>
const std::string AbstractSolver<S>::EVALUATOR = "Evaluator";
template <class S>
const int AbstractSolver<S>::EVOLUTION_SIZE = 10;
 
template <class S>
AbstractSolver<S>::AbstractSolver()
    : maxEvaluations(DEFAULT_EVALUATIONS_LIMIT),
      performedEvaluations(0),
      populationSize(DEFAULT_POPULATION_SIZE),
      elapsedTime(0.0),
      nextCheckpoint(0) {
    evolution = {};
    avgEvolution = {};
    evolutionInterval = maxEvaluations / EVOLUTION_SIZE;
}
 
template <class S>
AbstractSolver<S>::AbstractSolver(const int &maxEvals, const int &popsize)
    : maxEvaluations(maxEvals),
      performedEvaluations(0),
      populationSize(popsize),
      elapsedTime(0.0),
      nextCheckpoint(0) {
    evolutionInterval = maxEvaluations / EVOLUTION_SIZE;
    problem = nullptr;
    this->evaluator = make_unique<PopulationEvaluator<S>>();
    evolution = {};
    avgEvolution = {};
}
 
template <class S>
AbstractSolver<S>::AbstractSolver(unique_ptr<PopulationEvaluator<S>> eval,
                          const int &maxEvals, const int &popsize)
    : maxEvaluations(maxEvals),
      performedEvaluations(0),
      populationSize(popsize),
      elapsedTime(0.0),
      nextCheckpoint(0) {
    problem = nullptr;
    evaluator = move(eval);
    evolution = {};
    avgEvolution = {};
    evolutionInterval = maxEvaluations / EVOLUTION_SIZE;
}
 
template <class S>
AbstractSolver<S>::~AbstractSolver() {
    population.clear();
    population.shrink_to_fit();
}
 
template <class S>
void AbstractSolver<S>::updateEvolution(vector<S> &solutions) {
    if (nextCheckpoint > maxEvaluations) {
        string where = "nextCheckpoint > maxEvals(" +
                       to_string(maxEvaluations) +
                       ") in AbstractSolver::updateEvolution with: " +
                       to_string(nextCheckpoint) + " evals";
        throw(OutOfRange(where));
    }
    if (performedEvaluations >= nextCheckpoint) {
        evolution.update(nextCheckpoint, solutions);
        avgEvolution.update(nextCheckpoint, solutions);
        nextCheckpoint += evolutionInterval;
    }
}
 
template <class S>
void AbstractSolver<S>::updateEvolution(const int &checkpoint,
                                    vector<S> &solutions) {
    if (checkpoint > (maxEvaluations + evolutionInterval)) {
        string where =
            "checkpoint > maxEvals in AbstractSolver::updateEvolution with: " +
            to_string(checkpoint) +
            " evals and maxEvals: " + to_string(maxEvaluations);
        throw(OutOfRange(where));
    }
    if (checkpoint >= nextCheckpoint) {
        evolution.update(checkpoint, solutions);
        avgEvolution.update(nextCheckpoint, solutions);
        nextCheckpoint += evolutionInterval;
    }
}
 
template <class S>
Evolution<S> AbstractSolver<S>::getEvolution() const {
    return this->evolution;
}
 
template <class S>
void AbstractSolver<S>::setPopulationSize(int pSize) {
    this->populationSize = pSize;
    this->population.clear();
    this->population.reserve(populationSize);
}
 
template <class S>
void AbstractSolver<S>::setPopulation(const vector<S> &pop) {
    this->population = pop;
    this->populationSize = pop.size();
}
template <class S>
json AbstractSolver<S>::to_json() const {
    json info;
    Evolution copy = this->evolution;
    AvgEvolution avgCopy = this->avgEvolution;
    info["name"] = this->getName();
    info["max_evals"] = this->maxEvaluations;
    info["pop_size"] = this->populationSize;
    info["elapsed_time"] = this->elapsedTime;
    info["evaluator"] = this->evaluator->getName();
    info["evolution"] = copy.results();
    info["avg_evolution"] = avgCopy.results();
    return info;
};
 
#endif  // DIGNEA_ABSTRACTEA_H