evolution_replacement.h

Go to the documentation of this file.

 
#if !defined(ULTRA_EVOLUTION_REPLACEMENT_H)
#define      ULTRA_EVOLUTION_REPLACEMENT_H
 
#include "kernel/alps.h"
#include "kernel/evaluator.h"
#include "kernel/evolution_selection.h"
#include "kernel/evolution_status.h"
#include "kernel/linear_population.h"
 
namespace ultra::replacement
{
/// ultra::evolution_strategy class.
///
template<Evaluator E>
class strategy
{
public:
  using individual_t = evaluator_individual_t<E>;
  using fitness_t    = evaluator_fitness_t<E>;
  using scored_t     = scored_individual<individual_t, fitness_t>;
  using status_t     = evolution_status<individual_t, fitness_t>;
 
  strategy(E &, const parameters &);
 
protected:
  E &eva_;
  const parameters &params_;
};

template<Evaluator E>
class tournament : public strategy<E>
{
public:
  using strategy<E>::strategy;
  using typename strategy<E>::individual_t;
  using typename strategy<E>::scored_t;
  using typename strategy<E>::status_t;
 
  template<Population P>
  bool operator()(P &, const scored_t &, status_t &) const;
};
 
template<Evaluator E> tournament(E &, const parameters &) -> tournament<E>;

template<Evaluator E>
class alps : public strategy<E>
{
public:
  using strategy<E>::strategy;
  using typename strategy<E>::individual_t;
  using typename strategy<E>::scored_t;
  using typename strategy<E>::status_t;
 
  template<PopulationWithMutex P>
  void operator()(alps_layer_pair<P>, const scored_t &, status_t &) const;
 
  template<PopulationWithMutex P>
  void try_promote_individuals(const P &, P &) const;
 
private:
  template<PopulationWithMutex P, class S>
  bool try_add_to_layer(alps_layer_pair<P>, const S &) const
    requires (std::same_as<S, individual_t> || std::same_as<S, scored_t>);
 
  template<PopulationWithMutex P, class S>
  bool try_add_to_layer(P &, const S &) const
    requires (std::same_as<S, individual_t> || std::same_as<S, scored_t>);
};
 
template<Evaluator E> alps(E &, const parameters &) -> alps<E>;
 
template<Evaluator E>
class de : public strategy<E>
{
public:
  using strategy<E>::strategy;
  using typename strategy<E>::individual_t;
  using typename strategy<E>::status_t;
 
  bool operator()(individual_t &, const individual_t &, status_t &) const;
};
 
template<Evaluator E> de(E &, const parameters &) -> de<E>;
 
#include "kernel/evolution_replacement.tcc"
 
}  // namespace ultra::replacement
 
#endif  // include guard