interpreter.cc

Go to the documentation of this file.

 
#include "kernel/gp/mep/interpreter.h"
#include "kernel/gp/mep/i_mep.h"
 
namespace vita
{
 
interpreter<i_mep>::interpreter(const i_mep *ind)
  : core_interpreter(), prg_(ind), cache_(ind->size(), ind->categories()),
    ip_(ind->best())
{
  Expects(ind);
}
 
value_t interpreter<i_mep>::run_locus(const locus &ip)
{
  for (auto &e : cache_)
    e.valid = false;
 
  ip_ = ip;
  return (*prg_)[ip_].sym->eval(*this);
}
 
value_t interpreter<i_mep>::run_nvi()
{
  return run_locus(prg_->best());
}
 
terminal_param_t interpreter<i_mep>::fetch_param() const
{
  const gene &g((*prg_)[ip_]);
 
  assert(g.sym->terminal() && terminal::cast(g.sym)->parametric());
  return g.par;
}
 
value_t interpreter<i_mep>::fetch_arg(unsigned i)
{
  const gene &g((*prg_)[ip_]);
 
  assert(g.sym->arity());
  assert(i < g.sym->arity());
 
  auto &elem(cache_(g.locus_of_argument(i)));
 
  if (!elem.valid)
  {
    elem.value = fetch_opaque_arg(i);
    elem.valid = true;
  }
#if !defined(NDEBUG)
  else  // cache not empty... checking if the cached value is right
  {
    assert(fetch_opaque_arg(i) == elem.value);
  }
#endif
 
  Ensures(elem.valid);
  return elem.value;
}
 
value_t interpreter<i_mep>::fetch_opaque_arg(unsigned i)
{
  const gene &g((*prg_)[ip_]);
 
  assert(g.sym->arity());
  assert(i < g.sym->arity());
 
  const locus backup(ip_);
  ip_ = g.locus_of_argument(i);
  assert(ip_.index > backup.index);
 
  const auto ret((*prg_)[ip_].sym->eval(*this));
  ip_ = backup;
 
  return ret;
}
 
index_t interpreter<i_mep>::fetch_index(unsigned i) const
{
  const gene &g((*prg_)[ip_]);
 
  assert(g.sym->arity());
  assert(i < g.sym->arity());
 
  return g.args[i];
}
 
double interpreter<i_mep>::penalty_locus(const locus &ip)
{
  ip_ = ip;
  return (*prg_)[ip_].sym->penalty(this);
}
 
double interpreter<i_mep>::penalty_nvi()
{
  return penalty_locus(prg_->best());
}
 
bool interpreter<i_mep>::is_valid_nvi() const
{
  return ip_.index < prg_->size();
}
 
}  // namespace vita