i_de.cc

Go to the documentation of this file.

 
#include "kernel/ga/i_de.h"
#include "kernel/cache_hash.h"
#include "kernel/log.h"
#include "kernel/random.h"
 
namespace vita
{
i_de::i_de(const problem &p) : individual(), genome_(p.sset.categories())
{
  Expects(parameters());
 
  std::generate(genome_.begin(), genome_.end(),
                [&, n = 0]() mutable
                {
                  return p.sset.roulette_terminal(n++).init();
                });
 
  Ensures(is_valid());
}
 
void i_de::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_de &de, std::ostream &s)
{
  std::copy(de.begin(), de.end(), infix_iterator<i_de::value_type>(s, " "));
  return s;
}
 
i_de i_de::crossover(double p, const range_t<double> &f,
                     const i_de &a, const i_de &b, const i_de &c) const
{
  Expects(0.0 <= p && p <= 1.0);
 
  const auto ps(parameters());
  Expects(ps == a.parameters());
  Expects(ps == b.parameters());
  Expects(ps == c.parameters());
 
  // The weighting factor is randomly selected from an interval for each
  // difference vector (a technique called dither). Dither improves convergence
  // behaviour significantly, especially for noisy objective functions.
  const auto rf(random::in(f));
 
  i_de ret(c);
 
  for (auto i(decltype(ps){0}); i < ps - 1; ++i)
    if (random::boolean(p))
      ret[i] += rf * (a[i] - b[i]);
    else
      ret[i] = operator[](i);
  ret[ps - 1] += rf * (a[ps - 1] - b[ps - 1]);
 
  ret.set_older_age(std::max({age(), a.age(), b.age()}));
 
  ret.signature_.clear();
  Ensures(ret.is_valid());
  return ret;
}
 
hash_t i_de::signature() const
{
  if (signature_.empty())
    signature_ = hash();
 
  return signature_;
}
 
hash_t i_de::hash() const
{
  const auto len(genome_.size() * sizeof(genome_[0]));
  return vita::hash::hash128(genome_.data(), len);
}
 
double distance(const i_de &lhs, const i_de &rhs)
{
  Expects(lhs.parameters() == rhs.parameters());
 
  const auto cs(lhs.parameters());
  assert(cs);
 
  double d(0.0);
  for (unsigned i(0); i < cs; ++i)
    d += std::fabs(lhs[i] - rhs[i]);
 
  Ensures(d >= 0.0);
  return d;
}
 
i_de &i_de::operator=(const std::vector<i_de::value_type> &v)
{
  Expects(v.size() == parameters());
 
  genome_ = v;
 
  return *this;
}
 
bool i_de::is_valid() const
{
  if (empty())
  {
    if (!genome_.empty())
    {
      vitaERROR << "Inconsistent internal status for empty individual";
      return false;
    }
 
    if (!signature_.empty())
    {
      vitaERROR << "Empty individual must have empty signature";
      return false;
    }
 
    return true;
  }
 
  if (!signature_.empty() && signature_ != hash())
  {
    vitaERROR << "Wrong signature: " << signature_ << " should be " << hash();
    return false;
  }
 
  return true;
}
 
bool i_de::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 (!load_float_from_stream(in, &g))
      return false;
 
  genome_ = v;
 
  return true;
}
 
bool i_de::save_impl(std::ostream &out) const
{
  out << parameters() << '\n';
  for (const auto &v : genome_)
  {
    save_float_to_stream(out, v);
    out << '\n';
  }
 
  return out.good();
}
 
std::ostream &operator<<(std::ostream &s, const i_de &ind)
{
  return in_line(ind, s);
}
 
i_de::operator std::vector<i_de::value_type>() const
{
  return genome_;
}
 
bool operator==(const i_de &lhs, const i_de &rhs)
{
  const bool eq(std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()));
 
  Ensures((lhs.signature() == rhs.signature()) == eq);
  return eq;
}
 
}  // namespace vita