team.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_TEAM_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_TEAM_TCC)
#define      ULTRA_TEAM_TCC

template<Individual I>
team<I>::team(std::size_t n)
{
  Expects(n <= max_team_size);
 
  individuals_.resize(n);
  signature_ = hash();
 
  Ensures(is_valid());
}

template<Individual I>
team<I>::team(const problem &p)
{
  Expects(p.params.team.individuals);
  Expects(p.params.team.individuals <= max_team_size);
 
  auto n(p.params.team.individuals);
  individuals_.reserve(n);
 
  for (std::size_t i(0); i < n; ++i)
    individuals_.emplace_back(p);
 
  signature_ = hash();
 
  Ensures(is_valid());
}

template<Individual I>
team<I>::team(std::vector<I> v) : individuals_(std::move(v))
{
  signature_ = hash();
  Ensures(is_valid());
}

template<Individual I>
unsigned team<I>::mutation(const problem &prb, double temperature)
{
  //const auto nm(random::element(individuals_).mutation(prb, temperature));
  //if (nm)
  //  signature_.clear();
  //return nm;
 
  unsigned nm(0);
  for (auto &i : individuals_)
    nm += i.mutation(prb, temperature);
 
  if (nm)
    signature_ = hash();
 
  return nm;
}

template<Individual I>
team<I> crossover(const problem &prb, const team<I> &lhs, const team<I> &rhs)
{
  Expects(lhs.size() == rhs.size());
 
  std::vector<I> crossed;
  crossed.reserve(lhs.size());
 
  std::ranges::transform(
    lhs, rhs, std::back_inserter(crossed),
    [&prb](const auto &i1, const auto &i2) { return crossover(prb, i1, i2); });
 
  return team(std::move(crossed));
}

template<Individual I>
team_decision_vector extract_decision_vector(const team<I> &t)
{
  team_decision_vector ret;
 
  for (std::size_t i(0); i < t.size(); ++i)
  {
    auto i_dv = extract_decision_vector(t[i]);
 
    for (std::size_t j(0); j < i_dv.size(); ++j)
    {
      const auto &e(i_dv.coords[j]);
      ret.values.push_back(i_dv.values[j]);
      ret.coords.push_back({{i, e.coord.loc, e.coord.arg_index}, e.kind});
    }
  }
 
  Ensures(ret.is_valid());
  return ret;
}

template<Individual I>
void team<I>::apply_decision_vector(const team_decision_vector &v)
{
  Expects(v.is_valid());
 
  using ind_dv_t = ultra::decision_vector_t<I>;
 
  std::vector<ind_dv_t> per_ind(size());
 
  for (auto &&[value, c] : std::views::zip(v.values, v.coords))
  {
    Expects(c.coord.ind_index < size());
 
    auto &ind_v(per_ind[c.coord.ind_index]);
    ind_v.values.push_back(value);
    ind_v.coords.push_back({{c.coord.loc, c.coord.arg_index}, c.kind});
  }
 
  for (std::size_t i(0); i < size(); ++i)
    if (!per_ind[i].empty())
      individuals_[i].apply_decision_vector(per_ind[i]);
 
  signature_ = hash();
  Ensures(is_valid());
}

template<Individual I>
typename team<I>::const_iterator team<I>::begin() const noexcept
{
  return individuals_.begin();
}

template<Individual I>
typename team<I>::const_iterator team<I>::end() const noexcept
{
  return individuals_.end();
}

template<Individual I>
const I &team<I>::operator[](std::size_t i) const
{
  Expects(i < size());
  return individuals_[i];
}

template<Individual I>
bool team<I>::empty() const noexcept
{
  return individuals_.empty();
}

template<Individual I>
std::size_t team<I>::size() const noexcept
{
  return individuals_.size();
}

template<Individual I> unsigned active_slots(const team<I> &t)
{
  return std::accumulate(t.begin(), t.end(), 0u,
                         [](unsigned n, const I &ind)
                         {
                           return n + active_slots(ind);
                         });
}

template<Individual I>
hash_t team<I>::signature() const noexcept
{
  return signature_;
}

template<Individual I>
hash_t team<I>::hash() const
{
  hash_t ret;
 
  for (const auto &i : individuals_)
    ret.combine(i.signature());
 
  return ret;
}

template<Individual I>
bool operator==(const team<I> &lhs, const team<I> &rhs) noexcept
{
  return std::ranges::equal(lhs, rhs);
}

template<Individual I>
unsigned distance(const team<I> &lhs, const team<I> &rhs)
{
  Expects(lhs.size() == rhs.size());
 
  return std::inner_product(lhs.begin(), lhs.end(), rhs.begin(), 0u,
                            std::plus{},
                            [](const auto &i1, const auto &i2)
                            {
                              return distance(i1, i2);
                            });
}

template<Individual I>
ultra::individual::age_t team<I>::age() const
{
  if (empty())
    return 0;
 
  using age_t = ultra::individual::age_t;
 
  const unsigned age_sum(std::accumulate(
                           begin(), end(), static_cast<age_t>(0),
                           [](age_t sum, const I &i)
                           {
                             return sum + i.age();
                           }));
 
  return age_sum / size();
}

template<Individual I>
void team<I>::inc_age(unsigned delta)
{
  for (auto &i : individuals_)
    i.inc_age(delta);
}

template<Individual I>
bool team<I>::is_valid() const
{
  if (size() > max_team_size)
    return false;
 
  if (std::ranges::any_of(individuals_,
                          [](const I &i) { return !i.is_valid(); }))
    return false;
 
  return signature_ == hash();
}

template<Individual I>
bool team<I>::load(std::istream &in, const symbol_set &ss)
{
  std::size_t n;
  if (!(in >> n) || n > max_team_size)
    return false;
 
  decltype(individuals_) v;
  v.reserve(n);
 
  for (std::size_t j(0); j < n; ++j)
  {
    I i;
    if (!i.load(in, ss))
      return false;
 
    v.push_back(std::move(i));
  }
 
  individuals_ = std::move(v);
 
  // We don't save/load signature: it can be easily calculated on the fly.
  signature_ = hash();
 
  return true;
}

template<Individual I>
bool team<I>::save(std::ostream &out) const
{
  out << size() << '\n';
  if (!out.good())
    return false;
 
  if (std::ranges::any_of(*this,
                          [&](const I &i) { return !i.save(out); }))
    return false;
 
  return out.good();
}

template<Individual I>
std::ostream &operator<<(std::ostream &s, const team<I> &t)
{
  const auto format(out::print_format_flag(s));
 
  for (const auto &i : t)
  {
    if (format == out::in_line_f)
      s << '{';
 
    s << i;
 
    if (format == out::in_line_f)
      s << '}';
    else
      s << '\n';
  }
 
  return s;
}
 
#endif  // include guard