void weighTree(meTree *T)
{
meEdge *e;
T->weight = 0;
for(e = depthFirstTraverse(T,NULL);NULL!=e;e=depthFirstTraverse(T,e))
T->weight += e->distance;
}
edge *indexedEdge(tree *T, int i)
{
edge *e;
for(e = depthFirstTraverse(T,NULL);NULL!=e;e=depthFirstTraverse(T,e))
if (i == e->head->index)
return(e);
return(NULL);
}
void compareSets(meTree *T, meSet *S, FILE *ofile)
{
meEdge *e;
meNode *v,*w;
meSet *X;
e = depthFirstTraverse(T,NULL);
while (NULL != e)
{
v = e->head;
for(X = S; NULL != X; X = X->secondNode)
{
w = X->firstNode;
if (0 == strcmp(v->label,w->label))
{
v->index2 = w->index2;
w->index2 = -1;
break;
}
}
e = depthFirstTraverse(T,e);
}
v = T->root;
for(X = S; NULL != X; X = X->secondNode)
{
w = X->firstNode;
if (0 == strcmp(v->label,w->label))
{
v->index2 = w->index2;
w->index2 = -1;
break;
}
}
if (-1 == v->index2)
{
fprintf(stderr,"Error leaf %s in meTree not in distance matrix.\n",v->label);
exit(EXIT_FAILURE);
}
e = depthFirstTraverse(T,NULL);
while (NULL != e)
{
v = e->head;
if ((leaf(v)) && (-1 == v->index2))
{
fprintf(stderr,"Error leaf %s in meTree not in distance matrix.\n",v->label);
exit(EXIT_FAILURE);
}
e = depthFirstTraverse(T,e);
}
for(X = S; NULL != X; X = X->secondNode)
if (X->firstNode->index2 > -1)
{
fprintf(ofile,"(v1:0.0)v2;");
fclose(ofile);
fprintf(stderr,"Error meNode %s in matrix but not a leaf in tree.\n",X->firstNode->label);
exit(EXIT_FAILURE);
}
}
void compareSets(tree *T, set *S)
{
edge *e;
node *v,*w;
set *X;
e = depthFirstTraverse(T,NULL);
while (NULL != e)
{
v = e->head;
for(X = S; NULL != X; X = X->secondNode)
{
w = X->firstNode;
if (0 == strcmp(v->label,w->label))
{
v->index2 = w->index2;
w->index2 = -1;
break;
}
}
e = depthFirstTraverse(T,e);
}
v = T->root;
for(X = S; NULL != X; X = X->secondNode)
{
w = X->firstNode;
if (0 == strcmp(v->label,w->label))
{
v->index2 = w->index2;
w->index2 = -1;
break;
}
}
if (-1 == v->index2)
{
Rprintf("Error leaf %s in tree not in distance matrix.\n",v->label);
exit(0);
}
e = depthFirstTraverse(T,NULL);
while (NULL != e)
{
v = e->head;
if ((leaf(v)) && (-1 == v->index2))
{
Rprintf("Error leaf %s in tree not in distance matrix.\n",v->label);
exit(0);
}
e = depthFirstTraverse(T,e);
}
for(X = S; NULL != X; X = X->secondNode)
if (X->firstNode->index2 > -1)
{
Rprintf("Error node %s in matrix but not a leaf in tree.\n",X->firstNode->label);
exit(0);
}
return;
}
node *indexedNode(tree *T, int i)
{
edge *e;
for(e = depthFirstTraverse(T,NULL);NULL!=e;e=depthFirstTraverse(T,e))
if (i == e->head->index)
return(e->head);
if (i == T->root->index)
return(T->root);
return(NULL);
}
void SPR(tree *T, double **D, double **A, int *count)
{
int i,j,k;
node *v;
/*FILE *treefile;*/
edge *e,*f;
/* char filename[MAX_LABEL_LENGTH];*/
double ***swapWeights;
double swapValue = 0.0;
swapWeights = (double ***)malloc(2*sizeof(double **));
makeBMEAveragesTable(T,D,A);
assignBMEWeights(T,A);
weighTree(T);
/*if (verbose)
printf("Before SPRs: tree length is %lf.\n",T->weight);*/
for(i=0;i<2;i++)
swapWeights[i] = initDoubleMatrix(T->size);
do
{
swapValue=0.0;
zero3DMatrix(swapWeights,2,T->size,T->size);
i = j = k = 0;
for(e=depthFirstTraverse(T,NULL);NULL!=e;e=depthFirstTraverse(T,e))
assignSPRWeights(e->head,A,swapWeights);
findTableMin(&i,&j,&k,T->size,swapWeights,&swapValue);
swapValue = swapWeights[i][j][k];
if (swapValue < -EPSILON)
{
// if (verbose)
// printf("New tree weight should be %lf.\n",T->weight + 0.25*swapValue);
v = indexedNode(T,j);
f = indexedEdge(T,k);
// if (verbose)
// printf("Swapping tree below %s to split edge %s with head %s and tail %s\n",
// v->parentEdge->label,f->label,f->head->label,f->tail->label);
SPRTopShift(T,v,f,2-i);
makeBMEAveragesTable(T,D,A);
assignBMEWeights(T,A);
weighTree(T);
(*count)++;
/*sprintf(filename,"tree%d.new",*count);*/
// if (verbose)
// printf("After %d SPRs, tree weight is %lf.\n\n",*count,T->weight);
/*treefile = fopen(filename,"w");
NewickPrintTree(T,treefile);
fclose(treefile);*/
}
} while (swapValue < -EPSILON);
for(i=0;i<2;i++)
freeMatrix(swapWeights[i],T->size);
free(swapWeights);
/*if (verbose)
readOffTree(T);*/
}
void assignBMEWeights(meTree *T, double **A)
{
meEdge *e;
e = depthFirstTraverse(T,NULL);
while (NULL != e) {
if ((leaf(e->head)) || (leaf(e->tail)))
BalWFext(e,A);
else
BalWFint(e,A);
e = depthFirstTraverse(T,e);
}
}
void printMatrix(double **M, int dim, FILE *ofile,meTree *T)
{
meEdge *e,*f;
fprintf(ofile,"%d\n",dim-1);
for(e=depthFirstTraverse(T,NULL);NULL!=e;e=depthFirstTraverse(T,e))
{
fprintf(ofile,"%s ",e->head->label);
for(f=depthFirstTraverse(T,NULL);NULL!=f;f=depthFirstTraverse(T,f))
fprintf(ofile,"%lf ",M[e->head->index][f->head->index]);
fprintf(ofile,"\n");
}
}
void partitionSizes(meTree *T)
{
meEdge *e;
e = depthFirstTraverse(T,NULL);
while (NULL != e)
{
if (leaf(e->head))
e->bottomsize = 1;
else
e->bottomsize = e->head->leftEdge->bottomsize
+ e->head->rightEdge->bottomsize;
e->topsize = (T->size + 2)/2 - e->bottomsize;
e = depthFirstTraverse(T,e);
}
}
void calcTBRaverages(tree *T, edge *esplit, double **A, double **dXTop)
{
edge *ebottom, *par, *sib;
for (ebottom = findBottomLeft(esplit); ebottom != esplit; ebottom = depthFirstTraverse(T,ebottom))
{
par = esplit->tail->parentEdge;
sib = siblingEdge(esplit);
calcTBRTopBottomAverage(ebottom->head,A, dXTop, 0.0, esplit, par,esplit,UP);
calcTBRTopBottomAverage(ebottom->head,A, dXTop, 0.0, esplit, sib,esplit,DOWN);
}
}
void BMEcalcNewvAverages(meTree *T, meNode *v, double **D, double **A)
{
/*loop over edges*/
/*depth-first search*/
meEdge *e;
e = NULL;
e = depthFirstTraverse(T,e); /*the downward averages need to be
calculated from bottom to top */
while(NULL != e)
{
BMEcalcDownAverage(T,v,e,D,A);
e = depthFirstTraverse(T,e);
}
e = topFirstTraverse(T,e); /*the upward averages need to be calculated
from top to bottom */
while(NULL != e)
{
BMEcalcUpAverage(T,v,e,D,A);
e = topFirstTraverse(T,e);
}
}
void NNIupdateAverages(double **A, edge *e, edge *par, edge *skew,
edge *swap, edge *fixed, tree *T)
{
node *v;
edge *elooper;
v = e->head;
/*first, v*/
A[e->head->index][e->head->index] =
(swap->bottomsize*
((skew->bottomsize*A[skew->head->index][swap->head->index]
+ fixed->bottomsize*A[fixed->head->index][swap->head->index])
/ e->bottomsize) +
par->topsize*
((skew->bottomsize*A[skew->head->index][par->head->index]
+ fixed->bottomsize*A[fixed->head->index][par->head->index])
/ e->bottomsize)
) / e->topsize;
elooper = findBottomLeft(e); /*next, we loop over all the edges
which are below e*/
while (e != elooper)
{
A[e->head->index][elooper->head->index] =
A[elooper->head->index][v->index]
= (swap->bottomsize*A[elooper->head->index][swap->head->index] +
par->topsize*A[elooper->head->index][par->head->index])
/ e->topsize;
elooper = depthFirstTraverse(T,elooper);
}
elooper = findBottomLeft(swap); /*next we loop over all the edges below and
including swap*/
while (swap != elooper)
{
A[e->head->index][elooper->head->index] =
A[elooper->head->index][e->head->index]
= (skew->bottomsize * A[elooper->head->index][skew->head->index] +
fixed->bottomsize*A[elooper->head->index][fixed->head->index])
/ e->bottomsize;
elooper = depthFirstTraverse(T,elooper);
}
/*now elooper = skew */
A[e->head->index][elooper->head->index] =
A[elooper->head->index][e->head->index]
= (skew->bottomsize * A[elooper->head->index][skew->head->index] +
fixed->bottomsize* A[elooper->head->index][fixed->head->index])
/ e->bottomsize;
/*finally, we loop over all the edges in the tree
on the far side of parEdge*/
elooper = T->root->leftEdge;
while ((elooper != swap) && (elooper != e)) /*start a top-first traversal*/
{
A[e->head->index][elooper->head->index] =
A[elooper->head->index][e->head->index]
= (skew->bottomsize * A[elooper->head->index][skew->head->index]
+ fixed->bottomsize* A[elooper->head->index][fixed->head->index])
/ e->bottomsize;
elooper = topFirstTraverse(T,elooper);
}
/*At this point, elooper = par.
We finish the top-first traversal, excluding the subtree below par*/
elooper = moveUpRight(par);
while (NULL != elooper)
{
A[e->head->index][elooper->head->index]
= A[elooper->head->index][e->head->index]
= (skew->bottomsize * A[elooper->head->index][skew->head->index] +
fixed->bottomsize* A[elooper->head->index][fixed->head->index])
/ e->bottomsize;
elooper = topFirstTraverse(T,elooper);
}
}
void makeBMEAveragesTable(meTree *T, double **D, double **A)
{
meEdge *e, *f, *exclude;
meNode *u,*v;
/*first, let's deal with the averages involving the root of T*/
e = T->root->leftEdge;
f = depthFirstTraverse(T,NULL);
while (NULL != f) {
if (leaf(f->head))
A[e->head->index][f->head->index] = A[f->head->index][e->head->index]
= D[e->tail->index2][f->head->index2];
else
{
u = f->head->leftEdge->head;
v = f->head->rightEdge->head;
A[e->head->index][f->head->index] = A[f->head->index][e->head->index]
= 0.5*(A[e->head->index][u->index] + A[e->head->index][v->index]);
}
f = depthFirstTraverse(T,f);
}
e = depthFirstTraverse(T,NULL);
while (T->root->leftEdge != e) {
f = exclude = e;
while (T->root->leftEdge != f) {
if (f == exclude)
exclude = exclude->tail->parentEdge;
else if (leaf(e->head))
{
if (leaf(f->head))
A[e->head->index][f->head->index] =
A[f->head->index][e->head->index]
= D[e->head->index2][f->head->index2];
else
{
u = f->head->leftEdge->head; /*since f is chosen using a
depth-first search, other values
have been calculated*/
v = f->head->rightEdge->head;
A[e->head->index][f->head->index]
= A[f->head->index][e->head->index]
= 0.5*(A[e->head->index][u->index] + A[e->head->index][v->index]);
}
}
else
{
u = e->head->leftEdge->head;
v = e->head->rightEdge->head;
A[e->head->index][f->head->index] = A[f->head->index][e->head->index] = 0.5*(A[f->head->index][u->index] + A[f->head->index][v->index]);
}
f = depthFirstTraverse(T,f);
}
e = depthFirstTraverse(T,e);
}
e = depthFirstTraverse(T,NULL);
while (T->root->leftEdge != e)
{
calcUpAverages(D,A,e,e); /*calculates averages for
A[e->head->index][g->head->index] for
any meEdge g in path from e to root of tree*/
e = depthFirstTraverse(T,e);
}
} /*makeAveragesMatrix*/
void TBR(tree *T, double **D, double **A)
{
int i;
edge *esplit, *etop, *eBestTop, *eBestBottom, *eBestSplit;
edge *eout, *block;
edge *left, *right, *par, *sib;
double **dXTop; /*dXTop[i][j] is average distance from subtree rooted at i to tree above split edge, if
SPR above split edge cuts edge whose head has index j*/
double bestWeight;
double ***TBRWeights;
dXTop = initDoubleMatrix(T->size);
weighTree(T);
TBRWeights = (double ***)calloc(T->size,sizeof(double **));
for(i=0;i<T->size;i++)
TBRWeights[i] = initDoubleMatrix(T->size);
do
{
zero3DMatrix(TBRWeights,T->size,T->size,T->size);
bestWeight = 0.0;
eBestSplit = eBestTop = eBestBottom = NULL;
for(esplit=depthFirstTraverse(T,NULL);NULL!=esplit;esplit=depthFirstTraverse(T,esplit))
{
par = esplit->tail->parentEdge;
if (NULL != par)
{
sib = siblingEdge(esplit);
/*next two lines calculate the possible improvements for any SPR above esplit*/
assignTBRDownWeightsUp(par,esplit->head,sib->head,NULL,NULL,0.0,1.0,A,TBRWeights,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
assignTBRDownWeightsSkew(sib,esplit->head,sib->tail,NULL,NULL,0.0,1.0,A,TBRWeights,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
calcTBRaverages(T,esplit,A,dXTop); /*calculates the average distance from any subtree
below esplit to the entire subtree above esplit,
after any possible SPR above*/
/*for etop above esplit, we loop using information from above to calculate values
for all possible SPRs below esplit*/
}
right = esplit->head->rightEdge;
if (NULL != right)
{
left = esplit->head->leftEdge;
/*test case: etop = null means only do bottom SPR*/
assignTBRUpWeights(left,esplit->head,right->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,NULL,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
assignTBRUpWeights(right,esplit->head,left->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,NULL,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
block = esplit;
while (NULL != block)
{
if (block != esplit)
{
etop = block;
assignTBRUpWeights(left,esplit->head,right->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,etop,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
assignTBRUpWeights(right,esplit->head,left->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,etop,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
}
eout = siblingEdge(block);
if (NULL != eout)
{
etop = findBottomLeft(eout);
while (etop->tail != eout->tail)
{
/*for ebottom below esplit*/
assignTBRUpWeights(left,esplit->head,right->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,etop,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
assignTBRUpWeights(right,esplit->head,left->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,etop,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
etop = depthFirstTraverse(T,etop);
}
/*etop == eout*/
assignTBRUpWeights(left,esplit->head,right->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,etop,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
assignTBRUpWeights(right,esplit->head,left->head,NULL,NULL,0.0,1.0,A,dXTop,TBRWeights,etop,&bestWeight,&eBestSplit,&eBestTop,&eBestBottom);
}
block = block->tail->parentEdge;
}
} /*if NULL != right*/
} /*for esplit*/
/*find bestWeight, best split edge, etc.*/
if (bestWeight < -EPSILON)
{
// if (verbose)
// {
// printf("TBR #%d: Splitting edge %s: top edge %s, bottom edge %s\n",*count+1,
// eBestSplit->label, eBestTop->label,eBestBottom->label);
// printf("Old tree weight is %lf, new tree weight should be %lf\n",T->weight, T->weight + 0.25*bestWeight);
// }
TBRswitch(T,eBestSplit,eBestTop,eBestBottom);
makeBMEAveragesTable(T,D,A);
assignBMEWeights(T,A);
weighTree(T);
// if (verbose)
// printf("TBR: new tree weight is %lf\n\n",T->weight);<
// (*count)++;
}
else
bestWeight = 1.0;
} while (bestWeight < -EPSILON);
for(i=0;i<T->size;i++)
freeMatrix(TBRWeights[i],T->size);
freeMatrix(dXTop,T->size);
}
//void bNNI(tree *T, double **avgDistArray, int *count)
void bNNI(tree *T, double **avgDistArray, int *count, double **D, int numSpecies)
{
edge *e;//, *centerEdge deleted by EP, 2013-09-26, see also below
edge **edgeArray;
int *p, *location, *q;
int i,j;
int possibleSwaps;
double *weights;
p = initPerm(T->size+1);
q = initPerm(T->size+1);
edgeArray = (edge **) malloc((T->size+1)*sizeof(double));
weights = (double *) malloc((T->size+1)*sizeof(double));
location = (int *) malloc((T->size+1)*sizeof(int));
double epsilon = 0.0;
for (i=0; i<numSpecies; i++)
for (j=0; j<numSpecies; j++)
epsilon += D[i][j];
epsilon = (epsilon / (numSpecies * numSpecies)) * EPSILON;
for (i=0;i<T->size+1;i++)
{
weights[i] = 0.0;
location[i] = NONE;
}
/* if (verbose)
{
assignBMEWeights(T,avgDistArray);
weighTree(T);
}*/
e = findBottomLeft(T->root->leftEdge);
while (NULL != e)
{
edgeArray[e->head->index+1] = e;
location[e->head->index+1] =
bNNIEdgeTest(e,T,avgDistArray,weights + e->head->index + 1);
e = depthFirstTraverse(T,e);
}
possibleSwaps = makeThreshHeap(p,q,weights,T->size+1,0.0);
permInverse(p,q,T->size+1);
/*we put the negative values of weights into a heap, indexed by p
with the minimum value pointed to by p[1]*/
/*p[i] is index (in edgeArray) of edge with i-th position
in the heap, q[j] is the position of edge j in the heap */
while (weights[p[1]] + epsilon < 0)
{
/* centerEdge = edgeArray[p[1]]; apparently unused later, deleted by EP, 2013-09-26 */
(*count)++;
/* if (verbose)
{
T->weight = T->weight + weights[p[1]];
printf("New tree weight is %lf.\n",T->weight);
}*/
bNNItopSwitch(T,edgeArray[p[1]],location[p[1]],avgDistArray);
location[p[1]] = NONE;
weights[p[1]] = 0.0; /*after the bNNI, this edge is in optimal
configuration*/
popHeap(p,q,weights,possibleSwaps--,1);
/*but we must retest the other edges of T*/
/*CHANGE 2/28/2003 expanding retesting to _all_ edges of T*/
e = depthFirstTraverse(T,NULL);
while (NULL != e)
{
bNNIRetestEdge(p,q,e,T,avgDistArray,weights,location,&possibleSwaps);
e = depthFirstTraverse(T,e);
}
}
free(p);
free(q);
free(location);
free(edgeArray);
free(weights);
assignBMEWeights(T,avgDistArray);
}
void SPR (tree *T, double **D, double **A, int *count, FILE *statfile)
{
int i, j, k;
node *v;
edge *e, *f;
double ***swapWeights;
double treeWeightBefore;
double swapValue = 0.0;
boolean firstSPR = TRUE;
swapWeights = (double ***) mCalloc (2, sizeof(double **));
makeBMEAveragesTable (T, D, A);
assignBMEWeights (T, A);
weighTree (T);
treeWeightBefore = T->weight;
for (i=0; i<2; i++)
swapWeights[i] = initDoubleMatrix (T->size);
do
{
swapValue = 0.0;
zero3DMatrix (swapWeights, 2, T->size, T->size);
i = j = k = 0;
for (e = depthFirstTraverse (T, NULL); NULL != e; e = depthFirstTraverse (T, e))
assignSPRWeights (e->head, A, swapWeights);
findTableMin (&i, &j, &k, T->size, swapWeights, &swapValue);
swapValue = swapWeights[i][j][k];
if (swapValue < -FLT_EPSILON)
{
if (firstSPR)
{
firstSPR = FALSE;
if (!isBoostrap)
{
if (verbose > 2)
Debug ( (char*)"Before SPR: tree length is %f.", treeWeightBefore);
else if (verbose > 1)
Message ( (char*)". Before SPR: tree length is %f.", treeWeightBefore);
}
}
if (verbose > 2 && !isBoostrap)
Debug ( (char*)"New tree length should be %f.", T->weight + 0.25 * swapValue);
v = indexedNode (T, j);
f = indexedEdge (T, k);
if (verbose > 2 && !isBoostrap)
{
if ((NULL == f->head->label) || (strlen (f->head->label) == 0))
{
if ((NULL == f->tail->label) || (strlen (f->tail->label) == 0))
Debug ( (char*)"Swapping tree below '%s' to split edge '%s' with internal head and tail.",
v->parentEdge->label, f->label);
else
Debug ( (char*)"Swapping tree below '%s' to split edge '%s' with internal head and tail '%s'.",
v->parentEdge->label, f->label, f->tail->label);
}
else
{
if ((NULL == f->tail->label) || (strlen (f->tail->label) == 0))
Debug ( (char*)"Swapping tree below '%s' to split edge '%s' with head '%s' and internal tail.",
v->parentEdge->label, f->label, f->head->label, f->tail->label);
else
Debug ( (char*)"Swapping tree below '%s' to split edge '%s' with head '%s' and tail '%s'.",
v->parentEdge->label, f->label, f->head->label, f->tail->label);
}
}
SPRTopShift (v, f, 2-i);
makeBMEAveragesTable (T, D, A);
assignBMEWeights (T, A);
weighTree (T);
(*count)++;
if (!isBoostrap)
{
if (verbose > 2)
Debug ( (char*)"SPR %5d: new tree length is %f.", *count, T->weight);
else if (verbose > 1)
Message ( (char*)". SPR %5d: new tree length is %f.", *count, T->weight);
}
}
} while (swapValue < -FLT_EPSILON);
for (i=0; i<2; i++)
freeMatrix (swapWeights[i], T->size);
free (swapWeights);
return;
}
//void NNI(tree *T, double **avgDistArray, int *count)
void NNI(tree *T, double **avgDistArray, int *count, double **D, int numSpecies)
{
edge *e, *centerEdge;
edge **edgeArray;
int *location;
int *p,*q;
int i,j;
int possibleSwaps;
double *weights;
p = initPerm(T->size+1);
q = initPerm(T->size+1);
edgeArray = (edge **) malloc((T->size+1)*sizeof(double));
weights = (double *) malloc((T->size+1)*sizeof(double));
location = (int *) malloc((T->size+1)*sizeof(int));
double epsilon = 0.0;
for (i=0; i<numSpecies; i++)
for (j=0; j<numSpecies; j++)
epsilon += D[i][j];
epsilon = (epsilon / (numSpecies * numSpecies)) * EPSILON;
for (i=0;i<T->size+1;i++)
{
weights[i] = 0.0;
location[i] = NONE;
}
e = findBottomLeft(T->root->leftEdge);
/* *count = 0; */
while (NULL != e)
{
edgeArray[e->head->index+1] = e;
location[e->head->index+1] =
NNIEdgeTest(e,T,avgDistArray,weights + e->head->index + 1);
e = depthFirstTraverse(T,e);
}
possibleSwaps = makeThreshHeap(p,q,weights,T->size+1,0.0);
permInverse(p,q,T->size+1);
/*we put the negative values of weights into a heap, indexed by p
with the minimum value pointed to by p[1]*/
/*p[i] is index (in edgeArray) of edge with i-th position
in the heap, q[j] is the position of edge j in the heap */
while (weights[p[1]] + epsilon < 0)
{
centerEdge = edgeArray[p[1]];
(*count)++;
T->weight = T->weight + weights[p[1]];
NNItopSwitch(T,edgeArray[p[1]],location[p[1]],avgDistArray);
location[p[1]] = NONE;
weights[p[1]] = 0.0; /*after the NNI, this edge is in optimal
configuration*/
popHeap(p,q,weights,possibleSwaps--,1);
/*but we must retest the other four edges*/
e = centerEdge->head->leftEdge;
NNIRetestEdge(p,q,e,T,avgDistArray,weights,location,&possibleSwaps);
e = centerEdge->head->rightEdge;
NNIRetestEdge(p,q,e,T,avgDistArray,weights,location,&possibleSwaps);
e = siblingEdge(centerEdge);
NNIRetestEdge(p,q,e,T,avgDistArray,weights,location,&possibleSwaps);
e = centerEdge->tail->parentEdge;
NNIRetestEdge(p,q,e,T,avgDistArray,weights,location,&possibleSwaps);
}
free(p);
free(q);
free(location);
free(edgeArray);
}
void bNNI (tree *T, double **avgDistArray, int *count, FILE *statfile)
{
edge *e;
edge **edgeArray;
int *p, *location, *q;
int i;
int possibleSwaps;
double *weights;
p = initPerm (T->size+1);
q = initPerm (T->size+1);
edgeArray = (edge **) mCalloc ((T->size+1), sizeof (edge *));
weights = (double *) mCalloc ((T->size+1), sizeof (double));
location = (int *) mCalloc ((T->size+1), sizeof (int));
for (i=0; i<T->size+1; i++)
{
weights[i] = 0.0;
location[i] = NONE;
}
assignBMEWeights (T, avgDistArray);
weighTree (T);
if (!isBoostrap)
{
if (statfile)
fprintf (statfile, "\tBefore NNI: tree length is %f.\n", T->weight);
if (verbose > 2)
Debug ( (char*)"Before NNI: tree length is %f.", T->weight);
else if (verbose > 1)
Message ( (char*)". Before NNI: tree length is %f.", T->weight);
}
e = findBottomLeft (T->root->leftEdge);
while (NULL != e)
{
edgeArray[e->head->index+1] = e;
location[e->head->index+1] = bNNIEdgeTest (e, T, avgDistArray,
weights + e->head->index + 1);
e = depthFirstTraverse (T,e);
}
possibleSwaps = makeThreshHeap (p, q, weights, T->size+1,0.0);
permInverse (p, q, T->size+1);
/* We put the negative values of weights into a heap, indexed by p
* with the minimum value pointed to by p[1]
* p[i] is index (in edgeArray) of edge with i-th position in the
* heap, q[j] is the position of edge j in the heap */
while (weights[p[1]] < -DBL_EPSILON)
{
(*count)++;
T->weight = T->weight + weights[p[1]];
if (!isBoostrap)
{
if (statfile)
fprintf (statfile, "\tNNI %5d: new tree length is %f.\n", *count, T->weight);
if (verbose > 2)
Debug ( (char*)"NNI %5d: new tree length is %f.", *count, T->weight);
else if (verbose > 1)
Message ( (char*)". NNI %5d: new tree length is %f.", *count, T->weight);
}
bNNItopSwitch (edgeArray[p[1]], location[p[1]], avgDistArray);
location[p[1]] = NONE;
weights[p[1]] = 0.0; //after the bNNI, this edge is in optimal configuration
popHeap (p, q, weights, possibleSwaps--, 1);
/* but we must retest the other edges of T */
/* CHANGE 2/28/2003 expanding retesting to _all_ edges of T */
e = depthFirstTraverse (T, NULL);
while (NULL != e)
{
bNNIRetestEdge (p, q, e, T, avgDistArray, weights, location, &possibleSwaps);
e = depthFirstTraverse (T, e);
}
}
free (p);
free (q);
free (location);
free (edgeArray);
free (weights);
assignBMEWeights (T, avgDistArray);
return;
}
void bNNI(meTree *T, double **avgDistArray, int *count)
{
meEdge *e, *centerEdge;
meEdge **edgeArray;
int *p, *location, *q;
int i;
int possibleSwaps;
double *weights;
p = initPerm(T->size+1);
q = initPerm(T->size+1);
edgeArray = (meEdge **) malloc((T->size+1)*sizeof(double));
weights = (double *) malloc((T->size+1)*sizeof(double));
location = (int *) malloc((T->size+1)*sizeof(int));
for (i=0;i<T->size+1;i++)
{
weights[i] = 0.0;
location[i] = NONE;
}
if (verbose)
{
assignBalWeights(T,avgDistArray);
weighTree(T);
}
e = findBottomLeft(T->root->leftEdge);
while (NULL != e)
{
edgeArray[e->head->index+1] = e;
location[e->head->index+1] =
bNNIEdgeTest(e,T,avgDistArray,weights + e->head->index + 1);
e = depthFirstTraverse(T,e);
}
possibleSwaps = makeThreshHeap(p,q,weights,T->size+1,0.0);
permInverse(p,q,T->size+1);
/*we put the negative values of weights into a heap, indexed by p
with the minimum value pointed to by p[1]*/
/*p[i] is index (in edgeArray) of edge with i-th position
in the heap, q[j] is the position of edge j in the heap */
/*NOTE: the loop below should test that weights[p[1]] < 0, but
if compiled with optimization it is possible that weights[p[1]]
ends up negative and very small, so that changes to the heap
become cyclic and the loop becomes infinite. To avoid this
behavior, stop the loop short of 0.0. This is a workaround
until the roundoff sensitivity is removed algorithmically */
while (weights[p[1]] < -1e-8)
{
centerEdge = edgeArray[p[1]];
(*count)++;
if (verbose)
{
T->weight = T->weight + weights[p[1]];
printf("New tree weight is %lf.\n",T->weight);
}
bNNItopSwitch(T,edgeArray[p[1]],location[p[1]],avgDistArray);
location[p[1]] = NONE;
weights[p[1]] = 0.0; /*after the bNNI, this edge is in optimal
configuration*/
popHeap(p,q,weights,possibleSwaps--,1);
/*but we must retest the other edges of T*/
/*CHANGE 2/28/2003 expanding retesting to _all_ edges of T*/
e = depthFirstTraverse(T,NULL);
while (NULL != e)
{
bNNIRetestEdge(p,q,e,T,avgDistArray,weights,location,&possibleSwaps);
e = depthFirstTraverse(T,e);
}
}
free(p);
free(q);
free(location);
free(edgeArray);
assignBalWeights(T,avgDistArray);
}
