layered_population.h

Go to the documentation of this file.

 
#if !defined(ULTRA_LAYERED_POPULATION_H)
#define      ULTRA_LAYERED_POPULATION_H
 
#include "kernel/linear_population.h"
#include "kernel/problem.h"
#include "kernel/random.h"
 
#include "utility/log.h"
#include "utility/misc.h"
 
#include <algorithm>
#include <list>
#include <numeric>
#include <ranges>
 
namespace ultra
{

template<Individual I>
class layered_population
{
public:
  // ---- Member types ----
  using layer_t = linear_population<I>;
  using layer_iter = typename std::list<layer_t>::iterator;
  using layer_const_iter = typename std::list<layer_t>::const_iterator;
 
  using value_type = I;
 
  struct coord
  {
    std::size_t layer_index;
    layer_t::coord individual_coord;
 
    friend auto operator<=>(const coord &, const coord &) noexcept = default;
  };
 
  // ---- Constructors ----
  explicit layered_population(const ultra::problem &, bool = true);
 
  // ---- Layer-related / accessors ----
  [[nodiscard]] const layer_t &front() const;
  [[nodiscard]] layer_t &front();
  [[nodiscard]] const layer_t &back() const;
  [[nodiscard]] layer_t &back();
 
  [[nodiscard]] std::size_t layers() const noexcept;
  [[nodiscard]] const layer_t &layer(std::size_t) const;
  [[nodiscard]] layer_t &layer(std::size_t);
 
  [[nodiscard]] auto range_of_layers() const;
  [[nodiscard]] auto range_of_layers();
 
  [[nodiscard]] const I &operator[](coord) const;
  [[nodiscard]] I &operator[](coord);
 
  void init(layer_t &);
  void add_layer();
  bool erase(layer_t &);
  layer_iter erase(layer_iter);
 
  // ---- Capacity ----
  [[nodiscard]] std::size_t size() const;
 
  // ---- Misc ----
  void inc_age();
 
  [[nodiscard]] const ultra::problem &problem() const;
 
  // ---- Iterators ----
  template<bool> class base_iterator;
  using const_iterator = base_iterator<true>;
  using iterator = base_iterator<false>;
 
  [[nodiscard]] const_iterator begin() const;
  [[nodiscard]] const_iterator end() const;
  [[nodiscard]] iterator begin();
  [[nodiscard]] iterator end();
 
  [[nodiscard]] bool is_valid() const;
 
  // ---- Serialization ----
  [[nodiscard]] bool load(std::istream &);
  [[nodiscard]] bool save(std::ostream &) const;
 
private:
  // Holds a non-owning pointer to the associated problem.
  // The referenced problem must outlive the population.
  const ultra::problem *prob_;
 
  std::list<layer_t> layers_ {};
};
 
namespace random
{
 
template<LayeredPopulation P>
[[nodiscard]] const auto &subgroup(const P &);
template<LayeredPopulation P>
[[nodiscard]] typename P::coord coord(const P &);
 
}  // namespace random
 
#include "kernel/layered_population.tcc"
#include "kernel/layered_population_iterator.tcc"
 
}  // namespace ultra
 
#endif  // include guard