analyzer.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_ANALYZER_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_ANALYZER_TCC)
#define      ULTRA_ANALYZER_TCC
 
namespace internal
{
 
inline void merge_ct(auto &destination, const auto &source)
{
  for (const auto &[ct, n] : source)
    destination[ct] += n;
}
 
}  // namespace internal
 
template<class C> concept has_active_crossover_type = requires(const C &c)
{
  { c.active_crossover_type() } -> std::convertible_to<int>;
};
 
template<Individual I, Fitness F>
group_stat<I, F>::group_stat(population_uid id) : uid(id)
{
}

template<Individual I, Fitness F>
void group_stat<I, F>::add(const I &ind, const F &f)
{
  age.add(ind.age());
 
  const std::size_t len(active_slots(ind));
 
  length.add(len);
 
  using std::isfinite;
  if (isfinite(f))
    fitness.add(f);
 
  if constexpr (has_active_crossover_type<I>)
    ++crossover_type[ind.active_crossover_type()];
}
 
template<Individual I, Fitness F>
void group_stat<I, F>::merge(group_stat gs)
{
  age.merge(gs.age);
  fitness.merge(gs.fitness);
  length.merge(gs.length);
 
  internal::merge_ct(crossover_type, gs.crossover_type);
}

template<Individual I, Fitness F>
template<LayeredPopulation P, Evaluator E> analyzer<I, F>::analyzer(
  const P &pop, const E &eva)
{
  const auto gather_subgroup_stats([&eva](auto layer_iter)
  {
    group_stat<I, F> ret(layer_iter->uid());
 
    for (const auto &ind : *layer_iter)
      ret.add(ind, eva(ind));
 
    return ret;
  });
 
  const auto range(pop.range_of_layers());
  std::vector<std::future<group_stat<I, F>>> tasks;
  for (auto l(range.begin()); l != range.end(); ++l)
    tasks.push_back(std::async(std::launch::async, gather_subgroup_stats, l));
 
  for (auto &task : tasks)
    group_stat_.push_back(task.get());
}

template<Individual I, Fitness F>
void analyzer<I, F>::clear()
{
  *this = {};
}
 
template<Individual I, Fitness F>
const group_stat<I, F> *analyzer<I, F>::group(population_uid uid) const
{
  const auto iter(std::ranges::find_if(group_stat_,
                                       [uid](const auto &grp)
                                       {
                                         return grp.uid == uid;
                                       }));
 
  return iter == group_stat_.end() ? nullptr : std::addressof(*iter);
}
 
template<Individual I, Fitness F>
group_stat<I, F> *analyzer<I, F>::group(population_uid uid)
{
  // My goodness... however, nobody ever got fired for following Scott Meyers.
  return const_cast<group_stat<I, F> *>(std::as_const(*this).group(uid));
}

template<Individual I, Fitness F>
group_stat<I, F> analyzer<I, F>::overall_group_stat() const
{
  group_stat<I, F> ret;
 
  for (const auto &gs : group_stat_)
    ret.merge(gs);
 
  return ret;
}

template<Individual I, Fitness F>
auto analyzer<I, F>::crossover_types() const
{
  decltype(group_stat<I, F>::crossover_type) ret;
  for (const auto &gs : group_stat_)
    internal::merge_ct(ret, gs.crossover_type);
 
  return ret;
}

template<Individual I, Fitness F>
const auto &analyzer<I, F>::crossover_types(population_uid g) const
{
  const auto *ptr(group(g));
  assert(ptr);
 
  return ptr->crossover_type;
}

template<Individual I, Fitness F>
template<Population P>
const auto &analyzer<I, F>::crossover_types(const P &g) const
{
  return crossover_types(g.uid());
}

template<Individual I, Fitness F>
distribution<double> analyzer<I, F>::age_dist() const
{
  distribution<double> ret;
  for (const auto &gs : group_stat_)
    ret.merge(gs.age);
 
  return ret;
}

template<Individual I, Fitness F>
const distribution<double> &analyzer<I, F>::age_dist(population_uid g) const
{
  const auto *ptr(group(g));
  assert(ptr);
 
  return ptr->age;
}

template<Individual I, Fitness F>
template<Population P>
const distribution<double> &analyzer<I, F>::age_dist(const P &g) const
{
  return age_dist(g.uid());
}

template<Individual I, Fitness F>
distribution<F> analyzer<I, F>::fit_dist() const
{
  distribution<F> ret;
  for (const auto &gs : group_stat_)
    ret.merge(gs.fitness);
 
  return ret;
}

template<Individual I, Fitness F>
const distribution<F> &analyzer<I, F>::fit_dist(population_uid g) const
{
  const auto *ptr(group(g));
  assert(ptr);
 
  return ptr->fitness;
}

template<Individual I, Fitness F>
template<Population P>
const distribution<F> &analyzer<I, F>::fit_dist(const P &g) const
{
  return fit_dist(g.uid());
}

template<Individual I, Fitness F>
distribution<double> analyzer<I, F>::length_dist() const
{
  distribution<double> ret;
  for (const auto &gs : group_stat_)
    ret.merge(gs.length);
 
  return ret;
}

template<Individual I, Fitness F>
const distribution<double> &analyzer<I, F>::length_dist(population_uid g) const
{
  const auto *ptr(group(g));
  assert(ptr);
 
  return ptr->length;
}

template<Individual I, Fitness F>
template<Population P>
const distribution<double> &analyzer<I, F>::length_dist(const P &g) const
{
  return length_dist(g.uid());
}

template<Individual I, Fitness F>
bool analyzer<I, F>::is_valid() const
{
  const auto ad(age_dist());
  const auto cts(crossover_types());
  const auto fd(fit_dist());
  const auto ld(length_dist());
 
  for (const auto &g : group_stat_)
  {
    if (g.age.min() < ad.min())
      return false;
    if (g.age.max() > ad.max())
      return false;
 
    if (!g.fitness.empty())
    {
      if (fd.empty())
        return false;
 
      if (g.fitness.min() < fd.min())
        return false;
      if (g.fitness.max() > fd.max())
        return false;
    }
 
    if (g.length.min() < ld.min())
      return false;
    if (g.length.max() > ld.max())
      return false;
 
    if constexpr (has_active_crossover_type<I>)
    {
      std::size_t sum_cross(0);
 
      for (auto [type,num] : g.crossover_type)
      {
        sum_cross += num;
 
        if (type >= I::NUM_CROSSOVERS)
          return false;
 
        if (num > cts.at(type))
          return false;
      }
 
      if (sum_cross != g.age.size())
        return false;
    }
    else
    {
      if (!g.crossover_type.empty())
        return false;
    }
 
    if (g.age.size() != g.length.size())
      return false;
    if (g.fitness.size() > g.age.size())  // could be smaller, invalid fitness
      return false;                       // values are skipped
  }
 
  return true;
}

template<Individual I, Fitness F>
void analyzer<I, F>::add(const I &ind, const F &f, population_uid uid)
{
  if (auto *selected = group(uid))
    selected->add(ind, f);
  else
  {
    group_stat_.emplace_back(uid);
    group_stat_.back().add(ind, f);
  }
}
 
#endif  // include guard