GPTreeNode* GPTreeADFPoint::xmlPrint() const
{
if (NULL == mFunc)
{
std::ostringstream out;
out << mInputPos;
return new GPTreeNode(GPStrings::GPTreeADF_INPUTS, out.str());
}
GPTreeNode* root = new GPTreeNode(GPStrings::GPTreeADF_FUNCTION, mFunc->name);
GPPtr<GPTreeNode> status = new GPTreeNode(GPStrings::GPTreeADF_STATUS, "");
root->addChild(status);
for (int j=0; j<mStatus.size(); ++j)
{
const IStatusType* s = mStatus[j]->type();
std::ostringstream values;
mStatus[j]->print(values);
status->addChild(s->name(), values.str());
}
GPPtr<GPTreeNode> children = new GPTreeNode(GPStrings::GPTreeADF_CHILDREN, "");
root->addChild(children);
GPASSERT(mChildren.size() == mFunc->inputType.size());
for (int i=0; i<mChildren.size(); ++i)
{
GPTreeADFPoint* p = (GPTreeADFPoint*)(mChildren[i]);
children->addChild(p->xmlPrint());
}
return root;
}
void GPTreeADFPoint::getinput(std::vector<const IStatusType*>& tlist) const
{
tlist.insert(tlist.end(), (mFunc.inputs).begin(), (mFunc.inputs).end());
for (int i=0; i<mChildren.size(); ++i)
{
GPTreeADFPoint* p = (GPTreeADFPoint*)mChildren[i];
p->getinput(tlist);
}
}
GPContents* GPTreeADFPoint::compute(GPContents* input, int& cur)
{
GPContents outsideinputs;
GPASSERT(input->size()>=(mFunc.inputs).size());
for (int i=0; i<(mFunc.inputs).size(); ++i)
{
outsideinputs.push(input->contents[cur++]);
}
GPContents childreninputs;
//Get Inputs from childern point
for (int i=0; i<mChildren.size(); ++i)
{
GPTreeADFPoint* p = (GPTreeADFPoint*)(mChildren[i]);
GPASSERT(NULL!=p);
GPContents* out = p->compute(input, cur);
const auto& output_unit = out->contents;
for (int j=0; j<output_unit.size(); ++j)
{
childreninputs.push(output_unit[j]);
}
delete out;
}
/*For function that don't know inputType, just copy all contents to totalInputs*/
GPContents totalInputs;
/*Merge outsideinputs and childreninputs*/
int children_cur = 0;
int outside_cur = 0;
for (int i=0; i<mFunc.useChildrenInput.size(); ++i)
{
if (mFunc.useChildrenInput[i]>0)
{
totalInputs.push(childreninputs.contents[children_cur++]);
}
else
{
totalInputs.push(outsideinputs.contents[outside_cur++]);
}
}
GPASSERT(outside_cur == outsideinputs.size());
GPASSERT(children_cur == childreninputs.size());
//Get status
for (int i=0; i<mStatus.size(); ++i)
{
totalInputs.push(mStatus[i]->content(), mStatus[i]->type());
}
GPContents* result;
{
#ifdef DEBUG_TIMES
GP_Clock c(__LINE__, (mFunc->name).c_str());
#endif
result = mFunc.basic->basic(&totalInputs);
}
//Free All children' memory
childreninputs.clear();
return result;
}
int GPTreeADF::vMapStructure(GPParameter* para, bool& changed)
{
const int number = 3;
changed = false;
if (NULL == para)
{
return number;
}
GPASSERT(para->size() == number);
/*Replace*/
if (para->get(0) > mProducer->getLargetVary())
{
return number;
}
changed = true;
float pos = para->get(1);
GPTreeADFPoint* p = find(pos);
const vector<const IStatusType*> outputs = p->func()->outputType;
//TODO If outputs is empty, Use function name to vary
if (!outputs.empty())
{
vector<const IStatusType*> inputs;
p->pGetInputs(inputs);
vector<vector<GPTreeADFPoint*> > queue;
mProducer->searchAllSequences(queue, outputs, inputs);
GPASSERT(!queue.empty());
size_t n = para->get(2)*queue.size();
if (n >= queue.size())
{
n = queue.size()-1;
}
auto q = queue[n];
GPASSERT(1 == q.size());
if (p != mRoot)
{
mRoot->replace(p, q[0]);
}
else
{
mRoot->decRef();
mRoot = q[0];
q[0]->addRef();
}
for (auto que : queue)
{
for (auto _q : que)
{
_q->decRef();
}
}
_refreshInputsAndOutputs();
}
return number;
}
GPTreeADFPoint* GPTreeADFPoint::xmlLoad(const GPTreeNode* node, const GPFunctionDataBase* base)
{
GPASSERT(NULL!=node);
GPTreeADFPoint* res = NULL;
if (node->name() == GPStrings::GPTreeADF_FUNCTION)
{
res = new GPTreeADFPoint(base->vQueryFunction(node->attr()), -1);
for (auto c : node->getChildren())
{
if (c->name() == GPStrings::GPTreeADF_STATUS)
{
std::vector<istream*> streams;
for (auto cc : c->getChildren())
{
std::istringstream* is = new std::istringstream(cc->attr());
streams.push_back(is);
}
res->initStatus(streams);
for (auto is : streams)
{
delete is;
}
}
else if (c->name() == GPStrings::GPTreeADF_CHILDREN)
{
for (auto cc : c->getChildren())
{
res->addPoint(xmlLoad(cc.get(), base));
}
}
}
}
else if (node->name() == GPStrings::GPTreeADF_INPUTS)
{
int inputpos = -1;
std::istringstream is(node->attr());
is >> inputpos;
res = new GPTreeADFPoint(NULL, inputpos);
}
GPTreeNode* GPTreeADFPoint::xmlPrint() const
{
GPTreeNode* root = new GPTreeNode(GPStrings::GPTreeADF_FUNCTION, mFunc.basic->name);
GPPtr<GPTreeNode> status = new GPTreeNode(GPStrings::GPTreeADF_STATUS, "");
root->addChild(status);
for (int j=0; j<mStatus.size(); ++j)
{
const IStatusType* s = mStatus[j]->type();
std::ostringstream values;
mStatus[j]->print(values);
status->addChild(s->name(), values.str());
}
GPPtr<GPTreeNode> children = new GPTreeNode(GPStrings::GPTreeADF_CHILDREN, "");
root->addChild(children);
for (int i=0; i<mChildren.size(); ++i)
{
GPTreeADFPoint* p = (GPTreeADFPoint*)(mChildren[i]);
children->addChild(p->xmlPrint());
}
if (mFunc.inputs.size() > 0)
{
std::ostringstream inputTypes;
for (int i=0; i<mFunc.inputs.size(); ++i)
{
inputTypes << mFunc.inputs[i]->name() << " ";
}
GPPtr<GPTreeNode> inputs = new GPTreeNode(GPStrings::GPTreeADF_INPUTS, inputTypes.str());
root->addChild(inputs);
std::ostringstream childflags;
for (int i=0; i<mFunc.useChildrenInput.size(); ++i)
{
childflags << mFunc.useChildrenInput[i] << " ";
}
GPPtr<GPTreeNode> childflagsn = new GPTreeNode(GPStrings::GPTreeADF_INPUTFLAGS, childflags.str());
root->addChild(childflagsn);
}
return root;
}