evolution_selection.h

Go to the documentation of this file.

 
#if !defined(ULTRA_EVOLUTION_SELECTION_H)
#define      ULTRA_EVOLUTION_SELECTION_H
 
#include "kernel/evaluator.h"
#include "kernel/linear_population.h"
#include "kernel/parameters.h"
#include "kernel/scored_individual.h"
 
#include <array>
 
namespace ultra::selection
{

template<Evaluator E>
class strategy
{
public:
  using scored_t = scored_individual<evaluator_individual_t<E>,
                                     evaluator_fitness_t<E>>;
 
  strategy(E &, const parameters &);
 
protected:
  E &eva_;
  const parameters &params_;
};

template<Evaluator E>
class tournament : public strategy<E>
{
public:
  using typename strategy<E>::scored_t;
 
  using strategy<E>::strategy;
 
  template<SizedRandomAccessPopulation P>
  [[nodiscard]] std::vector<scored_t> operator()(const P &) const;
};
 
template<Evaluator E> tournament(E &, const parameters &) -> tournament<E>;

template<Evaluator E>
class alps : public strategy<E>
{
public:
  using typename strategy<E>::scored_t;
 
  using strategy<E>::strategy;
 
  template<PopulationWithMutex P>
  [[nodiscard]] std::array<scored_t, 2> operator()(
    alps_layer_pair<const P>) const;
};
 
template<Evaluator E> alps(E &, const parameters &) -> alps<E>;

class de
{
public:
  template<Individual I>
  struct selected_refs
  {
    I &target;      // also called parent
    const I &base;
    const I &a;
    const I &b;
 
    // Due to reference aliasing all the data members could possibly point to
    // the same individual.
    // So the const-ness of `base`, `a` and `b` is only partial. Anyway it
    // prevents some kinds of programming errors.
  };
 
  template<SizedRandomAccessPopulation P>
  [[nodiscard]] selected_refs<typename P::value_type> operator()(P &) const;
};
 
#include "kernel/evolution_selection.tcc"
 
}  // namespace ultra::selection
 
#endif  // include guard