void addtraverse(node *p, node *q, boolean contin)
{ /* traverse through a tree, finding best place to add p */
insert_(p, q);
numtrees++;
if (evaluate(&curtree) > bestree.likelihood) {
copy_(&curtree, &bestree);
addwhere = q;
}
copy_(&priortree, &curtree);
if (!q->tip && contin) {
addtraverse(p, q->next->back, contin);
addtraverse(p, q->next->next->back, contin);
}
} /* addtraverse */
void addtraverse(node *p, node *q, boolean contin, long *numtrees,
boolean *succeeded)
{
/* traverse through a tree, finding best place to add p */
insert_(p, q, true);
(*numtrees)++;
if (evaluate(&curtree) > bestree.likelihood){
copy_(&curtree, &bestree);
(*succeeded)=true;
}
copy_(&priortree, &curtree);
if (!q->tip && contin) {
addtraverse(p, q->next->back, contin,numtrees,succeeded);
addtraverse(p, q->next->next->back, contin,numtrees,succeeded);
}
} /* addtraverse */
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 addtraverse(node2 *a, node2 *b, node2 *c, long *m, long *n,
valptr valyew, placeptr place)
{
/* traverse all places to add b */
if (done)
return;
if ((*m) <= 2 || !(noroot && (a == root || a == root->next->back))) {
add3(a, b, c, &root, treenode);
(*n)++;
evaluate(root);
examined++;
if (examined == howoften) {
examined = 0;
mults++;
if (mults == howmanny)
done = true;
if (progress) {
printf("%6ld", mults);
if (bestyet >= 0)
printf("%18.5f", bestyet);
else
printf(" - ");
printf("%17ld%20.2f\n", nextree - 1, fracdone * 100);
#ifdef WIN32
phyFillScreenColor();
#endif
}
}
valyew[(*n) - 1] = like;
place[(*n) - 1] = a->index;
re_move3(&b, &c, &root, treenode);
}
if (!a->tip) {
addtraverse(a->next->back, b, c, m,n,valyew,place);
addtraverse(a->next->next->back, b, c, m,n,valyew,place);
}
} /* addtraverse */
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()
{ /* construct the tree */
long i;
if (usertree) {
/* Open in binary: ftell() is broken for UNIX line-endings under WIN32 */
openfile(&intree,INTREE,"input tree file", "rb",progname,intreename);
numtrees = countsemic(&intree);
if(numtrees > MAXSHIMOTREES)
shimotrees = MAXSHIMOTREES;
else
shimotrees = numtrees;
if (numtrees > 2)
initseed(&inseed, &inseed0, seed);
if (treeprint) {
fprintf(outfile, "User-defined tree");
if (numtrees > 1)
putc('s', outfile);
putc('\n', outfile);
}
setuptree(&curtree, nonodes2);
for (which = 1; which <= spp; which++)
inittip(which, &curtree);
which = 1;
while (which <= numtrees) {
for (i = 0 ; i < nonodes2 ; i++) {
if ( i > spp) {
/* must do this since not all nodes may be used if an
unrooted tree is read in after a rooted one */
curtree.nodep[i]->back = NULL;
curtree.nodep[i]->next->back = NULL;
curtree.nodep[i]->next->next->back = NULL;
}
else curtree.nodep[i]->back = NULL;
}
treeread2 (intree, &curtree.start, curtree.nodep,
lengths, &trweight, &goteof, &haslengths, &spp,false,nonodes2);
curtree.start = curtree.nodep[outgrno - 1]->back;
treevaluate();
printree();
summarize();
which++;
}
FClose(intree);
if (numtrees > 1 && loci > 1 ) {
weight = (long *)Malloc(loci*sizeof(long));
for (i = 0; i < loci; i++)
weight[i] = 1;
standev2(numtrees, maxwhich, 0, loci-1, maxlogl, l0gl, l0gf, seed);
free(weight);
fprintf(outfile, "\n\n");
}
} else { /* if ( !usertree ) */
if (jumb == 1) {
setuptree(&curtree, nonodes2);
setuptree(&priortree, nonodes2);
setuptree(&bestree, nonodes2);
if (njumble > 1)
setuptree(&bestree2, nonodes2);
}
for (i = 1; i <= spp; i++)
enterorder[i - 1] = i;
if (jumble)
randumize(seed, enterorder);
nextsp = 3;
buildsimpletree(&curtree);
curtree.start = curtree.nodep[enterorder[0] - 1]->back;
if (jumb == 1) numtrees = 1;
nextsp = 4;
if (progress) {
printf("Adding species:\n");
writename(0, 3, enterorder);
#ifdef WIN32
phyFillScreenColor();
#endif
}
while (nextsp <= spp) {
buildnewtip(enterorder[nextsp - 1], &curtree, nextsp);
copy_(&curtree, &priortree);
bestree.likelihood = -DBL_MAX;
addtraverse(curtree.nodep[enterorder[nextsp - 1] - 1]->back,
curtree.start, true );
copy_(&bestree, &curtree);
if (progress) {
writename(nextsp - 1, 1, enterorder);
#ifdef WIN32
phyFillScreenColor();
#endif
}
if (global && nextsp == spp) {
if (progress) {
printf("\nDoing global rearrangements\n");
printf(" !");
for (i = 1; i <= spp - 2; i++)
if ( (i - spp) % (( nonodes2 / 72 ) + 1 ) == 0 )
putchar('-');
printf("!\n");
printf(" ");
}
}
succeeded = true;
while (succeeded) {
succeeded = false;
if ( global && nextsp == spp )
globrearrange();
else
rearrange(curtree.start);
if (global && nextsp == spp)
putc('\n', outfile);
}
if (global && nextsp == spp && progress)
putchar('\n');
if (njumble > 1) {
if (jumb == 1 && nextsp == spp)
copy_(&bestree, &bestree2);
else if (nextsp == spp) {
if (bestree2.likelihood < bestree.likelihood)
copy_(&bestree, &bestree2);
}
}
if (nextsp == spp && jumb == njumble) {
if (njumble > 1) copy_(&bestree2, &curtree);
curtree.start = curtree.nodep[outgrno - 1]->back;
printree();
summarize();
}
nextsp++;
}
}
if ( jumb < njumble)
return;
if (progress) {
printf("\nOutput written to file \"%s\"\n", outfilename);
if (trout)
printf("\nTree also written onto file \"%s\"\n", outtreename);
}
freeview(&curtree, nonodes2);
if (!usertree) {
freeview(&bestree, nonodes2);
freeview(&priortree, nonodes2);
}
for (i = 0; i < spp; i++)
free(x[i]);
if (!contchars) {
free(locus);
free(pbar);
}
} /* maketree */
void maketree()
{
/* contruct the tree */
long nextsp,numtrees;
boolean succeeded=false;
long i, j, which;
if (usertree) {
inputdata(replicates, printdata, lower, upper, x, reps);
setuptree(&curtree, nonodes2);
for (which = 1; which <= spp; which++)
setuptipf(which, &curtree);
if (eoln(infile)) {
fscanf(infile, "%*[^\n]");
getc(infile);
}
openfile(&intree,INTREE,"input tree file","r",progname,intreename);
fscanf(intree, "%ld%*[^\n]", &numtrees);
getc(intree);
if (numtrees > MAXNUMTREES) {
printf("\nERROR: number of input trees is read incorrectly from %s\n",
intreename);
exxit(-1);
}
if (treeprint) {
fprintf(outfile, "User-defined tree");
if (numtrees > 1)
putc('s', outfile);
fprintf(outfile, ":\n\n");
}
first = true;
which = 1;
while (which <= numtrees) {
treeread2 (intree, &curtree.start, curtree.nodep,
lengths, &trweight, &goteof, intreename, "Fitch",
&haslengths, &spp);
nums = spp;
curtree.start = curtree.nodep[outgrno - 1]->back;
treevaluate();
printree(&curtree, curtree.start, treeprint, false, false);
summarize(numtrees);
which++;
}
FClose(intree);
} else {
if (jumb == 1) {
inputdata(replicates, printdata, lower, upper, x, reps);
setuptree(&curtree, nonodes2);
setuptree(&priortree, nonodes2);
setuptree(&bestree, nonodes2);
if (njumble > 1) setuptree(&bestree2, nonodes2);
}
for (i = 1; i <= spp; i++)
enterorder[i - 1] = i;
if (jumble)
randumize(seed, enterorder);
nextsp = 3;
buildsimpletree(&curtree, nextsp);
curtree.start = curtree.nodep[enterorder[0] - 1]->back;
if (jumb == 1) numtrees = 1;
nextsp = 4;
if (progress) {
printf("Adding species:\n");
writename(0, 3, enterorder);
#ifdef WIN32
phyFillScreenColor();
#endif
}
while (nextsp <= spp) {
nums = nextsp;
buildnewtip(enterorder[nextsp - 1], &curtree, nextsp);
copy_(&curtree, &priortree);
bestree.likelihood = -99999.0;
addtraverse(curtree.nodep[enterorder[nextsp - 1] - 1]->back,
curtree.start, true, &numtrees,&succeeded);
copy_(&bestree, &curtree);
if (progress) {
writename(nextsp - 1, 1, enterorder);
#ifdef WIN32
phyFillScreenColor();
#endif
}
if (global && nextsp == spp) {
if (progress) {
printf("Doing global rearrangements\n");
printf(" !");
for (j = 1; j <= (spp - 2); j++)
putchar('-');
printf("!\n");
printf(" ");
}
}
succeeded = true;
while (succeeded) {
succeeded = false;
rearrange(curtree.start,
&numtrees,&nextsp,&succeeded);
if (global && ((nextsp) == spp) && progress)
printf("\n ");
}
if (global && nextsp == spp) {
putc('\n', outfile);
if (progress)
putchar('\n');
}
if (njumble > 1) {
if (jumb == 1 && nextsp == spp)
copy_(&bestree, &bestree2);
else if (nextsp == spp) {
if (bestree2.likelihood < bestree.likelihood)
copy_(&bestree, &bestree2);
}
}
if (nextsp == spp && jumb == njumble) {
if (njumble > 1) copy_(&bestree2, &curtree);
curtree.start = curtree.nodep[outgrno - 1]->back;
printree(&curtree, curtree.start, treeprint, true, false);
summarize(numtrees);
}
nextsp++;
}
}
if (jumb == njumble && progress) {
printf("\nOutput written to output file\n\n");
if (trout) {
printf("Tree also written onto file\n");
putchar('\n');
}
}
} /* maketree */
void addit(long m)
{
/* adds the species one by one, recursively */
long n;
valptr valyew;
placeptr place;
long i, j, n1, besttoadd = 0;
valptr bestval;
placeptr bestplace;
double oldfrac, oldfdone, sum, bestsum;
valyew = (valptr)Malloc(nonodes*sizeof(double));
bestval = (valptr)Malloc(nonodes*sizeof(double));
place = (placeptr)Malloc(nonodes*sizeof(long));
bestplace = (placeptr)Malloc(nonodes*sizeof(long));
if (simple && !firsttime) {
n = 0;
added[order[m - 1] - 1] = true;
addtraverse(root, treenode[order[m - 1] - 1],
treenode[spp + m - 2], &m,&n,valyew,place);
besttoadd = order[m - 1];
memcpy(bestplace, place, nonodes*sizeof(long));
memcpy(bestval, valyew, nonodes*sizeof(double));
} else {
bestsum = -1.0;
for (i = 1; i <= (spp); i++) {
if (!added[i - 1]) {
n = 0;
added[i - 1] = true;
addtraverse(root, treenode[i - 1], treenode[spp + m - 2], &m,
&n,valyew,place);
added[i - 1] = false;
sum = 0.0;
for (j = 0; j < (n); j++)
sum += valyew[j];
if (sum > bestsum) {
bestsum = sum;
besttoadd = i;
memcpy(bestplace, place, nonodes*sizeof(long));
memcpy(bestval, valyew, nonodes*sizeof(double));
}
}
}
}
order[m - 1] = besttoadd;
memcpy(place, bestplace, nonodes*sizeof(long));
memcpy(valyew, bestval, nonodes*sizeof(double));
shellsort(valyew, place, n);
oldfrac = fracinc;
oldfdone = fracdone;
n1 = 0;
for (i = 0; i < (n); i++) {
if (valyew[i] <= bestyet || bestyet < 0.0)
n1++;
}
if (n1 > 0)
fracinc /= n1;
for (i = 0; i < (n); i++) {
if (valyew[i] <= bestyet || bestyet < 0.0) {
current[m - 1] = place[i];
add3(treenode[place[i] - 1], treenode[besttoadd - 1],
treenode[spp + m - 2], &root, treenode);
added[besttoadd - 1] = true;
if (m < spp)
addit(m + 1);
else {
if (valyew[i] < bestyet || bestyet < 0.0) {
nextree = 1;
bestyet = valyew[i];
}
if (nextree <= maxtrees) {
memcpy(bestorders[nextree - 1], order,
spp*sizeof(long));
memcpy(bestrees[nextree - 1], current,
spp*sizeof(long));
}
nextree++;
firsttime = false;
}
re_move3(&treenode[besttoadd - 1], &treenode[spp + m - 2], &root, treenode);
added[besttoadd - 1] = false;
}
fracdone += fracinc;
}
fracinc = oldfrac;
fracdone = oldfdone;
free(valyew);
free(bestval);
free(place);
free(bestplace);
} /* addit */
