/*!
* \brief Set the value of the named GP primitive of the primitive sets.
* \param inName Name of the variable to set.
* \param inValue Value of the primitive.
* \param ioContext Context of the evaluation.
* \throw Beagle::RunTimeException If the named primitive is not found in any sets.
*/
void GP::EvaluationOp::setValue(std::string inName,
const Object& inValue,
GP::Context& ioContext) const
{
Beagle_StackTraceBeginM();
GP::PrimitiveSuperSet::Handle lSuperSet =
castHandleT<GP::PrimitiveSuperSet>(ioContext.getSystem().getComponent("GP-PrimitiveSuperSet"));
if(lSuperSet == NULL) {
throw Beagle_RunTimeExceptionM("There should be a GP::PrimitiveSuperSet component in the system");
}
bool lValueFound = false;
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::GP::EvaluationOp",
std::string("Setting the primitives named '")+inName+
std::string("' to the value: ")+inValue.serialize()
);
for(unsigned int i=0; i<lSuperSet->size(); i++) {
Primitive::Handle lPrimitive = (*lSuperSet)[i]->getPrimitiveByName(inName);
if(!lPrimitive) continue;
lValueFound = true;
lPrimitive->setValue(inValue);
}
if(lValueFound == false) {
std::string lMessage = "The primitive named '";
lMessage += inName;
lMessage += "' was not found in any ";
lMessage += "of the primitive sets. Maybe the primitive was not properly inserted ";
lMessage += "or the name is mispelled.";
throw Beagle_RunTimeExceptionM(lMessage);
}
Beagle_StackTraceEndM("void GP::EvaluationOp::setValue(string inName, const Object& inValue, GP::Context& ioContext) const");
}
/*!
* \brief Swap mutate a constrained GP individual.
* \param ioIndividual GP individual to swap mutate.
* \param ioContext Context of the evolution.
* \return True if the individual is effectively mutated, false if not.
*/
bool GP::MutationSwapDepthSelectiveConstrainedOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)
{
Beagle_StackTraceBeginM();
GP::Individual& lIndividual = castObjectT<GP::Individual&>(ioIndividual);
GP::Context& lContext = castObjectT<GP::Context&>(ioContext);
double lDistrProba = mDistributionProba->getWrappedValue();
unsigned int lNumberAttempts = mNumberAttempts->getWrappedValue();
bool lMutationDone = false;
//Select node to mutate
unsigned int lChoosenTree = 0;
unsigned int lChoosenNode = 0;
bool lDoParameterSearch = (lContext.getSystem().getRandomizer().rollUniform(0.0, 1.0) <= mMutParameterPb->getWrappedValue());
RouletteT< std::pair<unsigned int,unsigned int> > lRoulette;
//Select primitive based on type
for(unsigned int lTry = 0; lTry < 2; ++lTry) { //Do only twice
std::vector<const std::type_info*> lDesiredTypes(1, ArgEph);
DepthDependentSelectionOp::buildRoulette(lRoulette, lDesiredTypes, lIndividual, lContext,!lDoParameterSearch,lDoParameterSearch);
if(lRoulette.size() == 0) {
if(lDoParameterSearch) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
string("No EphemeralDouble node found.")
);
}
else {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
string("No non EphemeralDouble node found.")
);
}
lDoParameterSearch = !lDoParameterSearch;
if(lTry >= 1) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
"Unable to GP standard mutate the individual"
);
return false;
}
}
else {
std::pair<unsigned int,unsigned int> lSelectedNode = lRoulette.select(ioContext.getSystem().getRandomizer());
lChoosenTree = lSelectedNode.first;
lChoosenNode = lSelectedNode.second;
break;
}
}
if(lDoParameterSearch) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
string("Mutation applied only on EphemeralDouble node.")
);
}
else {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
string("Mutation applied on node that are not EphemeralDouble.")
);
}
GP::Tree& lTree = *lIndividual[lChoosenTree];
if(lTree.size() == 0) return false;
GP::Tree::Handle lOldTreeHandle = lContext.getGenotypeHandle();
unsigned int lOldTreeIndex = lContext.getGenotypeIndex();
lContext.setGenotypeHandle(lIndividual[lChoosenTree]);
lContext.setGenotypeIndex(lChoosenTree);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
std::string("Individual before constrained GP tree swap mutation: ")+ioIndividual.serialize()
);
if(lTree.size() > 1) {
bool lTypeNode = (lContext.getSystem().getRandomizer().rollUniform(0., 1.) < lDistrProba);
//Clean the roulette to include only the choosen tree
for(std::vector< std::pair<double, std::pair<unsigned int,unsigned int> > >::iterator lRouletteIter = lRoulette.begin(); lRouletteIter!=lRoulette.end();){
if(lRouletteIter->second.first != lChoosenTree || (lTree[lRouletteIter->second.second].mPrimitive->getNumberArguments() != 0) != lTypeNode ) {
lRouletteIter = lRoulette.erase(lRouletteIter++);
} else {
++lRouletteIter;
}
}
if(lRoulette.size() > 0)
lChoosenNode = lRoulette.select(ioContext.getSystem().getRandomizer()).second;
}
if( !lDoParameterSearch || lRoulette.size() > 0 ) {
Primitive::Handle lOriginalPrimitive = lTree[lChoosenNode].mPrimitive;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
std::string("Trying to constrained GP tree swap mutate the ")+uint2ordinal(lChoosenNode+1)+
std::string(" node (primitive: \"")+lOriginalPrimitive->getName()+
std::string("\" nb args: ")+uint2str(lOriginalPrimitive->getNumberArguments())+
std::string(") of the ")+uint2ordinal(lChoosenTree+1)+std::string(" tree")
);
GP::PrimitiveSet& lPrimitiveSet = lTree.getPrimitiveSet(lContext);
unsigned int lNbArgsPrimit = lTree[lChoosenNode].mPrimitive->getNumberArguments();
lTree.setContextToNode(lChoosenNode, lContext);
for(unsigned int lAttempt=0; lAttempt < lNumberAttempts; ++lAttempt) {
Primitive::Handle lChoosenPrimitive = lPrimitiveSet.select(lNbArgsPrimit, lContext);
if(lChoosenPrimitive==NULL) break;
lTree[lChoosenNode].mPrimitive = lChoosenPrimitive->giveReference(lNbArgsPrimit, lContext);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
std::string("Trying the primitive \"")+lChoosenPrimitive->getName()+
std::string("\"")
);
if(lTree.validateSubTree(lChoosenNode, lContext)) {
lMutationDone = true;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
"Constrained GP tree swap mutation valid"
);
break;
}
else {
lTree[lChoosenNode].mPrimitive = lOriginalPrimitive;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
"Constrained GP tree swap mutation invalid"
);
}
}
}
lContext.setGenotypeHandle(lOldTreeHandle);
lContext.setGenotypeIndex(lOldTreeIndex);
if(lMutationDone) {
if( !lDoParameterSearch ) {
//Set structure id invalid
castHandleT<TreeSTag>((lIndividual)[0])->setStructureIDInvalid();
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
std::string("Set structure id invalid") );
}
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
std::string("Individual after constrained GP swap mutation: ")+
ioIndividual.serialize()
);
}
else {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapDepthSelectiveConstrainedOp",
"Unable to swap mutate the constrained individual"
);
}
return lMutationDone;
Beagle_StackTraceEndM("bool GP::MutationSwapDepthSelectiveConstrainedOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)");
}
/*!
* \brief Swap mutate a GP individual.
* \param ioIndividual GP individual to swap mutate.
* \param ioContext Context of the evolution.
* \return True if the individual is effectively mutated, false if not.
*/
bool GP::MutationSwapOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)
{
Beagle_StackTraceBeginM();
GP::Individual& lIndividual = castObjectT<GP::Individual&>(ioIndividual);
GP::Context& lContext = castObjectT<GP::Context&>(ioContext);
double lDistrProba = mDistributionProba->getWrappedValue();
// Store original values.
GP::Tree::Handle lOldTreeHandle = lContext.getGenotypeHandle();
unsigned int lOldTreeIndex = lContext.getGenotypeIndex();
// Select the tree to mutate
unsigned int lNbNodes = 0;
for(unsigned int i=0; i<lIndividual.size(); i++) lNbNodes += lIndividual[i]->size();
if(lNbNodes == 0) return false;
unsigned int lChosenNode = lContext.getSystem().getRandomizer().rollInteger(0, lNbNodes-1);
unsigned int lChosenTree = 0;
for(; (lChosenTree+1)<lIndividual.size(); lChosenTree++) {
if(lChosenNode < lIndividual[lChosenTree]->size()) break;
else lChosenNode -= lIndividual[lChosenTree]->size();
}
GP::Tree& lTree = *lIndividual[lChosenTree];
if(lTree.size() == 0) return false;
// Store the new values
lContext.setGenotypeHandle(lIndividual[lChosenTree]);
lContext.setGenotypeIndex(lChosenTree);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapOp",
"Individual before GP swap mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapOp",
ioIndividual
);
// Choose the node to mutate.
if(lTree.size() > 1) {
bool lTypeNode = (lContext.getSystem().getRandomizer().rollUniform(0., 1.) < lDistrProba);
while((lTree[lChosenNode].mPrimitive->getNumberArguments() != 0) != lTypeNode) {
lChosenNode = lContext.getSystem().getRandomizer().rollInteger(0, lTree.size()-1);
}
}
Primitive::Handle lOriginalPrimitive = lTree[lChosenNode].mPrimitive;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapOp",
std::string("Swap mutating the ")+uint2ordinal(lChosenNode+1)+
std::string(" node (primitive: '")+lOriginalPrimitive->getName()+
std::string("' nb args: ")+uint2str(lOriginalPrimitive->getNumberArguments())+
std::string(") of the ")+uint2ordinal(lChosenTree+1)+std::string(" tree")
);
GP::PrimitiveSet& lPrimitiveSet = lTree.getPrimitiveSet(lContext);
unsigned int lNbArgsPrimit = lTree[lChosenNode].mPrimitive->getNumberArguments();
// Select primitive to replace choosen one.
Primitive::Handle lChosenPrimitive = lPrimitiveSet.select(lNbArgsPrimit, lContext);
if (lChosenPrimitive==NULL) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapOp",
std::string("Swap mutation failed because no primitive could be found that had ")+
uint2str(lNbArgsPrimit)+std::string(" arguments")
);
return false;
} else {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapOp",
std::string("Swap mutation chose primitive '")+lChosenPrimitive->getName()+std::string("'")
);
}
// Replace choose primitive.
lTree[lChosenNode].mPrimitive = lChosenPrimitive->giveReference(lNbArgsPrimit, lContext);
// Restore the original values.
lContext.setGenotypeHandle(lOldTreeHandle);
lContext.setGenotypeIndex(lOldTreeIndex);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapOp",
"Individual after GP swap mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapOp",
ioIndividual
);
return true;
Beagle_StackTraceEndM("bool GP::MutationSwapOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)");
}
/*!
* \brief Insert mutate a GP individual.
* \param ioIndividual GP individual to mutate.
* \param ioContext Context of the evolution.
* \return True if the individual is effectively mutated, false if not.
*/
bool GP::MutationInsertConstrainedOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)
{
Beagle_StackTraceBeginM();
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Mutating individual with GP::MutationInsertConstrainedOp")
);
GP::Individual& lIndividual = castObjectT<GP::Individual&>(ioIndividual);
GP::Context& lContext = castObjectT<GP::Context&>(ioContext);
const unsigned int lMaxAttempts = mNumberAttempts->getWrappedValue();
const unsigned int lMaxTreeDepth = mMaxTreeDepth->getWrappedValue();
const Factory& lFactory = ioContext.getSystem().getFactory();
GP::Tree::Alloc::Handle lTreeAlloc =
castHandleT<GP::Tree::Alloc>(lFactory.getConceptAllocator("Genotype"));
// Store original context values
const unsigned int lOldGenotypeIndex = lContext.getGenotypeIndex();
const GP::Tree::Handle lOldGenotypeHandle = lContext.getGenotypeHandle();
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
"Individual before constrained GP insert mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
ioIndividual
);
// Mutation attempts loop
for(unsigned int i=0; i<lMaxAttempts; ++i) {
// Choose tree and node to mutate
const unsigned int lChosenTree = lIndividual.chooseRandomTree(lContext);
const unsigned int lChosenNodeIndex = lIndividual.chooseRandomNode(lChosenTree, lContext);
GP::Tree::Handle lOriginalTree = lIndividual[lChosenTree];
// Compute depth of tree generated by mutation
lContext.setGenotypeIndex(lChosenTree);
lContext.setGenotypeHandle(lOriginalTree);
lContext.emptyCallStack();
lOriginalTree->setContextToNode(lChosenNodeIndex, lContext);
const unsigned int lMutationDepth =
lContext.getCallStackSize() + lOriginalTree->getTreeDepth(lChosenNodeIndex);
// Check that mutation will not generate a tree deeper than the maximum allowed depth
if(lMutationDepth > lMaxTreeDepth) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Constrained insert mutation attempt failed as the generated tree will exceed ")+
std::string("maximum allowed tree depth")
);
continue;
}
// Create new tree
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Creating new tree")
);
GP::Tree::Handle lNewTree = castHandleT<GP::Tree>(lTreeAlloc->allocate());
lNewTree->setPrimitiveSetIndex(lOriginalTree->getPrimitiveSetIndex());
lNewTree->setNumberArguments(lOriginalTree->getNumberArguments());
// Replace original tree with new tree
lIndividual[lChosenTree] = lNewTree;
lContext.setGenotypeHandle(lNewTree);
// Copy unchanged part of original tree into new tree
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Copying unchanged part of original tree to new tree")
);
lNewTree->insert(lNewTree->end(),
lOriginalTree->begin(),
lOriginalTree->begin()+lChosenNodeIndex);
Beagle_AssertM(lNewTree->size() == lChosenNodeIndex);
// Generate new branch primitive to insert.
GP::PrimitiveSet& lPrimitiveSet = lNewTree->getPrimitiveSet(lContext);
Primitive::Handle lBranchInserted = lPrimitiveSet.select(GP::Primitive::eBranch, lContext);
if(lBranchInserted==NULL) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Constrained insert mutation attempt failed as it seems impossible ")+
std::string("to select a branch primitive in the actual context")
);
lIndividual[lChosenTree] = lOriginalTree;
lContext.setGenotypeHandle(lOriginalTree);
continue;
}
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Branch primitive to be inserted by mutation is primitive '")+
lBranchInserted->getName()+std::string("'")
);
// Insert new branch
lBranchInserted = lBranchInserted->giveReference(GP::Primitive::eBranch, lContext);
lNewTree->push_back(Node(lBranchInserted,1));
if(lBranchInserted->validate(lContext) == false) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Constrained insert mutation attempt failed as the selected ")+
std::string("branch doesn't match the constraints")
);
lIndividual[lChosenTree] = lOriginalTree;
lContext.setGenotypeHandle(lOriginalTree);
continue;
}
const unsigned int lNbArgsInsertedBranch = lBranchInserted->getNumberArguments();
Beagle_AssertM(lNbArgsInsertedBranch != 0);
const unsigned int lSubtreeArgIndex =
lContext.getSystem().getRandomizer().rollInteger(0, lNbArgsInsertedBranch-1);
Beagle_AssertM(lSubtreeArgIndex < lNbArgsInsertedBranch);
const unsigned int lSubtreeSize = (*lOriginalTree)[lChosenNodeIndex].mSubTreeSize;
// Generate inserted node subtrees
bool lArgsGenFailed = false;
for(unsigned int j=0; j<lNbArgsInsertedBranch; ++j) {
if(j == lSubtreeArgIndex) {
const unsigned int lSubtreeIndex = lNewTree->size();
lNewTree->insert(lNewTree->end(),
lOriginalTree->begin()+lChosenNodeIndex,
lOriginalTree->begin()+lChosenNodeIndex+lSubtreeSize);
lContext.pushCallStack(lSubtreeIndex);
if(lNewTree->validateSubTree(lSubtreeIndex, lContext) == false) {
lArgsGenFailed = true;
break;
}
lContext.popCallStack();
(*lNewTree)[lChosenNodeIndex].mSubTreeSize += lSubtreeSize;
} else {
Primitive::Handle lArgInserted = lPrimitiveSet.select(GP::Primitive::eTerminal, lContext);
if(lArgInserted == NULL) {
lArgsGenFailed = true;
break;
}
lArgInserted = lArgInserted->giveReference(GP::Primitive::eTerminal, lContext);
const unsigned int lSubtreeIndex = lNewTree->size();
lNewTree->push_back(Node(lArgInserted,1));
lContext.pushCallStack(lSubtreeIndex);
if(lArgInserted->validate(lContext) == false) {
lArgsGenFailed = true;
break;
}
lContext.popCallStack();
++(*lNewTree)[lChosenNodeIndex].mSubTreeSize;
}
}
if(lArgsGenFailed) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Constrained insert mutation attempt failed as it seems impossible ")+
std::string("to select a terminal primitive under the inserted branch in the actual context")
);
lIndividual[lChosenTree] = lOriginalTree;
lContext.setGenotypeHandle(lOriginalTree);
continue;
}
// Complete new tree with rest of original tree
Beagle_AssertM(lOriginalTree->size() >= (lChosenNodeIndex+lSubtreeSize));
lNewTree->insert(lNewTree->end(),
lOriginalTree->begin()+lChosenNodeIndex+lSubtreeSize,
lOriginalTree->end());
Beagle_AssertM(lNewTree->size() == (lOriginalTree->size()+lNbArgsInsertedBranch));
// Correct subtree size data and terminate mutation process
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("Correcting the 'mSubTreeSize' fields of tree")
);
lContext.popCallStack();
for(unsigned int j=0; j<lContext.getCallStackSize(); ++j) {
(*lNewTree)[lContext[j]].mSubTreeSize += lNbArgsInsertedBranch;
}
// Mutation successful, log messages and return
std::ostringstream lOSS;
lOSS << "Successfully inserted a new node at index " << lChosenNodeIndex;
lOSS << " of the " << uint2ordinal(lChosenTree) << " tree of the actual individual";
Beagle_LogTraceM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationInsertConstrainedOp",
lOSS.str()
);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationInsertConstrainedOp",
"Individual after constrained GP insert mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationInsertConstrainedOp",
ioIndividual
);
lContext.emptyCallStack();
lContext.setGenotypeIndex(lOldGenotypeIndex);
lContext.setGenotypeHandle(lOldGenotypeHandle);
return true;
}
// Insert mutation failed, return without mutating the individual
lContext.emptyCallStack();
lContext.setGenotypeIndex(lOldGenotypeIndex);
lContext.setGenotypeHandle(lOldGenotypeHandle);
Beagle_LogTraceM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationInsertConstrainedOp",
std::string("All constrained insert mutation attempts failed; ")+
std::string("resuming from mutation without modifying the individual")
);
return false;
Beagle_StackTraceEndM("bool GP::MutationInsertConstrainedOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)");
}
/*!
* \brief Swap mutate a constrained GP individual.
* \param ioIndividual GP individual to swap mutate.
* \param ioContext Context of the evolution.
* \return True if the individual is effectively mutated, false if not.
*/
bool GP::MutationSwapConstrainedOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)
{
Beagle_StackTraceBeginM();
GP::Individual& lIndividual = castObjectT<GP::Individual&>(ioIndividual);
GP::Context& lContext = castObjectT<GP::Context&>(ioContext);
double lDistrProba = mDistributionProba->getWrappedValue();
unsigned int lNumberAttempts = mNumberAttempts->getWrappedValue();
bool lMutationDone = false;
unsigned int lNbNodes = 0;
for(unsigned int i=0; i<lIndividual.size(); i++) lNbNodes += lIndividual[i]->size();
if(lNbNodes == 0) return false;
unsigned int lChoosenNode = lContext.getSystem().getRandomizer().rollInteger(0, lNbNodes-1);
unsigned int lChoosenTree = 0;
for(; (lChoosenTree+1)<lIndividual.size(); lChoosenTree++) {
if(lChoosenNode < lIndividual[lChoosenTree]->size()) break;
else lChoosenNode -= lIndividual[lChoosenTree]->size();
}
GP::Tree& lTree = *lIndividual[lChoosenTree];
if(lTree.size() == 0) return false;
GP::Tree::Handle lOldTreeHandle = lContext.getGenotypeHandle();
unsigned int lOldTreeIndex = lContext.getGenotypeIndex();
lContext.setGenotypeHandle(lIndividual[lChoosenTree]);
lContext.setGenotypeIndex(lChoosenTree);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapConstrainedOp",
"Individual before constrained GP tree swap mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapConstrainedOp",
ioIndividual
);
if(lTree.size() > 1) {
bool lTypeNode = (lContext.getSystem().getRandomizer().rollUniform(0., 1.) < lDistrProba);
while((lTree[lChoosenNode].mPrimitive->getNumberArguments() != 0) != lTypeNode) {
lChoosenNode = lContext.getSystem().getRandomizer().rollInteger(0, lTree.size()-1);
}
}
Primitive::Handle lOriginalPrimitive = lTree[lChoosenNode].mPrimitive;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapConstrainedOp",
std::string("Trying to constrained GP tree swap mutate the ")+uint2ordinal(lChoosenNode+1)+
std::string(" node (primitive: '")+lOriginalPrimitive->getName()+
std::string("' nb args: ")+uint2str(lOriginalPrimitive->getNumberArguments())+
std::string(") of the ")+uint2ordinal(lChoosenTree+1)+std::string(" tree")
);
GP::PrimitiveSet& lPrimitiveSet = lTree.getPrimitiveSet(lContext);
unsigned int lNbArgsPrimit = lTree[lChoosenNode].mPrimitive->getNumberArguments();
lTree.setContextToNode(lChoosenNode, lContext);
for(unsigned int lAttempt=0; lAttempt < lNumberAttempts; ++lAttempt) {
Primitive::Handle lChoosenPrimitive = lPrimitiveSet.select(lNbArgsPrimit, lContext);
if(lChoosenPrimitive==NULL) break;
lTree[lChoosenNode].mPrimitive = lChoosenPrimitive->giveReference(lNbArgsPrimit, lContext);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapConstrainedOp",
std::string("Trying the primitive '")+lChoosenPrimitive->getName()+
std::string("'")
);
if(lTree.validateSubTree(lChoosenNode, lContext)) {
lMutationDone = true;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapConstrainedOp",
"Constrained GP tree swap mutation valid"
);
break;
} else {
lTree[lChoosenNode].mPrimitive = lOriginalPrimitive;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationSwapConstrainedOp",
"Constrained GP tree swap mutation invalid"
);
}
}
lContext.setGenotypeHandle(lOldTreeHandle);
lContext.setGenotypeIndex(lOldTreeIndex);
if(lMutationDone) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapConstrainedOp",
"Individual after constrained GP swap mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapConstrainedOp",
ioIndividual
);
} else {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationSwapConstrainedOp",
"Unable to swap mutate the constrained individual"
);
}
return lMutationDone;
Beagle_StackTraceEndM("bool GP::MutationSwapConstrainedOp::mutate(Beagle::Individual& ioIndividual, Beagle::Context& ioContext)");
}
