i_ga.cc

Go to the documentation of this file.

 
#include "kernel/ga/i_ga.h"
#include "kernel/cache_hash.h"
#include "kernel/log.h"
#include "kernel/random.h"
 
namespace vita
{
i_ga::i_ga(const problem &p) : individual(), genome_(p.sset.categories())
{
  Expects(parameters());
 
  std::generate(genome_.begin(), genome_.end(),
                [&, n = 0]() mutable
                {
                  return static_cast<value_type>(
                    p.sset.roulette_terminal(n++).init());
                });
 
  Ensures(is_valid());
}
 
void i_ga::graphviz(std::ostream &s) const
{
  s << "graph {";
 
  for (const auto &g : genome_)
    s << "g [label=" << g << ", shape=circle];";
 
  s << '}';
}
 
std::ostream &in_line(const i_ga &ga, std::ostream &s)
{
  std::copy(ga.begin(), ga.end(), infix_iterator<i_ga::value_type>(s, " "));
  return s;
}
 
unsigned i_ga::mutation(double pgm, const problem &prb)
{
  Expects(0.0 <= pgm);
  Expects(pgm <= 1.0);
 
  unsigned n(0);
 
  const auto ps(parameters());
  for (category_t c(0); c < ps; ++c)
    if (random::boolean(pgm))
      if (const auto g =
          static_cast<value_type>(prb.sset.roulette_terminal(c).init());
          g != genome_[c])
      {
        ++n;
        genome_[c] = g;
      }
 
  if (n)
    signature_ = hash();
 
  Ensures(is_valid());
  return n;
}
 
i_ga crossover(const i_ga &lhs, const i_ga &rhs)
{
  Expects(lhs.parameters() == rhs.parameters());
 
  const auto ps(lhs.parameters());
  const auto cut1(random::sup(ps - 1));
  const auto cut2(random::between(cut1 + 1, ps));
 
  i_ga ret(rhs);
  for (auto i(cut1); i < cut2; ++i)
    ret.genome_[i] = lhs[i];  // not using `operator[](unsigned)` to avoid
                              // multiple signature resets.
  ret.set_older_age(lhs.age());
  ret.signature_ = ret.hash();
 
  Ensures(ret.is_valid());
  return ret;
}
 
hash_t i_ga::signature() const
{
  if (signature_.empty())
    signature_ = hash();
 
  return signature_;
}
 
hash_t i_ga::hash() const
{
  // Length in bytes.
  const auto len(genome_.size() * sizeof(genome_[0]));  // length in bytes
  return vita::hash::hash128(genome_.data(), len);
}
 
bool i_ga::operator==(const i_ga &x) const
{
  const bool eq(genome_ == x.genome_);
 
  assert(signature_.empty() != x.signature_.empty() ||
         (signature_ == x.signature_) == eq);
 
  return eq;
}
 
unsigned i_ga::distance(const i_ga &ind) const
{
  const auto cs(parameters());
 
  unsigned d(0);
  for (auto i(decltype(cs){0}); i < cs; ++i)
    if (genome_[i] != ind.genome_[i])
      ++d;
 
  return d;
}
 
bool i_ga::is_valid() const
{
  if (empty())
  {
    if (!genome_.empty())
    {
      vitaERROR << "Inconsistent internal status for empty individual";
      return false;
    }
 
    if (!signature_.empty())
    {
      vitaERROR << "Empty individual must empty signature";
      return false;
    }
 
    return true;
  }
 
  if (!signature_.empty() && signature_ != hash())
  {
    vitaERROR << "Wrong signature: " << signature_ << " should be " << hash();
    return false;
  }
 
  return true;
}
 
bool i_ga::load_impl(std::istream &in, const symbol_set &)
{
  decltype(parameters()) sz;
  if (!(in >> sz))
    return false;
 
  decltype(genome_) v(sz);
  for (auto &g : v)
    if (!(in >> g))
      return false;
 
  genome_ = v;
 
  return true;
}
 
bool i_ga::save_impl(std::ostream &out) const
{
  out << parameters() << '\n';
  for (const auto &g : genome_)
    out << g << '\n';
 
  return out.good();
}
 
std::ostream &operator<<(std::ostream &s, const i_ga &ind)
{
  return in_line(ind, s);
}
 
i_ga::operator std::vector<i_ga::value_type>() const
{
  return genome_;
}
 
bool operator==(const i_ga &lhs, const i_ga &rhs)
{
  const bool eq(std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()));
 
  Ensures((lhs.signature() == rhs.signature()) == eq);
  return eq;
}
 
}  // namespace vita