void TreeSTag::readWithContext(PACC::XML::ConstIterator inIter, Beagle::Context& ioContext){
Beagle_StackTraceBeginM();
GP::Context& lGPContext = castObjectT<GP::Context&>(ioContext);
if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!="Genotype"))
throw Beagle_IOExceptionNodeM(*inIter, "tag <Genotype> expected!");
std::string lType = inIter->getAttribute("type").c_str();
if(lType.empty())
throw Beagle_IOExceptionNodeM(*inIter, "GP tree type of the genotype is not present!");
if(lType != "gptreetag")
throw Beagle_IOExceptionNodeM(*inIter, std::string("type of genotype mismatch, expected ")
+std::string("\"gptreetag\" but read \"")+lType+std::string("\" instead!"));
//Get structure id
std::string lStructureID = inIter->getAttribute("structureid").c_str();
mStructureID = str2uint(lStructureID);
// Get primitive set index
std::string lPrimitiveSetIndexText = inIter->getAttribute("primitiveSetIndex").c_str();
if(lPrimitiveSetIndexText.empty()) {
// No primitive set index was specified. This must be an old
// tree. Assume index is equal to tree's index
unsigned int lGenotypeIndex = ioContext.getGenotypeIndex();
if(lGenotypeIndex >= lGPContext.getSystem().getPrimitiveSuperSet().size()) {
throw Beagle_RunTimeExceptionM(std::string("In GP::Tree::readWithContext(): The ")+
std::string("'primitiveSetIndex' attribute was missing from an individual's genotype. ")+
std::string("It would normally be assumed that such a tree was to be mapped to the ")+
std::string("primitive set of the same index as the genotype. In this case that would ")+
std::string("result in an incorrect mapping because there are not enough primitive sets ")+
std::string("in the System. Perhaps this individual was not intended to be read with the ")+
std::string("current set of primitive sets?"));
}
setPrimitiveSetIndex(lGenotypeIndex);
}
else {
// primitiveSetIndex is a valid attribute.
unsigned int lPrimitiveSetIndex = str2uint(lPrimitiveSetIndexText);
if(lPrimitiveSetIndex >= lGPContext.getSystem().getPrimitiveSuperSet().size()) {
std::string lMessage = std::string("In GP::Tree::readWithContext(): The 'primitiveSetIndex' ")+
std::string("attribute contained the value '") + lPrimitiveSetIndexText +
std::string("' which was read as the number '") + uint2str(lPrimitiveSetIndex) +
std::string("'. This value is incorrect as there are not enough primitive sets in the ")+
std::string("System. Perhaps this individual was not intended to be read with the current ")+
std::string("set of primitive sets?");
throw Beagle_RunTimeExceptionM(lMessage);
}
setPrimitiveSetIndex(lPrimitiveSetIndex);
}
// Get numberArguments attribute
std::string lNumberArgumentsText = inIter->getAttribute("numberArguments").c_str();
if(lNumberArgumentsText.empty()) {
// numberArguments attribute wasn't defined. This must be an old
// tree. Assume the number of arguments is zero.
setNumberArguments(0);
}
else {
// numberArguments is a valid attribute.
setNumberArguments(str2uint(lNumberArgumentsText));
}
// Get size attribute and reserve size accordingly
std::string lSizeText = inIter->getAttribute("size").c_str();
if(lSizeText.empty()==false) reserve(str2uint(lSizeText));
PACC::XML::ConstIterator lChild = inIter->getFirstChild();
if((!lChild) || (lChild->getType()!=PACC::XML::eData))
throw Beagle_IOExceptionNodeM(*lChild, "expected a XML tag for the GP tree!");
clear();
readSubTree(lChild, lGPContext);
//Read BondGraph if any
const PACC::XML::Node* lParent = inIter->getParent();
PACC::XML::ConstFinder lIndivFinder = PACC::XML::ConstIterator(lParent);
PACC::XML::ConstIterator lBGTag = lIndivFinder.find("//BondGraph");
if(!lBGTag) {
return;
}
// mBondGraph = new GrowingHybridBondGraph;
// mBondGraph->read(lBGTag);
Beagle_StackTraceEndM("void GP::Tree::readWithContext(PACC::XML::ConstIterator inIter, Beagle::Context& ioContext)");
}
bool Beagle::GP::MutationEphemeralOpT<T>::mutate(Beagle::Individual& ioIndividual,
Beagle::Context& ioContext)
{
Beagle_StackTraceBeginM();
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationEphemeralOpT",
std::string("Mutating ")+uint2ordinal(ioContext.getGenotypeIndex()+1)+
std::string(" individual with GP::MutationEphemeralOpT")
);
GP::Individual& lIndividual = castObjectT<GP::Individual&>(ioIndividual);
GP::Context& lContext = castObjectT<GP::Context&>(ioContext);
// Get index of potential primitives with parameters that can be selected for mutation.
std::vector< std::pair<unsigned int,unsigned int> > lPotentialParam;
for(unsigned int i=0; i<lIndividual.size(); ++i) {
GP::Tree& lTree = *lIndividual[i];
for(unsigned int j=0; j<lTree.size(); ++j) {
if(lTree[j].mPrimitive->getName() == *mEphemeralName) {
lPotentialParam.push_back(std::make_pair(i,j));
}
}
}
// Return if there is not potential parameters.
if(lPotentialParam.empty()) return false;
// Mutating a primitive
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationEphemeralOpT",
"Individual before GP parameters mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationEphemeralOpT",
ioIndividual
);
// Store original context values
unsigned int lOldGenotypeIndex = lContext.getGenotypeIndex();
GP::Tree::Handle lOldGenotypeHandle = lContext.getGenotypeHandle();
// Get reference to primitive to mutate and other objects.
const unsigned int lSelectedParam =
lContext.getSystem().getRandomizer().rollInteger(0,lPotentialParam.size()-1);
GP::Tree::Handle lSelectedTree = lIndividual[lPotentialParam[lSelectedParam].first];
lContext.setGenotypeIndex(lPotentialParam[lSelectedParam].first);
lContext.setGenotypeHandle(lSelectedTree);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationEphemeralOpT",
std::string("Mutating the parameter of the ")+
uint2ordinal(lPotentialParam[lSelectedParam].second+1)+
std::string(" node in the ")+uint2ordinal(lPotentialParam[lSelectedParam].first+1)+
std::string(" tree")
);
// Mutate parameter value.
GP::Primitive::Handle lSelectedPrimit =
(*lSelectedTree)[lPotentialParam[lSelectedParam].second].mPrimitive;
typename GP::EphemeralT<T>::Handle lSelectedEphemeral =
castHandleT<typename GP::EphemeralT<T> >(lSelectedPrimit);
GP::Primitive::Handle lGeneratedPrimit =
lSelectedEphemeral->generate(mEphemeralName->getWrappedValue(), lContext);
(*lSelectedTree)[lPotentialParam[lSelectedParam].second].mPrimitive = lGeneratedPrimit;
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"mutation", "Beagle::GP::MutationEphemeralOpT",
std::string("Changing the ephemeral from ")+lSelectedPrimit->serialize()+
std::string(" to ")+lGeneratedPrimit->serialize()
);
// Restore original context values
lContext.setGenotypeIndex(lOldGenotypeIndex);
lContext.setGenotypeHandle(lOldGenotypeHandle);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationEphemeralOpT",
"Individual after GP parameters mutation"
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"mutation",
"Beagle::GP::MutationEphemeralOpT",
ioIndividual
);
return true;
Beagle_StackTraceEndM("bool GP::MutationEphemeralOpT<T>::mutate(Individual& ioIndividual, Context& ioContext)");
}