symbol_set.h

Go to the documentation of this file.

 
#if !defined(ULTRA_SYMBOL_SET_H)
#define      ULTRA_SYMBOL_SET_H
 
#include "kernel/terminal.h"
#include "kernel/gp/function.h"
 
#include <algorithm>
#include <concepts>
#include <initializer_list>
#include <memory>
#include <set>
#include <string>
 
namespace ultra
{
 
namespace internal
{
 
struct w_symbol
{
  using weight_t = unsigned;

  static constexpr weight_t base_weight = 100;
 
  explicit w_symbol(const symbol *, weight_t = base_weight);
 
  [[nodiscard]] bool operator==(const w_symbol &) const noexcept = default;
 
  const symbol *sym;

  weight_t weight;
};
 
 
class sum_container
{
public:
  explicit sum_container(std::string);
 
  void insert(const w_symbol &);
 
  [[nodiscard]] std::size_t size() const noexcept;
 
  [[nodiscard]] auto begin() noexcept { return elems_.begin(); }
  [[nodiscard]] auto begin() const noexcept { return elems_.begin(); }
  [[nodiscard]] auto end() const noexcept { return elems_.end(); }
 
  [[nodiscard]] w_symbol::weight_t sum() const noexcept;
 
  template<class F> void scale_weights(double, F);
  [[nodiscard]] const symbol *roulette() const;
 
  [[nodiscard]] bool is_valid() const;
 
private:
  std::vector<w_symbol> elems_ {};
 
  // Sum of the weights of the symbols in the container.
  w_symbol::weight_t sum_ {0};
 
  std::string name_;
};
 
 
// A collection is a structured-view on `symbols_` or on a subset of
// `symbols_` (e.g. only on symbols of a specific category).
class collection
{
public:
  explicit collection(std::string = "");
 
  [[nodiscard]] bool is_valid() const;
 
  void insert(const w_symbol &);
 
  sum_container       all {"all"};
  sum_container functions {"functions"};
  sum_container terminals {"terminals"};
 
private:
  std::string name_;
};
 
}  // namespace internal
 

class symbol_set
{
public:
  // ---- Member types ----
  using weight_t = internal::w_symbol::weight_t;
  static constexpr weight_t default_weight = internal::w_symbol::base_weight;
 
  // ---- Constructor ----
  symbol_set() = default;
 
  // ---- Modifiers ----
  void clear();
 
  symbol *insert(std::unique_ptr<symbol>, weight_t = default_weight);
 
  template<Symbol S, weight_t = default_weight, class ...Args>
  requires std::constructible_from<S, Args...>
  std::add_pointer_t<S> insert(Args &&...);
 
  template<std::derived_from<function> F, weight_t W = default_weight,
           std::convertible_to<symbol::category_t> C = symbol::category_t>
  std::add_pointer_t<F> insert(symbol::category_t,
                               std::initializer_list<C>);
 
  template<std::derived_from<function> F, weight_t W = default_weight,
           std::convertible_to<symbol::category_t> C = symbol::category_t>
  std::add_pointer_t<F> insert(std::initializer_list<C>);
 
  // ---- Capacity ----
  [[nodiscard]] bool enough_terminals() const noexcept;
  [[nodiscard]] symbol::category_t categories() const noexcept;
  [[nodiscard]] std::size_t functions(
    symbol::category_t = symbol::default_category) const noexcept;
  [[nodiscard]] std::size_t terminals(
    symbol::category_t = symbol::default_category) const noexcept;
  [[nodiscard]] std::size_t variables(
    symbol::category_t = symbol::default_category) const noexcept;
  template<Symbol S> [[nodiscard]] std::size_t count_if(
    symbol::category_t = symbol::default_category) const noexcept;
 
  // ---- Lookup / symbol access ----
  [[nodiscard]] value_t random_argument(
    std::size_t, symbol::category_t, double) const;
  [[nodiscard]] const symbol *roulette(
    symbol::category_t = symbol::default_category) const;
  [[nodiscard]] const function *roulette_function(
    symbol::category_t = symbol::default_category) const;
  [[nodiscard]] value_t roulette_terminal(
    symbol::category_t = symbol::default_category) const;
  [[nodiscard]] const symbol *roulette_free(
    symbol::category_t = symbol::default_category) const;
 
  [[nodiscard]] const symbol *decode(symbol::opcode_t) const;
  [[nodiscard]] const symbol *decode(const std::string &) const;
 
  [[nodiscard]] const terminal *front_terminal(
    symbol::category_t = symbol::default_category) const;
 
  // ---- Misc ----
  [[nodiscard]] weight_t weight(const symbol &) const;
 
  [[nodiscard]] std::set<symbol::category_t>
    categories_missing_terminal() const;
 
  [[nodiscard]] bool is_valid() const;
 
  friend std::ostream &operator<<(std::ostream &, const symbol_set &);
 
private:
  // This is the real, raw repository of symbols (it owns/stores the symbols).
  std::vector<std::unique_ptr<symbol>> symbols_ {};
 
  // The last element of the vector contains the category-agnostic view of
  // symbols:
  // - `views_.back().all.size()` is equal to the total number of symbols
  // - `views_[0].all.size()` is the number of symbols in category `0`
  std::vector<internal::collection> views_ {};
};

template<Symbol S>
std::size_t symbol_set::count_if(symbol::category_t c) const noexcept
{
  if (c >= categories())
    return 0;
 
  if constexpr (std::derived_from<S, function>)
    return std::ranges::count_if(
      views_[c].functions, [](const auto &ws) { return is<S>(ws.sym); });
  else if constexpr (std::derived_from<S, terminal>)
    return std::ranges::count_if(
      views_[c].terminals, [](const auto &ws) { return is<S>(ws.sym); });
  else
    return std::ranges::count_if(
      views_[c].all, [](const auto &ws) { return is<S>(ws.sym); });
}

template<Symbol S, symbol_set::weight_t W, class ...Args>
requires std::constructible_from<S, Args...>
std::add_pointer_t<S> symbol_set::insert(Args &&... args)
{
  return static_cast<std::add_pointer_t<S>>(
    insert(std::make_unique<S>(std::forward<Args>(args)...), W));
}

template<std::derived_from<function> F, symbol_set::weight_t W,
         std::convertible_to<symbol::category_t> C>
std::add_pointer_t<F> symbol_set::insert(symbol::category_t ret,
                                         std::initializer_list<C> pt)
{
  return insert<F, W>(ret, function::param_data_types(pt.begin(), pt.end()));
}

template<std::derived_from<function> F, symbol_set::weight_t W,
         std::convertible_to<symbol::category_t> C>
std::add_pointer_t<F> symbol_set::insert(std::initializer_list<C> pt)
{
  return insert<F, W>(symbol::default_category, pt);
}
 
std::ostream &operator<<(std::ostream &, const symbol_set &);
 
}  // namespace ultra
 
#endif  // include guard