evolution_strategy.h

Go to the documentation of this file.

 
#if !defined(VITA_EVOLUTION_STRATEGY_H)
#define      VITA_EVOLUTION_STRATEGY_H
 
#include "kernel/evolution_recombination.h"
#include "kernel/evolution_replacement.h"
#include "kernel/evolution_selection.h"
 
namespace vita
{
template<class T,
         template<class> class SS,
         template<class> class CS,
         template<class> class RS>
class evolution_strategy
{
public:
  evolution_strategy(population<T> &pop, evaluator<T> &eva, summary<T> *s)
    : selection(pop, eva, *s), recombination(pop, eva, s),
      replacement(pop, eva), pop_(pop), sum_(s)
  {
    Expects(s);
  }
 
  void log_strategy(unsigned, unsigned) const {}
 
  static environment shape(const environment &env) { return env; }
 
  void init() const {}
 
  void after_generation() const {}
 
  bool stop_condition() const { return false; }
 
  static constexpr bool is_alps =
    std::is_same<SS<T>, typename vita::selection::alps<T>>::value &&
    std::is_same<RS<T>, typename vita::replacement::alps<T>>::value;
 
  static constexpr bool is_de =
    std::is_same<CS<T>, typename vita::recombination::de<T>>::value;
 
public:
  SS<T> selection;
  CS<T> recombination;
  RS<T> replacement;
 
protected:
  population<T> &pop_;
  summary<T>    *sum_;
};
 
template<class T, template<class> class CS>
class basic_alps_es : public evolution_strategy<T,
                                                selection::alps,
                                                CS,
                                                replacement::alps>
{
public:
  using basic_alps_es::evolution_strategy::evolution_strategy;
 
  void log_strategy(unsigned, unsigned) const;
  void after_generation();
 
  static environment shape(environment);
};
 
template<class T> using alps_es = basic_alps_es<T, recombination::base>;
 
template<class T>
class std_es : public evolution_strategy<T,
                                         selection::tournament,
                                         recombination::base,
                                         replacement::tournament>
{
public:
  using std_es::evolution_strategy::evolution_strategy;
 
  bool stop_condition() const;
 
  static environment shape(environment);
};
 
template<class T>
class de_es : public evolution_strategy<T,
                                        selection::random,
                                        recombination::de,
                                        replacement::tournament>
{
public:
  using de_es::evolution_strategy::evolution_strategy;
};
 
template<class T>
class de_alps_es : public basic_alps_es<T, recombination::de>
{
public:
  using de_alps_es::basic_alps_es::basic_alps_es;
};
 
#include "kernel/evolution_strategy.tcc"
}  // namespace vita
 
#endif  // include guard