factory.cc

Go to the documentation of this file.

 
#include "kernel/gp/src/primitive/factory.h"
#include "kernel/gp/src/primitive/int.h"
#include "kernel/gp/src/primitive/real.h"
#include "kernel/gp/src/primitive/string.h"
#include "kernel/gp/src/constant.h"
 
namespace vita
{
 
namespace
{
domain_t find_domain(const std::string &s)
{
  if (is_number(s))
    return s.find('.') == std::string::npos ? domain_t::d_int
                                            : domain_t::d_double;
  return domain_t::d_string;
}
}  // unnamed namespace
 
symbol_factory::symbol_factory()
{
  register_symbol<real::abs>    ("FABS", 1);
  register_symbol<real::add>    ("FADD", 1);
  register_symbol<real::aq>     ("FAQ", 1);
  register_symbol<real::cos>    ("FCOS", 1);
  register_symbol<real::div>    ("FDIV", 1);
  register_symbol<real::idiv>   ("FIDIV", 1);
  register_symbol<real::ife>    ("FIFE", 2);
  register_symbol<real::ifl>    ("FIFL", 2);
  register_symbol<real::ifz>    ("FIFZ", 1);
  register_symbol<real::length> ("FLENGTH", 2);
  register_symbol<real::ln>     ("FLN", 1);
  register_symbol<real::max>    ("FMAX", 1);
  register_symbol<real::mod>    ("FMOD", 1);
  register_symbol<real::mul>    ("FMUL", 1);
  register_symbol<real::integer>("REAL", 1);
  register_symbol<real::sigmoid>("FSIGMOID", 1);
  register_symbol<real::sin>    ("FSIN", 1);
  register_symbol<real::sqrt>   ("FSQRT", 1);
  register_symbol<real::sub>    ("FSUB", 1);
 
  register_symbol<integer::add>   ("ADD", 1);
  register_symbol<integer::div>   ("DIV", 1);
  register_symbol<integer::ife>   ("IFE", 2);
  register_symbol<integer::ifl>   ("IFL", 2);
  register_symbol<integer::ifz>   ("IFZ", 1);
  register_symbol<integer::mod>   ("MOD", 1);
  register_symbol<integer::mul>   ("MUL", 1);
  register_symbol<integer::number>("INT", 1);
  register_symbol<integer::shl>   ("SHL", 1);
  register_symbol<integer::sub>   ("SUB", 1);
 
  register_symbol<str::ife>("SIFE", 2);
}
 
std::unique_ptr<symbol> symbol_factory::make(const std::string &name, cvect c)
{
  Expects(!name.empty());
  Expects(!c.empty());
 
  if (const auto it = factory_.find(name); it != factory_.end())
  {
    while (c.size() < it->second.args)
      c.push_back(category_t(0));
 
    return it->second.make(c);
  }
 
  switch (find_domain(name))
  {
  case domain_t::d_double:
    return std::make_unique<constant<double>>(name, c[0]);
  case domain_t::d_int:
    return std::make_unique<constant<int>>(name, c[0]);
  case domain_t::d_string:
    return std::make_unique<constant<std::string>>(name, c[0]);
  default:
    return nullptr;
  }
}
 
std::unique_ptr<symbol> symbol_factory::make(domain_t d, int min, int max,
                                             category_t c)
{
  Expects(d == domain_t::d_double || d == domain_t::d_int);
 
  switch (d)
  {
  case domain_t::d_double:
    return std::make_unique<real::integer>(cvect{c}, min, max);
  case domain_t::d_int:
    return std::make_unique<integer::number>(cvect{c}, min, max);
  default:
    return nullptr;
  }
}
 
std::size_t symbol_factory::args(const std::string &name) const
{
  const auto it(factory_.find(name));
 
  return it == factory_.end() ? 1 : it->second.args;
}
 
bool symbol_factory::unregister_symbol(const std::string &name)
{
  return factory_.erase(name) == 1;
}
 
}  // namespace vita