mapElitesArchive.h

 
#ifndef MAP_ELITES_ARCHIVE_H
#define MAP_ELITES_ARCHIVE_H
 
#include <cmath>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
 
#include "learn/evaluationResult.h"
#include "tpg/tpgGraph.h"
 
namespace Selector {
    namespace MapElites {
 
        class MapElitesArchive
        {
          protected:
            uint64_t nbBinPerDescriptor;
 
            uint64_t nbDescriptors;
 
            double minValue;
 
            double maxValue;
 
            std::vector<double> archiveLimits;
 
            std::vector<std::pair<std::shared_ptr<Learn::EvaluationResult>,
                                  const TPG::TPGVertex*>>
                archive;
 
          public:
            MapElitesArchive(size_t nbBinPerDescriptor, size_t nbDescriptors,
                             double minValue, double maxValue)
                : nbBinPerDescriptor{nbBinPerDescriptor},
                  nbDescriptors{nbDescriptors}, minValue{minValue},
                  maxValue{maxValue}
            {
 
                if (nbBinPerDescriptor > 0 && nbDescriptors > 0) {
                    archive.resize(std::pow(nbBinPerDescriptor, nbDescriptors));
                }
 
                for (size_t idx = 1; idx <= nbBinPerDescriptor; ++idx) {
                    archiveLimits.push_back((double)idx *
                                                (maxValue - minValue) /
                                                (double)nbBinPerDescriptor +
                                            minValue);
                }
            }
 
            uint64_t size() const;
 
            std::pair<uint64_t, uint64_t> getDimensions() const;
 
            std::vector<double> getArchiveLimits() const;
 
            virtual const std::vector<
                std::pair<std::shared_ptr<Learn::EvaluationResult>,
                          const TPG::TPGVertex*>>&
            getAllArchive() const;
 
            virtual const std::pair<std::shared_ptr<Learn::EvaluationResult>,
                                    const TPG::TPGVertex*>&
            getArchiveAt(const std::vector<uint64_t>& indices) const;
 
            virtual const std::pair<std::shared_ptr<Learn::EvaluationResult>,
                                    const TPG::TPGVertex*>&
            getArchiveFromDescriptors(
                const std::vector<double>& descriptors) const;
 
            virtual void setArchiveAt(
                const TPG::TPGVertex* vertex,
                std::shared_ptr<Learn::EvaluationResult> eval,
                const std::vector<uint64_t>& indices);
 
            virtual void setArchiveFromDescriptors(
                const TPG::TPGVertex* vertex,
                std::shared_ptr<Learn::EvaluationResult> eval,
                const std::vector<double>& descriptors);
 
            virtual uint64_t getIndexArchive(double value) const;
 
            virtual uint64_t computeLinearIndex(
                const std::vector<uint64_t>& indices) const;
 
            virtual std::vector<uint64_t> computeIndices(uint64_t index) const;
 
            virtual bool containsRoot(const TPG::TPGVertex* root) const;
 
            virtual void removeRootFromArchiveIfNotComplete(
                const TPG::TPGVertex* root, size_t maxNbEvaluation);
 
            virtual void removeRootFromArchive(const TPG::TPGVertex* root,
                                               size_t maxNbEvaluation);
 
            virtual std::set<const TPG::TPGVertex*> getVerticesInArchive()
                const;
        };
 
    }; // namespace MapElites
}; // namespace Selector
 
#endif // MAP_ELITES_SELECTOR_H