search_stats.tcc

Go to the documentation of this file.

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

template<Individual I, Fitness F>
void search_stats<I, F>::update(const I &lr_best_prg,
                                const model_measurements<F> &lr_measurements,
                                std::chrono::milliseconds lr_elapsed)
{
  Expects(lr_measurements.fitness.has_value());
  Expects(!std::isnan(*lr_measurements.fitness));
 
  const std::size_t initial_run_id(runs());
 
  // `upper_bound` finds the first run ranked after `lr_measurements` according
  // to the comparator below, so insertion preserves the descending
  // lexicographic order of `stats_`.
  auto it(std::ranges::upper_bound(
            stats_, lr_measurements,
            [](const auto &lhs, const auto &rhs)
            {
              if (*lhs.fitness > *rhs.fitness)
                return true;
 
              if (*rhs.fitness > *lhs.fitness)
                return false;
 
              return lhs.accuracy > rhs.accuracy;
            },
            &run_summary::best_measurements));
 
  run_summary new_run{initial_run_id, lr_best_prg, lr_measurements};
  stats_.insert(it, std::move(new_run));
 
  using std::isfinite;
  if (const auto fit(lr_measurements.fitness); fit && isfinite(*fit))
    fitness_distribution.add(*fit);
 
  elapsed += lr_elapsed;
}

template<Individual I, Fitness F>
std::set<std::size_t> search_stats<I, F>::good_runs(
  const model_measurements<F> &threshold) const
{
  std::set<std::size_t> ret;
 
  if (threshold.empty())
    return ret;
 
  for (const auto &s : stats_)
    if (s.best_measurements >= threshold)
      ret.insert(s.run);
 
  // When an accuracy threshold is present, `best_run()` (selected primarily by
  // fitness) might fail it even if another run with lower fitness satisfies it.
  Ensures(ret.empty() || threshold.accuracy.has_value()
          || ret.contains(best_run()));
  return ret;
}

template<Individual I, Fitness F>
std::size_t search_stats<I, F>::best_run() const noexcept
{
  Expects(runs());
  return stats_.front().run;
}

template<Individual I, Fitness F>
const I &search_stats<I, F>::best_individual() const noexcept
{
  Expects(runs());
  return stats_.front().best_individual;
}

template<Individual I, Fitness F>
const model_measurements<F> &
search_stats<I, F>::best_measurements() const noexcept
{
  Expects(runs());
  return stats_.front().best_measurements;
}

template<Individual I, Fitness F>
std::size_t search_stats<I, F>::runs() const noexcept
{
  return stats_.size();
}

template<Individual I, Fitness F>
double search_stats<I, F>::success_rate(
  const model_measurements<F> &threshold) const noexcept
{
  const auto solutions(static_cast<double>(good_runs(threshold).size()));
 
  return runs() ? solutions / static_cast<double>(runs()) : 0;
}

template<Individual I, Fitness F>
std::span<const typename search_stats<I, F>::run_summary>
search_stats<I, F>::elite_runs(double perc) const noexcept
{
  Expects(in_0_1(perc));
 
  const std::size_t total(stats_.size());
  if (total == 0 || issmall(perc))
    return {};
 
  const auto n(static_cast<std::size_t>(
    std::ceil(static_cast<double>(total) * perc)));
 
  return {stats_.data(), n};
}
 
#endif  // include guard