/*!
* \brief Get reference the tree to invoke.
* \param ioContext Evolutionary context.
* \return Handle to the invoked tree.
*/
GP::Tree::Handle GP::ADF::getInvokedTree(GP::Context& ioContext) const
{
Beagle_StackTraceBeginM();
Beagle_AssertM(mIndex < ioContext.getIndividual().size());
return ioContext.getIndividual()[mIndex];
Beagle_StackTraceEndM("GP::Tree::Handle GP::ADF::getInvokedTree(GP::Context& ioContext) const");
}
/*!
* \brief Return indices of the trees that can be invoked by the ADF.
* \param outCandidates Indices of tree that can be selected as invokable in the actual context.
* \param inNumberArguments Number of arguments for which the selection is desired.
* \param ioContext Evolutionary context.
*/
void GP::ADF::getCandidatesToInvoke(std::vector<unsigned int>& outCandidates,
unsigned int inNumberArguments,
GP::Context& ioContext) const
{
Beagle_StackTraceBeginM();
outCandidates.clear();
for(unsigned int i=(ioContext.getGenotypeIndex()+1); i<ioContext.getIndividual().size(); ++i) {
GP::Tree::Handle lTree = castHandleT<GP::Tree>(ioContext.getIndividual()[i]);
const unsigned int lNbArgsTree = lTree->getNumberArguments();
if(inNumberArguments == GP::Primitive::eAny) outCandidates.push_back(i);
else if((inNumberArguments == GP::Primitive::eBranch) && (lNbArgsTree>0))
outCandidates.push_back(i);
else if(inNumberArguments == lNbArgsTree) outCandidates.push_back(i);
}
Beagle_StackTraceEndM("void GP::ADF::getCandidatesToInvoke(std::vector<unsigned int>& outCandidates, unsigned int inNumberArguments, GP::Context& ioContext) const");
}
/*!
* \brief Generate a new ADF primitive from the given specifications.
* \param inIndex Tree index for which the primitive is created.
* \param inName Name of the primitive generated.
* \param inArgsName Name of the arguments associated to the invoker created.
* \param ioContext Evolutionary context.
*/
GP::Invoker::Handle GP::ADF::generateInvoker(unsigned int inIndex,
std::string inName,
std::string inArgsName,
GP::Context& ioContext) const
{
Beagle_StackTraceBeginM();
if(inIndex == UINT_MAX) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"primitive selection","Beagle::GP::ADF::generateInvoker",
"Generated ADF with UINT_MAX"
);
return new GP::ADF(UINT_MAX, UINT_MAX, inName, inArgsName);
} else {
GP::Tree::Handle lTree = ioContext.getIndividual()[inIndex];
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"primitive selection","Beagle::GP::ADF::generateInvoker",
std::string("Generated ADF with index ")+uint2str(inIndex)+" ("+uint2str(lTree->getNumberArguments())+" args)"
);
return new GP::ADF(inIndex, lTree->getNumberArguments(), inName, inArgsName);
}
Beagle_StackTraceEndM("GP::Invoker::Handle GP::ADF::generateInvoker(unsigned int inIndex, string inName, string inArgsName, GP::Context& ioContext) const");
}
/*!
* \brief Interpret the GP individual.
* \param outResult Datum containing the result of the interpretation.
* \param ioContext GP evolutionary context.
* \throw Beagle::ObjectException When individual or tree are empty.
* \throw Beagle::AssertException When context is not correctly set.
* \throw Beagle::GP::MaxNodesExecutionException If number of nodes execution is more than allowed.
* \throw Beagle::GP::MaxTimeExecutionException If elapsed execution time is more than allowed.
*/
void GP::Individual::run(GP::Datum& outResult, GP::Context& ioContext)
{
Beagle_StackTraceBeginM();
if(&ioContext.getIndividual() != this) {
std::ostringstream lOSS;
lOSS << "In GP::Individual::run(): For the given context, ";
lOSS << "getIndividual() did not return the same individual as was passed to this (run) ";
lOSS << "method. Consider setting the context's individual to be the same by using the ";
lOSS << "method Context::setIndividualHandle().";
throw Beagle_RunTimeExceptionM(lOSS.str());
}
if(empty()) throw Beagle_ObjectExceptionM("Could not interpret, individual has no trees!");
if((*this)[0]->empty()) throw Beagle_ObjectExceptionM("Could not interpret, 1st tree is empty!");
Tree::Handle lOldTreeHandle = ioContext.getGenotypeHandle();
unsigned int lOldTreeIndex = ioContext.getGenotypeIndex();
ioContext.setGenotypeIndex(0);
ioContext.setGenotypeHandle((*this)[0]);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Running the ")+uint2ordinal(ioContext.getIndividualIndex()+1)+
std::string(" individual")
);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
std::string("The individual is: ")
);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
(*this)
);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
std::string("Executing the first tree root node '")+
(*(*this)[0])[0].mPrimitive->getName()+"'"
);
ioContext.setNodesExecutionCount(0);
ioContext.incrementNodesExecuted();
ioContext.getExecutionTimer().reset();
ioContext.pushCallStack(0);
(*(*this)[0])[0].mPrimitive->execute(outResult, ioContext);
ioContext.popCallStack();
ioContext.checkExecutionTime();
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
std::string("Result of executing the ")+uint2ordinal(ioContext.getIndividualIndex()+1)+
std::string(" individual: ")+outResult.serialize()
);
ioContext.setGenotypeIndex(lOldTreeIndex);
ioContext.setGenotypeHandle(lOldTreeHandle);
Beagle_StackTraceEndM();
}
/*!
* \brief Validate the ADF position in the tree.
* \param ioContext Evolutionary context.
* \return True if the ADF is correctly positioned, false if not.
* \throw Beagle::AssertException If the context is in a bad state.
*/
bool GP::ADF::validate(GP::Context& ioContext) const
{
Beagle_StackTraceBeginM();
if(mIndex <= ioContext.getGenotypeIndex()) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"validation","Beagle::GP::ADF::validate",
std::string("Validation failed because the ADF's index (")+uint2str(mIndex)+
") is less than or equal to the genotype index ("+uint2str(ioContext.getGenotypeIndex())+")"
);
return false;
}
if(mIndex >= ioContext.getIndividual().size()) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"validation","Beagle::GP::ADF::validate",
std::string("Validation failed because the ADF's index (")+uint2str(mIndex)+
") is greater than or equal to the individual's size ("+
uint2str(ioContext.getIndividual().size())+")"
);
return false;
}
if(ioContext.getIndividual()[mIndex]->getNumberArguments() != getNumberArguments()) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"validation","Beagle::GP::ADF::validate",
std::string("Validation failed because the number of arguments for the tree (")+
uint2str(ioContext.getIndividual()[mIndex]->getNumberArguments())+
") differed from the number of arguments for the primitive ("+
uint2str(getNumberArguments())+")"
);
return false;
}
return GP::Primitive::validate(ioContext);
Beagle_StackTraceEndM("bool GP::ADF::validate(GP::Context& ioContext) const");
}