TSPDomain.h

Go to the documentation of this file.

 
#ifndef DIGNEA_ITSPPROBLEM_H
#define DIGNEA_ITSPPROBLEM_H
 
#include <dignea/generator/AbstractDomain.h>
#include <dignea/generator/instances/TSPInstance.h>
#include <dignea/problems/TSP.h>
#include <dignea/types/SolutionTypes.h>
 
class TSPDomain : public AbstractDomain<TSP, TSPInstance> {
   public:
    TSPDomain();
 
    explicit TSPDomain(const int &numberOfVars, const int &numberOfObjs = 1);
 
    TSPDomain(const TSPDomain *prob);
 
    virtual ~TSPDomain() = default;
 
    TSPDomain(const string &pathToInstance) = delete;
 
    TSPDomain(const int &numberOfVars, const int &numberOfObjs,
                const float &maxL, const float &minL, const float e = 5.0,
                const int minN = 2);
 
    shared_ptr<TSP> genOptProblem(const TSPInstance &instance) const override;
 
    void evaluate(TSPInstance &solution) const override { return; };
 
    vector<TSPInstance> createSolutions(
        const int &maxSolutions) const override;
 
    void beforeEvaluation(vector<TSPInstance> &) override { return; };
 
    void afterEvaluation(vector<TSPInstance> &) override;
 
    TSPInstance createSolution() const override;
 
    TSPInstance createSolution(ParallelPRNG &engine) const override;
 
    bool evaluateConstraints(TSPInstance &solution) const override {
        return true;
    }
    int getOptimizationDirection(const int i) const override;
 
    string getName() const override { return "TSPDomain"; }
 
    float getUpperLimit(const int i) const override;
 
    float getLowerLimit(const int i) const override;
 
    void setUpperLimit(const float &l) { this->upperLimit = l; }
 
    void setLowerLimit(const float &l) { this->lowerLimit = l; }
 
    void setEPS(const float e) { eps = e; }
 
    float getEPS() const { return eps; }
 
    void setMinNeighbors(const int m) { minNeighbors = m; }
 
    int getMinNeighbors() const { return minNeighbors; }
 
    void readData(const string &path) override{};
 
   private:
    coords computeCentroid(const vector<coords> &points);
 
    float instanceRadius(const vector<coords> &points, const coords &centroid);
 
    float distinctDistances(const vector<vector<float>> &distances);
 
   private:
    float upperLimit;
    float lowerLimit;
    float eps;
    int minNeighbors;
};
 
#endif