population.h

Go to the documentation of this file.

 
#if !defined(ULTRA_POPULATION_H)
#define      ULTRA_POPULATION_H
 
#include "kernel/individual.h"
#include "kernel/random.h"
 
#include <concepts>
#include <ranges>
#include <shared_mutex>
 
namespace ultra
{

using population_uid = unsigned;
 
template<class P>
concept RandomAccessIndividuals =
  std::ranges::random_access_range<P>
  && Individual<std::ranges::range_value_t<P>>;
 
template<class P>
concept Population =
  std::ranges::range<P>
  && Individual<std::ranges::range_value_t<P>>;
 
template<class P>
concept LayeredPopulation = Population<P> && requires(P &p)
{
  { p.layers() } -> std::integral;
  { p.range_of_layers() } -> std::ranges::range;
  { p.back() };
};
 
template<class P>
concept SizedRandomAccessPopulation =
  Population<P>
  && std::ranges::sized_range<P>
  && std::ranges::random_access_range<P>
  && requires(const P &p)
{
  typename P::coord;
  p[typename P::coord()];
};
 
template<class P>
concept PopulationWithMutex =
  SizedRandomAccessPopulation<P> && requires(const P &p)
{
  p.mutex();
};
 
namespace random
{
 
template<SizedRandomAccessPopulation P>
[[nodiscard]] typename P::coord coord(const P &p)
{
  Expects(p.size() > 0);
  return static_cast<typename P::coord>(sup(p.size()));
}

template<SizedRandomAccessPopulation P>
[[nodiscard]] typename P::coord
coord(const P &p, std::size_t i, std::size_t mate_zone)
{
  Expects(i < p.size());
  Expects(mate_zone);  // non-zero after auto-tune
 
  return static_cast<typename P::coord>(random::ring(i, mate_zone, p.size()));
}

template<PopulationWithMutex P>
[[nodiscard]] std::ranges::range_value_t<P> individual(const P &p)
{
  std::shared_lock lock(p.mutex());
  return p[random::coord(p)];
}
 
}  // namespace random
 
}  // namespace ultra
 
#endif  // include guard