layered_population.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_LAYERED_POPULATION_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_LAYERED_POPULATION_TCC)
#define      ULTRA_LAYERED_POPULATION_TCC
 
namespace internal
{
 
template<LayeredPopulation P>
[[nodiscard]] std::size_t random_layer_index(const P &p)
{
  Expects(p.layers());
  Expects(p.size());
 
  // With multiple layers we cannot be sure that every layer has the same
  // number of individuals. So the simple (and fast) solution:
  //
  //     return random::sup(p.layers());
  //
  // isn't appropriate.
 
  auto idx(random::sup(p.size()));
 
  for (std::size_t layer(0); const auto &l : p.range_of_layers())
  {
    if (idx < l.size())
      return layer;
 
    idx -= l.size();
    ++layer;
  }
 
  return p.layers() - 1;
}
 
}  // namespace internal

template<Individual I>
layered_population<I>::layered_population(const ultra::problem &p,
                                          bool init_subgroups)
  : prob_(&p)
{
  if (init_subgroups)
  {
    for (std::size_t l(0); l < p.params.population.init_subgroups; ++l)
      layers_.emplace_back(p);
 
    assert(layers() == p.params.population.init_subgroups);
  }
 
  Ensures(is_valid());
}

template<Individual I>
const typename layered_population<I>::layer_t &
layered_population<I>::layer(std::size_t l) const
{
  Expects(l < layers());
  return *std::next(layers_.begin(), l);
}

template<Individual I>
typename layered_population<I>::layer_t &
layered_population<I>::layer(std::size_t l)
{
  Expects(l < layers());
  return *std::next(layers_.begin(), l);
}

template<Individual I>
const typename layered_population<I>::layer_t &
layered_population<I>::front() const
{
  Expects(layers());
  return layers_.front();
}

template<Individual I>
typename layered_population<I>::layer_t &layered_population<I>::front()
{
  Expects(layers());
  return layers_.front();
}

template<Individual I>
const typename layered_population<I>::layer_t &
layered_population<I>::back() const
{
  Expects(layers());
  return layers_.back();
}

template<Individual I>
typename layered_population<I>::layer_t &layered_population<I>::back()
{
  Expects(layers());
  return layers_.back();
}

template<Individual I>
const I &layered_population<I>::operator[](coord c) const
{
  return layer(c.layer_index)[c.individual_coord];
}

template<Individual I>
I &layered_population<I>::operator[](coord c)
{
  return layer(c.layer_index)[c.individual_coord];
}
 
template<Individual I>
auto layered_population<I>::range_of_layers() const
{
  return std::ranges::subrange(layers_.cbegin(), layers_.cend());
}
 
template<Individual I>
auto layered_population<I>::range_of_layers()
{
  return std::ranges::subrange(layers_.begin(), layers_.end());
}

template<Individual I>
void layered_population<I>::init(layer_t &l)
{
  l.clear();
  l.allowed(problem().params.population.individuals);
 
  std::generate_n(std::back_inserter(l), l.allowed(),
                  [this] {return I(problem()); });
}

template<Individual I>
std::size_t layered_population<I>::layers() const noexcept
{
  return layers_.size();
}

template<Individual I>
std::size_t layered_population<I>::size() const
{
  return std::ranges::fold_left(layers_, 0uz,
                                [](auto accumulator, const auto &l)
                                {
                                  return accumulator + l.size();
                                });
}

template<Individual I>
const ultra::problem &layered_population<I>::problem() const
{
  Expects(prob_);
  return *prob_;
}

template<Individual I>
void layered_population<I>::add_layer()
{
#if !defined(NDEBUG)
  const auto nl(layers());
#endif
 
  layers_.emplace(layers_.begin(), problem());
 
#if !defined(NDEBUG)
  Ensures(layers() == nl + 1);
#endif
}

template<Individual I>
bool layered_population<I>::erase(layer_t &l)
{
  for (auto it(layers_.begin()); it != layers_.end(); ++it)
    if (std::addressof(l) == std::addressof(*it))
    {
      layers_.erase(it);
      return true;
    }
 
  return false;
}

template<Individual I>
typename layered_population<I>::layer_iter
layered_population<I>::erase(layer_iter pos)
{
  Expects(iterator_of(pos, range_of_layers()));
  return layers_.erase(pos);
}

template<Individual I>
typename layered_population<I>::const_iterator
layered_population<I>::begin() const
{
  return const_iterator(*this, true);
}

template<Individual I>
typename layered_population<I>::const_iterator
layered_population<I>::end() const
{
  return const_iterator(*this, false);
}

template<Individual I>
typename layered_population<I>::iterator layered_population<I>::begin()
{
  return iterator(*this, true);
}

template<Individual I>
typename layered_population<I>::iterator layered_population<I>::end()
{
  return iterator(*this, false);
}

template<Individual I>
void layered_population<I>::inc_age()
{
  std::ranges::for_each(layers_, [](auto &l) { l.inc_age(); });
}
 
namespace random
{

template<LayeredPopulation P>
const auto &subgroup(const P &p)
{
  return p.layer(internal::random_layer_index(p));
}

template<LayeredPopulation P>
typename P::coord coord(const P &p)
{
  const auto layer_i(internal::random_layer_index(p));
  return {layer_i, random::coord(p.layer(layer_i))};
}
 
}  // namespace random

template<Individual I>
bool layered_population<I>::load(std::istream &in)
{
  std::size_t n_layers;
  if (!(in >> n_layers))
    return false;
 
  layered_population<I> lp(problem(), false);
 
  for (std::size_t l(0); l < n_layers; ++l)
  {
    if (layer_t tmp; tmp.load(in, prob_->sset))
      lp.layers_.push_back(std::move(tmp));
    else
      return false;
  }
 
  *this = lp;
  return true;
}

template<Individual I>
bool layered_population<I>::save(std::ostream &out) const
{
  const auto n(layers());
 
  out << n << '\n';
 
  for (const auto &l : layers_)
    if (!l.save(out))
      return false;
 
  return out.good();
}

template<Individual I>
bool layered_population<I>::is_valid() const
{
  for (const auto &l : layers_)
    if (!l.is_valid())
      return false;
 
  if (!prob_)
  {
    ultraERROR("Undefined `problem`");
    return false;
  }
 
  return true;
}
 
#endif  // include guard