SimulatedAnnealing.h

//
// Created by amarrero on 25/6/21.
//
 
#ifndef DIGNEA_SIMULATEDANNEALING_H
#define DIGNEA_SIMULATEDANNEALING_H
 
#include <dignea/core/AbstractEA.h>
#include <dignea/utilities/exceptions/NoMOAllowed.h>
#include <dignea/utilities/random/PseudoRandom.h>
 
#include <cmath>
#include <vector>
 
using namespace std;
 
template <class S>
class SimulatedAnnealing : public AbstractEA<S> {
   public:
    SimulatedAnnealing(const int &maxEvaluations, const float &initialTemp,
                       const float &tempVariation);
 
    virtual ~SimulatedAnnealing() = default;
 
    void run() override;
    string getName() const override { return "Simulated Annealing"; };
    string getID() const override { return "SA"; }
 
    Front<S> getResults() const override;
 
    void setProblem(shared_ptr<Problem<S>> prob) override;
 
    void setProblem(Problem<S> *prob) override;
    float getTempVariation() const { return tempVariation; }
    void setTempVariation(float tempVariation) {
        SimulatedAnnealing::tempVariation = tempVariation;
    }
    float getCurrentTemp() const { return currentTemp; }
    void setCurrentTemp(float currentTemp) {
        SimulatedAnnealing::currentTemp = currentTemp;
    }
 
    void setPopulationSize(const int &pSize);
 
   protected:
    void initProgress() override;
 
    void updateProgress() override;
 
    void finishProgress() override;
 
    bool isStoppingConditionReached() override;
 
    void createInitialPopulation() override;
 
    void evaluatePopulation(vector<S> &vector1) override{};
 
    S evaluateInds(S &popInd, S &offspring);
 
   private:
    S applyPerturbations();
 
    void updateTemp() { currentTemp *= tempVariation; }
 
   private:
    float tempVariation;
    float currentTemp;
};
 
template <class S>
SimulatedAnnealing<S>::SimulatedAnnealing(const int &maxEvaluations,
                                          const float &initialTemp,
                                          const float &tempVariation)
    : AbstractEA<S>(maxEvaluations, 1),
      tempVariation(tempVariation),
      currentTemp(initialTemp) {}
 
template <class S>
void SimulatedAnnealing<S>::run() {
    if (this->problem) {
        this->createInitialPopulation();
        this->startTime = chrono::system_clock::now();
        while (!this->isStoppingConditionReached()) {
            S offspring = applyPerturbations();
            this->population[0] = evaluateInds(this->population[0], offspring);
            updateTemp();
            this->updateProgress();
        }
        this->endTime = chrono::system_clock::now();
        this->finishProgress();
    } else {
        throw std::runtime_error("Problem is not set in SA::run");
    }
}
 
template <class S>
Front<S> SimulatedAnnealing<S>::getResults() const {
    return Front<S>(this->population);
}
 
template <class S>
void SimulatedAnnealing<S>::initProgress() {
    this->performedEvaluations = 1;
}
 
template <class S>
void SimulatedAnnealing<S>::updateProgress() {
    this->performedEvaluations += 2;
}
 
template <class S>
void SimulatedAnnealing<S>::finishProgress() {
    std::chrono::duration<double> diff = this->endTime - this->startTime;
    this->elapsedTime = diff.count();
}
 
template <class S>
bool SimulatedAnnealing<S>::isStoppingConditionReached() {
    return (this->performedEvaluations >= this->maxEvaluations);
}
 
template <class S>
void SimulatedAnnealing<S>::createInitialPopulation() {
    this->population.resize(1);
    this->population[0] = this->problem->createSolution();
    this->evaluatePopulation(this->population);
    this->nextCheckpoint = 0;
    this->updateEvolution(0, this->population);
    this->initProgress();
}
 
template <class S>
S SimulatedAnnealing<S>::evaluateInds(S &popInd, S &offspring) {
    this->evaluator->evaluate(popInd, this->problem.get());
    this->evaluator->evaluate(offspring, this->problem.get());
    double diff = offspring.getFitness() - popInd.getFitness();
    if (diff < 0.0) {
        return offspring;
    } else {
        const double randProb = PseudoRandom::randDouble();
        const double e = exp(-diff / this->currentTemp);
        const double prob = min(1.0, e);
        return (randProb < prob) ? offspring : popInd;
    }
}
 
template <class S>
S SimulatedAnnealing<S>::applyPerturbations() {
    S offspring = this->population[0];
    double pert = PseudoRandom::randDouble();
    vector vars = offspring.getVariables();
    for (unsigned int i = 0; i < vars.size(); i++) {
        double newValue = pert * (this->problem->getUpperLimit(i) -
                                  this->problem->getLowerLimit(i)) +
                          this->problem->getLowerLimit(i);
        vars[i] = newValue;
    }
    offspring.setVariables(vars);
    return offspring;
}
 
template <class S>
void SimulatedAnnealing<S>::setProblem(shared_ptr<Problem<S>> prob) {
    if (prob->getNumberOfObjs() != 1) {
        std::string where = "SimulatedAnnealing setProblem";
        throw(NoMOAllowed(where));
    }
    this->problem = prob;
}
 
template <class S>
void SimulatedAnnealing<S>::setProblem(Problem<S> *prob) {
    if (prob->getNumberOfObjs() != 1) {
        std::string where = "SimulatedAnnealing setProblem";
        throw(NoMOAllowed(where));
    }
    this->problem.reset(prob);
}
 
template <class S>
void SimulatedAnnealing<S>::setPopulationSize(const int &pSize) {
    std::string where = "SimulatedAnnealing setPopulationSize";
    throw(NotImplemented(where));
}
 
#endif  // DIGNEA_SIMULATEDANNEALING_H