AbstractInstance.h

Go to the documentation of this file.

 
#ifndef __EIG_SOLUTION_H__
#define __EIG_SOLUTION_H__
 
#include <dignea/core/Front.h>
#include <dignea/core/Solution.h>
 
#include <algorithm>
#include <vector>
 
using namespace std;
 
template <typename V, typename O>
class AbstractInstance : public Solution<V, O> {
   public:
    AbstractInstance();
 
    explicit AbstractInstance(const int &nVars, const int &nObjs = 1,
                              const int &nCons = 0);
 
    AbstractInstance(const AbstractInstance &solution);
 
    explicit AbstractInstance(const AbstractInstance *solution);
 
    AbstractInstance(unique_ptr<AbstractInstance> &ptr) = delete;
 
    virtual ~AbstractInstance() = default;
 
    AbstractInstance &operator=(const AbstractInstance &copy);
 
    bool operator==(const AbstractInstance &other) const;
 
    json to_json() const override { return Solution<V, O>::to_json(); }
 
    void setFeatures(const vector<float> &v);
 
    virtual vector<float> getFeatures() const { return features; }
 
    float getDiversity() const { return diversity; }
 
    void setDiversity(float diversity) {
        AbstractInstance::diversity = diversity;
    }
 
    float getBiasedFitness() const { return biasedFitness; }
 
    void setBiasedFitness(float bFitness) {
        AbstractInstance::biasedFitness = bFitness;
    }
 
    void setConfigFitness(const vector<vector<float>> &fitness) {
        this->portFitness = fitness;
    }
 
    void setAvgConfigFitness(const vector<float> &fitness) {
        this->avgPortFitness = fitness;
    }
 
    vector<vector<float>> getPortFitness() const { return portFitness; }
 
    vector<float> getAvgPortFitness() const { return avgPortFitness; }
 
    virtual void to_instance(std::ostream &os) const {
        os << "Not implemented in AbstractInstance" << std::endl;
    };
 
    friend std::ostream &operator<<(std::ostream &os,
                                    AbstractInstance<V, O> const &solution) {
        solution.to_instance(os);
        return os;
    }
 
   protected:
    vector<float> features;
    float diversity;
    float biasedFitness;
    vector<vector<float>> portFitness;
    vector<float> avgPortFitness;
};
 
template <typename V, typename O>
AbstractInstance<V, O>::AbstractInstance()
    : Solution<V, O>(),
      features({}),
      diversity(0.0),
      biasedFitness(0.0),
      portFitness({}),
      avgPortFitness({}) {}
 
template <typename V, typename O>
AbstractInstance<V, O>::AbstractInstance(const int &nVars, const int &nObjs,
                                         const int &nCons)
    : Solution<V, O>(nVars, nObjs, nCons),
      features({}),
      diversity(0.0),
      biasedFitness(0.0),
      portFitness({}),
      avgPortFitness({}) {}
 
template <typename V, typename O>
AbstractInstance<V, O>::AbstractInstance(const AbstractInstance &solution)
    : Solution<V, O>(solution),
      features(solution.features),
      diversity(solution.diversity),
      biasedFitness(solution.biasedFitness),
      portFitness(solution.portFitness),
      avgPortFitness(solution.avgPortFitness) {}
 
template <typename V, typename O>
AbstractInstance<V, O>::AbstractInstance(const AbstractInstance *solution)
    : Solution<V, O>(solution),
      features(solution->features),
      diversity(solution->diversity),
      biasedFitness(solution->biasedFitness),
      portFitness(solution->portFitness),
      avgPortFitness(solution->avgPortFitness) {}
 
template <typename V, typename O>
void AbstractInstance<V, O>::setFeatures(const vector<float> &v) {
    this->features = v;
}
 
template <typename V, typename O>
AbstractInstance<V, O> &AbstractInstance<V, O>::operator=(
    const AbstractInstance &copy) {
    if (this == &copy) {
        return *this;
    }
    this->nVars = copy.nVars;
    this->nObjs = copy.nObjs;
    this->nCons = copy.nCons;
    this->fitness = copy.fitness;
    this->constraintCoeff = copy.constraintCoeff;
    this->variables = copy.variables;
    this->objectives = copy.objectives;
    this->constraints = copy.constraints;
    features = copy.features;
    diversity = copy.diversity;
    biasedFitness = copy.biasedFitness;
    portFitness = copy.portFitness;
    avgPortFitness = copy.avgPortFitness;
 
    return *this;
}
 
template <typename V, typename O>
bool AbstractInstance<V, O>::operator==(const AbstractInstance &other) const {
    if (other.fitness != this->fitness) {
        return false;
    }
    if (other.diversity != this->diversity) {
        return false;
    }
    if (other.biasedFitness != this->biasedFitness) {
        return false;
    }
    if (other.constraintCoeff != this->constraintCoeff) {
        return false;
    }
    if ((this->nVars != other.nVars) || (this->nObjs != other.nObjs) ||
        (this->nCons != other.nCons)) {
        return false;
    }
    for (int i = 0; i < other.nVars; i++) {
        if (other.variables[i] != this->variables[i]) {
            return false;
        }
    }
    for (int i = 0; i < other.nObjs; i++) {
        if (other.objectives[i] != this->objectives[i]) {
            return false;
        }
    }
    for (int i = 0; i < other.nCons; i++) {
        if (other.constraints[i] != this->constraints[i]) {
            return false;
        }
    }
    for (unsigned int i = 0; i < other.features.size(); i++) {
        if (other.features[i] != this->features[i]) {
            return false;
        }
    }
    return true;
}
 
#endif  // __EIG_SOLUTION_H__