linear_population.tcc

Go to the documentation of this file.

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

template<Individual I>
linear_population<I>::linear_population(const ultra::problem &p)
  : allowed_(std::max(p.params.population.individuals,
                      p.params.population.min_individuals)),
    min_allowed_(p.params.population.min_individuals)
{
  reset(p);
}

template<Individual I>
void linear_population<I>::reset(const ultra::problem &p)
{
  Expects(allowed() >= min_allowed_);
 
  members_.clear();
  std::generate_n(std::back_inserter(members_), allowed(),
                  [&p] { return I(p); });
}

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

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

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

template<Individual I>
std::size_t linear_population<I>::safe_size() const
{
  std::lock_guard lock(mutex_);
  return members_.size();
}

template<Individual I>
unsigned linear_population<I>::max_age() const noexcept
{
  return max_age_;
}

template<Individual I>
void linear_population<I>::max_age(unsigned m) noexcept
{
  max_age_ = m;
}

template<Individual I>
std::shared_mutex &linear_population<I>::mutex() const
{
  return mutex_;
}

template<Individual I>
std::size_t linear_population<I>::allowed() const noexcept
{
  return allowed_;
}

template<Individual I>
void linear_population<I>::allowed(std::size_t n)
{
  // Don't drop under a predefined number of individuals.
  n = std::max(n, min_allowed_);
 
  if (size() > n)
  {
    const auto delta(size() - n);
    members_.erase(members_.end() - delta, members_.end());
 
    assert(size() == n);
  }
 
  allowed_ = n;
 
  Ensures(is_valid());
}

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

template<Individual I>
void linear_population<I>::clear() noexcept
{
  members_.clear();
}

template<Individual I>
void linear_population<I>::push_back(const I &i)
{
  if (size() < allowed())
    members_.push_back(i);
}

template<Individual I>
void linear_population<I>::pop_back()
{
  Expects(!empty());
  members_.pop_back();
}

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

template<Individual I>
typename linear_population<I>::iterator linear_population<I>::begin() noexcept
{
  return members_.begin();
}

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

template<Individual I>
typename linear_population<I>::iterator linear_population<I>::end() noexcept
{
  return members_.end();
}

template<Individual I>
void linear_population<I>::inc_age()
{
  std::ranges::for_each(*this, [](auto &i) { i.inc_age(); });
}

template<Individual I>
bool linear_population<I>::load(std::istream &in, const symbol_set &ss)
{
  unsigned tmp_max_age;
  if (!(in >> tmp_max_age))
    return false;
 
  std::size_t tmp_min_allowed;
  if (!(in >> tmp_min_allowed))
    return false;
 
  std::size_t tmp_allowed;
  if (!(in >> tmp_allowed))
    return false;
 
  if (tmp_allowed < tmp_min_allowed)
    return false;
 
  std::size_t n_elem;
  if (!(in >> n_elem))
    return false;
 
  if (tmp_allowed < n_elem)
    return false;
 
  std::vector<I> tmp_members;
  tmp_members.reserve(n_elem);
  for (std::size_t i(0); i < n_elem; ++i)
    if (I ind; !ind.load(in, ss))
      return false;
    else
      tmp_members.push_back(ind);
 
  max_age(tmp_max_age);
  members_ = std::move(tmp_members);
  min_allowed_ = tmp_min_allowed;
  allowed(tmp_allowed);
 
  Ensures(is_valid());
  return true;
}

template<Individual I>
bool linear_population<I>::save(std::ostream &out) const
{
  out << max_age() << ' ' << min_allowed_ << ' ' << allowed() << ' ' << size()
      << '\n';
 
  for (const auto &prg : *this)
    if (!prg.save(out))
      return false;
 
  return out.good();
}

template<Individual I>
population_uid linear_population<I>::uid() const noexcept
{
  return uid_;
}

template<Individual I>
bool linear_population<I>::is_valid() const
{
  if (!std::ranges::all_of(*this, [](const auto &i) { return i.is_valid(); }))
    return false;
 
  if (allowed() < min_allowed_)
    return false;
 
  return size() <= allowed();
}
 
#endif  // include guard