evolution_summary.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_EVOLUTION_SUMMARY_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_EVOLUTION_SUMMARY_TCC)
#define      ULTRA_EVOLUTION_SUMMARY_TCC

template<Individual I, Fitness F>
void summary<I, F>::clear()
{
  *this = {};
}

template<Individual I, Fitness F>
evolution_status<I, F> summary<I, F>::starting_status()
{
  return evolution_status<I, F>(&generation,
                                [this](scored_individual<I, F> prg)
                                {
                                  update_if_better(prg);
                                });
}

template<Individual I, Fitness F>
summary<I, F> &summary<I, F>::on_new_best(on_new_best_callback_t f)
{
  // This lock isn't required, but the cost is negligible and it keeps the
  // implementation safe even if someone breaks the contract later.
  std::lock_guard lock(mutex_);
 
  Expects(elapsed == std::chrono::milliseconds(0));
  Expects(!generation);
  Expects(data_.best.empty());
  Expects(!data_.last_improvement);
 
  on_new_best_callback_ = std::move(f);
  return *this;
}
 
template<Individual I, Fitness F>
typename summary<I, F>::data summary<I, F>::data_snapshot() const
{
  std::lock_guard lock(mutex_);
  return data_;
}

template<Individual I, Fitness F>
bool summary<I, F>::update_if_better(scored_individual<I, F> prg)
{
  on_new_best_callback_t callback(nullptr);
  bool improved(false);
 
  if (std::lock_guard lock(mutex_); prg > data_.best)
  {
    data_.best = prg;
    data_.last_improvement = generation;
    callback = on_new_best_callback_;
    improved = true;
  }
 
  if (callback)
    callback(prg);
 
  return improved;
}

template<Individual I, Fitness F>
void summary<I, F>::set_best_fitness(F fit)
{
  // The mutex protects memory access, but cannot detect an intervening change
  // of best.
  std::lock_guard lock(mutex_);
  Expects(!data_.best.empty());
  data_.best.fit = std::move(fit);
}
 
template<Individual I, Fitness F>
unsigned summary<I, F>::stagnation() const
{
  return generation - last_improvement();
}

template<Individual I, Fitness F>
scored_individual<I, F> summary<I, F>::best() const
{
  return data_snapshot().best;
}

template<Individual I, Fitness F>
unsigned summary<I, F>::last_improvement() const
{
  return data_snapshot().last_improvement;
}

template<Individual I, Fitness F>
bool summary<I, F>::load(std::istream &in, const problem &p)
{
  summary tmp_summary;
 
  std::chrono::milliseconds tmp_elapsed;
  if (int ms; !(in >> ms))
    return false;
  else
    tmp_elapsed = std::chrono::milliseconds(ms);
 
  unsigned tmp_generation;
  if (!(in >> tmp_generation))
    return false;
 
  struct data tmp_data;
 
  if (!(in >> tmp_data.last_improvement))
    return false;
 
  if (!tmp_data.best.load(in, p))
    return false;
 
  elapsed = tmp_elapsed;
  generation = tmp_generation;
  data_ = tmp_data;
 
  return true;
}

template<Individual I, Fitness F>
bool summary<I, F>::save(std::ostream &out) const
{
  const auto snapshot(data_snapshot());
 
  // Since `data_` depends on `generation`, saving `generation` before
  // `status` is very important.
  out << elapsed.count() << ' ' << generation << ' '
      << snapshot.last_improvement << '\n';
 
  // analyzer `az` doesn't need to be saved: it'll be recalculated at the
  // beginning of evolution.
 
  if (!snapshot.best.save(out))
    return false;
 
  return out.good();
}
 
#endif  // include guard