Solution.h

//
// Created by amarrero on 2/12/20.
//
 
#ifndef DIGNEA_SOLUTION_H
#define DIGNEA_SOLUTION_H
 
#include <dignea/utilities/exceptions/OutOfRange.h>
 
#include <iostream>
#include <memory>
#include <nlohmann/json.hpp>
#include <vector>
 
using namespace std;
using json = nlohmann::json;
 
template <typename V, typename O>
class Solution {
   public:
    Solution();
 
    virtual ~Solution();
 
    Solution(const int &nVars, const int &nObjs);
 
    Solution(const int &nVars, const int &nObjs, const int &nCons);
 
    Solution(const Solution<V, O> &);
 
    Solution(const Solution<V, O> *);
 
    Solution &operator=(const Solution &copy);
 
    bool operator==(const Solution &other) const;
 
    virtual const vector<O> &getObjectives() const { return objectives; }
 
    virtual void setObjectives(const vector<O> &objs);
 
    virtual const vector<V> &getVariables() const { return variables; }
 
    virtual void setVariables(const vector<V> &vars);
 
    virtual const vector<O> &getConstraints() const { return constraints; }
 
    virtual void setConstraints(const vector<O> &constr);
    virtual int getNumberOfVars() const { return nVars; }
 
    virtual void setNumberOfVars(const int &numberOfVars) {
        this->nVars = numberOfVars;
    }
 
    virtual int getNumberOfObjs() const { return nObjs; }
 
    virtual void setNumberOfbjs(const int &numberOfObjs) {
        this->nObjs = numberOfObjs;
    }
 
    virtual int getNumberOfCons() const { return nCons; }
 
    virtual void setNumberOfCons(const int &nConstraints) {
        this->nCons = nConstraints;
    }
 
    virtual void setRank(int id) { this->rank = id; }
 
    virtual int getRank() const { return this->rank; }
 
    virtual void setCrowDistance(float d) { this->crowDistance = d; }
 
    virtual float getCrowDistance() const { return this->crowDistance; }
 
    virtual void setVarAt(const int &, const V &v);
 
    virtual void setObjAt(const int &, const O &obj);
 
    virtual void setConstAt(const int &, const O &cons);
 
    virtual V getVarAt(const int &index) const;
 
    virtual O getObjAt(const int &index) const;
 
    virtual O getConstAt(const int &index) const;
 
    virtual float getFitness() const { return fitness; };
 
    virtual void setFitness(const float &f) { fitness = f; };
 
    float getConstraintCoeff() const { return constraintCoeff; }
 
    void setConstraintCoeff(float constraintCoeff) {
        Solution::constraintCoeff = constraintCoeff;
    }
 
    virtual json to_json() const;
 
   protected:
    int nVars;     
    int nObjs;     
    int nCons;     
    float fitness; 
    float constraintCoeff; 
    vector<O> objectives;  
    vector<V> variables;   
    vector<O> constraints; 
   private:
    int rank; 
    float
        crowDistance; 
};
 
template <typename V, typename O>
Solution<V, O>::Solution()
    : nVars(0),
      nObjs(0),
      nCons(0),
      fitness(0.0f),
      constraintCoeff(0.0f),
      objectives({}),
      variables({}),
      constraints({}),
      rank(-1),
      crowDistance(-1.0) {}
 
template <typename V, typename O>
Solution<V, O>::Solution(const int &nVars, const int &nObjs)
    : nVars(nVars),
      nObjs(nObjs),
      nCons(0),
      fitness(0.0f),
      constraintCoeff(0.0f),
      objectives{},
      variables{},
      constraints({}),
      rank(-1),
      crowDistance(-1.0) {
    variables.resize(nVars, (V)0);
    objectives.resize(nObjs, (O)0.0);
}
 
template <typename V, typename O>
Solution<V, O>::Solution(const int &nVars, const int &nObjs, const int &nCons)
    : nVars(nVars),
      nObjs(nObjs),
      nCons(nCons),
      fitness(0.0f),
      constraintCoeff(0.0f),
      objectives{},
      variables{},
      constraints{},
      rank(-1),
      crowDistance(-1.0) {
    variables.resize(nVars, (V)0);
    objectives.resize(nObjs, (O)0);
    constraints.resize(nCons, (O)0);
}
 
template <typename V, typename O>
Solution<V, O>::Solution(const Solution<V, O> &copy)
    : nVars(copy.nVars),
      nObjs(copy.nObjs),
      nCons(copy.nCons),
      fitness(copy.fitness),
      constraintCoeff(copy.constraintCoeff),
      objectives{},
      variables{},
      constraints{},
      rank(copy.rank),
      crowDistance(copy.crowDistance) {
    variables.resize(nVars);
    objectives.resize(nObjs);
    constraints.resize(nCons);
    for (int i = 0; i < nVars; i++) {
        variables[i] = copy.variables[i];
    }
    for (int i = 0; i < nObjs; i++) {
        objectives[i] = copy.objectives[i];
    }
    for (int i = 0; i < nCons; i++) {
        constraints[i] = copy.constraints[i];
    }
}
 
