evolution_recombination.h

Go to the documentation of this file.

 
#if !defined(ULTRA_EVOLUTION_RECOMBINATION_H)
#define      ULTRA_EVOLUTION_RECOMBINATION_H
 
#include "kernel/evaluator.h"
#include "kernel/evolution_selection.h"
#include "kernel/fitness.h"
#include "kernel/individual.h"
#include "kernel/population.h"
#include "kernel/problem.h"
#include "kernel/scored_individual.h"
 
namespace ultra::recombination
{

/// the evolution class.
///
/// A recombination acts upon sets of individuals to generate offspring
/// (this definition generalizes the traditional mutation and crossover
/// operators).
///
/// Operator application is atomic from the point of view of the
/// evolutionary algorithm and every recombination is applied to a well
/// defined list of individuals, without dependencies upon past history.
///
/// In the strategy design pattern, this class is the strategy interface and
/// ultra::evolution is the context.
///
/// This is an abstract class: introduction of new operators or redefinition
/// of existing ones is obtained implementing recombination::strategy.
///
/// \see
/// - https://en.wikipedia.org/wiki/Strategy_pattern
///
template<Evaluator E>
class strategy
{
public:
  using scored_t =
    scored_individual<evaluator_individual_t<E>, evaluator_fitness_t<E>>;
 
  strategy(E &, const problem &);
 
protected:
  E &eva_;
  const problem &prob_;
};

template<Evaluator E>
class base : public strategy<E>
{
public:
  using typename strategy<E>::scored_t;
 
  using base::strategy::strategy;
 
  template<class R> [[nodiscard]] auto operator()(const R &) const
    requires std::ranges::random_access_range<const R>
             && std::ranges::sized_range<const R>
             && std::same_as<std::ranges::range_value_t<const R>, scored_t>;
};
 
template<Evaluator E> base(E &, const problem &) -> base<E>;

class de
{
public:
  explicit de(const problem &prob) : prob_(prob) {}
 
  template<Individual I>
  [[nodiscard]] I operator()(const selection::de::selected_refs<I> &) const;
 
private:
  const problem &prob_;
};
 
#include "kernel/evolution_recombination.tcc"
 
}  // namespace ultra::recombination
 
#endif  // include guard