vector_individual.tcc

Go to the documentation of this file.

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

template<class T>
vector_individual<T>::vector_individual(std::size_t n) : genome_(n)
{
  Expects(parameters());
}

template<class T>
vector_individual<T>::vector_individual(const ultra::problem &p)
  : vector_individual(p.sset.categories())
{
  static_assert(std::same_as<T, D_INT> || std::same_as<T, D_DOUBLE>);
 
  std::ranges::generate(
    genome_,
    [&, n = 0]() mutable
    {
      return std::get<T>(p.sset.roulette_terminal(n++));
    });
 
  signature_ = hash();
  Ensures(is_valid());
}

template<class T>
typename vector_individual<T>::const_iterator
vector_individual<T>::begin() const noexcept
{
  return genome_.begin();
}

template<class T>
typename vector_individual<T>::const_iterator
vector_individual<T>::end() const noexcept
{
  return genome_.end();
}

template<class T>
const typename vector_individual<T>::value_type &
vector_individual<T>::operator[](std::size_t i) const
{
  Expects(i < parameters());
  return genome_[i];
}

template<class T>
vector_individual<T>::operator const std::vector<T> &() const noexcept
{
  return genome_;
}

template<class T>
template<class F>
requires std::invocable<F &, T &>
         && std::same_as<std::invoke_result_t<F &, T &>, void>
void vector_individual<T>::apply_each(std::size_t first, std::size_t last, F &&f)
{
  Expects(first <= last);
  Expects(last <= parameters());
 
  for (auto i(first); i < last; ++i)
    std::invoke(std::forward<F>(f), genome_[i]);
 
  signature_ = hash();
  Ensures(is_valid());
}

template<class T>
template<class F>
requires std::invocable<F &, T &>
         && std::same_as<std::invoke_result_t<F &, T &>, void>
void vector_individual<T>::apply_each(F &&f)
{
  apply_each(0, size(), std::forward<F>(f));
}

template<class T>
vector_individual<T> &
vector_individual<T>::operator=(const std::vector<T> &v)
{
  Expects(empty() || v.size() == size());
 
  genome_ = v;
  signature_ = hash();
 
  Ensures(is_valid());
  return *this;
}

template<class T>
bool vector_individual<T>::empty() const noexcept
{
  return genome_.empty();
}

template<class T>
std::size_t vector_individual<T>::parameters() const noexcept
{
  return size();
}

template<class T>
std::size_t vector_individual<T>::size() const noexcept
{
  return genome_.size();
}

template<class T>
hash_t vector_individual<T>::hash() const
{
  const auto len(genome_.size() * sizeof(genome_[0]));  // length in bytes
  return len ? ultra::hash::hash128(genome_.data(), len) : hash_t();
}

template<class T>
bool operator==(const vector_individual<T> &lhs,
                const vector_individual<T> &rhs) noexcept
{
  return std::ranges::equal(lhs, rhs);
}

template<class T>
std::size_t active_slots(const vector_individual<T> &ind) noexcept
{
  return ind.parameters();
}

template<class T>
bool vector_individual<T>::is_valid() const
{
  const auto expected(hash());
  if (signature() == expected)
    return true;
 
  ultraERROR("Wrong signature: {} should be {}",
             internal::streamed(signature()),
             internal::streamed(expected));
  return false;
}

template<class T>
bool vector_individual<T>::load_impl(std::istream &in, const symbol_set &ss)
{
  std::size_t sz;
  if (!(in >> sz))
    return false;
 
  genome_t v(sz);
  for (auto &g : v)
  {
    if constexpr (std::same_as<T, D_DOUBLE>)
    {
      if (!load_float_from_stream(in, &g))
        return false;
    }
    else if constexpr (std::same_as<T, value_t>)
    {
      if (!ultra::load(in, ss, g))
        return false;
    }
    else if (!(in >> g))
      return false;
  }
 
  genome_ = std::move(v);
  return true;
}

template<class T>
bool vector_individual<T>::save_impl(std::ostream &out) const
{
  out << parameters() << '\n';
  for (const auto &g : genome_)
  {
    if constexpr (std::same_as<T, D_DOUBLE>)
      save_float_to_stream(out, g);
    else if constexpr (std::same_as<T, value_t>)
      ultra::save(out, g);
    else
      out << g;
 
    out << '\n';
  }
 
  return out.good();
}
 
#endif  // include guard