team.h

Go to the documentation of this file.

 
#if !defined(ULTRA_TEAM_H)
#define      ULTRA_TEAM_H
 
#include "kernel/cache.h"
#include "kernel/decision_vector.h"
#include "kernel/individual.h"
#include "kernel/problem.h"
 
#include <algorithm>
#include <ranges>
 
namespace ultra::gp
{

struct team_decision_coordinate
{
  std::size_t ind_index;
  locus loc;
  std::size_t arg_index;
};

using team_decision_vector = ultra::decision_vector<team_decision_coordinate>;


///
/// \note
/// The team size has to be large enough to cause an improved prediction
/// compared to the traditional approach, i.e. team size one (but the
/// complexity of the search space and the training time, respectively,
/// grow exponentially with the number of coevolved programs).
///
/// \see https://github.com/morinim/ultra/wiki/bibliography#16
///
template<Individual I>
class team
{
public:
  static constexpr std::size_t max_team_size {1024};
 
  team() = default;
  explicit team(std::size_t);
  explicit team(const problem &);
  explicit team(std::vector<I>);
 
  // ---- Recombination operators ----
  unsigned mutation(const problem &, double = 1.0);
  template<Individual U> friend team<U> crossover(const problem &,
                                                  const team<U> &,
                                                  const team<U> &);
  void apply_decision_vector(const team_decision_vector &v);
 
  // ---- Element access ----
  [[nodiscard]] const I &operator[](std::size_t) const;
 
  // ---- Capacity ----
  [[nodiscard]] bool empty() const noexcept;
  [[nodiscard]] std::size_t size() const noexcept;
 
  // ---- Misc ----
  [[nodiscard]] hash_t signature() const noexcept;
 
  [[nodiscard]] ultra::individual::age_t age() const;
  void inc_age(unsigned = 1);
 
  [[nodiscard]] bool is_valid() const;
 
  // ---- Iterators ----
  using members_t = std::vector<I>;
  using const_iterator = typename members_t::const_iterator;
  using value_type = typename members_t::value_type;
  [[nodiscard]] const_iterator begin() const noexcept;
  [[nodiscard]] const_iterator end() const noexcept;
 
  // ---- Serialization ----
  bool load(std::istream &, const symbol_set &);
  bool save(std::ostream &) const;
 
private:
  // ---- Private support methods ----
  [[nodiscard]] hash_t hash() const;
 
  // ---- Private data members ----
  members_t individuals_ {};
 
  hash_t signature_ {};
};
 
// ***********************************************************************
// *  Comparison operators                                               *
// ***********************************************************************
template<Individual I> [[nodiscard]] bool operator==(const team<I> &,
                                                     const team<I> &) noexcept;
template<Individual I> [[nodiscard]] unsigned distance(const team<I> &,
                                                       const team<I> &);
 
 
template<Individual I> [[nodiscard]] unsigned active_slots(const team<I> &);
template<Individual I> [[nodiscard]] team<I> crossover(const problem &,
                                                       const team<I> &,
                                                       const team<I> &);
template<Individual I> [[nodiscard]]
team_decision_vector extract_decision_vector(const team<I> &);
 
template<Individual I> std::ostream &operator<<(std::ostream &,
                                                const team<I> &);
 
 
template<class> inline constexpr bool is_team_v = false;
template<Individual I> inline constexpr bool is_team_v<team<I>> = true;
template<class T> concept Team = is_team_v<std::remove_cvref_t<T>>;
 
#include "kernel/gp/team.tcc"
 
}  // namespace ultra::gp
 
#endif  // include guard