Individual.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_INDIVIDUAL_H
#define GRAIL_INDIVIDUAL_H
 
#include "EvoParam.hh"
#include <memory>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
 
namespace grail
{
namespace evolution
{
    class Individual
    {
        friend struct Mutation;
        friend struct Crossover;
        friend class EAOptimizer;
        friend class FitnessRepository;
 
    public:
        virtual ~Individual();
 
        virtual std::unique_ptr<Individual> Instantiate() const = 0;
 
        void SetFitness(double fitness);
 
        double GetFitness() const;
 
        std::unique_ptr<Individual> Clone() const;
 
        std::vector<std::unique_ptr<Individual>> CloneMany(int cloneCount) const;
 
        void Randomize(std::mt19937_64& randomGenerator);
 
        long GetPossibleRealizationsCount() const;
 
        std::vector<std::unique_ptr<Individual>> GetRandomRealizations(
            std::mt19937_64& randomGenerator,
            std::size_t count) const;
 
        std::size_t EvoParamsCount() const;
 
        float CalculateSimilarity(const Individual& other) const;
 
        virtual std::string ToString() const;
 
        const BaseEvoParam& GetEvoParamAt(std::size_t index) const;
        
        std::size_t GetHashCode() const;
 
        bool Equals(const Individual& other) const;
 
    protected:
        void SetMemberParameterOptimizable(BaseEvoParam& parameter);
 
        template<typename ForwardIterator>
        void SetMemberParameterOptimizable(ForwardIterator beginIterator, ForwardIterator endIterator)
        {
            for (; beginIterator != endIterator; ++beginIterator)
            {
                SetMemberParameterOptimizable(*beginIterator);
            }
        }
 
        std::vector<std::reference_wrapper<BaseEvoParam>> parameters{};
 
    private:
        void CopyEvoParamValuesFrom(const Individual& other);
 
        void ExchangeParams(Individual& other, std::size_t inclusiveFrom, std::size_t exclusiveTo);
 
        void SerializeState(std::ostream& outputStream) const;
        void DeserializeState(std::ifstream& inputStream);
    
    private:
        double fitness = -1.0;
        bool evaluationUpdated = false;
 
        std::vector<std::reference_wrapper<BaseEvoParam>>& GetEvoParams();
    };
 
    bool IndividualComparator(const std::unique_ptr<Individual>& first, const std::unique_ptr<Individual>& second);
}
}
#endif // GRAIL_INDIVIDUAL_H