void libDHStandard<T, B, S>::GetAncestors(std::set<typename S::MPNode*>& Ancestors, typename S::MPNode* r) {
for(typename std::vector<typename S::MsgContainer>::iterator c=r->Parents.begin(),c_e=r->Parents.end();c!=c_e;++c) {
typename S::MPNode* ptr = c->node;
Ancestors.insert(ptr);
GetAncestors(Ancestors, ptr);
}
}
int main()
{
#if 1
AddNode(&pRoot,4);
AddNode(&pRoot,6);
AddNode(&pRoot,2);
AddNode(&pRoot,3);
AddNode(&pRoot,5);
AddNode(&pRoot,7);
AddNode(&pRoot,1);
//SubTree
pRootSub = getbtNode(2);
pRootSub->left = getbtNode(1);
pRootSub->right = getbtNode(3);//true subtree case
//pRootSub->right = getbtNode(4);//fasle subtree case
#else//for Sum Tree
pRoot = getbtNode(30);
pRoot->left = getbtNode(10);
pRoot->right = getbtNode(5);
pRoot->left->left = getbtNode(6);
pRoot->left->right = getbtNode(4);
pRoot->right->right = getbtNode(3);
pRoot->right->left = getbtNode(2);
#endif
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Inorder Traversal ::"<<endl;
Inorder(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Preorder Traversal ::"<<endl;
Preorder(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Postorder Traversal ::"<<endl;
Postorder(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Level Order Traversal ::"<<endl;
LOrder(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Size of the Tree ::"<<endl;
cout<<GetTreeSize(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Height of the Tree ::"<<endl;
cout<<GetTreeHeight(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
#if 0
DeleteTree(&pRoot);
AddNode(&pRoot,1);
cout<<"Inorder Traversal after Deletion::"<<endl;
Inorder(pRoot);
cout<<endl;
#endif
MirrorTree(pRoot);
cout<<"Inorder Traversal after MirrorTree operation::"<<endl;
Inorder(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
MirrorTree(pRoot);
cout<<"Inorder Traversal after MirrorTree operation for second time::"<<endl;
Inorder(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Max Element of the Tree ::"<<endl;
cout<<MaxTreeElement(pRoot);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
int path[7];
cout<<"Root To Leaf Paths ::"<<endl;
RootToLeafPath(pRoot,path,0);
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Number of Leaf Nodes::"<<NumberOfLeafNodes(pRoot)<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"Ancestors of 7 are ::"<<endl;
GetAncestors(pRoot,7);
cout<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<"CheckSumTree ::"<<IsSumTree(pRoot)<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<endl<<"Lowest Common Ancestor of 1 and 3 ::"<<LCA(pRoot,1,3)->data<<endl;
cout<<endl<<"Lowest Common Ancestor of 1 and 7 ::"<<LCA(pRoot,1,7)->data<<endl;
cout<<endl<<"Lowest Common Ancestor of 4 and 6 ::"<<LCA(pRoot,4,6)->data<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<endl<<"Tree has Path Sum 9 ::"<<hasPathSum(pRoot,9)<<endl;
cout<<endl<<"Tree has Path Sum 100 ::"<<hasPathSum(pRoot,100)<<endl;
cout<<endl<<"Tree has Path Sum 15 ::"<<hasPathSum(pRoot,15)<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
cout<<endl<<"Subtree ::"<<IsSubTree(pRoot,pRootSub)<<endl;
cout<<endl<<"##########################################################################################################"<<endl;
return 0;
}
int libDHStandard<T, B, S>::Marginalize(std::vector<GRAPH_TYPE>* graph) {
ObservedEmpiricalMean.assign(NumFeatures, T(0.0));
phi->x->assign(graph->size(), GRAPH_TYPE());
for(size_t x=0,x_e=graph->size();x!=x_e;++x) {
std::vector<size_t>* y_x = &y->at(x);
std::map<typename S::MPNode*,typename S::MPNode*> OriginalRegion2NewRegion;
std::vector<std::pair<std::set<size_t>,typename S::MPNode*> > VariableIXs2Node;
GRAPH_TYPE* ptr = &graph->at(x);
GRAPH_TYPE* ptrH = &phi->x->at(x);
for(typename GRAPH_TYPE::iterator rit=ptr->begin(),rit_e=ptr->end();rit!=rit_e;++rit) {
typename S::MPNode* r = *rit;
size_t pos = 0;
size_t numLatent = 0;
for(size_t v=0,v_e=r->num_variables;v!=v_e;++v) {
size_t x_v = (*y_x)[r->var_ix[v]];
if(x_v==size_t(-1)) {
++numLatent;
} else {
pos += x_v*r->cum_num_states[v];
}
}
if(numLatent==0) {
for(size_t k=0,k_e=r->featureIDs.size();k!=k_e;++k) {
ObservedEmpiricalMean[r->featureIDs[k]] += (*r->potOrig[k])[pos];
}
} else {
std::set<size_t> varIXset;
for(size_t v=0,v_e=r->num_variables;v!=v_e;++v) {
size_t x_v = (*y_x)[r->var_ix[v]];
if(x_v==size_t(-1)) {
varIXset.insert(r->var_ix[v]);
}
}
typename S::MPNode* ExistingNode = NULL;
for(typename std::vector<std::pair<std::set<size_t>,typename S::MPNode*> >::iterator xs=VariableIXs2Node.begin(),xs_e=VariableIXs2Node.end();xs!=xs_e;++xs) {
if(xs->first.size()==varIXset.size()) {
std::set<size_t> res;
std::set_difference(xs->first.begin(),xs->first.end(),varIXset.begin(),varIXset.end(),std::inserter(res,res.end()));
if(res.size()==0) {
ExistingNode = xs->second;
break;
}
}
}
if(ExistingNode==NULL) {
typename S::MPNode* tmp = new typename S::MPNode;
OriginalRegion2NewRegion[r] = tmp;
VariableIXs2Node.push_back(std::make_pair<std::set<size_t>,typename S::MPNode*>(varIXset,tmp));
tmp->num_variables = numLatent;
tmp->flag = r->flag;
tmp->c_r = -std::numeric_limits<T>::max();
tmp->SR = NULL;
tmp->num_states = new size_t[numLatent];
tmp->cum_num_states = new size_t[numLatent+1];tmp->cum_num_states[0] = 1;
tmp->var_ix = new size_t[numLatent];
size_t* multiplier = new size_t[numLatent];
size_t cnt = 0;
for(size_t v=0,v_e=r->num_variables;v!=v_e;++v) {
size_t x_v = (*y_x)[r->var_ix[v]];
if(x_v==size_t(-1)) {
multiplier[cnt] = r->cum_num_states[v];
tmp->num_states[cnt] = r->num_states[v];
tmp->var_ix[cnt] = r->var_ix[v];
tmp->cum_num_states[cnt+1] = tmp->cum_num_states[cnt]*r->num_states[v];
++cnt;
}
}
size_t potSize = tmp->cum_num_states[tmp->num_variables];
tmp->pot = new typename S::Data;
tmp->loss = NULL;
size_t numFeatures = r->featureIDs.size();
tmp->featureIDs = r->featureIDs;
tmp->potOrig.assign(numFeatures, NULL);
for(size_t r_=0;r_<numFeatures;++r_) {
tmp->potOrig[r_] = new typename S::Data;
T* buf = new T[potSize];
typename S::Data* oldbuf = r->potOrig[r_];
for(size_t x_v=0;x_v!=potSize;++x_v) {
size_t oldPos = pos;
for(size_t v=0,v_e=tmp->num_variables;v!=v_e;++v) {
oldPos += ((x_v/tmp->cum_num_states[v])%tmp->num_states[v]) * multiplier[v];
}
buf[x_v] = (*oldbuf)[oldPos];
}
tmp->potOrig[r_]->ResetDataNew(buf,potSize,true,true);
}
delete [] multiplier;
ptrH->push_back(tmp);
} else {
OriginalRegion2NewRegion[r] = ExistingNode;
size_t* num_states = new size_t[numLatent];
size_t* cum_num_states = new size_t[numLatent+1];cum_num_states[0] = 1;
size_t* var_ix = new size_t[numLatent];
size_t* multiplier = new size_t[numLatent];
size_t cnt = 0;
for(size_t v=0,v_e=r->num_variables;v!=v_e;++v) {
size_t x_v = (*y_x)[r->var_ix[v]];
if(x_v==size_t(-1)) {
multiplier[cnt] = r->cum_num_states[v];
num_states[cnt] = r->num_states[v];
var_ix[cnt] = r->var_ix[v];
cum_num_states[cnt+1] = cum_num_states[cnt]*r->num_states[v];
++cnt;
}
}
size_t potSize = cum_num_states[numLatent];
size_t numFeatures = r->featureIDs.size();
for(size_t r_=0;r_<numFeatures;++r_) {
std::vector<size_t>::iterator rFound = std::find(ExistingNode->featureIDs.begin(), ExistingNode->featureIDs.end(), r->featureIDs[r_]);
size_t r_tmp;
if(rFound==ExistingNode->featureIDs.end()) {
r_tmp = ExistingNode->featureIDs.size();
ExistingNode->featureIDs.push_back(r->featureIDs[r_]);
typename S::Data* buf = new typename S::Data;
//T* bufbuf = new T[potSize];
//std::fill(bufbuf,bufbuf+potSize, T(0.0));
//buf->ResetDataNew(bufbuf,potSize,true,true);
buf->ResetDataNew((T*)NULL,(size_t*)NULL,0,true);
ExistingNode->potOrig.push_back(buf);
} else {
r_tmp = rFound-ExistingNode->featureIDs.begin();
}
T* NewDataVec = new T[potSize];
typename S::Data* buf = ExistingNode->potOrig[r_tmp];
typename S::Data* oldbuf = r->potOrig[r_];
for(size_t x_v=0;x_v!=potSize;++x_v) {
size_t oldPos = pos;
std::map<size_t,size_t> VarStates;
for(size_t v=0;v!=numLatent;++v) {
size_t buf = (x_v/cum_num_states[v])%num_states[v];
VarStates[var_ix[v]] = buf;
oldPos += buf * multiplier[v];
}
size_t newPos = 0;
for(size_t v=0;v!=numLatent;++v) {
newPos += VarStates[ExistingNode->var_ix[v]]*ExistingNode->cum_num_states[v];
}
NewDataVec[newPos] = (*buf)[newPos] + (*oldbuf)[oldPos];
}
buf->ResetDataNew(NewDataVec, potSize, true, true);
}
delete [] num_states;
delete [] cum_num_states;
delete [] var_ix;
delete [] multiplier;
}
}
}
for(typename GRAPH_TYPE::iterator rit=ptr->begin(),rit_e=ptr->end();rit!=rit_e;++rit) {
typename S::MPNode* r = *rit;
typename std::map<typename S::MPNode*,typename S::MPNode*>::iterator res = OriginalRegion2NewRegion.find(r);
if(res!=OriginalRegion2NewRegion.end()) {
size_t potSize = res->second->cum_num_states[res->second->num_variables];
for(typename std::vector<typename S::MsgContainer>::iterator p=r->Parents.begin(),p_e=r->Parents.end();p!=p_e;++p) {
typename std::map<typename S::MPNode*,typename S::MPNode*>::iterator res_p = OriginalRegion2NewRegion.find(p->node);
assert(res_p!=OriginalRegion2NewRegion.end());
if(res_p->second!=res->second) {
typename S::MsgContainer ptmp;
ptmp.node = res_p->second;
ptmp.lambda = new T[potSize];
memset(ptmp.lambda, 0, sizeof(T)*potSize);
res->second->Parents.push_back(ptmp);
typename S::MsgContainer ctmp;
ctmp.node = res->second;
ctmp.lambda = ptmp.lambda;
res_p->second->Childs.push_back(ctmp);
}
}
}
}
if(DHParams->BetheCountingNumbers>0) {
bool AllRegionsAssigned = false;
while(!AllRegionsAssigned) {
AllRegionsAssigned = true;
for(typename GRAPH_TYPE::iterator rit=ptrH->begin(),rit_e=ptrH->end();rit!=rit_e;++rit) {
typename S::MPNode* r = *rit;
if(r->c_r!=-std::numeric_limits<T>::max()) {
continue;
}
std::set<typename S::MPNode*> Ancestors;
GetAncestors(Ancestors, r);
bool allAncestorsAssigned = true;
T ancestorSum = T(0.0);
for(typename std::set<typename S::MPNode*>::iterator ac=Ancestors.begin(),ac_e=Ancestors.end();ac!=ac_e;++ac) {
typename S::MPNode* ptr = *ac;
if(ptr->c_r==-std::numeric_limits<T>::max()) {
allAncestorsAssigned = false;
break;
}
ancestorSum += ptr->c_r;
}
if(allAncestorsAssigned) {
r->c_r = T(1.0) - ancestorSum;
} else {
AllRegionsAssigned = false;
}
}
}
} else {
for(typename GRAPH_TYPE::iterator rit=ptrH->begin(),rit_e=ptrH->end();rit!=rit_e;++rit) {
typename S::MPNode* r = *rit;
r->c_r = T(1.0);
}
}
}
return 0;
}
