NSPerformance.h

//
// Created by amarrero on 28/6/21.
//
 
#ifndef DIGNEA_NSPERFORMANCE_H
#define DIGNEA_NSPERFORMANCE_H
 
#include <dignea/distances/Distance.h>
#include <dignea/generator/AbstractInstance.h>
#include <dignea/searches/NSFeatures.h>
#include <dignea/utilities/KNN.h>
#include <dignea/utilities/Sorter.h>
 
#include <iostream>
#include <nlohmann/json.hpp>
#include <vector>
 
using namespace std;
using json = nlohmann::json;
 
template <typename S>
class NSPerformance : public NoveltySearch<S> {
   public:
    NSPerformance() = default;
 
    explicit NSPerformance(unique_ptr<Distance<float>> dist,
                           const float &threshold = 2000,
                           const float &finalThresh = 2000, const int &k = 15);
 
    virtual ~NSPerformance() = default;
 
    virtual json to_json() override;
 
   protected:
    virtual vector<Descriptor> beforeRun(const vector<S> &population) override;
 
    virtual vector<Descriptor> beforeCmpFinals(
        const vector<S> &population) override;
 
    virtual void insertFinal(const S &solution);
};
 
template <typename S>
NSPerformance<S>::NSPerformance(unique_ptr<Distance<float>> dist,
                                const float &threshold,
                                const float &finalThresh, const int &k)
    : NoveltySearch<S>(move(dist), threshold, finalThresh, k) {}
 
template <typename S>
vector<Descriptor> NSPerformance<S>::beforeRun(const vector<S> &population) {
    vector<Descriptor> combinedPop;
    combinedPop.reserve(population.size() + this->noveltyArchive.size());
    for (const S &solution : population) {
        combinedPop.push_back(solution.getAvgPortFitness());
    }
    for (const S &solution : this->noveltyArchive) {
        combinedPop.push_back(solution.getAvgPortFitness());
    }
    // combinedPop.insert(combinedPop.end(), this->noveltyArchive.begin(),
    //                    this->noveltyArchive.end(),
    //                    [](const S &s) { return s.getAvgPortFitness(); });
    return combinedPop;
}
 
template <typename S>
vector<Descriptor> NSPerformance<S>::beforeCmpFinals(
    const vector<S> &population) {
    vector<Descriptor> descriptors;
    descriptors.reserve(population.size());
    for (const S &solution : population) {
        descriptors.push_back(solution.getAvgPortFitness());
    }
    return descriptors;
}
 
template <typename S>
void NSPerformance<S>::insertFinal(const S &solution) {
    this->finalSs.push_back(solution);
    this->finalSsDesc.push_back(solution.getAvgPortFitness());
}
 
template <typename S>
json NSPerformance<S>::to_json() {
    json data = NoveltySearch<S>::to_json();
    data["name"] = "NSPerformance";
 
    return data;
}
 
#endif