cvtMapElitesArchive.h

#ifndef CVT_MAP_ELITES_ARCHIVE_H
#define CVT_MAP_ELITES_ARCHIVE_H
 
#include "mapElitesArchive.h"
#include <gegelati.h>
 
namespace Selector {
    namespace MapElites {
 
        class CvtMapElitesArchive : public MapElitesArchive
        {
          protected:
            size_t nbCentroids;
 
            size_t nbIterationInit;
 
            size_t nbDotsInit;
 
            double a1;
 
            double b1;
 
            double a2;
 
            double b2;
 
            std::vector<std::vector<double>> centroids;
 
          public:
            CvtMapElitesArchive(Mutator::RNG& rng, size_t nbCentroids,
                                size_t nbDescriptors, double minValue,
                                double maxValue, size_t nbIterationInit,
                                size_t nbDotsInit, double a1, double b1,
                                double a2, double b2)
                : MapElitesArchive(0, nbDescriptors, minValue, maxValue),
                  nbCentroids{nbCentroids}, nbIterationInit{nbIterationInit},
                  nbDotsInit{nbDotsInit}, a1{a1}, b1{b1}, a2{a2}, b2{b2}
            {
                centroids.resize(nbCentroids);
                archive.resize(nbCentroids);
                initialize_cvt(rng);
            }
 
            double dist_squared(const std::vector<double>& a,
                                const std::vector<double>& b);
 
            std::vector<double> add(const std::vector<double>& a,
                                    const std::vector<double>& b);
 
            std::vector<double> scalar_mult(const std::vector<double>& a,
                                            double s);
 
            std::vector<double> average(
                const std::vector<std::vector<double>>& points);
 
            std::vector<double> random_point(Mutator::RNG& rng);
 
            size_t nearest(const std::vector<double>& point,
                           const std::vector<std::vector<double>>& centroids);
 
            void initialize_cvt(Mutator::RNG& rng);
 
            size_t getIndexForDescriptor(
                const std::vector<double>& descriptors) const;
 
            const std::pair<std::shared_ptr<Learn::EvaluationResult>,
                            const TPG::TPGVertex*>&
            getArchiveFromDescriptors(
                const std::vector<double>& descriptors) const override;
 
            void setArchiveFromDescriptors(
                const TPG::TPGVertex* vertex,
                std::shared_ptr<Learn::EvaluationResult> eval,
                const std::vector<double>& descriptors) override;
 
            virtual const std::vector<std::vector<double>>& getCentroids()
                const;
        };
    }; // namespace MapElites
}; // namespace Selector
 
#endif