alps.h

Go to the documentation of this file.

 
#if !defined(ULTRA_ALPS_H)
#define      ULTRA_ALPS_H
 
#include "kernel/population.h"
 
#include <array>
#include <cstddef>
#include <functional>
#include <span>
 
namespace ultra
{

template<class Layer>
class alps_layer_pair
{
public:
  alps_layer_pair(Layer &l) noexcept
    : layers_{std::ref(l), std::ref(l)}, has_secondary_(false) {}

  alps_layer_pair(Layer &p, Layer &s) noexcept
    : layers_{std::ref(p), std::ref(s)}, has_secondary_(true) {}

  [[nodiscard]] constexpr std::size_t size() const noexcept
  {
    return 1 + static_cast<std::size_t>(has_secondary_);
  }

  [[nodiscard]] constexpr bool has_secondary() const noexcept
  {
    return has_secondary_;
  }

  [[nodiscard]] constexpr auto begin() const noexcept
  {
    return layers_.begin();
  }

  [[nodiscard]] constexpr auto end() const noexcept
  {
    return layers_.begin() + static_cast<std::ptrdiff_t>(size());
  }

  [[nodiscard]] constexpr Layer &primary() const noexcept
  {
    return layers_[0].get();
  }

  [[nodiscard]] constexpr Layer &secondary() const noexcept
  {
    Expects(has_secondary());
    return layers_[1].get();
  }

  [[nodiscard]] Layer &random(double p_pri) const
  {
    Expects(in_0_1(p_pri));
    return !has_secondary_ || random::boolean(p_pri) ? primary() : secondary();
  }
 
private:
  std::array<std::reference_wrapper<Layer>, 2> layers_;
  bool has_secondary_ {false};
};
 
template<class Layer>
alps_layer_pair(Layer &) -> alps_layer_pair<Layer>;
 
template<class Layer>
alps_layer_pair(Layer &, Layer &) -> alps_layer_pair<Layer>;
 
template<class Layer>
alps_layer_pair(const Layer &) -> alps_layer_pair<const Layer>;
 
template<class Layer>
alps_layer_pair(const Layer &, const Layer &) -> alps_layer_pair<const Layer>;
 
namespace alps
{

struct parameters
{
  [[nodiscard]] unsigned max_age(std::size_t) const;
  [[nodiscard]] unsigned max_age(std::size_t, std::size_t) const;

  unsigned age_gap {0};

  std::size_t max_layers {0};

  double p_main_layer {-1.0};
};
 
template<LayeredPopulation P>
void set_age(P &pop)
{
  const auto layers(pop.layers());
  if (!layers)
    return;
 
  const auto &params(pop.problem().params);
 
  for (std::size_t l(0); l < layers; ++l)
    pop.layer(l).max_age(params.alps.max_age(l, layers));
}

template<LayeredPopulation P>
alps_layer_pair<typename P::layer_t>
replacement_layers(P &pop, typename P::layer_iter l)
{
  Expects(pop.layers());
  Expects(iterator_of(l, pop.range_of_layers()));
 
  if (l == std::prev(pop.range_of_layers().end()))
    return *l;
 
  return {*l, pop.back()};
}

template<LayeredPopulation P>
alps_layer_pair<const typename P::layer_t>
selection_layers(const P &pop, typename P::layer_const_iter l)
{
  Expects(pop.layers());
  Expects(iterator_of(l, pop.range_of_layers()));
 
  if (l == pop.range_of_layers().begin())
    return *l;
 
  return {*l, *std::prev(l)};
}
 
}  // namespace alps
}  // namespace ultra
 
#endif  // include guard