evolutionary_loop.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <future>
#include <utility>
#include <vector>
 
#include "pulsatrix/data_thread_pool.hpp"
#include "pulsatrix/individual.hpp"
 
namespace pulsatrix {
 
template <typename Genotype, typename FitnessT, typename FitnessFn>
void EvaluatePopulation(std::vector<Individual<Genotype, FitnessT>>& population,
                        FitnessFn& fitness_fn, DataThreadPool* thread_pool) {
    if (thread_pool == nullptr) {
        for (auto& ind : population) {
            ind.fitness = fitness_fn(ind.genes);
        }
        return;
    }
 
    std::vector<std::future<FitnessT>> futures;
    futures.reserve(population.size());
    for (auto& ind : population) {
        Genotype genes_copy = ind.genes;  // copied into the task -- avoids a dangling
                                           // reference to population while other threads run
        futures.push_back(
            thread_pool->submit([&fitness_fn, genes_copy]() { return fitness_fn(genes_copy); }));
    }
    for (size_t i = 0; i < population.size(); ++i) {
        population[i].fitness = futures[i].get();
    }
}
 
template <typename Genotype, typename FitnessT, typename FitnessFn, typename OffspringFn,
          typename SurvivorFn>
std::vector<Individual<Genotype, FitnessT>> RunEvolutionaryLoop(
    std::vector<Individual<Genotype, FitnessT>> population, size_t num_generations,
    size_t lambda_size, FitnessFn fitness_fn, OffspringFn produce_offspring_genotype,
    SurvivorFn survivor_selector, DataThreadPool* thread_pool = nullptr) {
    const size_t mu = population.size();
    EvaluatePopulation(population, fitness_fn, thread_pool);
 
    for (size_t generation = 0; generation < num_generations; ++generation) {
        std::vector<Individual<Genotype, FitnessT>> offspring;
        offspring.reserve(lambda_size);
        for (size_t i = 0; i < lambda_size; ++i) {
            offspring.push_back(Individual<Genotype, FitnessT>{produce_offspring_genotype(population),
                                                                 FitnessT{}});
        }
        EvaluatePopulation(offspring, fitness_fn, thread_pool);
        population = survivor_selector(population, std::move(offspring), mu);
    }
    return population;
}
 
}  // namespace pulsatrix