template <typename V, typename O>
Solution<V, O>::Solution(const Solution<V, O> *copy) {
    if (copy == nullptr) {
        throw(runtime_error(
            "Copy Solution is nullptr in Solution(Solution* copy)"));
    }
    this->nVars = copy->nVars;
    this->nObjs = copy->nObjs;
    this->nCons = copy->nCons;
    this->fitness = copy->fitness;
    this->constraintCoeff = copy->constraintCoeff;
    this->variables.resize(this->nVars);
    this->objectives.resize(this->nObjs);
    this->constraints.resize(this->nCons);
    this->rank = copy->rank;
    this->crowDistance = copy->crowDistance;
    for (int i = 0; i < this->nVars; i++) {
        this->variables[i] = copy->variables[i];
    }
    for (int i = 0; i < this->nObjs; i++) {
        this->objectives[i] = copy->objectives[i];
    }
    for (int i = 0; i < this->nCons; i++) {
        this->constraints[i] = copy->constraints[i];
    }
}
 
template <typename V, typename O>
Solution<V, O>::~Solution() {
    objectives.clear();
    variables.clear();
    constraints.clear();
    objectives.shrink_to_fit();
    variables.shrink_to_fit();
    constraints.shrink_to_fit();
}
 
template <typename V, typename O>
void Solution<V, O>::setVarAt(const int &index, const V &v) {
    if (index < 0 || index >= this->nVars) {
        std::string where = "setVarAt with index = " + to_string(index);
        throw(OutOfRange(where));
    }
    this->variables[index] = v;
}
 
template <typename V, typename O>
void Solution<V, O>::setObjAt(const int &index, const O &obj) {
    if (index < 0 || index >= this->nObjs) {
        std::string where = "setObjAt with index = " + to_string(index);
        throw(OutOfRange(where));
    }
    this->objectives[index] = obj;
}
 
template <typename V, typename O>
V Solution<V, O>::getVarAt(const int &index) const {
    if (index < 0 || index >= this->nVars) {
        std::string where = "getVarAt with index = " + to_string(index);
        throw(OutOfRange(where));
    }
    return this->variables[index];
}
 
template <typename V, typename O>
O Solution<V, O>::getObjAt(const int &index) const {
    if (index < 0 || index >= this->nObjs) {
        std::string where = "getObjAt with index = " + to_string(index);
        throw(OutOfRange(where));
    }
    return this->objectives[index];
}
 
template <typename V, typename O>
void Solution<V, O>::setConstAt(const int &index, const O &value) {
    if (index < 0 || index >= this->nCons) {
        std::string where = "setConstAt with index = " + to_string(index);
        throw(OutOfRange(where));
    }
    this->constraints[index] = value;
}
 
template <typename V, typename O>
O Solution<V, O>::getConstAt(const int &index) const {
    if (index < 0 || index >= this->nCons) {
        std::string where = "getConstAt with index = " + to_string(index);
        throw(OutOfRange(where));
    }
    return this->constraints[index];
}
 
template <typename V, typename O>
void Solution<V, O>::setObjectives(const vector<O> &objs) {
    if (objs.size() != (unsigned int)this->nObjs) {
        std::string where = "objs.size() != nObjs in Solution::setObjectives";
        throw(OutOfRange(where));
    }
    this->objectives = objs;
}
 
template <typename V, typename O>
void Solution<V, O>::setVariables(const vector<V> &vars) {
    if (vars.size() != (unsigned int)this->nVars) {
        auto vsize = vars.size();
        std::string where = "vars.size() = " + to_string(vsize) +
                            " != nVars = " + to_string(this->nVars) +
                            " in Solution::setVariables";
        throw(OutOfRange(where));
    }
    this->variables = vars;
}
 
template <typename V, typename O>
void Solution<V, O>::setConstraints(const vector<O> &constr) {
    if (constr.size() != (unsigned int)this->nCons) {
        std::string where =
            "constr.size() != nConst in Solution::setConstraints";
        throw(OutOfRange(where));
    }
    this->constraints = constr;
}
 
template <typename V, typename O>
Solution<V, O> &Solution<V, O>::operator=(const Solution &copy) {
    if (this == &copy) {
        return *this;
    }
    nVars = copy.nVars;
    nObjs = copy.nObjs;
    nCons = copy.nCons;
    fitness = copy.fitness;
    constraintCoeff = copy.constraintCoeff;
    variables = copy.variables;
    objectives = copy.objectives;
    constraints = copy.constraints;
    rank = copy.rank;
    crowDistance = copy.crowDistance;
    return *this;
}
 
template <typename V, typename O>
bool Solution<V, O>::operator==(const Solution &other) const {
    if (other.fitness != this->fitness) {
        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;
        }
    }
    if (other.constraintCoeff != this->constraintCoeff) {
        return false;
    }
    if (other.rank != this->rank) {
        return false;
    }
    if (other.crowDistance != this->crowDistance) {
        return false;
    }
    return true;
}
 
template <typename V, typename O>
json Solution<V, O>::to_json() const {
    json data;
    data["num_vars"] = this->nVars;
    data["num_objs"] = this->nObjs;
    data["num_cons"] = this->nCons;
    data["fitness"] = this->fitness;
    data["const_coeff"] = this->constraintCoeff;
    data["vars"] = this->variables;
    data["objs"] = this->objectives;
    data["cons"] = this->constraints;
    data["rank"] = this->rank;
    data["crow_distance"] = this->crowDistance;
    return data;
}
 
#endif  // DIGNEA_SOLUTION_H