evolution.h

Go to the documentation of this file.

 
#if !defined(ULTRA_EVOLUTION_H)
#define      ULTRA_EVOLUTION_H
 
#include "kernel/evolution_callbacks.h"
#include "kernel/evolution_strategy.h"
#include "kernel/layered_population.h"
#include "kernel/refiner.h"
#include "kernel/search_log.h"
 
#include "utility/term.h"
#include "utility/thread_pool.h"
#include "utility/timer.h"
 
#include <atomic>
#include <future>
#include <vector>
 
namespace ultra
{
 
namespace internal
{
struct print_status;
}

template<Evaluator E>
class evolution
{
public:
  using individual_t = evaluator_individual_t<E>;
  using fitness_t = evaluator_fitness_t<E>;
 
  using after_generation_callback_t =
    ultra::after_generation_callback_t<individual_t, fitness_t>;
  using refinement_callback_t = ultra::refinement_callback_t<E>;
  using on_new_best_callback_t =
    ultra::on_new_best_callback_t<individual_t, fitness_t>;
 
  // ---- Constructor ----
  explicit evolution(const problem &, E &);
 
  // ---- Run ----
  template<template<class> class ES>
  summary<individual_t, fitness_t> run();
 
  // ---- Callback and configuration methods ----
  evolution &after_generation(after_generation_callback_t);
  evolution &logger(search_log &);
  evolution &refinement(refinement_callback_t);
  evolution &messages(bool) noexcept;
  evolution &on_new_best(on_new_best_callback_t);
  evolution &shake_function(shake_function_callback_t);
  evolution &stop_source(std::stop_source);
  evolution &tag(const std::string &);
 
  // ---- Misc ----
  [[nodiscard]] bool is_valid() const;
 
private:
  enum class message {status, summary};
 
  // ---- Private methods ----
  template<Population P> [[nodiscard]] bool perform_refinement(
    P &, internal::print_status &);
  void print(message, internal::print_status &) const;
  template<Population P> [[nodiscard]] auto refinement_tournament(const P &);
 
  [[nodiscard]] bool stop_condition() const;
 
  // ---- Data members ----
  layered_population<individual_t> pop_;
  E &eva_;
 
  summary<individual_t, fitness_t> sum_ {};
 
  shake_function_callback_t shake_ {};
 
  after_generation_callback_t after_generation_callback_ {};
  refinement_callback_t refinement_callback_ {};
 
  mutable search_log *search_log_ {nullptr};
  std::stop_source external_stop_source_ {std::nostopstate};
  std::string tag_ {};
  bool emit_messages_ {true};
};
 
#include "kernel/evolution.tcc"
}  // namespace ultra
 
#endif  // include guard