void rearrange(node *p)
{ /* rearranges the tree locally */
node *q, *r;
if (!p->tip && !p->back->tip) {
r = p->next->next;
re_move(&r, &q );
copy_(&curtree, &priortree);
addtraverse(r, q->next->back, false);
addtraverse(r, q->next->next->back, false);
copy_(&bestree, &curtree);
}
if (!p->tip) {
rearrange(p->next->back);
rearrange(p->next->next->back);
}
} /* rearrange */
void rearrange(node *p, long *numtrees, long *nextsp, boolean *succeeded)
{
node *q, *r;
if (!p->tip && !p->back->tip) {
r = p->next->next;
re_move(&r, &q);
copy_(&curtree, &priortree);
addtraverse(r, q->next->back, false, numtrees,succeeded);
addtraverse(r, q->next->next->back, false, numtrees,succeeded);
copy_(&bestree, &curtree);
if (global && ((*nextsp) == spp)) {
putchar('.');
fflush(stdout);
}
}
if (!p->tip) {
rearrange(p->next->back, numtrees,nextsp,succeeded);
rearrange(p->next->next->back, numtrees,nextsp,succeeded);
}
} /* rearrange */
void tryadd(node *p, node **item, node **nufork)
{
/* temporarily adds one fork and one tip to the tree.
if the location where they are added yields greater
"likelihood" than other locations tested up to that
time, then keeps that location as there */
long pos;
boolean found;
add(p, *item, *nufork, &root, treenode);
evaluate(root);
if (lastrearr) {
if (like >= bstlike2) {
savetree();
if (like > bstlike2) {
bestlike = bstlike2 = like;
pos = 1;
nextree = 1;
dollop_addtree(&pos);
} else {
pos = 0;
findtree(&found, &pos, nextree, place, bestrees);
/* findtree calls for a bestelm* but is getting */
/* a long**, LM */
if (!found) {
if (nextree <= maxtrees)
dollop_addtree(&pos);
}
}
}
}
if (like > bestyet) {
bestyet = like;
there = p;
}
re_move(item, nufork, &root, treenode);
} /* tryadd */
void globrearrange()
{ /* does global rearrangements */
tree globtree;
tree oldtree;
int i,j,k,num_sibs,num_sibs2;
node *where,*sib_ptr,*sib_ptr2;
double oldbestyet = curtree.likelihood;
int success = false;
alloctree(&globtree.nodep,nonodes2);
alloctree(&oldtree.nodep,nonodes2);
setuptree(&globtree,nonodes2);
setuptree(&oldtree,nonodes2);
allocview(&oldtree, nonodes2, totalleles);
allocview(&globtree, nonodes2, totalleles);
copy_(&curtree,&globtree);
copy_(&curtree,&oldtree);
for ( i = spp ; i < nonodes2 ; i++ ) {
num_sibs = count_sibs(curtree.nodep[i]);
sib_ptr = curtree.nodep[i];
if ( (i - spp) % (( nonodes2 / 72 ) + 1 ) == 0 )
putchar('.');
fflush(stdout);
for ( j = 0 ; j <= num_sibs ; j++ ) {
re_move(&sib_ptr,&where);
copy_(&curtree,&priortree);
if (where->tip) {
copy_(&oldtree,&curtree);
copy_(&oldtree,&bestree);
sib_ptr = sib_ptr->next;
continue;
}
else num_sibs2 = count_sibs(where);
sib_ptr2 = where;
for ( k = 0 ; k < num_sibs2 ; k++ ) {
addwhere = NULL;
addtraverse(sib_ptr,sib_ptr2->back,true);
if ( addwhere && where != addwhere && where->back != addwhere
&& bestree.likelihood > globtree.likelihood) {
copy_(&bestree,&globtree);
success = true;
}
sib_ptr2 = sib_ptr2->next;
}
copy_(&oldtree,&curtree);
copy_(&oldtree,&bestree);
sib_ptr = sib_ptr->next;
}
}
copy_(&globtree,&curtree);
copy_(&globtree,&bestree);
if (success && globtree.likelihood > oldbestyet) {
succeeded = true;
}
else {
succeeded = false;
}
freeview(&oldtree, nonodes2);
freeview(&globtree, nonodes2);
freetree(&globtree.nodep,nonodes2);
freetree(&oldtree.nodep,nonodes2);
}
void maketree()
{
/* constructs a binary tree from the pointers in treenode.
adds each node at location which yields highest "likelihood"
then rearranges the tree for greatest "likelihood" */
long i, j, nextnode;
double gotlike;
node *item, *nufork, *dummy, *p;
char *treestr;
fullset = (1L << (bits + 1)) - (1L << 1);
if (!usertree) {
for (i = 1; i <= (spp); i++)
enterorder[i - 1] = i;
if (jumble)
randumize(seed, enterorder);
root = treenode[enterorder[0] - 1];
add(treenode[enterorder[0] - 1], treenode[enterorder[1] - 1],
treenode[spp], &root, treenode);
if (progress) {
printf("Adding species:\n");
writename(0, 2, enterorder);
#ifdef WIN32
phyFillScreenColor();
#endif
}
lastrearr = false;
for (i = 3; i <= (spp); i++) {
bestyet = -350.0 * spp * chars;
item = treenode[enterorder[i - 1] - 1];
nufork = treenode[spp + i - 2];
addpreorder(root, item, nufork);
add(there, item, nufork, &root, treenode);
like = bestyet;
rearrange(&root);
if (progress) {
writename(i - 1, 1, enterorder);
#ifdef WIN32
phyFillScreenColor();
#endif
}
lastrearr = (i == spp);
if (lastrearr) {
if (progress) {
printf("\nDoing global rearrangements\n");
printf(" !");
for (j = 1; j <= (nonodes); j++)
if ( j % (( nonodes / 72 ) + 1 ) == 0 )
putchar('-');
printf("!\n");
#ifdef WIN32
phyFillScreenColor();
#endif
}
bestlike = bestyet;
if (jumb == 1) {
bstlike2 = bestlike;
nextree = 1;
}
do {
if (progress)
printf(" ");
gotlike = bestlike;
for (j = 0; j < (nonodes); j++) {
bestyet = - 350.0 * spp * chars;
item = treenode[j];
if (item != root) {
nufork = treenode[j]->back;
re_move(&item, &nufork, &root, treenode);
there = root;
addpreorder(root, item, nufork);
add(there, item, nufork, &root, treenode);
}
if (progress) {
if ( j % (( nonodes / 72 ) + 1 ) == 0 )
putchar('.');
fflush(stdout);
}
}
if (progress) {
putchar('\n');
#ifdef WIN32
phyFillScreenColor();
#endif
}
} while (bestlike > gotlike);
}
}
if (progress)
putchar('\n');
for (i = spp - 1; i >= 1; i--)
re_move(&treenode[i], &dummy, &root, treenode);
if (jumb == njumble) {
if (treeprint) {
putc('\n', outfile);
if (nextree == 2)
fprintf(outfile, "One most parsimonious tree found:\n");
else
fprintf(outfile, "%6ld trees in all found\n", nextree - 1);
}
if (nextree > maxtrees + 1) {
if (treeprint)
fprintf(outfile, "here are the first%4ld of them\n", (long)maxtrees);
nextree = maxtrees + 1;
}
if (treeprint)
putc('\n', outfile);
for (i = 0; i <= (nextree - 2); i++) {
root = treenode[0];
add(treenode[0], treenode[1], treenode[spp], &root, treenode);
for (j = 3; j <= spp; j++) {
add(treenode[bestrees[i].btree[j - 1] - 1], treenode[j - 1],
treenode[spp + j - 2], &root, treenode);}
evaluate(root);
printree(1.0, treeprint, root);
describe();
for (j = 1; j < (spp); j++)
re_move(&treenode[j], &dummy, &root, treenode);
}
}
} else {
if (numtrees > 2) {
emboss_initseed(inseed, &inseed0, seed);
printf("\n");
}
if (treeprint) {
fprintf(outfile, "User-defined tree");
if (numtrees > 1)
putc('s', outfile);
fprintf(outfile, ":\n");
}
names = (boolean *)Malloc(spp*sizeof(boolean));
which = 1;
firsttree = true; /**/
nodep = NULL; /**/
nextnode = 0; /**/
haslengths = 0; /**/
phirst = 0; /**/
zeros = (long *)Malloc(chars*sizeof(long)); /**/
for (i = 0; i < chars; i++) /**/
zeros[i] = 0; /**/
while (which <= numtrees) {
treestr = ajStrGetuniquePtr(&phylotrees[which-1]->Tree);
treeread(&treestr, &root, treenode, &goteof, &firsttree,
nodep, &nextnode, &haslengths,
&grbg, initdollopnode,false,nonodes);
for (i = spp; i < (nonodes); i++) {
p = treenode[i];
for (j = 1; j <= 3; j++) {
p->stateone = (bitptr)Malloc(words*sizeof(long));
p->statezero = (bitptr)Malloc(words*sizeof(long));
p = p->next;
}
} /* debug: see comment at initdollopnode() */
if (treeprint)
fprintf(outfile, "\n\n");
evaluate(root);
printree(1.0, treeprint, root);
describe();
which++;
}
FClose(intree);
fprintf(outfile, "\n\n");
if (numtrees > 1 && chars > 1)
standev(numtrees, minwhich, minsteps, nsteps, fsteps, seed);
free(names);
}
if (jumb == njumble) {
if (progress) {
printf("Output written to file \"%s\"\n\n", outfilename);
if (trout)
printf("Trees also written onto file \"%s\"\n\n", outtreename);
}
if (ancseq)
freegarbage(&garbage);
}
} /* maketree */
void re_move( struct node * root,struct node *del){
if(del==NULL) return;
if(del->next==NULL && del->prev==NULL){
if(del->father==NULL){
del->name=NULL;
del->value=NULL;
}
else if(del==del->father->prev){
del->father->prev=NULL;
free(del);
}
else{
del->father->next=NULL;
free(del);
}
}
else
if(del->next==NULL||del->prev==NULL){
if(del->next==NULL){
if(del->father==NULL){
del->next=NULL;
root=del->next;
}
else
if(del->father->next==del){
del->father->next= del->prev;
del->prev->father=del->father;
free(del);
}
else
if(del->father->prev==del){
del->father->prev= del->prev;
del->prev->father=del->father;
free(del);
}
}
else
if(del->prev==NULL){
if(del->father==NULL){
del->prev=NULL;
root=del->prev;
}
else
if(del->father->prev==del){
del->father->prev=del->next;
del->next->father=del->father;
free(del);
}
else if (del->father->next==del){
del->father->next=del->next;
del->next->father=del->father;
free(del);
}
}
}
else{
struct node *temp;
temp=min(del->next);
del->value=temp->value;
del->name=temp->name;
re_move( root, temp);
}
}
