PrimitiveSet.cpp

#include "../ECF_base.h"
#include "Tree.h"
 
 
namespace Tree
{
 
PrimitiveSet::PrimitiveSet()
{   }
 
 
PrimitiveSet::~PrimitiveSet()
{   }
 
 
bool PrimitiveSet::initialize(StateP state)
{
    state_ = state;
 
    // register existing primitives
    PrimitiveP prim = (PrimitiveP) (new Primitives::Add);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Sub);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Mul);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Div);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Sin);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Cos);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Pos);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Neg);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Max);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP) (new Primitives::Min);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP)(new Primitives::Sqrt);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP)(new Primitives::Log);
    mAllPrimitives_[prim->getName()] = prim;
    prim = (PrimitiveP)(new Primitives::Avg);
    mAllPrimitives_[prim->getName()] = prim;
 
    prim_iter primIter;
    for(primIter = mAllPrimitives_.begin(); primIter != mAllPrimitives_.end(); ++primIter)
        primIter->second->initialize(state);
    
    // register terminal types
    mTypeNames_.insert(std::pair<std::string, Primitives::terminal_type>("DOUBLE", Primitives::Double));
    mTypeNames_.insert(std::pair<std::string, Primitives::terminal_type>("INT", Primitives::Int));
    mTypeNames_.insert(std::pair<std::string, Primitives::terminal_type>("BOOL", Primitives::Bool));
    mTypeNames_.insert(std::pair<std::string, Primitives::terminal_type>("CHAR", Primitives::Char));
    mTypeNames_.insert(std::pair<std::string, Primitives::terminal_type>("STRING", Primitives::String));
 
    return true;
}
 

PrimitiveP PrimitiveSet::getRandomFunction()
{
    return functionSet_[state_->getRandomizer()->getRandomInteger((int) functionSet_.size())];
}
 

PrimitiveP PrimitiveSet::getRandomTerminal()
{
    return terminalSet_[state_->getRandomizer()->getRandomInteger((int) terminalSet_.size())];
}
 

PrimitiveP PrimitiveSet::getRandomPrimitive()
{
    return primitives_[state_->getRandomizer()->getRandomInteger((int) primitives_.size())];
}
 

PrimitiveP PrimitiveSet::getFunctionByName(std::string name)
{
    prim_iter iter = mFunctionSet_.find(name);
    if(iter == mFunctionSet_.end())
        return PrimitiveP();
 
    return iter->second;
}
 

PrimitiveP PrimitiveSet::getTerminalByName(std::string name)
{
    prim_iter iter = mTerminalSet_.find(name);
    if(iter == mTerminalSet_.end())
        return PrimitiveP();
 
    return iter->second;
}
 

PrimitiveP PrimitiveSet::getPrimitiveByName(std::string name)
{
    prim_iter iter = mPrimitiveSet_.find(name);
    if(iter == mPrimitiveSet_.end())
        return PrimitiveP();
 
    return iter->second;
}
 
 
//void PrimitiveSet::addFunction(PrimitiveP functionPrimitive)
//{
//  if(functionPrimitive->getNumberOfArguments() == 0) {
//      terminalSet_.push_back(functionPrimitive);
//      mTerminalSet_[functionPrimitive->getName()] = functionPrimitive;
//  }
//  else {
//      functionSet_.push_back(functionPrimitive);
//      mFunctionSet_[functionPrimitive->getName()] = functionPrimitive;
//  }
//
//  primitives_.push_back(functionPrimitive);
//  mPrimitives_[functionPrimitive->getName()] = functionPrimitive;
//}
 

bool PrimitiveSet::addFunction(std::string name)
{
    prim_iter iter = mAllPrimitives_.find(name);
    if(iter == mAllPrimitives_.end())
        return false;
 
    if(iter->second->getNumberOfArguments() == 0) {
        terminalSet_.push_back(iter->second);
        mTerminalSet_[iter->first] = iter->second;
    }
    else {
        functionSet_.push_back(iter->second);
        mFunctionSet_[iter->first] = iter->second;
    }
 
    primitives_.push_back(iter->second);
    mPrimitiveSet_[iter->first] = iter->second;
 
    return true;
}
 

void PrimitiveSet::addTerminal(PrimitiveP terminalPrimitive)
{
    terminalSet_.push_back(terminalPrimitive);
    mTerminalSet_[terminalPrimitive->getName()] = terminalPrimitive;
 
    primitives_.push_back(terminalPrimitive);
    mPrimitiveSet_[terminalPrimitive->getName()] = terminalPrimitive;
}
 

uint PrimitiveSet::getFunctionSetSize()
{
    return (uint) functionSet_.size();
}
 

uint PrimitiveSet::getTerminalSetSize()
{
    return (uint) terminalSet_.size();
}
 

uint PrimitiveSet::getPrimitivesSize()
{
    return (uint) primitives_.size();
}
 
}