Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

utilities.c

Visit:

Last change on this file was 17478, checked in by westram, 7 years ago
reintegrates 'svalues' into 'trunk' implements #614 adds: log:branches/svalues@17357:17419,17428:17464,17469,17471:17477
File size: 250.5 KB

Line
1	/*
2
3	PhyML: a program that computes maximum likelihood phylogenies from
4	DNA or AA homologous sequences.
5
6	Copyright (C) Stephane Guindon. Oct 2003 onward.
7
8	All parts of the source except where indicated are distributed under
9	the GNU public licence. See http://www.opensource.org for details.
10
11	*/
12
13	#include "utilities.h"
14
15	//////////////////////////////////////////////////////////////
16	//////////////////////////////////////////////////////////////
17
18	phydbl String_To_Dbl(char *string)
19	{
20	phydbl buff;
21	char *endptr;
22
23	if(!string)
24	{
25	PhyML_Printf("\n== String object empty.");
26	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
27	Exit("\n");
28	}
29
30
31	buff = strtod(string,&endptr);
32	if(string == endptr \|\| errno == ERANGE)
33	{
34	PhyML_Printf("\n== Error in translating string '%s' to double.",string);
35	Exit("\n");
36	}
37	return buff;
38	}
39
40	//////////////////////////////////////////////////////////////
41	//////////////////////////////////////////////////////////////
42
43	void Unroot_Tree(char **subtrees)
44	{
45	char **tmp_sub;
46	int degree,i,j;
47
48	PhyML_Printf("\n. Removing the root...\n");
49
50	tmp_sub = Sub_Trees(subtrees[0],&degree);
51	if(degree >= 2)
52	{
53	strcpy(subtrees[2],subtrees[1]);
54	Clean_Multifurcation(tmp_sub,degree,2);
55	For(j,2) strcpy(subtrees[j],tmp_sub[j]);
56	}
57	else
58	{
59	tmp_sub = Sub_Trees(subtrees[1],&degree);
60	strcpy(subtrees[2],subtrees[0]);
61	Clean_Multifurcation(tmp_sub,degree,2);
62	For(j,2) strcpy(subtrees[j],tmp_sub[j]);
63	}
64
65	For(i,degree) Free(tmp_sub[i]);
66	Free(tmp_sub);
67	}
68
69	//////////////////////////////////////////////////////////////
70	//////////////////////////////////////////////////////////////
71
72	void Make_Edge_Dirs(t_edge b, t_node a, t_node d, t_tree tree)
73	{
74	int i;
75
76	if(a == b->rght)
77	{
78	PhyML_Printf("\n== a->num = %3d ; d->num = %3d",a->num,d->num);
79	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
80	Exit("\n");
81	}
82
83	if(d == b->left)
84	{
85	PhyML_Printf("\n== a->num = %3d ; d->num = %3d",a->num,d->num);
86	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
87	Exit("\n");
88	}
89
90	b->l_r = b->r_l = -1;
91	For(i,3)
92	{
93	/* if((a->v[i]) && ((a->v[i] == d) \|\| (e_root && a->b[i] == e_root))) */
94	if((a->v[i]) && ((a->v[i] == d)))
95	{
96	b->l_r = i; /* we consider here that 'a' is on the left handside of 'b'*/
97	a->b[i] = b;
98	}
99	/* if((d->v[i]) && ((d->v[i] == a) \|\| (e_root && d->b[i] == e_root))) */
100	if((d->v[i]) && ((d->v[i] == a)))
101	{
102	b->r_l = i; /* we consider here that 'd' is on the right handside of 'b'*/
103	d->b[i] = b;
104	}
105	}
106
107	if(a->tax) {b->r_l = 0; For(i,3) if(d->v[i]==a) {b->l_r = i; break;}}
108
109	b->l_v1 = b->l_v2 = b->r_v1 = b->r_v2 = -1;
110	For(i,3)
111	{
112	if(b->left->v[i] != b->rght)
113	{
114	if(b->l_v1 < 0) b->l_v1 = i;
115	else b->l_v2 = i;
116	}
117
118	if(b->rght->v[i] != b->left)
119	{
120	if(b->r_v1 < 0) b->r_v1 = i;
121	else b->r_v2 = i;
122	}
123	}
124	}
125
126	//////////////////////////////////////////////////////////////
127	//////////////////////////////////////////////////////////////
128
129	//////////////////////////////////////////////////////////////
130	//////////////////////////////////////////////////////////////
131
132	//////////////////////////////////////////////////////////////
133	//////////////////////////////////////////////////////////////
134
135
136	void Restrict_To_Coding_Position(align *data, option io)
137	{
138	int i,j,curr_pos;
139
140	if(io->codpos != -1)
141	{
142	For(i,io->n_otu)
143	{
144	curr_pos = 0;
145	for(j=io->codpos-1;j<data[i]->len;j+=3)
146	{
147	data[i]->state[curr_pos] = data[i]->state[j];
148	curr_pos++;
149	}
150	data[i]->len /= 3;
151	}
152	}
153	}
154
155
156
157	void Uppercase(char *ch)
158	{
159	/* convert ch to upper case -- either ASCII or EBCDIC */
160	ch = isupper((int)ch) ? ch : toupper((int)ch);
161	}
162
163	//////////////////////////////////////////////////////////////
164	//////////////////////////////////////////////////////////////
165
166
167	void Lowercase(char *ch)
168	{
169	/* convert ch to upper case -- either ASCII or EBCDIC */
170	ch = isupper((int)ch) ? tolower((int)ch) : ch;
171	}
172
173	//////////////////////////////////////////////////////////////
174	//////////////////////////////////////////////////////////////
175
176	calign Compact_Data(align data, option io)
177	{
178	calign cdata_tmp,cdata;
179	int i,j,k,site;
180	int n_patt,which_patt,n_invar;
181	char **sp_names;
182	int n_otu, n_sites;
183	pnode *proot;
184	int compress;
185	int n_ambigu,is_ambigu;
186
187	n_otu = io->n_otu;
188	n_patt = 0;
189	which_patt = 0;
190
191	sp_names = (char *)mCalloc(n_otu,sizeof(char ));
192	For(i,n_otu)
193	{
194	sp_names[i] = (char *)mCalloc(T_MAX_NAME,sizeof(char));
195	strcpy(sp_names[i],data[i]->name);
196	}
197
198	cdata_tmp = Make_Cseq(n_otu,data[0]->len,io->state_len,data[0]->len,sp_names);
199	proot = (pnode *)Create_Pnode(T_MAX_ALPHABET);
200
201	For(i,n_otu) Free(sp_names[i]);
202	Free(sp_names);
203
204	if(data[0]->len%io->state_len)
205	{
206	PhyML_Printf("\n== Sequence length is not a multiple of %d\n",io->state_len);
207	Exit("\n");
208	}
209
210	compress = io->colalias;
211	n_ambigu = 0;
212	is_ambigu = 0;
213
214	if(!io->quiet && !compress)
215	{
216	PhyML_Printf("\n== WARNING: sequences are not compressed !\n");
217	}
218
219	Fors(site,data[0]->len,io->state_len)
220	{
221	if(io->rm_ambigu)
222	{
223	is_ambigu = 0;
224	For(j,n_otu) if(Is_Ambigu(data[j]->state+site,io->datatype,io->state_len)) break;
225	if(j != n_otu)
226	{
227	is_ambigu = 1;
228	n_ambigu++;
229	}
230	}
231
232	if(!is_ambigu)
233	{
234	if(compress)
235	{
236	which_patt = -1;
237
238	Traverse_Prefix_Tree(site,-1,&which_patt,&n_patt,data,io,proot);
239	if(which_patt == n_patt-1) /* New pattern found */
240	{
241	n_patt--;
242	k=n_patt;
243	}
244	else
245	{
246	k = n_patt-10;
247	}
248	}
249	else
250	{
251	k = n_patt;
252	}
253
254	if(k == n_patt) /* add a new site pattern */
255	{
256	For(j,n_otu)
257	Copy_One_State(data[j]->state+site,
258	cdata_tmp->c_seq[j]->state+n_patt*io->state_len,
259	io->state_len);
260
261	For(i,n_otu)
262	{
263	For(j,n_otu)
264	{
265	if(!(Are_Compatible(cdata_tmp->c_seq[i]->state+n_patt*io->state_len,
266	cdata_tmp->c_seq[j]->state+n_patt*io->state_len,
267	io->state_len,
268	io->datatype))) break;
269	}
270	if(j != n_otu) break;
271	}
272
273	if((j == n_otu) && (i == n_otu)) /* all characters at that site are compatible with one another:
274	the site may be invariant */
275	{
276	For(j,n_otu)
277	{
278	cdata_tmp->invar[n_patt] = Assign_State(cdata_tmp->c_seq[j]->state+n_patt*io->state_len,
279	io->datatype,
280	io->state_len);
281
282	if(cdata_tmp->invar[n_patt] > -1.) break;
283	}
284	}
285	else cdata_tmp->invar[n_patt] = -1;
286
287	cdata_tmp->sitepatt[site] = n_patt;
288	cdata_tmp->wght[n_patt] += 1;
289	n_patt += 1;
290	}
291	else
292	{
293	cdata_tmp->sitepatt[site] = which_patt;
294	cdata_tmp->wght[which_patt] += 1;
295	}
296	}
297	}
298
299	data[0]->len -= n_ambigu;
300
301	cdata_tmp->init_len = data[0]->len;
302	cdata_tmp->crunch_len = n_patt;
303	For(i,n_otu) cdata_tmp->c_seq[i]->len = n_patt;
304
305	if(!io->quiet) PhyML_Printf("\n. %d patterns found (out of a total of %d sites). \n",n_patt,data[0]->len);
306
307	if((io->rm_ambigu) && (n_ambigu)) PhyML_Printf("\n. Removed %d columns of the alignment as they contain ambiguous characters (e.g., gaps) \n",n_ambigu);
308
309	/* For(i,n_otu) */
310	/* { */
311	/* For(j,cdata_tmp->crunch_len) */
312	/* { */
313	/* printf("%c",cdata_tmp->c_seq[i]->state[jio->state_len+1]); /
314	/* } */
315	/* printf("\n"); */
316	/* } */
317
318	n_invar=0;
319	For(i,cdata_tmp->crunch_len)
320	{
321	if(cdata_tmp->invar[i] > -1.) n_invar+=(int)cdata_tmp->wght[i];
322	}
323
324	if(!io->quiet) PhyML_Printf("\n. %d sites without polymorphism (%.2f%c).\n",n_invar,100.*(phydbl)n_invar/data[0]->len,'%');
325
326	cdata_tmp->obs_pinvar = (phydbl)n_invar/data[0]->len;
327
328	n_sites = 0;
329	For(i,cdata_tmp->crunch_len) n_sites += cdata_tmp->wght[i];
330	if(n_sites != data[0]->len / io->state_len)
331	{
332	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
333	Warn_And_Exit("");
334	}
335
336
337
338	if(io->datatype == NT) Get_Base_Freqs(cdata_tmp);
339	else if(io->datatype == AA) Get_AA_Freqs(cdata_tmp);
340	else {/* Uniform state frequency distribution.*/}
341
342	cdata = Copy_Cseq(cdata_tmp,io);
343
344	Free_Cseq(cdata_tmp);
345	Free_Prefix_Tree(proot,T_MAX_ALPHABET);
346
347	Check_Ambiguities(cdata,io->datatype,io->state_len);
348	Set_D_States(cdata,io->datatype,io->state_len);
349
350	return cdata;
351	}
352
353	//////////////////////////////////////////////////////////////
354	//////////////////////////////////////////////////////////////
355
356
357	calign Compact_Cdata(calign data, option *io)
358	{
359	calign *cdata;
360	int i,j,k,site;
361	int n_patt,which_patt;
362	int n_otu;
363
364	n_otu = data->n_otu;
365
366	cdata = (calign *)mCalloc(1,sizeof(calign));
367	cdata->n_otu = n_otu;
368	cdata->c_seq = (align *)mCalloc(n_otu,sizeof(align ));
369	cdata->wght = (int *)mCalloc(data->crunch_len,sizeof(int));
370	cdata->b_frq = (phydbl *)mCalloc(io->mod->ns,sizeof(phydbl));
371	cdata->ambigu = (short int *)mCalloc(data->crunch_len,sizeof(short int));
372	cdata->invar = (short int *)mCalloc(data->crunch_len,sizeof(short int));
373
374	cdata->crunch_len = cdata->init_len = -1;
375	For(j,n_otu)
376	{
377	cdata->c_seq[j] = (align *)mCalloc(1,sizeof(align));
378	cdata->c_seq[j]->name = (char *)mCalloc(T_MAX_NAME,sizeof(char));
379	strcpy(cdata->c_seq[j]->name,data->c_seq[j]->name);
380	cdata->c_seq[j]->state = (char *)mCalloc(data->crunch_len,sizeof(char));
381	cdata->c_seq[j]->is_ambigu = (short int *)mCalloc(data->crunch_len,sizeof(short int));
382	cdata->c_seq[j]->state[0] = data->c_seq[j]->state[0];
383	}
384
385
386	n_patt = which_patt = 0;
387
388	For(site,data->crunch_len)
389	{
390	if(data->wght[site])
391	{
392	For(k,n_patt)
393	{
394	For(j,n_otu)
395	{
396	if(strncmp(cdata->c_seq[j]->state+k*io->state_len,
397	data->c_seq[j]->state+site*io->state_len,
398	io->state_len))
399	break;
400	}
401
402	if(j == n_otu)
403	{
404	which_patt = k;
405	break;
406	}
407	}
408
409	/* /\* TO DO \/ /
410	/* k = n_patt; */
411
412	if(k == n_patt)
413	{
414	For(j,n_otu) Copy_One_State(data->c_seq[j]->state+site*io->state_len,
415	cdata->c_seq[j]->state+n_patt*io->state_len,
416	io->state_len);
417
418	For(i,n_otu)
419	{
420	For(j,n_otu)
421	{
422	if(!(Are_Compatible(cdata->c_seq[i]->state+n_patt*io->state_len,
423	cdata->c_seq[j]->state+n_patt*io->state_len,
424	io->state_len,
425	io->datatype))) break;
426	}
427	if(j != n_otu) break;
428	}
429
430	if((j == n_otu) && (i == n_otu))
431	{
432	For(j,n_otu)
433	{
434	cdata->invar[n_patt] = Assign_State(cdata->c_seq[j]->state+n_patt*io->state_len,
435	io->datatype,
436	io->state_len);
437
438	if(cdata->invar[n_patt] > -1.) break;
439	}
440	}
441	else cdata->invar[n_patt] = -1;
442
443	cdata->wght[n_patt] += data->wght[site];
444	n_patt+=1;
445	}
446	else cdata->wght[which_patt] += data->wght[site];
447
448	/* Print_Site(cdata,k,n_otu,"\n",io->stepsize); */
449	}
450	}
451
452	cdata->init_len = data->crunch_len;
453	cdata->crunch_len = n_patt;
454	For(i,n_otu) cdata->c_seq[i]->len = n_patt;
455
456	if(io->datatype == NT) Get_Base_Freqs(cdata);
457	else if(io->datatype == AA) Get_AA_Freqs(cdata);
458	else {/* Not implemented yet */}
459
460	return cdata;
461	}
462
463	//////////////////////////////////////////////////////////////
464	//////////////////////////////////////////////////////////////
465
466
467	void Traverse_Prefix_Tree(int site, int seqnum, int patt_num, int n_patt, align *data, option io, pnode *n)
468	{
469	if(seqnum == io->n_otu-1)
470	{
471	n->weight++;
472	if(n->weight == 1)
473	{
474	n->num = *n_patt;
475	(*n_patt) += 1;
476	}
477	(*patt_num) = n->num;
478	return;
479	}
480	else
481	{
482	int next_state;
483
484	next_state = -1;
485	next_state = Assign_State_With_Ambiguity(data[seqnum+1]->state+site,
486	io->datatype,
487	io->state_len);
488
489	if(!n->next[next_state]) n->next[next_state] = Create_Pnode(T_MAX_ALPHABET);
490	Traverse_Prefix_Tree(site,seqnum+1,patt_num,n_patt,data,io,n->next[next_state]);
491	}
492
493	}
494
495	//////////////////////////////////////////////////////////////
496	//////////////////////////////////////////////////////////////
497
498
499	pnode *Create_Pnode(int size)
500	{
501	pnode *n;
502	int i;
503
504	n = (pnode *)mCalloc(1,sizeof(pnode ));
505	n->next = (pnode *)mCalloc(size,sizeof(pnode ));
506	For(i,size) n->next[i] = NULL;
507	n->weight = 0;
508	n->num = -1;
509	return n;
510	}
511	//////////////////////////////////////////////////////////////
512	//////////////////////////////////////////////////////////////
513
514	//////////////////////////////////////////////////////////////
515	//////////////////////////////////////////////////////////////
516
517
518	void Get_Base_Freqs(calign *data)
519	{
520	int i,j,k;
521	phydbl A,C,G,T;
522	phydbl fA,fC,fG,fT;
523	int w;
524
525	fA = fC = fG = fT = .25;
526
527	For(k,8)
528	{
529	A = C = G = T = .0;
530	For(i,data->n_otu)
531	{
532	For(j,data->crunch_len)
533	{
534	w = data->wght[j];
535	if(w)
536	{
537	switch(data->c_seq[i]->state[j])
538	{
539	case 'A' : A+=w;
540	break;
541	case 'C' : C+=w;
542	break;
543	case 'G' : G+=w;
544	break;
545	case 'T' : T+=w;
546	break;
547	case 'U' : T+=w;
548	break;
549	case 'M' : C+=wfC/(fC+fA); A+=wfA/(fA+fC);
550	break;
551	case 'R' : G+=wfG/(fA+fG); A+=wfA/(fA+fG);
552	break;
553	case 'W' : T+=wfT/(fA+fT); A+=wfA/(fA+fT);
554	break;
555	case 'S' : C+=wfC/(fC+fG); G+=wfG/(fC+fG);
556	break;
557	case 'Y' : C+=wfC/(fC+fT); T+=wfT/(fT+fC);
558	break;
559	case 'K' : G+=wfG/(fG+fT); T+=wfT/(fT+fG);
560	break;
561	case 'B' : C+=wfC/(fC+fG+fT); G+=wfG/(fC+fG+fT); T+=w*fT/(fC+fG+fT);
562	break;
563	case 'D' : A+=wfA/(fA+fG+fT); G+=wfG/(fA+fG+fT); T+=w*fT/(fA+fG+fT);
564	break;
565	case 'H' : A+=wfA/(fA+fC+fT); C+=wfC/(fA+fC+fT); T+=w*fT/(fA+fC+fT);
566	break;
567	case 'V' : A+=wfA/(fA+fC+fG); C+=wfC/(fA+fC+fG); G+=w*fG/(fA+fC+fG);
568	break;
569	case 'N' : case 'X' : case '?' : case 'O' : case '-' :
570	A+=wfA; C+=wfC; G+=wfG; T+=wfT; break;
571	default : break;
572	}
573	}
574	}
575	}
576	fA = A/(A+C+G+T);
577	fC = C/(A+C+G+T);
578	fG = G/(A+C+G+T);
579	fT = T/(A+C+G+T);
580	}
581
582	data->b_frq[0] = fA;
583	data->b_frq[1] = fC;
584	data->b_frq[2] = fG;
585	data->b_frq[3] = fT;
586	}
587
588	//////////////////////////////////////////////////////////////
589	//////////////////////////////////////////////////////////////
590
591
592	void Get_AA_Freqs(calign *data)
593	{
594	int i,j,k;
595	phydbl A,C,D,E,F,G,H,I,K,L,M,N,P,Q,R,S,T,V,W,Y;
596	phydbl fA,fC,fD,fE,fF,fG,fH,fI,fK,fL,fM,fN,fP,fQ,fR,fS,fT,fV,fW,fY;
597	int w;
598	phydbl sum;
599
600	fA = fC = fD = fE = fF = fG = fH = fI = fK = fL =
601	fM = fN = fP = fQ = fR = fS = fT = fV = fW = fY = 1./20.;
602
603	For(k,8)
604	{
605	A = C = D = E = F = G = H = I = K = L =
606	M = N = P = Q = R = S = T = V = W = Y = .0;
607
608	For(i,data->n_otu)
609	{
610	For(j,data->crunch_len)
611	{
612	w = data->wght[j];
613	if(w)
614	{
615	switch(data->c_seq[i]->state[j])
616	{
617	case 'A' : A+=w; break;
618	case 'C' : C+=w; break;
619	case 'D' : D+=w; break;
620	case 'E' : E+=w; break;
621	case 'F' : F+=w; break;
622	case 'G' : G+=w; break;
623	case 'H' : H+=w; break;
624	case 'I' : I+=w; break;
625	case 'K' : K+=w; break;
626	case 'L' : L+=w; break;
627	case 'M' : M+=w; break;
628	case 'N' : N+=w; break;
629	case 'P' : P+=w; break;
630	case 'Q' : Q+=w; break;
631	case 'R' : R+=w; break;
632	case 'S' : S+=w; break;
633	case 'T' : T+=w; break;
634	case 'V' : V+=w; break;
635	case 'W' : W+=w; break;
636	case 'Y' : Y+=w; break;
637	case 'Z' : Q+=w; break;
638	case 'X' : case '?' : case 'O' : case '-' :
639	A+=w*fA;
640	C+=w*fC;
641	D+=w*fD;
642	E+=w*fE;
643	F+=w*fF;
644	G+=w*fG;
645	H+=w*fH;
646	I+=w*fI;
647	K+=w*fK;
648	L+=w*fL;
649	M+=w*fM;
650	N+=w*fN;
651	P+=w*fP;
652	Q+=w*fQ;
653	R+=w*fR;
654	S+=w*fS;
655	T+=w*fT;
656	V+=w*fV;
657	W+=w*fW;
658	Y+=w*fY;
659	break;
660	default : break;
661	}
662	}
663	}
664	}
665	sum = (A+C+D+E+F+G+H+I+K+L+M+N+P+Q+R+S+T+V+W+Y);
666	fA = A/sum; fC = C/sum; fD = D/sum; fE = E/sum;
667	fF = F/sum; fG = G/sum; fH = H/sum; fI = I/sum;
668	fK = K/sum; fL = L/sum; fM = M/sum; fN = N/sum;
669	fP = P/sum; fQ = Q/sum; fR = R/sum; fS = S/sum;
670	fT = T/sum; fV = V/sum; fW = W/sum; fY = Y/sum;
671	}
672
673	data->b_frq[0] = fA; data->b_frq[1] = fR; data->b_frq[2] = fN; data->b_frq[3] = fD;
674	data->b_frq[4] = fC; data->b_frq[5] = fQ; data->b_frq[6] = fE; data->b_frq[7] = fG;
675	data->b_frq[8] = fH; data->b_frq[9] = fI; data->b_frq[10] = fL; data->b_frq[11] = fK;
676	data->b_frq[12] = fM; data->b_frq[13] = fF; data->b_frq[14] = fP; data->b_frq[15] = fS;
677	data->b_frq[16] = fT; data->b_frq[17] = fW; data->b_frq[18] = fY; data->b_frq[19] = fV;
678
679	}
680
681	//////////////////////////////////////////////////////////////
682	//////////////////////////////////////////////////////////////
683
684
685	// Swap the nodes on the left and right of e1 with the nodes
686	// on the left and right of e2 respectively, or on the
687	// right and left of e2 if swap == YES
688
689	void Swap_Nodes_On_Edges(t_edge e1, t_edge e2, int swap, t_tree *tree)
690	{
691	t_node *buff;
692
693	e1->left->l[e1->l_r] = e1->l->v;
694	e1->rght->l[e1->r_l] = e1->l->v;
695
696	e2->left->l[e2->l_r] = e2->l->v;
697	e2->rght->l[e2->r_l] = e2->l->v;
698
699	printf("\n. Swap edge %d (%d %d) with %d (%d %d)",e1->num,e1->left->num,e1->rght->num,e2->num,e2->left->num,e2->rght->num);
700
701	if(swap == NO)
702	{
703	buff = e1->left;
704	e1->left = e2->left;
705	e2->left = buff;
706
707	buff = e1->rght;
708	e1->rght = e2->rght;
709	e2->rght = buff;
710
711	}
712	else
713	{
714	buff = e1->left;
715	e1->left = e2->rght;
716	e2->rght = buff;
717
718	buff = e1->rght;
719	e1->rght = e2->left;
720	e2->left = buff;
721	}
722
723	Connect_One_Edge_To_Two_Nodes(e1->left,e1->rght,e1,tree);
724	Connect_One_Edge_To_Two_Nodes(e2->left,e2->rght,e2,tree);
725	}
726
727	//////////////////////////////////////////////////////////////
728	//////////////////////////////////////////////////////////////
729
730	void Connect_Edges_To_Nodes_Recur(t_node a, t_node d, t_tree *tree)
731	{
732	int i;
733
734	Connect_One_Edge_To_Two_Nodes(a,d,tree->a_edges[tree->num_curr_branch_available],tree);
735
736	if(d->tax) return;
737	else For(i,3) if(d->v[i] != a) Connect_Edges_To_Nodes_Recur(d,d->v[i],tree);
738	}
739
740	//////////////////////////////////////////////////////////////
741	//////////////////////////////////////////////////////////////
742
743	void Connect_One_Edge_To_Two_Nodes(t_node a, t_node d, t_edge b, t_tree tree)
744	{
745	int i,dir_a_d,dir_d_a;
746
747	dir_a_d = -1;
748	For(i,3) if(a->v[i] == d) {dir_a_d = i; break;}
749
750	dir_d_a = -1;
751	For(i,3) if(d->v[i] == a) {dir_d_a = i; break;}
752
753	if(dir_a_d == -1 \|\| dir_d_a == -1)
754	{
755	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
756	Warn_And_Exit("");
757	}
758
759	a->b[dir_a_d] = b;
760	d->b[dir_d_a] = b;
761	b->num = tree->num_curr_branch_available;
762	b->left = a;
763	b->rght = d;
764	if(a->tax) {b->rght = a; b->left = d;} /* root */
765	/* a tip is necessary on the right hand side of the t_edge */
766
767	tree->num_curr_branch_available += 1;
768
769	(b->left == a)?
770	(Make_Edge_Dirs(b,a,d,tree)):
771	(Make_Edge_Dirs(b,d,a,tree));
772
773	b->l->v = a->l[b->l_r];
774	if(a->tax) b->l->v = a->l[b->r_l];
775	b->l_old->v = b->l->v;
776	}
777
778	//////////////////////////////////////////////////////////////
779	//////////////////////////////////////////////////////////////
780
781	void Update_Dirs(t_tree *tree)
782	{
783	int i;
784	int buff;
785	t_edge *b;
786
787	b = NULL;
788	buff = -1;
789	For(i,2*tree->n_otu-3)
790	{
791	b = tree->a_edges[i];
792
793	if((!b->left->tax) && (b->left->v[b->l_v1]->num < b->left->v[b->l_v2]->num))
794	{
795	buff = b->l_v1;
796	b->l_v1 = b->l_v2;
797	b->l_v2 = buff;
798	}
799	if((!b->rght->tax) && (b->rght->v[b->r_v1]->num < b->rght->v[b->r_v2]->num))
800	{
801	buff = b->r_v1;
802	b->r_v1 = b->r_v2;
803	b->r_v2 = buff;
804	}
805	}
806
807	}
808
809	//////////////////////////////////////////////////////////////
810	//////////////////////////////////////////////////////////////
811
812	void Exit(char *message)
813	{
814	fflush(NULL);
815	PhyML_Fprintf(stderr,"%s",message);
816	exit(1);
817	}
818
819	//////////////////////////////////////////////////////////////
820	//////////////////////////////////////////////////////////////
821
822
823	void *mCalloc(int nb, size_t size)
824	{
825	void *allocated;
826
827	if((allocated = calloc((size_t)nb,size)) != NULL)
828	/* if((allocated = malloc((size_t)nb(size_t)size)) != NULL) /
829	{
830	return allocated;
831	}
832	else
833	Exit("\n== Err: low memory\n");
834
835	return NULL;
836	}
837
838	//////////////////////////////////////////////////////////////
839	//////////////////////////////////////////////////////////////
840
841	void mRealloc(void p,int nb, size_t size)
842	{
843	if((p = realloc(p,(size_t)nb*size)) != NULL)
844	return p;
845	else
846	Exit("\n== Err: low memory\n");
847
848	return NULL;
849	}
850
851	//////////////////////////////////////////////////////////////
852	//////////////////////////////////////////////////////////////
853
854
855	/* t_tree Make_Light_Tree_Struct(int n_otu) /
856	/* { */
857	/* t_tree tree; /
858	/* int i; */
859
860	/* tree = (t_tree )mCalloc(1,sizeof(t_tree )); /
861	/* tree->a_edges = (t_edge *)mCalloc(2n_otu-3,sizeof(t_edge )); /
862	/* tree->a_nodes = (t_node *)mCalloc(2n_otu-2,sizeof(t_node )); /
863	/* tree->n_otu = n_otu; */
864
865	/* For(i,2n_otu-3) /
866	/* tree->a_edges[i] = Make_Edge_Light(NULL,NULL,i); */
867
868	/* For(i,2n_otu-2) /
869	/* tree->a_nodes[i] = Make_Node_Light(i); */
870
871	/* return tree; */
872	/* } */
873
874	//////////////////////////////////////////////////////////////
875	//////////////////////////////////////////////////////////////
876
877
878	int Sort_Phydbl_Decrease(const void a, const void b)
879	{
880	if(((phydbl )(a)) >= ((phydbl )(b))) return -1;
881	else return 1;
882	}
883
884	//////////////////////////////////////////////////////////////
885	//////////////////////////////////////////////////////////////
886
887
888	void Qksort_Int(int A, int B, int ilo, int ihi)
889	{
890	phydbl pivot; // pivot value for partitioning array
891	int ulo, uhi; // indices at ends of unpartitioned region
892	int ieq; // least index of array entry with value equal to pivot
893	int tempEntry; // temporary entry used for swapping
894
895	if (ilo >= ihi) {
896	return;
897	}
898	// Select a pivot value.
899	pivot = A[(ilo + ihi)/2];
900	// Initialize ends of unpartitioned region and least index of entry
901	// with value equal to pivot.
902	ieq = ulo = ilo;
903	uhi = ihi;
904	// While the unpartitioned region is not empty, try to reduce its size.
905	while (ulo <= uhi) {
906	if (A[uhi] > pivot) {
907	// Here, we can reduce the size of the unpartitioned region and
908	// try again.
909	uhi--;
910	} else {
911	// Here, A[uhi] <= pivot, so swap entries at indices ulo and
912	// uhi.
913	tempEntry = A[ulo];
914	A[ulo] = A[uhi];
915	A[uhi] = tempEntry;
916
917	if(B)
918	{
919	tempEntry = B[ulo];
920	B[ulo] = B[uhi];
921	B[uhi] = tempEntry;
922	}
923
924
925
926	// After the swap, A[ulo] <= pivot.
927	if (A[ulo] < pivot) {
928	// Swap entries at indices ieq and ulo.
929	tempEntry = A[ieq];
930	A[ieq] = A[ulo];
931	A[ulo] = tempEntry;
932
933
934	if(B)
935	{
936	tempEntry = B[ieq];
937	B[ieq] = B[ulo];
938	B[ulo] = tempEntry;
939	}
940
941
942	// After the swap, A[ieq] < pivot, so we need to change
943	// ieq.
944	ieq++;
945	// We also need to change ulo, but we also need to do
946	// that when A[ulo] = pivot, so we do it after this if
947	// statement.
948	}
949	// Once again, we can reduce the size of the unpartitioned
950	// region and try again.
951	ulo++;
952	}
953	}
954	// Now, all entries from index ilo to ieq - 1 are less than the pivot
955	// and all entries from index uhi to ihi + 1 are greater than the
956	// pivot. So we have two regions of the array that can be sorted
957	// recursively to put all of the entries in order.
958	Qksort_Int(A, B, ilo, ieq - 1);
959	Qksort_Int(A, B, uhi + 1, ihi);
960
961	}
962
963	//////////////////////////////////////////////////////////////
964	//////////////////////////////////////////////////////////////
965
966
967	/* Sort in ascending order. Elements in B (if provided) are also re-ordered according to the ordering of A */
968	void Qksort(phydbl A, phydbl B, int ilo, int ihi)
969	{
970	phydbl pivot; // pivot value for partitioning array
971	int ulo, uhi; // indices at ends of unpartitioned region
972	int ieq; // least index of array entry with value equal to pivot
973	phydbl tempEntry; // temporary entry used for swapping
974
975	if (ilo >= ihi) {
976	return;
977	}
978	// Select a pivot value.
979	pivot = A[(ilo + ihi)/2];
980	// Initialize ends of unpartitioned region and least index of entry
981	// with value equal to pivot.
982	ieq = ulo = ilo;
983	uhi = ihi;
984	// While the unpartitioned region is not empty, try to reduce its size.
985	while (ulo <= uhi) {
986	if (A[uhi] > pivot) {
987	// Here, we can reduce the size of the unpartitioned region and
988	// try again.
989	uhi--;
990	} else {
991	// Here, A[uhi] <= pivot, so swap entries at indices ulo and
992	// uhi.
993	tempEntry = A[ulo];
994	A[ulo] = A[uhi];
995	A[uhi] = tempEntry;
996
997	if(B)
998	{
999	tempEntry = B[ulo];
1000	B[ulo] = B[uhi];
1001	B[uhi] = tempEntry;
1002	}
1003
1004
1005
1006	// After the swap, A[ulo] <= pivot.
1007	if (A[ulo] < pivot) {
1008	// Swap entries at indices ieq and ulo.
1009	tempEntry = A[ieq];
1010	A[ieq] = A[ulo];
1011	A[ulo] = tempEntry;
1012
1013
1014	if(B)
1015	{
1016	tempEntry = B[ieq];
1017	B[ieq] = B[ulo];
1018	B[ulo] = tempEntry;
1019	}
1020
1021
1022	// After the swap, A[ieq] < pivot, so we need to change
1023	// ieq.
1024	ieq++;
1025	// We also need to change ulo, but we also need to do
1026	// that when A[ulo] = pivot, so we do it after this if
1027	// statement.
1028	}
1029	// Once again, we can reduce the size of the unpartitioned
1030	// region and try again.
1031	ulo++;
1032	}
1033	}
1034	// Now, all entries from index ilo to ieq - 1 are less than the pivot
1035	// and all entries from index uhi to ihi + 1 are greater than the
1036	// pivot. So we have two regions of the array that can be sorted
1037	// recursively to put all of the entries in order.
1038	Qksort(A, B, ilo, ieq - 1);
1039	Qksort(A, B, uhi + 1, ihi);
1040	}
1041
1042	/********************************************************/
1043
1044	void Qksort_Matrix(phydbl **A, int col, int ilo, int ihi)
1045	{
1046	phydbl pivot; // pivot value for partitioning array
1047	int ulo, uhi; // indices at ends of unpartitioned region
1048	int ieq; // least index of array entry with value equal to pivot
1049	phydbl *tempEntry; // temporary entry used for swapping
1050
1051	tempEntry = NULL;
1052
1053	if (ilo >= ihi) {
1054	return;
1055	}
1056	// Select a pivot value.
1057	pivot = A[(ilo + ihi)/2][col];
1058	// Initialize ends of unpartitioned region and least index of entry
1059	// with value equal to pivot.
1060	ieq = ulo = ilo;
1061	uhi = ihi;
1062	// While the unpartitioned region is not empty, try to reduce its size.
1063	while (ulo <= uhi) {
1064	if (A[uhi][col] > pivot) {
1065	// Here, we can reduce the size of the unpartitioned region and
1066	// try again.
1067	uhi--;
1068	} else {
1069	// Here, A[uhi] <= pivot, so swap entries at indices ulo and
1070	// uhi.
1071	tempEntry = A[ulo];
1072	A[ulo] = A[uhi];
1073	A[uhi] = tempEntry;
1074	// After the swap, A[ulo] <= pivot.
1075	if (A[ulo][col] < pivot) {
1076	// Swap entries at indices ieq and ulo.
1077	tempEntry = A[ieq];
1078	A[ieq] = A[ulo];
1079	A[ulo] = tempEntry;
1080	// After the swap, A[ieq] < pivot, so we need to change
1081	// ieq.
1082	ieq++;
1083	// We also need to change ulo, but we also need to do
1084	// that when A[ulo] = pivot, so we do it after this if
1085	// statement.
1086	}
1087	// Once again, we can reduce the size of the unpartitioned
1088	// region and try again.
1089	ulo++;
1090	}
1091	}
1092	// Now, all entries from index ilo to ieq - 1 are less than the pivot
1093	// and all entries from index uhi to ihi + 1 are greater than the
1094	// pivot. So we have two regions of the array that can be sorted
1095	// recursively to put all of the entries in order.
1096	Qksort_Matrix(A, col, ilo, ieq - 1);
1097	Qksort_Matrix(A, col, uhi + 1, ihi);
1098	}
1099
1100
1101	//////////////////////////////////////////////////////////////
1102	//////////////////////////////////////////////////////////////
1103
1104	char Add_Taxa_To_Constraint_Tree(FILE fp, calign *cdata)
1105	{
1106	char line,long_line;
1107	t_tree *tree;
1108	int i,j;
1109
1110	rewind(fp);
1111
1112	line = Return_Tree_String_Phylip(fp);
1113	tree = Read_Tree(&line);
1114
1115	long_line = (char *)mCalloc(T_MAX_LINE,sizeof(char));
1116	strcpy(long_line,line);
1117
1118	long_line[strlen(line)-1] = '\0';
1119
1120	For(i,cdata->n_otu)
1121	{
1122	For(j,tree->n_otu)
1123	{
1124	if(!strcmp(tree->a_nodes[j]->name,cdata->c_seq[i]->name))
1125	break;
1126	}
1127
1128	if(j == tree->n_otu)
1129	{
1130	strcat(long_line,",");
1131	strcat(long_line,cdata->c_seq[i]->name);
1132	}
1133
1134	}
1135
1136	strcat(long_line,");");
1137
1138	Free_Tree(tree);
1139	Free(line);
1140
1141
1142	return long_line;
1143	}
1144
1145	//////////////////////////////////////////////////////////////
1146	//////////////////////////////////////////////////////////////
1147
1148	void Check_Constraint_Tree_Taxa_Names(t_tree tree, calign cdata)
1149	{
1150	int i,j,n_otu_tree,n_otu_cdata;
1151
1152	n_otu_tree = tree->n_otu;
1153	n_otu_cdata = cdata->n_otu;
1154
1155	For(i,n_otu_tree)
1156	{
1157	For(j,n_otu_cdata)
1158	{
1159	if(!strcmp(tree->a_nodes[i]->name,cdata->c_seq[j]->name))
1160	break;
1161	}
1162
1163	if(j==n_otu_cdata)
1164	{
1165	PhyML_Printf("\n. '%s' was not found in sequence data set\n",tree->a_nodes[i]->name);
1166	Warn_And_Exit("");
1167	}
1168	}
1169	}
1170
1171	//////////////////////////////////////////////////////////////
1172	//////////////////////////////////////////////////////////////
1173
1174	void Copy_Tax_Names_To_Tip_Labels(t_tree tree, calign data)
1175	{
1176	int i;
1177
1178	For(i,tree->n_otu)
1179	{
1180	tree->a_nodes[i]->name = (char *)mCalloc((int)strlen(data->c_seq[i]->name)+1,sizeof(char));
1181	tree->a_nodes[i]->ori_name = tree->a_nodes[i]->name;
1182	strcpy(tree->a_nodes[i]->name,data->c_seq[i]->name);
1183	tree->a_nodes[i]->tax = 1;
1184	tree->a_nodes[i]->num = i;
1185	}
1186	}
1187
1188	//////////////////////////////////////////////////////////////
1189	//////////////////////////////////////////////////////////////
1190
1191	void Share_Lk_Struct(t_tree t_full, t_tree t_empt)
1192	{
1193	int i,j,n_otu;
1194	t_edge b_e,b_f;
1195	t_node n_e, n_f;
1196
1197	n_otu = t_full->n_otu;
1198	t_empt->n_root = t_full->n_root;
1199	t_empt->e_root = t_full->e_root;
1200	t_empt->c_lnL_sorted = t_full->c_lnL_sorted;
1201	t_empt->log_site_lk_cat = t_full->log_site_lk_cat;
1202	t_empt->cur_site_lk = t_full->cur_site_lk;
1203	t_empt->old_site_lk = t_full->old_site_lk;
1204	t_empt->triplet_struct = t_full->triplet_struct;
1205	t_empt->log_lks_aLRT = t_full->log_lks_aLRT;
1206	t_empt->site_lk_cat = t_full->site_lk_cat;
1207
1208	For(i,2*n_otu-3)
1209	{
1210	b_f = t_full->a_edges[i];
1211	b_e = t_empt->a_edges[i];
1212
1213	b_e->Pij_rr = b_f->Pij_rr;
1214
1215	b_e->nni = b_f->nni;
1216	}
1217
1218
1219	for(i=n_otu;i<2*n_otu-2;i++)
1220	{
1221	n_f = t_full->a_nodes[i];
1222	n_e = t_empt->a_nodes[i];
1223
1224	For(j,3)
1225	{
1226	if(n_f->b[j]->left == n_f)
1227	{
1228	if(n_e->b[j]->left == n_e)
1229	{
1230	n_e->b[j]->p_lk_left = n_f->b[j]->p_lk_left;
1231	n_e->b[j]->p_lk_loc_left = n_f->b[j]->p_lk_loc_left;
1232	n_e->b[j]->patt_id_left = n_f->b[j]->patt_id_left;
1233	n_e->b[j]->sum_scale_left = n_f->b[j]->sum_scale_left;
1234	n_e->b[j]->sum_scale_left_cat = n_f->b[j]->sum_scale_left_cat;
1235	n_e->b[j]->p_lk_tip_l = n_f->b[j]->p_lk_tip_l;
1236	}
1237	else
1238	{
1239	n_e->b[j]->p_lk_rght = n_f->b[j]->p_lk_left;
1240	n_e->b[j]->p_lk_loc_rght = n_f->b[j]->p_lk_loc_left;
1241	n_e->b[j]->patt_id_rght = n_f->b[j]->patt_id_left;
1242	n_e->b[j]->sum_scale_rght = n_f->b[j]->sum_scale_left;
1243	n_e->b[j]->sum_scale_rght_cat = n_f->b[j]->sum_scale_left_cat;
1244	n_e->b[j]->p_lk_tip_r = n_f->b[j]->p_lk_tip_l;
1245	}
1246	}
1247	else
1248	{
1249	if(n_e->b[j]->rght == n_e)
1250	{
1251	n_e->b[j]->p_lk_rght = n_f->b[j]->p_lk_rght;
1252	n_e->b[j]->p_lk_loc_rght = n_f->b[j]->p_lk_loc_rght;
1253	n_e->b[j]->patt_id_rght = n_f->b[j]->patt_id_rght;
1254	n_e->b[j]->sum_scale_rght = n_f->b[j]->sum_scale_rght;
1255	n_e->b[j]->sum_scale_rght_cat = n_f->b[j]->sum_scale_rght_cat;
1256	n_e->b[j]->p_lk_tip_r = n_f->b[j]->p_lk_tip_r;
1257	}
1258	else
1259	{
1260	n_e->b[j]->p_lk_left = n_f->b[j]->p_lk_rght;
1261	n_e->b[j]->p_lk_loc_left = n_f->b[j]->p_lk_loc_rght;
1262	n_e->b[j]->patt_id_left = n_f->b[j]->patt_id_rght;
1263	n_e->b[j]->sum_scale_left = n_f->b[j]->sum_scale_rght;
1264	n_e->b[j]->sum_scale_left_cat = n_f->b[j]->sum_scale_rght_cat;
1265	n_e->b[j]->p_lk_tip_l = n_f->b[j]->p_lk_tip_r;
1266	}
1267	}
1268	}
1269	}
1270
1271	For(i,n_otu)
1272	{
1273	n_f = t_full->a_nodes[i];
1274	n_e = t_empt->a_nodes[i];
1275
1276	if(n_f->b[0]->rght == n_f)
1277	{
1278	n_e->b[0]->p_lk_rght = n_f->b[0]->p_lk_rght;
1279	n_e->b[0]->p_lk_loc_rght = n_f->b[0]->p_lk_loc_rght;
1280	n_e->b[0]->patt_id_rght = n_f->b[0]->patt_id_rght;
1281	n_e->b[0]->sum_scale_rght = n_f->b[0]->sum_scale_rght;
1282	n_e->b[0]->sum_scale_rght_cat = n_f->b[0]->sum_scale_rght_cat;
1283	n_e->b[0]->p_lk_tip_r = n_f->b[0]->p_lk_tip_r;
1284	}
1285	else
1286	{
1287	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
1288	Warn_And_Exit("");
1289	}
1290	}
1291	}
1292
1293	//////////////////////////////////////////////////////////////
1294	//////////////////////////////////////////////////////////////
1295
1296	void Share_Spr_Struct(t_tree t_full, t_tree t_empt)
1297	{
1298	t_empt->size_spr_list = t_full->size_spr_list;
1299	t_empt->spr_list = t_full->spr_list;
1300	t_empt->best_spr = t_full->best_spr;
1301	}
1302
1303	//////////////////////////////////////////////////////////////
1304	//////////////////////////////////////////////////////////////
1305
1306
1307	void Share_Pars_Struct(t_tree t_full, t_tree t_empt)
1308	{
1309	int i;
1310
1311	t_empt->site_pars = t_full->site_pars;
1312	t_empt->step_mat = t_full->step_mat;
1313
1314	For(i,2*t_full->n_otu-3)
1315	{
1316	t_empt->a_edges[i]->ui_l = t_full->a_edges[i]->ui_l;
1317	t_empt->a_edges[i]->ui_r = t_full->a_edges[i]->ui_r;
1318
1319	t_empt->a_edges[i]->pars_l = t_full->a_edges[i]->pars_l;
1320	t_empt->a_edges[i]->pars_r = t_full->a_edges[i]->pars_r;
1321
1322	t_empt->a_edges[i]->p_pars_l = t_full->a_edges[i]->p_pars_l;
1323	t_empt->a_edges[i]->p_pars_r = t_full->a_edges[i]->p_pars_r;
1324	}
1325	}
1326
1327	//////////////////////////////////////////////////////////////
1328	//////////////////////////////////////////////////////////////
1329
1330
1331
1332	int Sort_Edges_NNI_Score(t_tree tree, t_edge *sorted_edges, int n_elem)
1333	{
1334	int i,j;
1335	t_edge *buff;
1336
1337	For(i,n_elem-1)
1338	{
1339	for(j=i+1;j<n_elem;j++)
1340	{
1341	if(sorted_edges[j]->nni->score < sorted_edges[i]->nni->score)
1342	{
1343	buff = sorted_edges[j];
1344	sorted_edges[j] = sorted_edges[i];
1345	sorted_edges[i] = buff;
1346	}
1347	}
1348	}
1349	return 1;
1350	}
1351
1352	//////////////////////////////////////////////////////////////
1353	//////////////////////////////////////////////////////////////
1354
1355	int Sort_Edges_Depth(t_tree tree, t_edge *sorted_edges, int n_elem)
1356	{
1357	int i,j;
1358	t_edge *buff;
1359	phydbl *depth,buff_depth;
1360
1361	depth = (phydbl *)mCalloc(n_elem,sizeof(phydbl));
1362
1363	For(i,n_elem)
1364	depth[i] =
1365	sorted_edges[i]->left->bip_size[sorted_edges[i]->l_r] *
1366	sorted_edges[i]->rght->bip_size[sorted_edges[i]->r_l] ;
1367
1368
1369	For(i,n_elem-1)
1370	{
1371	for(j=i+1;j<n_elem;j++)
1372	{
1373	if(depth[i] > depth[j])
1374	{
1375	buff = sorted_edges[i];
1376	sorted_edges[i] = sorted_edges[j];
1377	sorted_edges[j] = buff;
1378
1379	buff_depth = depth[i];
1380	depth[i] = depth[j];
1381	depth[j] = buff_depth;
1382	}
1383	}
1384	}
1385
1386	Free(depth);
1387
1388	return 1;
1389	}
1390
1391	//////////////////////////////////////////////////////////////
1392	//////////////////////////////////////////////////////////////
1393
1394	void NNI(t_tree tree, t_edge b_fcus, int do_swap)
1395	{
1396	t_node v1,v2,v3,v4;
1397	phydbl lk0, lk1, lk2;
1398	phydbl lk0_init, lk1_init, lk2_init;
1399	phydbl l0,l1,*l2;
1400	phydbl l_infa, l_infb;
1401	phydbl lk_init;
1402	t_edge *b;
1403	int i;
1404
1405	if(tree->prev)
1406	{
1407	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
1408	Exit("\n");
1409	}
1410
1411	lk_init = tree->c_lnL;
1412	b_fcus->nni->init_l = b_fcus->l->v;
1413	b_fcus->nni->init_lk = tree->c_lnL;;
1414	b_fcus->nni->best_conf = 0;
1415	b_fcus->nni->score = +1.0;
1416	lk0 = lk1 = lk2 = UNLIKELY;
1417	v1 = v2 = v3 = v4 = NULL;
1418
1419
1420	v1 = b_fcus->left->v[b_fcus->l_v1];
1421	v2 = b_fcus->left->v[b_fcus->l_v2];
1422	v3 = b_fcus->rght->v[b_fcus->r_v1];
1423	v4 = b_fcus->rght->v[b_fcus->r_v2];
1424
1425	Record_Br_Len(tree);
1426
1427	if(v1->num < v2->num)
1428	{
1429	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
1430	Exit("\n");
1431	}
1432	if(v3->num < v4->num)
1433	{
1434	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
1435	Exit("\n");
1436	}
1437
1438
1439	/***********/
1440	Swap(v2,b_fcus->left,b_fcus->rght,v3,tree);
1441	Set_Both_Sides(YES,tree);
1442
1443	MIXT_Set_Alias_Subpatt(YES,tree);
1444	lk1_init = Update_Lk_At_Given_Edge(b_fcus,tree);
1445	MIXT_Set_Alias_Subpatt(NO,tree);
1446
1447	l_infa = 10.;
1448	l_infb = tree->mod->l_min/b_fcus->l->v;
1449
1450	if(tree->mod->s_opt->fast_nni)
1451	{
1452	Fast_Br_Len(b_fcus,tree,1);
1453	lk1 = Lk(b_fcus,tree);
1454	}
1455	else
1456	{
1457	lk1 = Br_Len_Brent(l_infb,l_infa,b_fcus,tree);
1458	}
1459
1460	if(lk1 < lk1_init - tree->mod->s_opt->min_diff_lk_local)
1461	{
1462	PhyML_Printf("\n== %f %f %G",l_infa,l_infb,b_fcus->l->v);
1463	PhyML_Printf("\n== %f -- %f",lk1_init,lk1);
1464	PhyML_Printf("\n== Err. in NNI (1)");
1465	}
1466
1467	/* l1 = b_fcus->l->v; */
1468	l1 = MIXT_Get_Lengths_Of_This_Edge(b_fcus,tree);
1469	Swap(v3,b_fcus->left,b_fcus->rght,v2,tree);
1470	/***********/
1471
1472
1473	/***********/
1474	Swap(v2,b_fcus->left,b_fcus->rght,v4,tree);
1475	Restore_Br_Len(tree);
1476	Set_Both_Sides(YES,tree);
1477
1478	MIXT_Set_Alias_Subpatt(YES,tree);
1479	lk2_init = Update_Lk_At_Given_Edge(b_fcus,tree);
1480	MIXT_Set_Alias_Subpatt(NO,tree);
1481
1482	l_infa = 10.;
1483	l_infb = tree->mod->l_min/b_fcus->l->v;
1484
1485	if(tree->mod->s_opt->fast_nni)
1486	{
1487	Fast_Br_Len(b_fcus,tree,1);
1488	lk2 = Lk(b_fcus,tree);
1489	}
1490	else
1491	{
1492	lk2 = Br_Len_Brent(l_infb,l_infa,b_fcus,tree);
1493	}
1494
1495	if(lk2 < lk2_init - tree->mod->s_opt->min_diff_lk_local)
1496	{
1497	PhyML_Printf("\n== %f %f %G",l_infa,l_infb,b_fcus->l->v);
1498	PhyML_Printf("\n== %f -- %f",lk2_init,lk2);
1499	PhyML_Printf("\n== Err. in NNI (2)");
1500	}
1501
1502	/* l2 = b_fcus->l->v; */
1503	l2 = MIXT_Get_Lengths_Of_This_Edge(b_fcus,tree);
1504	Swap(v4,b_fcus->left,b_fcus->rght,v2,tree);
1505	/***********/
1506
1507
1508
1509	/***********/
1510	Restore_Br_Len(tree);
1511	Set_Both_Sides(YES,tree);
1512
1513	MIXT_Set_Alias_Subpatt(YES,tree);
1514	lk0_init = Update_Lk_At_Given_Edge(b_fcus,tree);
1515	MIXT_Set_Alias_Subpatt(NO,tree);
1516
1517	if(FABS(lk0_init - lk_init) > tree->mod->s_opt->min_diff_lk_local)
1518	{
1519	PhyML_Printf("\n== lk_init = %f; lk = %f diff = %f l = %G",
1520	lk_init,
1521	lk0_init,
1522	lk_init-lk0_init,
1523	b_fcus->l->v);
1524	PhyML_Printf("\n== Curr_lnL = %f",Lk(NULL,tree));
1525	Exit("\n== Err. in NNI (3)");
1526	}
1527
1528	l_infa = 10.;
1529	l_infb = tree->mod->l_min/b_fcus->l->v;
1530
1531	if(tree->mod->s_opt->fast_nni)
1532	{
1533	Fast_Br_Len(b_fcus,tree,1);
1534	lk0 = Lk(b_fcus,tree);
1535	}
1536	else
1537	{
1538	lk0 = Br_Len_Brent(l_infb,l_infa,b_fcus,tree);
1539	}
1540
1541	if(lk0 < lk_init - tree->mod->s_opt->min_diff_lk_local)
1542	{
1543	PhyML_Printf("\n== %f %f %f",l_infa,l_infb,b_fcus->l->v);
1544	PhyML_Printf("\n== %f -- %f",lk0_init,lk0);
1545	PhyML_Printf("\n== Err. in NNI (3)\n");
1546	Exit("\n");
1547	}
1548
1549	/* l0 = b_fcus->l->v; */
1550	l0 = MIXT_Get_Lengths_Of_This_Edge(b_fcus,tree);
1551	/***********/
1552
1553	b_fcus->nni->lk0 = lk0;
1554	b_fcus->nni->lk1 = lk1;
1555	b_fcus->nni->lk2 = lk2;
1556
1557	b = b_fcus;
1558	i = 0;
1559	do
1560	{
1561	b->nni->l0 = l0[i];
1562	b->nni->l1 = l1[i];
1563	b->nni->l2 = l2[i];
1564	b = b->next;
1565	i++;
1566	}
1567	while(b);
1568
1569	b_fcus->nni->score = lk0 - MAX(lk1,lk2);
1570
1571	if((b_fcus->nni->score < tree->mod->s_opt->min_diff_lk_local) &&
1572	(b_fcus->nni->score > -tree->mod->s_opt->min_diff_lk_local))
1573	{
1574	b_fcus->nni->score = .0;
1575	b_fcus->nni->lk1 = b_fcus->nni->lk0;
1576	b_fcus->nni->lk2 = b_fcus->nni->lk0;
1577	}
1578
1579	if(lk0 > MAX(lk1,lk2))
1580	{
1581	b_fcus->nni->best_conf = 0;
1582	b_fcus->nni->swap_node_v1 = NULL;
1583	b_fcus->nni->swap_node_v2 = NULL;
1584	b_fcus->nni->swap_node_v3 = NULL;
1585	b_fcus->nni->swap_node_v4 = NULL;
1586
1587	b = b_fcus;
1588	i = 0;
1589	do
1590	{
1591	b->nni->best_l = l0[i];
1592	b = b->next;
1593	i++;
1594	}
1595	while(b);
1596
1597
1598	}
1599	else if(lk1 > MAX(lk0,lk2))
1600	{
1601	b_fcus->nni->best_conf = 1;
1602	b_fcus->nni->swap_node_v1 = v2;
1603	b_fcus->nni->swap_node_v2 = b_fcus->left;
1604	b_fcus->nni->swap_node_v3 = b_fcus->rght;
1605	b_fcus->nni->swap_node_v4 = v3;
1606
1607	b = b_fcus;
1608	i = 0;
1609	do
1610	{
1611	b->nni->best_l = l1[i];
1612	b = b->next;
1613	i++;
1614	}
1615	while(b);
1616
1617
1618	}
1619	else if(lk2 > MAX(lk0,lk1))
1620	{
1621	b_fcus->nni->best_conf = 2;
1622	b_fcus->nni->swap_node_v1 = v2;
1623	b_fcus->nni->swap_node_v2 = b_fcus->left;
1624	b_fcus->nni->swap_node_v3 = b_fcus->rght;
1625	b_fcus->nni->swap_node_v4 = v4;
1626
1627	b = b_fcus;
1628	i = 0;
1629	do
1630	{
1631	b->nni->best_l = l2[i];
1632	b = b->next;
1633	i++;
1634	}
1635	while(b);
1636
1637
1638
1639	}
1640	else
1641	{
1642	b_fcus->nni->score = +1.0;
1643	b_fcus->nni->best_conf = 0;
1644	b_fcus->nni->swap_node_v1 = NULL;
1645	b_fcus->nni->swap_node_v2 = NULL;
1646	b_fcus->nni->swap_node_v3 = NULL;
1647	b_fcus->nni->swap_node_v4 = NULL;
1648
1649
1650	b = b_fcus;
1651	i = 0;
1652	do
1653	{
1654	b->nni->best_l = l0[i];
1655	b = b->next;
1656	i++;
1657	}
1658	while(b);
1659
1660
1661	}
1662
1663	if((do_swap) && ((lk1 > lk0) \|\| (lk2 > lk0)))
1664	{
1665	tree->n_swap++;
1666	PhyML_Printf("\n. Swap t_edge %d -> %f",b_fcus->num,MAX(lk1,lk2));
1667
1668	if(lk1 > lk2)
1669	{
1670	tree->best_lnL = lk1;
1671	Swap(v2,b_fcus->left,b_fcus->rght,v3,tree);
1672
1673	b = b_fcus;
1674	i = 0;
1675	do
1676	{
1677	b->l->v = l1[i];
1678	b = b->next;
1679	i++;
1680	}
1681	while(b);
1682
1683	Set_Both_Sides(YES,tree);
1684	Lk(NULL,tree);
1685	}
1686	else
1687	{
1688	tree->best_lnL = lk2;
1689	Swap(v2,b_fcus->left,b_fcus->rght,v4,tree);
1690
1691	b = b_fcus;
1692	i = 0;
1693	do
1694	{
1695	b->l->v = l2[i];
1696	b = b->next;
1697	i++;
1698	}
1699	while(b);
1700
1701	Set_Both_Sides(YES,tree);
1702	Lk(NULL,tree);
1703	}
1704	}
1705	else
1706	{
1707	Restore_Br_Len(tree);
1708	Update_PMat_At_Given_Edge(b_fcus,tree);
1709	tree->c_lnL = lk_init;
1710	}
1711
1712	Free(l0);
1713	Free(l1);
1714	Free(l2);
1715	}
1716
1717	//////////////////////////////////////////////////////////////
1718	//////////////////////////////////////////////////////////////
1719
1720
1721	void NNI_Pars(t_tree tree, t_edge b_fcus, int do_swap)
1722	{
1723	t_node v1,v2,v3,v4;
1724	int pars0, pars1, pars2;
1725	int pars_init;
1726
1727	pars_init = tree->c_pars;
1728	b_fcus->nni->best_conf = 0;
1729	b_fcus->nni->score = +1.0;
1730
1731	pars0 = pars1 = pars2 = 0;
1732	v1 = v2 = v3 = v4 = NULL;
1733
1734
1735	v1 = b_fcus->left->v[b_fcus->l_v1];
1736	v2 = b_fcus->left->v[b_fcus->l_v2];
1737	v3 = b_fcus->rght->v[b_fcus->r_v1];
1738	v4 = b_fcus->rght->v[b_fcus->r_v2];
1739
1740	if(v1->num < v2->num)
1741	{
1742	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
1743	Warn_And_Exit("");
1744	}
1745	if(v3->num < v4->num)
1746	{
1747	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
1748	Warn_And_Exit("");
1749	}
1750
1751
1752	/***********/
1753	Swap(v2,b_fcus->left,b_fcus->rght,v3,tree);
1754	Set_Both_Sides(YES,tree);
1755	pars1 = Update_Pars_At_Given_Edge(b_fcus,tree);
1756	Swap(v3,b_fcus->left,b_fcus->rght,v2,tree);
1757	/***********/
1758
1759	/***********/
1760	Swap(v2,b_fcus->left,b_fcus->rght,v4,tree);
1761	Set_Both_Sides(YES,tree);
1762	pars2 = Update_Pars_At_Given_Edge(b_fcus,tree);
1763	Swap(v4,b_fcus->left,b_fcus->rght,v2,tree);
1764	/***********/
1765
1766
1767	/***********/
1768	Set_Both_Sides(YES,tree);
1769	pars0 = Update_Pars_At_Given_Edge(b_fcus,tree);
1770
1771	if(pars0 != pars_init)
1772	{
1773	PhyML_Printf("\n. pars_init = %d; pars0 = %d\n",
1774	pars_init,
1775	pars0);
1776	Warn_And_Exit("\n. Err. in NNI (3)\n");
1777	}
1778	/***********/
1779
1780	tree->c_pars = pars0;
1781
1782	b_fcus->nni->score = MIN(pars1,pars2) - pars0;
1783
1784	if(pars0 < MIN(pars1,pars2))
1785	{
1786	b_fcus->nni->best_conf = 0;
1787	b_fcus->nni->swap_node_v1 = NULL;
1788	b_fcus->nni->swap_node_v2 = NULL;
1789	b_fcus->nni->swap_node_v3 = NULL;
1790	b_fcus->nni->swap_node_v4 = NULL;
1791	}
1792	else if(pars1 < MIN(pars0,pars2))
1793	{
1794	b_fcus->nni->best_conf = 1;
1795	b_fcus->nni->swap_node_v1 = v2;
1796	b_fcus->nni->swap_node_v2 = b_fcus->left;
1797	b_fcus->nni->swap_node_v3 = b_fcus->rght;
1798	b_fcus->nni->swap_node_v4 = v3;
1799	}
1800	else if(pars2 > MIN(pars0,pars1))
1801	{
1802	b_fcus->nni->best_conf = 2;
1803	b_fcus->nni->swap_node_v1 = v2;
1804	b_fcus->nni->swap_node_v2 = b_fcus->left;
1805	b_fcus->nni->swap_node_v3 = b_fcus->rght;
1806	b_fcus->nni->swap_node_v4 = v4;
1807	}
1808	else
1809	{
1810	b_fcus->nni->score = +1.0;
1811	b_fcus->nni->swap_node_v1 = NULL;
1812	b_fcus->nni->swap_node_v2 = NULL;
1813	b_fcus->nni->swap_node_v3 = NULL;
1814	b_fcus->nni->swap_node_v4 = NULL;
1815	}
1816	}
1817
1818	//////////////////////////////////////////////////////////////
1819	//////////////////////////////////////////////////////////////
1820
1821
1822	void Swap(t_node a, t_node b, t_node c, t_node d, t_tree *tree)
1823	{
1824	int ab, ba, cd, dc, bc;
1825	int i;
1826
1827	/* \ /d \ /a
1828	* \ / \ /
1829	* \b__...__c/ -> \b__...__c/
1830	* / \ / \
1831	* / \ / \
1832	* /a \ /d \
1833	*
1834	* nodes b and c are not necessarily on the same branch
1835	*/
1836
1837	if(!tree) return;
1838
1839	#ifdef DEBUG
1840	if(!a \|\| !b \|\| !c \|\| !d)
1841	{
1842	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
1843	Warn_And_Exit("");
1844	}
1845	#endif
1846
1847	ab = ba = cd = dc = bc = -1;
1848
1849	For(i,3) if(a->v[i] == b) { ab = i; break; }
1850	For(i,3) if(b->v[i] == a) { ba = i; break; }
1851	For(i,3) if(c->v[i] == d) { cd = i; break; }
1852	For(i,3) if(d->v[i] == c) { dc = i; break; }
1853	For(i,3) if(b->v[i] == c) { bc = i; break; }
1854
1855	#ifdef DEBUG
1856	if(ab < 0 \|\| ba < 0 \|\| cd < 0 \|\| dc < 0)
1857	{
1858	PhyML_Printf("\n== Nodes %d %d %d %d\n",a->num,b->num,c->num,d->num);
1859	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
1860	Exit("\n");
1861	}
1862	#endif
1863
1864	a->v[ab] = c;
1865	d->v[dc] = b;
1866	b->v[ba] = d;
1867	c->v[cd] = a;
1868	b->b[ba] = d->b[dc];
1869	c->b[cd] = a->b[ab];
1870
1871	(a->b[ab]->left == b)?
1872	(a->b[ab]->left = c):
1873	(a->b[ab]->rght = c);
1874
1875	(d->b[dc]->left == c)?
1876	(d->b[dc]->left = b):
1877	(d->b[dc]->rght = b);
1878
1879	For(i,3)
1880	{
1881	if(a->b[ab]->left->v[i] == a->b[ab]->rght) a->b[ab]->l_r = i;
1882	if(a->b[ab]->rght->v[i] == a->b[ab]->left) a->b[ab]->r_l = i;
1883	if(d->b[dc]->left->v[i] == d->b[dc]->rght) d->b[dc]->l_r = i;
1884	if(d->b[dc]->rght->v[i] == d->b[dc]->left) d->b[dc]->r_l = i;
1885	}
1886
1887	a->b[ab]->l_v1 = a->b[ab]->l_v2 =
1888	a->b[ab]->r_v1 = a->b[ab]->r_v2 =
1889	d->b[dc]->l_v1 = d->b[dc]->l_v2 =
1890	d->b[dc]->r_v1 = d->b[dc]->r_v2 = -1;
1891
1892	For(i,3)
1893	{
1894	if(i != a->b[ab]->l_r)
1895	{
1896	if(a->b[ab]->l_v1 < 0) a->b[ab]->l_v1 = i;
1897	else a->b[ab]->l_v2 = i;
1898	}
1899	if(i != a->b[ab]->r_l)
1900	{
1901	if(a->b[ab]->r_v1 < 0) a->b[ab]->r_v1 = i;
1902	else a->b[ab]->r_v2 = i;
1903	}
1904	if(i != d->b[dc]->l_r)
1905	{
1906	if(d->b[dc]->l_v1 < 0) d->b[dc]->l_v1 = i;
1907	else d->b[dc]->l_v2 = i;
1908	}
1909	if(i != d->b[dc]->r_l)
1910	{
1911	if(d->b[dc]->r_v1 < 0) d->b[dc]->r_v1 = i;
1912	else d->b[dc]->r_v2 = i;
1913	}
1914	}
1915	Update_Dirs(tree);
1916
1917	if(tree->next)
1918	Swap(a->next,b->next,c->next,d->next,tree->next);
1919	}
1920
1921	//////////////////////////////////////////////////////////////
1922	//////////////////////////////////////////////////////////////
1923
1924
1925	void Update_All_Partial_Lk(t_edge b_fcus, t_tree tree)
1926	{
1927
1928	Update_SubTree_Partial_Lk(b_fcus->left->b[b_fcus->l_v1],
1929	b_fcus->left,
1930	b_fcus->left->v[b_fcus->l_v1],
1931	tree);
1932
1933	Update_SubTree_Partial_Lk(b_fcus->left->b[b_fcus->l_v2],
1934	b_fcus->left,
1935	b_fcus->left->v[b_fcus->l_v2],
1936	tree);
1937
1938	Update_SubTree_Partial_Lk(b_fcus->rght->b[b_fcus->r_v1],
1939	b_fcus->rght,
1940	b_fcus->rght->v[b_fcus->r_v1],
1941	tree);
1942
1943	Update_SubTree_Partial_Lk(b_fcus->rght->b[b_fcus->r_v2],
1944	b_fcus->rght,
1945	b_fcus->rght->v[b_fcus->r_v2],
1946	tree);
1947
1948	tree->c_lnL = Lk(b_fcus,tree);
1949
1950
1951	if(tree->next) Update_All_Partial_Lk(tree->next->a_edges[b_fcus->num],
1952	tree->next);
1953	}
1954
1955	//////////////////////////////////////////////////////////////
1956	//////////////////////////////////////////////////////////////
1957
1958
1959	void Update_SubTree_Partial_Lk(t_edge b_fcus, t_node a, t_node d, t_tree tree)
1960	{
1961	int i;
1962
1963	Update_P_Lk(tree,b_fcus,a);
1964	if(d->tax) return;
1965	else For(i,3) if(d->v[i] != a)
1966	Update_SubTree_Partial_Lk(d->b[i],d,d->v[i],tree);
1967	}
1968
1969	//////////////////////////////////////////////////////////////
1970	//////////////////////////////////////////////////////////////
1971
1972
1973
1974	//////////////////////////////////////////////////////////////
1975	//////////////////////////////////////////////////////////////
1976
1977
1978	void Copy_Seq_Names_To_Tip_Labels(t_tree tree, calign data)
1979	{
1980	int i;
1981	For(i,tree->n_otu)
1982	{
1983	strcpy(tree->a_nodes[i]->name,data->c_seq[i]->name);
1984	}
1985	}
1986
1987	//////////////////////////////////////////////////////////////
1988	//////////////////////////////////////////////////////////////
1989
1990	calign Copy_Cseq(calign ori, option *io)
1991	{
1992	calign *new;
1993	int i,j,k,n_otu,c_len;
1994	char **sp_names;
1995
1996	n_otu = ori->n_otu;
1997	c_len = ori->crunch_len;
1998
1999
2000	sp_names = (char *)mCalloc(n_otu,sizeof(char ));
2001	For(i,n_otu)
2002	{
2003	sp_names[i] = (char *)mCalloc(strlen(ori->c_seq[i]->name)+1,sizeof(char));
2004	strcpy(sp_names[i],ori->c_seq[i]->name);
2005	}
2006
2007	new = Make_Cseq(n_otu,c_len+1,io->state_len,ori->init_len,sp_names);
2008
2009	new->obs_pinvar = ori->obs_pinvar;
2010
2011	For(i,ori->init_len) new->sitepatt[i] = ori->sitepatt[i];
2012
2013	For(j,ori->crunch_len)
2014	{
2015	For(i,ori->n_otu)
2016	{
2017	For(k,io->state_len)
2018	{
2019	new->c_seq[i]->state[j*io->state_len+k] =
2020	ori->c_seq[i]->state[j*io->state_len+k];
2021	}
2022	new->c_seq[i]->is_ambigu[j] = ori->c_seq[i]->is_ambigu[j];
2023	}
2024
2025	new->wght[j] = ori->wght[j];
2026	new->ambigu[j] = ori->ambigu[j];
2027	new->invar[j] = ori->invar[j];
2028	}
2029
2030	For(i,ori->n_otu)
2031	{
2032	new->c_seq[i]->len = ori->c_seq[i]->len;
2033	strcpy(new->c_seq[i]->name,ori->c_seq[i]->name);
2034	}
2035
2036	For(i,ori->n_otu) new->c_seq[i]->state[c_len*io->state_len] = '\0';
2037
2038	For(i,T_MAX_ALPHABET) new->b_frq[i] = ori->b_frq[i];
2039
2040	new->init_len = ori->init_len;
2041	new->clean_len = ori->clean_len;
2042	new->crunch_len = ori->crunch_len;
2043	new->n_otu = ori->n_otu;
2044
2045
2046	For(i,n_otu) Free(sp_names[i]);
2047	Free(sp_names);
2048
2049	return new;
2050	}
2051
2052	//////////////////////////////////////////////////////////////
2053	//////////////////////////////////////////////////////////////
2054
2055
2056	int Filexists(char *filename)
2057	{
2058	FILE *fp;
2059	fp =fopen(filename,"r");
2060	if (fp) {
2061	fclose(fp);
2062	return 1;
2063	} else
2064	return 0;
2065	}
2066
2067	//////////////////////////////////////////////////////////////
2068	//////////////////////////////////////////////////////////////
2069
2070	matrix K80_dist(calign data, phydbl g_shape)
2071	{
2072	int i,j,k;
2073	int diff;
2074	matrix *mat;
2075	phydbl **len;
2076
2077	len = (phydbl *)mCalloc(data->n_otu,sizeof(phydbl ));
2078	For(i,data->n_otu)
2079	len[i] = (phydbl *)mCalloc(data->n_otu,sizeof(phydbl));
2080
2081	mat = Make_Mat(data->n_otu);
2082
2083	Init_Mat(mat,data);
2084
2085	For(i,data->c_seq[0]->len)
2086	{
2087	For(j,data->n_otu-1)
2088	{
2089	for(k=j+1;k<data->n_otu;k++)
2090	{
2091	if(((data->c_seq[j]->state[i] == 'A' \|\| data->c_seq[j]->state[i] == 'G') &&
2092	(data->c_seq[k]->state[i] == 'C' \|\| data->c_seq[k]->state[i] == 'T'))\|\|
2093	((data->c_seq[j]->state[i] == 'C' \|\| data->c_seq[j]->state[i] == 'T') &&
2094	(data->c_seq[k]->state[i] == 'A' \|\| data->c_seq[k]->state[i] == 'G')))
2095	{
2096	diff++;
2097	mat->Q[j][k]+=data->wght[i];
2098	len[j][k]+=data->wght[i];
2099	len[k][j]=len[j][k];
2100	}
2101
2102	else
2103	if(((data->c_seq[j]->state[i] == 'A' && data->c_seq[k]->state[i] == 'G') \|\|
2104	(data->c_seq[j]->state[i] == 'G' && data->c_seq[k]->state[i] == 'A'))\|\|
2105	((data->c_seq[j]->state[i] == 'C' && data->c_seq[k]->state[i] == 'T') \|\|
2106	(data->c_seq[j]->state[i] == 'T' && data->c_seq[k]->state[i] == 'C')))
2107	{
2108	diff++;
2109	mat->P[j][k]+=data->wght[i];
2110	len[j][k]+=data->wght[i];
2111	len[k][j]=len[j][k];
2112	}
2113	else
2114	if((data->c_seq[j]->state[i] == 'A' \|\|
2115	data->c_seq[j]->state[i] == 'C' \|\|
2116	data->c_seq[j]->state[i] == 'G' \|\|
2117	data->c_seq[j]->state[i] == 'T')&&
2118	(data->c_seq[k]->state[i] == 'A' \|\|
2119	data->c_seq[k]->state[i] == 'C' \|\|
2120	data->c_seq[k]->state[i] == 'G' \|\|
2121	data->c_seq[k]->state[i] == 'T'))
2122	{
2123	len[j][k]+=data->wght[i];
2124	len[k][j]=len[j][k];
2125	}
2126	}
2127	}
2128	}
2129
2130
2131	For(i,data->n_otu-1)
2132	for(j=i+1;j<data->n_otu;j++)
2133	{
2134	if(len[i][j] > .0)
2135	{
2136	mat->P[i][j] /= len[i][j];
2137	mat->Q[i][j] /= len[i][j];
2138	}
2139	else
2140	{
2141	mat->P[i][j] = .5;
2142	mat->Q[i][j] = .5;
2143	}
2144
2145	mat->P[j][i] = mat->P[i][j];
2146	mat->Q[j][i] = mat->Q[i][j];
2147
2148
2149	if((1-2mat->P[i][j]-mat->Q[i][j] <= .0) \|\| (1-2mat->Q[i][j] <= .0))
2150	{
2151	mat->dist[i][j] = -1.;
2152	mat->dist[j][i] = -1.;
2153	continue;
2154	}
2155
2156	mat->dist[i][j] = (g_shape/2)*
2157	(POW(1-2*mat->P[i][j]-mat->Q[i][j],-1./g_shape) +
2158	0.5POW(1-2mat->Q[i][j],-1./g_shape) - 1.5);
2159
2160	if(mat->dist[i][j] > DIST_MAX) mat->dist[i][j] = DIST_MAX;
2161
2162	mat->dist[j][i] = mat->dist[i][j];
2163	}
2164
2165	For(i,data->n_otu) free(len[i]);
2166	free(len);
2167	return mat;
2168	}
2169
2170	//////////////////////////////////////////////////////////////
2171	//////////////////////////////////////////////////////////////
2172
2173
2174	matrix JC69_Dist(calign data, t_mod *mod)
2175	{
2176	int site,i,j,k;
2177	matrix *mat;
2178	phydbl **len;
2179	int datatype;
2180
2181
2182	len = (phydbl *)mCalloc(data->n_otu,sizeof(phydbl ));
2183	For(i,data->n_otu)
2184	len[i] = (phydbl *)mCalloc(data->n_otu,sizeof(phydbl));
2185
2186	mat = Make_Mat(data->n_otu);
2187	Init_Mat(mat,data);
2188
2189	datatype = mod->io->datatype;
2190
2191	For(site,data->c_seq[0]->len)
2192	{
2193	For(j,data->n_otu-1)
2194	{
2195	for(k=j+1;k<data->n_otu;k++)
2196	{
2197	if((!Is_Ambigu(data->c_seq[j]->state+site*mod->io->state_len,datatype,mod->io->state_len)) &&
2198	(!Is_Ambigu(data->c_seq[k]->state+site*mod->io->state_len,datatype,mod->io->state_len)))
2199	{
2200	len[j][k]+=data->wght[site];
2201	len[k][j]=len[j][k];
2202
2203
2204	if(strncmp(data->c_seq[j]->state+site*mod->io->state_len,
2205	data->c_seq[k]->state+site*mod->io->state_len,mod->io->state_len))
2206	/* if(!Are_Compatible(data->c_seq[j]->state+sitemod->io->state_len, /
2207	/* data->c_seq[k]->state+sitemod->io->state_len, /
2208	/* mod->io->state_len, */
2209	/* mod->io->datatype)) */
2210	mat->P[j][k]+=data->wght[site];
2211	}
2212	}
2213	}
2214	}
2215
2216
2217	For(i,data->n_otu-1)
2218	for(j=i+1;j<data->n_otu;j++)
2219	{
2220	if(len[i][j] > .0) mat->P[i][j] /= len[i][j];
2221	else mat->P[i][j] = 1.;
2222
2223	mat->P[j][i] = mat->P[i][j];
2224
2225	if((1.-(mod->ns)/(mod->ns-1.)*mat->P[i][j]) < .0) mat->dist[i][j] = -1.;
2226	else
2227	mat->dist[i][j] = -(mod->ns-1.)/(mod->ns)(phydbl)LOG(1.-(mod->ns)/(mod->ns-1.)mat->P[i][j]);
2228
2229	/* PhyML_Printf("\n. Incorrect JC distances"); */
2230	/* mat->dist[i][j] = len[i][j]; */
2231
2232	if(mat->dist[i][j] > DIST_MAX) mat->dist[i][j] = DIST_MAX;
2233
2234	mat->dist[j][i] = mat->dist[i][j];
2235	}
2236
2237	For(i,data->n_otu) free(len[i]);
2238	free(len);
2239
2240	return mat;
2241	}
2242
2243	//////////////////////////////////////////////////////////////
2244	//////////////////////////////////////////////////////////////
2245
2246
2247	matrix Hamming_Dist(calign data, t_mod *mod)
2248	{
2249	int i,j,k;
2250	matrix *mat;
2251	phydbl **len;
2252	int datatype;
2253
2254	len = (phydbl *)mCalloc(data->n_otu,sizeof(phydbl ));
2255	For(i,data->n_otu)
2256	len[i] = (phydbl *)mCalloc(data->n_otu,sizeof(phydbl));
2257
2258	mat = Make_Mat(data->n_otu);
2259	Init_Mat(mat,data);
2260
2261	datatype = mod->io->datatype;
2262
2263	For(i,data->crunch_len)
2264	{
2265	For(j,data->n_otu-1)
2266	{
2267	for(k=j+1;k<data->n_otu;k++)
2268	{
2269	if((!Is_Ambigu(data->c_seq[j]->state+i*mod->io->state_len,datatype,mod->io->state_len)) &&
2270	(!Is_Ambigu(data->c_seq[k]->state+i*mod->io->state_len,datatype,mod->io->state_len)))
2271	{
2272	len[j][k]+=data->wght[i];
2273	len[k][j]=len[j][k];
2274	/* if(data->c_seq[j]->state[i] != data->c_seq[k]->state[i]) */
2275	if(!Are_Compatible(data->c_seq[j]->state+i*mod->io->state_len,
2276	data->c_seq[k]->state+i*mod->io->state_len,
2277	mod->io->state_len,
2278	mod->io->datatype))
2279	{
2280	mat->P[j][k]+=data->wght[i];
2281	}
2282	}
2283	}
2284	}
2285	}
2286
2287	For(i,data->n_otu-1)
2288	for(j=i+1;j<data->n_otu;j++)
2289	{
2290	if(len[i][j] > .0)
2291	{
2292	mat->P[i][j] /= len[i][j];
2293	}
2294	else
2295	{
2296	mat->P[i][j] = 1.;
2297	}
2298
2299	mat->P[j][i] = mat->P[i][j];
2300
2301	mat->dist[i][j] = mat->P[i][j];
2302
2303
2304	if(mat->dist[i][j] > DIST_MAX)
2305	{
2306	mat->dist[i][j] = DIST_MAX;
2307	}
2308	mat->dist[j][i] = mat->dist[i][j];
2309	}
2310
2311	For(i,data->n_otu) free(len[i]);
2312	free(len);
2313
2314	return mat;
2315	}
2316
2317	//////////////////////////////////////////////////////////////
2318	//////////////////////////////////////////////////////////////
2319
2320	/* Test if the given site pattern is invariant. Does not handle ambiguities */
2321
2322	int Is_Invar(int patt_num, int stepsize, int datatype, calign *data)
2323	{
2324	int i, j;
2325
2326	For(i,data->n_otu)
2327	{
2328	For(j,data->n_otu)
2329	{
2330	if(!(Are_Compatible(data->c_seq[i]->state+patt_num,
2331	data->c_seq[j]->state+patt_num,
2332	stepsize,
2333	datatype)))
2334	{
2335	break;
2336	}
2337	}
2338	if(j != data->n_otu) break;
2339	}
2340
2341	if(i == data->n_otu) return 1;
2342	else return 0;
2343	}
2344
2345
2346	//////////////////////////////////////////////////////////////
2347	//////////////////////////////////////////////////////////////
2348
2349
2350	int Is_Ambigu(char *state, int datatype, int stepsize)
2351	{
2352	int val,i;
2353
2354	val = -1;
2355	if(datatype == NT)
2356	{
2357	For(i,stepsize)
2358	{
2359	switch(state[i])
2360	{
2361	case 'A' : case 'C' : case 'G' : case 'T' : case 'U' : { val=NO; break; }
2362	default : { val=YES; break; }
2363	}
2364	if(val == YES) break;
2365	}
2366	}
2367	else if(datatype == AA)
2368	{
2369	switch(state[0])
2370	{
2371	case 'X' : case '?' : case '-' : case '.' : {val=YES; break; }
2372	default : { val=NO; break; }
2373	}
2374	}
2375	else if(datatype == GENERIC)
2376	{
2377	int i;
2378	For(i,stepsize) if(!isdigit(state[i])) break;
2379	if(i == stepsize) val = NO;
2380	else val = YES;
2381	}
2382
2383	return val;
2384	}
2385
2386	//////////////////////////////////////////////////////////////
2387	//////////////////////////////////////////////////////////////
2388
2389	void Check_Ambiguities(calign *data, int datatype, int stepsize)
2390	{
2391	int i,j;
2392
2393	For(j,data->crunch_len)
2394	{
2395	data->ambigu[j] = NO;
2396	For(i,data->n_otu)
2397	{
2398	data->c_seq[i]->is_ambigu[j] = NO;
2399	}
2400
2401	For(i,data->n_otu)
2402	{
2403	if(Is_Ambigu(data->c_seq[i]->state+j*stepsize,
2404	datatype,
2405	stepsize))
2406	{
2407	data->ambigu[j] = YES;
2408	data->c_seq[i]->is_ambigu[j] = YES;
2409	}
2410	}
2411	}
2412	}
2413
2414	//////////////////////////////////////////////////////////////
2415	//////////////////////////////////////////////////////////////
2416
2417	void Set_D_States(calign *data, int datatype, int stepsize)
2418	{
2419	int i,j;
2420
2421	For(j,data->crunch_len)
2422	{
2423	For(i,data->n_otu)
2424	{
2425	if(data->c_seq[i]->is_ambigu[j] == NO)
2426	{
2427	data->c_seq[i]->d_state[j] = Assign_State(data->c_seq[i]->state+j,
2428	datatype,
2429	stepsize);
2430	}
2431	}
2432	}
2433	}
2434
2435	//////////////////////////////////////////////////////////////
2436	//////////////////////////////////////////////////////////////
2437
2438	int Get_State_From_Ui(int ui, int datatype)
2439	{
2440	if(datatype == NT)
2441	{
2442	switch(ui)
2443	{
2444	case 1 : {return 0; break;}
2445	case 2 : {return 1; break;}
2446	case 4 : {return 2; break;}
2447	case 8 : {return 3; break;}
2448	default :
2449	{
2450	PhyML_Printf("\n. ui=%d",ui);
2451	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
2452	Warn_And_Exit("");
2453	break;
2454	}
2455	}
2456	}
2457	else if(datatype == AA)
2458	{
2459	switch(ui)
2460	{
2461	case 1 : {return 0; break;}
2462	case 2 : {return 1; break;}
2463	case 4 : {return 2; break;}
2464	case 8 : {return 3; break;}
2465	case 16 : {return 4; break;}
2466	case 32 : {return 5; break;}
2467	case 64 : {return 6; break;}
2468	case 128 : {return 7; break;}
2469	case 256 : {return 8; break;}
2470	case 512 : {return 9; break;}
2471	case 1024 : {return 10; break;}
2472	case 2048 : {return 11; break;}
2473	case 4096 : {return 12; break;}
2474	case 8192 : {return 13; break;}
2475	case 16384 : {return 14; break;}
2476	case 32768 : {return 15; break;}
2477	case 65536 : {return 16; break;}
2478	case 131072 : {return 17; break;}
2479	case 262144 : {return 18; break;}
2480	case 524288 : {return 19; break;}
2481	default :
2482	{
2483	PhyML_Printf("\n. ui=%d",ui);
2484	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
2485	Warn_And_Exit("");
2486	}
2487	}
2488	}
2489	else
2490	{
2491	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
2492	Warn_And_Exit("");
2493	}
2494	return -1;
2495	}
2496
2497	//////////////////////////////////////////////////////////////
2498	//////////////////////////////////////////////////////////////
2499
2500
2501	int Assign_State(char *c, int datatype, int stepsize)
2502	{
2503	int state[3];
2504	int i;
2505
2506	state[0] = state[1] = state[2] = -1;
2507	if(datatype == NT)
2508	{
2509	For(i,stepsize)
2510	{
2511	switch(c[i])
2512	{
2513	case 'A' : {state[i]=0; break;}
2514	case 'C' : {state[i]=1; break;}
2515	case 'G' : {state[i]=2; break;}
2516	case 'T' : {state[i]=3; break;}
2517	case 'U' : {state[i]=3; break;}
2518	default : {state[i]=-1; break;}
2519	}
2520	}
2521	return (stepsize>1)?(state[0]16+state[1]4+state[2]):(state[0]);
2522	}
2523	else if(datatype == AA)
2524	{
2525	switch(c[0])
2526	{
2527	case 'A' : {state[0]=0 ; break;}
2528	case 'R' : {state[0]=1 ; break;}
2529	case 'N' : {state[0]=2 ; break;}
2530	case 'D' : {state[0]=3 ; break;}
2531	case 'C' : {state[0]=4 ; break;}
2532	case 'Q' : {state[0]=5 ; break;}
2533	case 'E' : {state[0]=6 ; break;}
2534	case 'G' : {state[0]=7 ; break;}
2535	case 'H' : {state[0]=8 ; break;}
2536	case 'I' : {state[0]=9 ; break;}
2537	case 'L' : {state[0]=10; break;}
2538	case 'K' : {state[0]=11; break;}
2539	case 'M' : {state[0]=12; break;}
2540	case 'F' : {state[0]=13; break;}
2541	case 'P' : {state[0]=14; break;}
2542	case 'S' : {state[0]=15; break;}
2543	case 'T' : {state[0]=16; break;}
2544	case 'W' : {state[0]=17; break;}
2545	case 'Y' : {state[0]=18; break;}
2546	case 'V' : {state[0]=19; break;}
2547
2548	case 'B' : {state[0] = 2; break;}
2549	case 'Z' : {state[0] = 5; break;}
2550	default : {state[0]=-1; break;}
2551	}
2552	return state[0];
2553	}
2554	else if(datatype == GENERIC)
2555	{
2556	char format[6];
2557	int ret;
2558
2559	sprintf(format,"%%%dd",stepsize);
2560	ret = sscanf(c,format,state);
2561	if(!ret) state[0] = -1;
2562	return state[0];
2563	}
2564	else
2565	{
2566	PhyML_Printf("\n. Not implemented yet.\n");
2567	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
2568	Warn_And_Exit("");
2569	}
2570
2571	return -1;
2572	}
2573
2574	//////////////////////////////////////////////////////////////
2575	//////////////////////////////////////////////////////////////
2576
2577
2578	char Reciproc_Assign_State(int i_state, int datatype)
2579	{
2580
2581	if(datatype == NT)
2582	{
2583	i_state = i_state%4;
2584	switch(i_state)
2585	{
2586	case 0 : {return 'A'; break;}
2587	case 1 : {return 'C'; break;}
2588	case 2 : {return 'G'; break;}
2589	case 3 : {return 'T'; break;}
2590	default :
2591	{
2592	PhyML_Printf("\n. i_state = %d",i_state);
2593	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
2594	Warn_And_Exit("");
2595	break;
2596	}
2597	}
2598	}
2599	else if(datatype == AA)
2600	{
2601	i_state = i_state%20;
2602	switch(i_state)
2603	{
2604	case 0 : {return 'A' ; break;}
2605	case 1 : {return 'R' ; break;}
2606	case 2 : {return 'N' ; break;}
2607	case 3 : {return 'D' ; break;}
2608	case 4 : {return 'C' ; break;}
2609	case 5 : {return 'Q' ; break;}
2610	case 6 : {return 'E' ; break;}
2611	case 7 : {return 'G' ; break;}
2612	case 8 : {return 'H' ; break;}
2613	case 9 : {return 'I' ; break;}
2614	case 10 : {return 'L'; break;}
2615	case 11 : {return 'K'; break;}
2616	case 12 : {return 'M'; break;}
2617	case 13 : {return 'F'; break;}
2618	case 14 : {return 'P'; break;}
2619	case 15 : {return 'S'; break;}
2620	case 16 : {return 'T'; break;}
2621	case 17 : {return 'W'; break;}
2622	case 18 : {return 'Y'; break;}
2623	case 19 : {return 'V'; break;}
2624	default :
2625	{
2626	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
2627	Warn_And_Exit("");
2628	break;
2629	}
2630	}
2631	}
2632	else if(datatype == GENERIC)
2633	{
2634	return (char)i_state;
2635	}
2636	return -1;
2637	}
2638
2639	//////////////////////////////////////////////////////////////
2640	//////////////////////////////////////////////////////////////
2641
2642
2643	int Assign_State_With_Ambiguity(char *c, int datatype, int stepsize)
2644	{
2645	int state[3];
2646	int i;
2647
2648	state[0] = state[1] = state[2] = -1;
2649	if(datatype == NT)
2650	{
2651	For(i,stepsize)
2652	{
2653	switch(c[i])
2654	{
2655	case 'A' : {state[i]= 0; break;}
2656	case 'C' : {state[i]= 1; break;}
2657	case 'G' : {state[i]= 2; break;}
2658	case 'T' : {state[i]= 3; break;}
2659	case 'U' : {state[i]= 3; break;}
2660	case 'M' : {state[i]= 4; break;}
2661	case 'R' : {state[i]= 5; break;}
2662	case 'W' : {state[i]= 6; break;}
2663	case 'S' : {state[i]= 7; break;}
2664	case 'Y' : {state[i]= 8; break;}
2665	case 'K' : {state[i]= 9; break;}
2666	case 'B' : {state[i]=10; break;}
2667	case 'D' : {state[i]=11; break;}
2668	case 'H' : {state[i]=12; break;}
2669	case 'V' : {state[i]=13; break;}
2670	case 'N' : case 'X' : case '?' : case 'O' : case '-' : {state[i]=T_MAX_ALPHABET-1; break;}
2671	default :
2672	{
2673	PhyML_Printf("\n. Unknown character state : '%c'\n",c[i]);
2674	Warn_And_Exit("\n. Init failed (check the data type)\n");
2675	break;
2676	}
2677	}
2678	return (stepsize>1)?(state[0]16+state[1]4+state[2]):(state[0]);
2679	}
2680	}
2681	else if(datatype == AA)
2682	{
2683	switch(c[0])
2684	{
2685	case 'A' : {state[0]= 0; break;}
2686	case 'R' : {state[0]= 1; break;}
2687	case 'N' : {state[0]= 2; break;}
2688	case 'D' : {state[0]= 3; break;}
2689	case 'C' : {state[0]= 4; break;}
2690	case 'Q' : {state[0]= 5; break;}
2691	case 'E' : {state[0]= 6; break;}
2692	case 'G' : {state[0]= 7; break;}
2693	case 'H' : {state[0]= 8; break;}
2694	case 'I' : {state[0]= 9; break;}
2695	case 'L' : {state[0]=10; break;}
2696	case 'K' : {state[0]=11; break;}
2697	case 'M' : {state[0]=12; break;}
2698	case 'F' : {state[0]=13; break;}
2699	case 'P' : {state[0]=14; break;}
2700	case 'S' : {state[0]=15; break;}
2701	case 'T' : {state[0]=16; break;}
2702	case 'W' : {state[0]=17; break;}
2703	case 'Y' : {state[0]=18; break;}
2704	case 'V' : {state[0]=19; break;}
2705	case 'B' : {state[0]= 2; break;}
2706	case 'Z' : {state[0]= 5; break;}
2707	case 'X' : case '?' : case '-' : {state[0]=T_MAX_ALPHABET-1; break;}
2708	default :
2709	{
2710	PhyML_Printf("\n. Unknown character state : %c\n",state[0]);
2711	Warn_And_Exit("\n. Init failed (check the data type)\n");
2712	break;
2713	}
2714	}
2715	return state[0];
2716	}
2717	else if(datatype == GENERIC)
2718	{
2719	if(Is_Ambigu(c,GENERIC,stepsize)) state[0] = T_MAX_ALPHABET-1;
2720	else
2721	{
2722	char format[6];
2723	sprintf(format,"%%%dd",stepsize);
2724	if(!sscanf(c,format,state))
2725	{
2726	PhyML_Printf("\n. Error reading character. Was expecting an integer, got '%c' instead.\n",c[0]);
2727	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
2728	Warn_And_Exit("");
2729	}
2730	}
2731	return state[0];
2732	}
2733
2734	return -1;
2735	}
2736
2737	//////////////////////////////////////////////////////////////
2738	//////////////////////////////////////////////////////////////
2739
2740
2741	void Clean_Tree_Connections(t_tree *tree)
2742	{
2743
2744	int i;
2745	For(i,2*tree->n_otu-2)
2746	{
2747	tree->a_nodes[i]->v[0] = NULL;
2748	tree->a_nodes[i]->v[1] = NULL;
2749	tree->a_nodes[i]->v[2] = NULL;
2750	tree->a_nodes[i]->b[0] = NULL;
2751	tree->a_nodes[i]->b[1] = NULL;
2752	tree->a_nodes[i]->b[2] = NULL;
2753	}
2754	}
2755
2756	//////////////////////////////////////////////////////////////
2757	//////////////////////////////////////////////////////////////
2758
2759
2760	void Bootstrap(t_tree *tree)
2761	{
2762	int *site_num, n_site;
2763	int replicate,j,k;
2764	int position,init_len;
2765	calign *boot_data;
2766	t_tree *boot_tree;
2767	t_mod *boot_mod;
2768	matrix *boot_mat;
2769	char *s;
2770	/* phydbl rf; */
2771
2772	tree->print_boot_val = 1;
2773	tree->print_alrt_val = 0;
2774	boot_tree = NULL;
2775
2776	site_num = (int *)mCalloc(tree->data->init_len,sizeof(int));
2777
2778	Free_Bip(tree);
2779	Alloc_Bip(tree);
2780	Get_Bip(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
2781
2782	n_site = 0;
2783	For(j,tree->data->crunch_len) For(k,tree->data->wght[j])
2784	{
2785	site_num[n_site] = j;
2786	n_site++;
2787	}
2788
2789	boot_data = Copy_Cseq(tree->data,tree->io);
2790
2791	PhyML_Printf("\n\n. Non parametric bootstrap analysis \n\n");
2792	PhyML_Printf(" [");
2793
2794	For(replicate,tree->mod->bootstrap)
2795	{
2796	For(j,boot_data->crunch_len) boot_data->wght[j] = 0;
2797
2798	init_len = 0;
2799	For(j,boot_data->init_len)
2800	{
2801	position = Rand_Int(0,(int)(tree->data->init_len-1.0));
2802	boot_data->wght[site_num[position]] += 1;
2803	init_len++;
2804	}
2805
2806	Set_D_States(boot_data,tree->io->datatype,tree->io->state_len);
2807
2808	if(init_len != tree->data->init_len) Exit("\n== Pb when copying sequences\n");
2809
2810	init_len = 0;
2811	For(j,boot_data->crunch_len) init_len += boot_data->wght[j];
2812
2813	if(init_len != tree->data->init_len) Exit("\n== Pb when copying sequences\n");
2814
2815	if(tree->io->datatype == NT) Get_Base_Freqs(boot_data);
2816	else if(tree->io->datatype == AA) Get_AA_Freqs(boot_data);
2817
2818	if(tree->io->random_boot_seq_order) Randomize_Sequence_Order(boot_data);
2819
2820	boot_mod = Copy_Model(tree->mod);
2821
2822	boot_mod->s_opt = tree->mod->s_opt; /* WARNING: re-using the same address here instead of creating a copying
2823	requires to leave the value of s_opt unchanged during the bootstrap. */
2824	boot_mod->io = tree->io; /* WARNING: re-using the same address here instead of creating a copying
2825	requires to leave the value of io unchanged during the bootstrap. */
2826
2827	Init_Model(boot_data,boot_mod,tree->io);
2828
2829	if(tree->io->mod->use_m4mod) M4_Init_Model(boot_mod->m4mod,boot_data,boot_mod);
2830
2831	if(tree->io->in_tree == 2)
2832	{
2833	rewind(tree->io->fp_in_tree);
2834	boot_tree = Read_Tree_File_Phylip(tree->io->fp_in_tree);
2835	}
2836	else
2837	{
2838	boot_mat = ML_Dist(boot_data,boot_mod);
2839	boot_mat->tree = Make_Tree_From_Scratch(boot_data->n_otu,boot_data);
2840	Fill_Missing_Dist(boot_mat);
2841	Bionj(boot_mat);
2842	boot_tree = boot_mat->tree;
2843	boot_tree->mat = boot_mat;
2844	}
2845
2846	boot_tree->mod = boot_mod;
2847	boot_tree->io = tree->io;
2848	boot_tree->data = boot_data;
2849	boot_tree->mod->s_opt->print = NO;
2850	boot_tree->n_pattern = boot_tree->data->crunch_len;
2851	boot_tree->io->print_site_lnl = 0;
2852	boot_tree->io->print_trace = 0;
2853
2854	Set_Both_Sides(YES,boot_tree);
2855
2856	if((boot_tree->mod->s_opt->random_input_tree) && (boot_tree->mod->s_opt->topo_search == SPR_MOVE)) Random_Tree(boot_tree);
2857
2858	Connect_CSeqs_To_Nodes(boot_data,boot_tree);
2859
2860	Check_Br_Lens(boot_tree);
2861	Share_Lk_Struct(tree,boot_tree);
2862	Share_Spr_Struct(tree,boot_tree);
2863	Share_Pars_Struct(tree,boot_tree);
2864	Fill_Dir_Table(boot_tree);
2865	Update_Dirs(boot_tree);
2866
2867	if(tree->mod->s_opt->greedy) Init_P_Lk_Tips_Double(boot_tree);
2868	else Init_P_Lk_Tips_Int(boot_tree);
2869	Init_Ui_Tips(boot_tree);
2870	Init_P_Pars_Tips(boot_tree);
2871	Br_Len_Not_Involving_Invar(boot_tree);
2872
2873
2874	if(boot_tree->io->do_alias_subpatt)
2875	{
2876	MIXT_Set_Alias_Subpatt(YES,boot_tree);
2877	Lk(NULL,boot_tree);
2878	MIXT_Set_Alias_Subpatt(NO,boot_tree);
2879	}
2880
2881
2882	if(boot_tree->mod->s_opt->opt_topo)
2883	{
2884	if(boot_tree->mod->s_opt->topo_search == NNI_MOVE)
2885	{
2886	Simu_Loop(boot_tree);
2887	}
2888	else if((boot_tree->mod->s_opt->topo_search == SPR_MOVE) \|\|
2889	(boot_tree->mod->s_opt->topo_search == BEST_OF_NNI_AND_SPR))
2890	{
2891	Speed_Spr_Loop(boot_tree);
2892	}
2893	}
2894	else
2895	{
2896	if(boot_tree->mod->s_opt->opt_subst_param \|\| boot_tree->mod->s_opt->opt_bl)
2897	Round_Optimize(boot_tree,boot_tree->data,ROUND_MAX);
2898	else
2899	Lk(NULL,boot_tree);
2900	}
2901
2902
2903	Free_Bip(boot_tree);
2904
2905	Alloc_Bip(boot_tree);
2906
2907	Match_Tip_Numbers(tree,boot_tree);
2908
2909	Get_Bip(boot_tree->a_nodes[0],
2910	boot_tree->a_nodes[0]->v[0],
2911	boot_tree);
2912
2913	Compare_Bip(tree,boot_tree,NO);
2914
2915	Check_Br_Lens(boot_tree);
2916	Br_Len_Involving_Invar(boot_tree);
2917
2918	if(tree->io->print_boot_trees)
2919	{
2920	s = Write_Tree(boot_tree,NO);
2921	PhyML_Fprintf(tree->io->fp_out_boot_tree,"%s\n",s);
2922	Free(s);
2923	Print_Fp_Out_Lines(tree->io->fp_out_boot_stats,0,0,boot_tree,tree->io,replicate+1);
2924	}
2925
2926	/* rf = .0; */
2927	/* For(j,2tree->n_otu-3) /
2928	/* rf += tree->a_edges[j]->bip_score; */
2929
2930
2931	PhyML_Printf(".");
2932	#ifndef QUIET
2933	fflush(stdout);
2934	#endif
2935	if(!((replicate+1)%tree->io->boot_prog_every))
2936	{
2937	PhyML_Printf("] %4d/%4d\n ",replicate+1,tree->mod->bootstrap);
2938	if(replicate != tree->mod->bootstrap-1) PhyML_Printf("[");
2939	}
2940
2941	Free_Tree(boot_tree);
2942	Free_Model(boot_mod);
2943	}
2944
2945	if(((replicate)%tree->io->boot_prog_every)) PhyML_Printf("] %4d/%4d\n ",replicate,tree->mod->bootstrap);
2946
2947	tree->lock_topo = YES; /* Topology should not be modified afterwards */
2948
2949	if(tree->io->print_boot_trees)
2950	{
2951	fclose(tree->io->fp_out_boot_tree);
2952	fclose(tree->io->fp_out_boot_stats);
2953	}
2954
2955	Free_Cseq(boot_data);
2956	Free(site_num);
2957	}
2958
2959	//////////////////////////////////////////////////////////////
2960	//////////////////////////////////////////////////////////////
2961
2962	void Br_Len_Involving_Invar(t_tree *tree)
2963	{
2964	int i;
2965
2966	if(tree->is_mixt_tree)
2967	{
2968	MIXT_Br_Len_Involving_Invar(tree);
2969	return;
2970	}
2971
2972	For(i,2tree->n_otu-1) tree->a_edges[i]->l->v = (1.0-tree->mod->ras->pinvar->v);
2973	}
2974
2975	//////////////////////////////////////////////////////////////
2976	//////////////////////////////////////////////////////////////
2977
2978	void Br_Len_Not_Involving_Invar(t_tree *tree)
2979	{
2980	int i;
2981
2982	if(tree->is_mixt_tree)
2983	{
2984	MIXT_Br_Len_Not_Involving_Invar(tree);
2985	return;
2986	}
2987
2988	For(i,2*tree->n_otu-1) tree->a_edges[i]->l->v /= (1.0-tree->mod->ras->pinvar->v);
2989	}
2990
2991	//////////////////////////////////////////////////////////////
2992	//////////////////////////////////////////////////////////////
2993
2994
2995	void Getstring_Stdin(char *s)
2996	{
2997	if(!fgets(s,T_MAX_LINE,stdin)) Exit("");
2998	if (strchr(s, '\n') != NULL)
2999	*strchr(s, '\n') = '\0';
3000	}
3001
3002	//////////////////////////////////////////////////////////////
3003	//////////////////////////////////////////////////////////////
3004
3005	phydbl Num_Derivatives_One_Param(phydbl (func)(t_tree tree), t_tree *tree,
3006	phydbl f0, phydbl *param, int which, int n_param, phydbl stepsize, int logt,
3007	phydbl *err, int precise, int is_positive)
3008	{
3009	int i,j;
3010	phydbl errt,fac,hh,*a,ans,sign;
3011	int n_iter;
3012
3013	sign = (phydbl *)mCalloc(n_param,sizeof(phydbl));
3014
3015	a = (phydbl *)mCalloc(11,sizeof(phydbl ));
3016	For(i,11) a[i] = (phydbl *)mCalloc(11,sizeof(phydbl));
3017
3018	n_iter = 10; /* */
3019
3020	ans = .0;
3021
3022	if(stepsize < SMALL) Warn_And_Exit("\n== h must be nonzero in Dfridr.");
3023
3024	hh=stepsize;
3025
3026	if(!precise)
3027	{
3028	param[which] = param[which]+hh;
3029
3030	if(logt == YES) For(i,n_param) param[i] = EXP(MIN(1.E+2,param[i]));
3031	For(i,n_param) sign[i] = param[i] > .0 ? 1. : -1.;
3032	if(is_positive == YES) For(i,n_param) param[i] = FABS(param[i]);
3033	a[0][0] = (*func)(tree);
3034	if(is_positive == YES) For(i,n_param) param[i] *= sign[i];
3035	if(logt == YES) For(i,n_param) param[i] = LOG(param[i]);
3036
3037	/* printf("\n. f0=%f f1=%f hh=%G %f",f0,a[0][0],hh,param[which]); */
3038
3039	a[0][0] -= f0;
3040	a[0][0] /= hh;
3041	param[which] = param[which]-hh;
3042
3043	ans = a[0][0];
3044	}
3045	else
3046	{
3047	param[which] = param[which]+hh;
3048
3049	if(logt == YES) For(i,n_param) param[i] = EXP(MIN(1.E+2,param[i]));
3050	For(i,n_param) sign[i] = param[i] > .0 ? 1. : -1.;
3051	if(is_positive == YES) For(i,n_param) param[i] = FABS(param[i]);
3052	a[0][0] = (*func)(tree);
3053	if(is_positive == YES) For(i,n_param) param[i] *= sign[i];
3054	if(logt == YES) For(i,n_param) param[i] = LOG(param[i]);
3055
3056	/* param[which] = param[which]-2hh; /
3057	/* a[0][0] -= (func)(tree); /
3058	/* a[0][0] /= (2.0hh); /
3059	/* param[which] = param[which]+hh; */
3060	a[0][0] -= f0;
3061	a[0][0] /= hh;
3062	param[which] = param[which]-hh;
3063
3064	*err=1e30;
3065	for(i=1;i<n_iter;i++)
3066	{
3067	hh /= 1.4;
3068
3069	/* param[which] = param[which]+hh; */
3070	/* a[0][i] = (func)(tree); /
3071	/* param[which] = param[which]-2hh; /
3072	/* a[0][i] -= (func)(tree); /
3073	/* a[0][i] /= (2.0hh); /
3074	/* param[which] = param[which]+hh; */
3075
3076	param[which] = param[which]+hh;
3077
3078	if(logt == YES) For(j,n_param) param[j] = EXP(MIN(1.E+2,param[j]));
3079	For(i,n_param) sign[i] = param[i] > .0 ? 1. : -1.;
3080	if(is_positive == YES) For(i,n_param) param[i] = FABS(param[i]);
3081	a[0][i] = (*func)(tree);
3082	if(is_positive == YES) For(i,n_param) param[i] *= sign[i];
3083	if(logt == YES) For(j,n_param) param[j] = LOG(param[j]);
3084
3085	/* param[which] = param[which]-2hh; /
3086	/* a[0][i] -= (func)(tree); /
3087	/* a[0][i] /= (2.0hh); /
3088	/* param[which] = param[which]+hh; */
3089	a[0][i] -= f0;
3090	a[0][i] /= hh;
3091	param[which] = param[which]-hh;
3092
3093
3094	fac=1.4*1.4;
3095	for (j=1;j<=i;j++)
3096	{
3097	a[j][i]=(a[j-1][i]*fac-a[j-1][i-1])/(fac-1.0);
3098	fac=1.41.4fac;
3099
3100	errt=MAX(FABS(a[j][i]-a[j-1][i]),FABS(a[j][i]-a[j-1][i-1]));
3101
3102	if (errt <= *err)
3103	{
3104	*err=errt;
3105	ans=a[j][i];
3106	}
3107	}
3108
3109	if(FABS(a[i][i]-a[i-1][i-1]) >= 2.0(err)) break;
3110	}
3111	}
3112	For(i,11) Free(a[i]);
3113	Free(a);
3114	Free(sign);
3115
3116	return ans;
3117	}
3118
3119	//////////////////////////////////////////////////////////////
3120	//////////////////////////////////////////////////////////////
3121
3122	phydbl Num_Derivatives_One_Param_Nonaligned(phydbl (func)(t_tree tree), t_tree *tree,
3123	phydbl f0, phydbl **param, int which, int n_param, phydbl stepsize, int logt,
3124	phydbl *err, int precise, int is_positive)
3125	{
3126	int i,j;
3127	phydbl errt,fac,hh,*a,ans,sign;
3128	int n_iter;
3129
3130	sign = (phydbl *)mCalloc(n_param,sizeof(phydbl));
3131
3132	a = (phydbl *)mCalloc(11,sizeof(phydbl ));
3133	For(i,11) a[i] = (phydbl *)mCalloc(11,sizeof(phydbl));
3134
3135	n_iter = 10; /* */
3136
3137	ans = .0;
3138
3139	if(stepsize < SMALL) Warn_And_Exit("\n== h must be nonzero in Dfridr.");
3140
3141	hh=stepsize;
3142
3143	if(!precise)
3144	{
3145	(param[which]) = (param[which])+hh;
3146
3147	if(logt == YES) For(i,n_param) (param[i]) = EXP(MIN(1.E+2,(param[i])));
3148	For(i,n_param) sign[i] = (*(param[i])) > .0 ? 1. : -1.;
3149	if(is_positive == YES) For(i,n_param) ((param[i])) = FABS((param[i]));
3150	a[0][0] = (*func)(tree);
3151	if(is_positive == YES) For(i,n_param) ((param[i])) = sign[i];
3152	if(logt == YES) For(i,n_param) (param[i]) = LOG((param[i]));
3153
3154	/* printf("\n. f0=%f f1=%f hh=%G %f",f0,a[0][0],hh,(param[which])); /
3155
3156	a[0][0] -= f0;
3157	a[0][0] /= hh;
3158	(param[which]) = (param[which])-hh;
3159
3160	ans = a[0][0];
3161	}
3162	else
3163	{
3164	(param[which]) = (param[which])+hh;
3165
3166	if(logt == YES) For(i,n_param) (param[i]) = EXP(MIN(1.E+2,(param[i])));
3167	For(i,n_param) sign[i] = (*(param[i])) > .0 ? 1. : -1.;
3168	if(is_positive == YES) For(i,n_param) ((param[i])) = FABS((param[i]));
3169	a[0][0] = (*func)(tree);
3170	if(is_positive == YES) For(i,n_param) ((param[i])) = sign[i];
3171	if(logt == YES) For(i,n_param) (param[i]) = LOG((param[i]));
3172
3173	/* (param[which] = (param[which]-2hh; /
3174	/* a[0][0] -= (func)(tree); /
3175	/* a[0][0] /= (2.0hh); /
3176	/* (param[which] = (param[which]+hh; */
3177	a[0][0] -= f0;
3178	a[0][0] /= hh;
3179	(param[which]) = (param[which])-hh;
3180
3181	*err=1e30;
3182	for(i=1;i<n_iter;i++)
3183	{
3184	hh /= 1.4;
3185
3186	/* (param[which] = (param[which]+hh; */
3187	/* a[0][i] = (func)(tree); /
3188	/* (param[which] = (param[which]-2hh; /
3189	/* a[0][i] -= (func)(tree); /
3190	/* a[0][i] /= (2.0hh); /
3191	/* (param[which] = (param[which]+hh; */
3192
3193	(param[which]) = (param[which])+hh;
3194
3195	if(logt == YES) For(j,n_param) (param[j]) = EXP(MIN(1.E+2,(param[j])));
3196	For(i,n_param) sign[i] = (*(param[i])) > .0 ? 1. : -1.;
3197	if(is_positive == YES) For(i,n_param) ((param[i])) = FABS((param[i]));
3198	a[0][i] = (*func)(tree);
3199	if(is_positive == YES) For(i,n_param) ((param[i])) = sign[i];
3200	if(logt == YES) For(j,n_param) (param[j]) = LOG((param[j]));
3201
3202	/* (param[which] = (param[which]-2hh; /
3203	/* a[0][i] -= (func)(tree); /
3204	/* a[0][i] /= (2.0hh); /
3205	/* (param[which] = (param[which]+hh; */
3206	a[0][i] -= f0;
3207	a[0][i] /= hh;
3208	(param[which]) = (param[which])-hh;
3209
3210
3211	fac=1.4*1.4;
3212	for (j=1;j<=i;j++)
3213	{
3214	a[j][i]=(a[j-1][i]*fac-a[j-1][i-1])/(fac-1.0);
3215	fac=1.41.4fac;
3216
3217	errt=MAX(FABS(a[j][i]-a[j-1][i]),FABS(a[j][i]-a[j-1][i-1]));
3218
3219	if (errt <= *err)
3220	{
3221	*err=errt;
3222	ans=a[j][i];
3223	}
3224	}
3225
3226	if(FABS(a[i][i]-a[i-1][i-1]) >= 2.0(err)) break;
3227	}
3228	}
3229	For(i,11) Free(a[i]);
3230	Free(a);
3231	Free(sign);
3232	return ans;
3233	}
3234
3235	//////////////////////////////////////////////////////////////
3236	//////////////////////////////////////////////////////////////
3237
3238	int Num_Derivative_Several_Param(t_tree tree, phydbl param, int n_param, phydbl stepsize, int logt,
3239	phydbl (func)(t_tree tree), phydbl *derivatives, int is_positive)
3240	{
3241	int i;
3242	phydbl err,f0,*sign;
3243
3244	sign = (phydbl *)mCalloc(n_param,sizeof(phydbl));
3245
3246	if(logt == YES) For(i,n_param) param[i] = EXP(MIN(1.E+2,param[i]));
3247	For(i,n_param) sign[i] = (param[i]) > .0 ? 1. : -1.;
3248	if(is_positive == YES) For(i,n_param) param[i] = FABS(param[i]);
3249	f0 = (*func)(tree);
3250	if(is_positive == YES) For(i,n_param) param[i] *= sign[i];
3251	if(logt == YES) For(i,n_param) param[i] = LOG(param[i]);
3252
3253	For(i,n_param)
3254	{
3255	derivatives[i] = Num_Derivatives_One_Param(func,
3256	tree,
3257	f0,
3258	param,
3259	i,
3260	n_param,
3261	stepsize,
3262	logt,
3263	&err,
3264	0,
3265	is_positive
3266	);
3267	}
3268
3269	Free(sign);
3270
3271	return 1;
3272	}
3273
3274	//////////////////////////////////////////////////////////////
3275	//////////////////////////////////////////////////////////////
3276
3277	int Num_Derivative_Several_Param_Nonaligned(t_tree tree, phydbl *param, int n_param, phydbl stepsize, int logt,
3278	phydbl (func)(t_tree tree), phydbl *derivatives, int is_positive)
3279	{
3280	int i;
3281	phydbl err,f0,*sign;
3282
3283	sign = (phydbl *)mCalloc(n_param,sizeof(phydbl));
3284
3285	if(logt == YES) For(i,n_param) ((param[i])) = EXP(MIN(1.E+2,(param[i])));
3286	For(i,n_param) sign[i] = (*(param[i])) > .0 ? 1. : -1.;
3287	if(is_positive == YES) For(i,n_param) (param[i]) = FABS((param[i]));
3288	f0 = (*func)(tree);
3289	if(is_positive == YES) For(i,n_param) (param[i]) = sign[i];
3290	if(logt == YES) For(i,n_param) ((param[i])) = LOG((param[i]));
3291
3292
3293	For(i,n_param)
3294	{
3295
3296	derivatives[i] = Num_Derivatives_One_Param_Nonaligned(func,
3297	tree,
3298	f0,
3299	param,
3300	i,
3301	n_param,
3302	stepsize,
3303	logt,
3304	&err,
3305	0,
3306	is_positive
3307	);
3308	}
3309
3310	Free(sign);
3311
3312	return 1;
3313	}
3314
3315	//////////////////////////////////////////////////////////////
3316	//////////////////////////////////////////////////////////////
3317
3318
3319	int Compare_Two_States(char state1, char state2, int state_size)
3320	{
3321
3322	/* 1 the two states are identical */
3323	/* 0 the two states are different */
3324	int i;
3325
3326	For(i,state_size) if(state1[i] != state2[i]) break;
3327
3328	return (i==state_size)?(1):(0);
3329	}
3330
3331	//////////////////////////////////////////////////////////////
3332	//////////////////////////////////////////////////////////////
3333
3334
3335	void Copy_One_State(char from, char to, int state_size)
3336	{
3337	int i;
3338	For(i,state_size) to[i] = from[i];
3339	}
3340
3341	//////////////////////////////////////////////////////////////
3342	//////////////////////////////////////////////////////////////
3343
3344	void Copy_Dist(phydbl cpy, phydbl orig, int n)
3345	{
3346	int i,j;
3347	For(i,n) For(j,n) cpy[i][j] = orig[i][j];
3348	}
3349
3350	//////////////////////////////////////////////////////////////
3351	//////////////////////////////////////////////////////////////
3352
3353	t_mod Copy_Model(t_mod ori)
3354	{
3355	t_mod *cpy;
3356
3357	cpy = Make_Model_Basic();
3358
3359	cpy->ns = ori->ns;
3360	cpy->ras->n_catg = ori->ras->n_catg;
3361	cpy->whichmodel = ori->whichmodel;
3362
3363	Make_Model_Complete(cpy);
3364	Record_Model(ori,cpy);
3365	cpy->m4mod = M4_Copy_M4_Model(ori, ori->m4mod);
3366
3367	return cpy;
3368	}
3369
3370	//////////////////////////////////////////////////////////////
3371	//////////////////////////////////////////////////////////////
3372
3373	void Record_Model(t_mod ori, t_mod cpy)
3374	{
3375	int i;
3376
3377	cpy->ns = ori->ns;
3378	cpy->ras->n_catg = ori->ras->n_catg;
3379
3380	cpy->kappa->v = ori->kappa->v;
3381	cpy->ras->alpha->v = ori->ras->alpha->v;
3382	cpy->lambda->v = ori->lambda->v;
3383	cpy->ras->pinvar->v = ori->ras->pinvar->v;
3384	cpy->br_len_multiplier->v = ori->br_len_multiplier->v;
3385
3386	strcpy(cpy->modelname->s,ori->modelname->s);
3387	strcpy(cpy->custom_mod_string->s,ori->custom_mod_string->s);
3388
3389	cpy->mod_num = ori->mod_num;
3390	cpy->whichmodel = ori->whichmodel;
3391	cpy->update_eigen = ori->update_eigen;
3392	cpy->bootstrap = ori->bootstrap;
3393	cpy->ras->invar = ori->ras->invar;
3394	cpy->r_mat->n_diff_rr = ori->r_mat->n_diff_rr;
3395	cpy->l_min = ori->l_min;
3396	cpy->l_max = ori->l_max;
3397	cpy->log_l = ori->log_l;
3398	cpy->ras->free_mixt_rates = ori->ras->free_mixt_rates;
3399	cpy->ras->gamma_median = ori->ras->gamma_median;
3400
3401
3402	if((ori->whichmodel == CUSTOM) \|\| (ori->whichmodel == GTR))
3403	{
3404	For(i,ori->ns*(ori->ns-1)/2)
3405	{
3406	cpy->r_mat->rr_num->v[i] = ori->r_mat->rr_num->v[i];
3407	cpy->r_mat->rr_val->v[i] = ori->r_mat->rr_val->v[i];
3408	cpy->r_mat->rr->v[i] = ori->r_mat->rr->v[i];
3409	cpy->r_mat->n_rr_per_cat->v[i] = ori->r_mat->n_rr_per_cat->v[i];
3410	}
3411	}
3412
3413	For(i,cpy->ns)
3414	{
3415	cpy->e_frq->pi->v[i] = ori->e_frq->pi->v[i];
3416	cpy->e_frq->pi_unscaled->v[i] = ori->e_frq->pi_unscaled->v[i];
3417	cpy->user_b_freq->v[i] = ori->user_b_freq->v[i];
3418	}
3419
3420	For(i,cpy->ns*cpy->ns) cpy->r_mat->qmat->v[i] = ori->r_mat->qmat->v[i];
3421
3422	For(i,cpy->ras->n_catg)
3423	{
3424	cpy->ras->gamma_r_proba->v[i] = ori->ras->gamma_r_proba->v[i];
3425	cpy->ras->gamma_rr->v[i] = ori->ras->gamma_rr->v[i];
3426	cpy->ras->gamma_r_proba_unscaled->v[i] = ori->ras->gamma_r_proba_unscaled->v[i];
3427	cpy->ras->gamma_rr_unscaled->v[i] = ori->ras->gamma_rr_unscaled->v[i];
3428	}
3429
3430	cpy->use_m4mod = ori->use_m4mod;
3431
3432	cpy->eigen->size = ori->eigen->size;
3433	For(i,2*ori->ns) cpy->eigen->space[i] = ori->eigen->space[i];
3434	For(i,2*ori->ns) cpy->eigen->space_int[i] = ori->eigen->space_int[i];
3435	For(i,ori->ns) cpy->eigen->e_val[i] = ori->eigen->e_val[i];
3436	For(i,ori->ns) cpy->eigen->e_val_im[i] = ori->eigen->e_val_im[i];
3437	For(i,ori->ns*ori->ns) cpy->eigen->r_e_vect[i] = ori->eigen->r_e_vect[i];
3438	For(i,ori->ns*ori->ns) cpy->eigen->r_e_vect[i] = ori->eigen->r_e_vect[i];
3439	For(i,ori->ns*ori->ns) cpy->eigen->r_e_vect_im[i] = ori->eigen->r_e_vect_im[i];
3440	For(i,ori->ns*ori->ns) cpy->eigen->l_e_vect[i] = ori->eigen->l_e_vect[i];
3441	For(i,ori->ns*ori->ns) cpy->eigen->q[i] = ori->eigen->q[i];
3442	}
3443
3444	//////////////////////////////////////////////////////////////
3445	//////////////////////////////////////////////////////////////
3446
3447	//////////////////////////////////////////////////////////////
3448	//////////////////////////////////////////////////////////////
3449
3450
3451
3452
3453	void Test_Node_Table_Consistency(t_tree *tree)
3454	{
3455	int i;
3456
3457	For(i,2*tree->n_otu-2)
3458	{
3459	if(tree->a_nodes[i]->num != i)
3460	{
3461	PhyML_Printf("\n. Node table is not consistent with node numbers.");
3462	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
3463	Warn_And_Exit("");
3464	}
3465	}
3466	}
3467
3468	//////////////////////////////////////////////////////////////
3469	//////////////////////////////////////////////////////////////
3470
3471
3472	void Get_Bip(t_node a, t_node d, t_tree *tree)
3473	{
3474	int i,j;
3475	t_node *tmp;
3476	int swapped;
3477
3478	if(!d \|\| !a \|\| !tree)
3479	{
3480	PhyML_Printf("\n== d: %p a: %p tree: %p",d,a,tree);
3481	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
3482	Exit("\n");
3483	}
3484
3485	if(d->tax)
3486	{
3487	if(d->common)
3488	{
3489	d->bip_node[0] = (t_node *)mCalloc(1,sizeof(t_node ));
3490	d->bip_node[0][0] = d;
3491	d->bip_size[0] = 1;
3492	d->bip_size[1] = -1;
3493	d->bip_size[2] = -1;
3494
3495	For(i,3)
3496	{
3497	if(a->v[i] == d)
3498	{
3499	a->bip_size[i] = 0;
3500	For(j,tree->n_otu)
3501	{
3502	if(strcmp(tree->a_nodes[j]->name,d->name))
3503	{
3504	a->bip_node[i] = (t_node *)realloc(a->bip_node[i],(a->bip_size[i]+1)sizeof(t_node *));
3505	a->bip_node[i][a->bip_size[i]] = tree->a_nodes[j];
3506	a->bip_size[i]++;
3507	}
3508	}
3509
3510	/* Sort bipartition */
3511	do
3512	{
3513	swapped = NO;
3514	For(j,a->bip_size[i]-1)
3515	{
3516	if(a->bip_node[i][j]->num > a->bip_node[i][j+1]->num)
3517	{
3518	swapped = YES;
3519	tmp = a->bip_node[i][j];
3520	a->bip_node[i][j] = a->bip_node[i][j+1];
3521	a->bip_node[i][j+1] = tmp;
3522	}
3523	}
3524	}while(swapped == YES);
3525
3526	break;
3527
3528	}
3529	}
3530	}
3531	return;
3532	}
3533	else
3534	{
3535	int k;
3536	int d_a;
3537
3538	d_a = -1;
3539
3540	For(i,3)
3541	{
3542	if(d->v[i] != a) Get_Bip(d,d->v[i],tree);
3543	else if(d->v[i] == a) d_a = i;
3544	}
3545
3546	d->bip_size[d_a] = 0;
3547	For(i,3)
3548	if(d->v[i] != a)
3549	{
3550	For(j,3)
3551	{
3552	if(d->v[i]->v[j] == d)
3553	{
3554	For(k,d->v[i]->bip_size[j])
3555	{
3556	d->bip_node[d_a] = (t_node *)realloc(d->bip_node[d_a],(d->bip_size[d_a]+1)sizeof(t_node *));
3557	d->bip_node[d_a][d->bip_size[d_a]] = d->v[i]->bip_node[j][k];
3558	d->bip_size[d_a]++;
3559	}
3560	break;
3561	}
3562	}
3563	}
3564
3565	do
3566	{
3567	swapped = NO;
3568	For(j,d->bip_size[d_a]-1)
3569	{
3570	if(d->bip_node[d_a][j]->num > d->bip_node[d_a][j+1]->num)
3571	{
3572	swapped = YES;
3573	tmp = d->bip_node[d_a][j];
3574	d->bip_node[d_a][j] = d->bip_node[d_a][j+1];
3575	d->bip_node[d_a][j+1] = tmp;
3576	}
3577	}
3578	}while(swapped == YES);
3579
3580
3581	For(i,3)
3582	if(a->v[i] == d)
3583	{
3584	a->bip_size[i] = 0;
3585	For(j,tree->n_otu)
3586	{
3587	For(k,d->bip_size[d_a])
3588	{
3589	if(d->bip_node[d_a][k] == tree->a_nodes[j])
3590	break;
3591	}
3592
3593	if((k == d->bip_size[d_a]) && (tree->a_nodes[j]->common))
3594	{
3595	a->bip_node[i] = (t_node *)realloc(a->bip_node[i],(a->bip_size[i]+1)sizeof(t_node *));
3596	a->bip_node[i][a->bip_size[i]] = tree->a_nodes[j];
3597	a->bip_size[i]++;
3598	}
3599	}
3600
3601	do
3602	{
3603	swapped = NO;
3604	For(j,a->bip_size[i]-1)
3605	{
3606	if(a->bip_node[i][j]->num > a->bip_node[i][j+1]->num)
3607	{
3608	swapped = YES;
3609	tmp = a->bip_node[i][j];
3610	a->bip_node[i][j] = a->bip_node[i][j+1];
3611	a->bip_node[i][j+1] = tmp;
3612	}
3613	}
3614	}while(swapped == YES);
3615
3616	if(a->bip_size[i] != tree->n_otu - d->bip_size[d_a])
3617	{
3618	PhyML_Printf("%d %d \n",a->bip_size[i],tree->n_otu - d->bip_size[d_a]);
3619	Warn_And_Exit("\n. Problem in counting bipartitions \n");
3620	}
3621	break;
3622	}
3623	}
3624	}
3625
3626	//////////////////////////////////////////////////////////////
3627	//////////////////////////////////////////////////////////////
3628
3629
3630	void Alloc_Bip(t_tree *tree)
3631	{
3632	int i;
3633
3634	if(tree->has_bip) return;
3635
3636	tree->has_bip = YES;
3637
3638	For(i,2*tree->n_otu-2)
3639	{
3640	tree->a_nodes[i]->bip_size = (int *)mCalloc(3,sizeof(int));
3641	tree->a_nodes[i]->bip_node = (t_node *)mCalloc(3,sizeof(t_node ));
3642
3643	/* For(j,3) */
3644	/* { */
3645	/* tree->a_nodes[i]->bip_node[j] = (t_node *)mCalloc(tree->n_otu,sizeof(t_node )); */
3646	/* } */
3647	}
3648	}
3649
3650	//////////////////////////////////////////////////////////////
3651	//////////////////////////////////////////////////////////////
3652
3653
3654	int Sort_Phydbl_Increase(const void a, const void b)
3655	{
3656	if(((phydbl )(a)) <= ((phydbl )(b))) return -1;
3657	else return 1;
3658	}
3659
3660	//////////////////////////////////////////////////////////////
3661	//////////////////////////////////////////////////////////////
3662
3663
3664	int Sort_String(const void a, const void b)
3665	{
3666	return(strcmp(((const char )(a)), ((const char **)(b))));
3667	}
3668
3669	//////////////////////////////////////////////////////////////
3670	//////////////////////////////////////////////////////////////
3671
3672	int Compare_Bip(t_tree tree1, t_tree tree2, int on_existing_edges_only)
3673	{
3674	int i,j,k;
3675	t_edge b1,b2;
3676	/* char bip1,bip2; */
3677	/* int bip1,bip2; */
3678	t_node bip1, bip2;
3679	int bip_size1, bip_size2, bip_size;
3680	int different,identical;
3681	int n_edges;
3682
3683	/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
3684	/* WARNING: call Match_Tip_Numbers and Get_Bip before using this function. */
3685	/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
3686
3687	if(on_existing_edges_only == YES)
3688	{
3689	n_edges = 0;
3690	For(i,2*tree1->n_otu-3)
3691	if(tree1->a_edges[i]->does_exist && tree2->a_edges[i]->does_exist) n_edges++;
3692	n_edges -= tree1->n_otu;
3693	}
3694	else
3695	{
3696	n_edges = tree1->n_otu-3;
3697	}
3698
3699	identical = 0;
3700	different = 0;
3701	For(i,2*tree1->n_otu-3)
3702	{
3703	b1 = tree1->a_edges[i];
3704	bip_size1 = MIN(b1->left->bip_size[b1->l_r],b1->rght->bip_size[b1->r_l]);
3705
3706	if(bip_size1 > 1 && ((on_existing_edges_only == YES && b1->does_exist) \|\| (on_existing_edges_only == NO)))
3707	{
3708	For(j,2*tree2->n_otu-3)
3709	{
3710	b2 = tree2->a_edges[j];
3711	bip_size2 = MIN(b2->left->bip_size[b2->l_r],b2->rght->bip_size[b2->r_l]);
3712
3713	if(bip_size2 > 1 && ((on_existing_edges_only == YES && b2->does_exist) \|\| (on_existing_edges_only == NO)))
3714	{
3715	if(bip_size1 == bip_size2)
3716	{
3717	bip_size = bip_size1;
3718
3719	if(b1->left->bip_size[b1->l_r] == b1->rght->bip_size[b1->r_l])
3720	{
3721	/* if(b1->left->bip_name[b1->l_r][0][0] < b1->rght->bip_name[b1->r_l][0][0]) */
3722	if(b1->left->bip_node[b1->l_r][0]->num < b1->rght->bip_node[b1->r_l][0]->num)
3723	{
3724	/* bip1 = b1->left->bip_name[b1->l_r]; */
3725	bip1 = b1->left->bip_node[b1->l_r];
3726	}
3727	else
3728	{
3729	/* bip1 = b1->rght->bip_name[b1->r_l]; */
3730	bip1 = b1->rght->bip_node[b1->r_l];
3731	}
3732	}
3733	else if(b1->left->bip_size[b1->l_r] < b1->rght->bip_size[b1->r_l])
3734	{
3735	/* bip1 = b1->left->bip_name[b1->l_r]; */
3736	bip1 = b1->left->bip_node[b1->l_r];
3737	}
3738	else
3739	{
3740	/* bip1 = b1->rght->bip_name[b1->r_l]; */
3741	bip1 = b1->rght->bip_node[b1->r_l];
3742	}
3743
3744
3745	if(b2->left->bip_size[b2->l_r] == b2->rght->bip_size[b2->r_l])
3746	{
3747	/* if(b2->left->bip_name[b2->l_r][0][0] < b2->rght->bip_name[b2->r_l][0][0]) */
3748	if(b2->left->bip_node[b2->l_r][0]->num < b2->rght->bip_node[b2->r_l][0]->num)
3749	{
3750	/* bip2 = b2->left->bip_name[b2->l_r]; */
3751	bip2 = b2->left->bip_node[b2->l_r];
3752	}
3753	else
3754	{
3755	/* bip2 = b2->rght->bip_name[b2->r_l]; */
3756	bip2 = b2->rght->bip_node[b2->r_l];
3757	}
3758	}
3759	else if(b2->left->bip_size[b2->l_r] < b2->rght->bip_size[b2->r_l])
3760	{
3761	/* bip2 = b2->left->bip_name[b2->l_r]; */
3762	bip2 = b2->left->bip_node[b2->l_r];
3763	}
3764	else
3765	{
3766	/* bip2 = b2->rght->bip_name[b2->r_l]; */
3767	bip2 = b2->rght->bip_node[b2->r_l];
3768	}
3769
3770	if(bip_size == 1) Warn_And_Exit("\n. Problem in Compare_Bip\n");
3771
3772	For(k,bip_size)
3773	{
3774	/* if(strcmp(bip1[k],bip2[k])) break; */
3775	if(bip1[k]->num != bip2[k]->num) break;
3776	}
3777
3778	if(k == bip_size) /* Branches b1 and b2 define the same bipartition */
3779	{
3780	b1->bip_score++;
3781	b2->bip_score++;
3782	identical++;
3783	goto out;
3784	}
3785	else
3786	{
3787	different++; // Bipartitions have identical sizes but distinct elements
3788	}
3789	}
3790	else different++; // Biparition have different sizes
3791	}
3792	}
3793	}
3794	out: ;
3795	}
3796	return n_edges - identical;
3797	/* return different; */
3798	}
3799
3800	//////////////////////////////////////////////////////////////
3801	//////////////////////////////////////////////////////////////
3802
3803	/* Modifiy the tip numbering in tree2 so that tips in
3804	tree1 and tree2 corresponding to the same taxon name
3805	also have the same tip numbering */
3806	void Match_Tip_Numbers(t_tree tree1, t_tree tree2)
3807	{
3808	int i,j;
3809
3810	if(tree1->n_otu != tree2->n_otu)
3811	{
3812	PhyML_Printf("\n. tree1 and tree2 must have the same number of tips.");
3813	/* Otherwise, if tree2->n_otu < tree->n_otu, then some tips in tree2
3814	will have a number (->num) that is the same as the number of an
3815	internal node in this tree */
3816	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
3817	Warn_And_Exit("");
3818	}
3819
3820	For(i,tree1->n_otu)
3821	{
3822	For(j,tree2->n_otu)
3823	{
3824	if(!strcmp(tree1->a_nodes[i]->name,tree2->a_nodes[j]->name))
3825	{
3826	tree2->a_nodes[j]->num = tree1->a_nodes[i]->num;
3827	break;
3828	}
3829	}
3830	}
3831
3832	}
3833
3834	//////////////////////////////////////////////////////////////
3835	//////////////////////////////////////////////////////////////
3836
3837	void Test_Multiple_Data_Set_Format(option *io)
3838	{
3839	char *line;
3840
3841	line = (char *)mCalloc(T_MAX_LINE,sizeof(char));
3842
3843	io->n_trees = 0;
3844
3845	while(fgets(line,T_MAX_LINE,io->fp_in_tree)) if(strstr(line,";")) io->n_trees++;
3846
3847	Free(line);
3848
3849	if((io->mod->bootstrap > 1) && (io->n_trees > 1))
3850	Warn_And_Exit("\n. Bootstrap option is not allowed with multiple input trees !\n");
3851
3852	rewind(io->fp_in_tree);
3853
3854	return;
3855	}
3856
3857	//////////////////////////////////////////////////////////////
3858	//////////////////////////////////////////////////////////////
3859
3860
3861	int Are_Compatible(char statea, char stateb, int stepsize, int datatype)
3862	{
3863	int i,j;
3864	char a,b;
3865
3866	if(datatype == NT)
3867	{
3868	For(i,stepsize)
3869	{
3870	a = statea[i];
3871	For(j,stepsize)
3872	{
3873	b = stateb[j];
3874
3875	switch(a)
3876	{
3877	case 'A':
3878	{
3879	switch(b)
3880	{
3881	case 'A' :
3882	case 'M' :
3883	case 'R' :
3884	case 'W' :
3885	case 'D' :
3886	case 'H' :
3887	case 'V' :
3888	case 'X' : {b=b; break;}
3889	default : return 0;
3890	}
3891	break;
3892	}
3893	case 'G':
3894	{
3895	switch(b)
3896	{
3897	case 'G' :
3898	case 'R' :
3899	case 'S' :
3900	case 'K' :
3901	case 'B' :
3902	case 'D' :
3903	case 'V' :
3904	case 'X' : {b=b; break;}
3905	default : return 0;
3906	}
3907	break;
3908	}
3909	case 'C':
3910	{
3911	switch(b)
3912	{
3913	case 'C' :
3914	case 'M' :
3915	case 'S' :
3916	case 'Y' :
3917	case 'B' :
3918	case 'H' :
3919	case 'V' :
3920	case 'X' : {b=b; break;}
3921	default : return 0;
3922	}
3923	break;
3924	}
3925	case 'T':
3926	{
3927	switch(b)
3928	{
3929	case 'T' :
3930	case 'W' :
3931	case 'Y' :
3932	case 'K' :
3933	case 'B' :
3934	case 'D' :
3935	case 'H' :
3936	case 'X' :
3937	{b=b; break;}
3938	default : return 0;
3939	}
3940	break;
3941	}
3942	case 'M' :
3943	{
3944	switch(b)
3945	{
3946	case 'M' :
3947	case 'A' :
3948	case 'C' :
3949	case 'R' :
3950	case 'W' :
3951	case 'S' :
3952	case 'Y' :
3953	case 'B' :
3954	case 'D' :
3955	case 'H' :
3956	case 'V' :
3957	case 'X' :
3958	{b=b; break;}
3959	default : return 0;
3960	}
3961	break;
3962	}
3963	case 'R' :
3964	{
3965	switch(b)
3966	{
3967	case 'R' :
3968	case 'A' :
3969	case 'G' :
3970	case 'M' :
3971	case 'W' :
3972	case 'S' :
3973	case 'K' :
3974	case 'B' :
3975	case 'D' :
3976	case 'H' :
3977	case 'V' :
3978	case 'X' : {b=b; break;}
3979	default : return 0;
3980	}
3981	break;
3982	}
3983
3984	case 'W' :
3985	{
3986	switch(b)
3987	{
3988	case 'W' :
3989	case 'A' :
3990	case 'T' :
3991	case 'M' :
3992	case 'R' :
3993	case 'Y' :
3994	case 'K' :
3995	case 'B' :
3996	case 'D' :
3997	case 'H' :
3998	case 'V' :
3999	case 'X' : {b=b; break;}
4000	default : return 0;
4001	}
4002	break;
4003	}
4004
4005	case 'S' :
4006	{
4007	switch(b)
4008	{
4009	case 'S' :
4010	case 'C' :
4011	case 'G' :
4012	case 'M' :
4013	case 'R' :
4014	case 'Y' :
4015	case 'K' :
4016	case 'B' :
4017	case 'D' :
4018	case 'H' :
4019	case 'V' :
4020	case 'X' : {b=b; break;}
4021	default : return 0;
4022	}
4023	break;
4024	}
4025
4026	case 'Y' :
4027	{
4028	switch(b)
4029	{
4030	case 'Y' :
4031	case 'C' :
4032	case 'T' :
4033	case 'M' :
4034	case 'W' :
4035	case 'S' :
4036	case 'K' :
4037	case 'B' :
4038	case 'D' :
4039	case 'H' :
4040	case 'V' :
4041	case 'X' : {b=b; break;}
4042	default : return 0;
4043	}
4044	break;
4045	}
4046
4047	case 'K' :
4048	{
4049	switch(b)
4050	{
4051	case 'K' :
4052	case 'G' :
4053	case 'T' :
4054	case 'R' :
4055	case 'W' :
4056	case 'S' :
4057	case 'Y' :
4058	case 'B' :
4059	case 'D' :
4060	case 'H' :
4061	case 'V' :
4062	case 'X' : {b=b; break;}
4063	default : return 0;
4064	}
4065	break;
4066	}
4067	case 'B' :
4068	{
4069	switch(b)
4070	{
4071	case 'B' :
4072	case 'C' :
4073	case 'G' :
4074	case 'T' :
4075	case 'M' :
4076	case 'R' :
4077	case 'W' :
4078	case 'S' :
4079	case 'Y' :
4080	case 'K' :
4081	case 'D' :
4082	case 'H' :
4083	case 'V' :
4084	case 'X' : {b=b; break;}
4085	default : return 0;
4086	}
4087	break;
4088	}
4089	case 'D' :
4090	{
4091	switch(b)
4092	{
4093	case 'D' :
4094	case 'A' :
4095	case 'G' :
4096	case 'T' :
4097	case 'M' :
4098	case 'R' :
4099	case 'W' :
4100	case 'S' :
4101	case 'Y' :
4102	case 'K' :
4103	case 'B' :
4104	case 'H' :
4105	case 'V' :
4106	case 'X' : {b=b; break;}
4107	default : return 0;
4108	}
4109	break;
4110	}
4111	case 'H' :
4112	{
4113	switch(b)
4114	{
4115	case 'H' :
4116	case 'A' :
4117	case 'C' :
4118	case 'T' :
4119	case 'M' :
4120	case 'R' :
4121	case 'W' :
4122	case 'S' :
4123	case 'Y' :
4124	case 'K' :
4125	case 'B' :
4126	case 'D' :
4127	case 'V' :
4128	case 'X' : {b=b; break;}
4129	default : return 0;
4130	}
4131	break;
4132	}
4133	case 'V' :
4134	{
4135	switch(b)
4136	{
4137	case 'V' :
4138	case 'A' :
4139	case 'C' :
4140	case 'G' :
4141	case 'M' :
4142	case 'R' :
4143	case 'W' :
4144	case 'S' :
4145	case 'Y' :
4146	case 'K' :
4147	case 'B' :
4148	case 'D' :
4149	case 'H' :
4150	case 'X' : {b=b; break;}
4151	default : return 0;
4152	}
4153	break;
4154	}
4155	case 'X' :
4156	{
4157	switch(b)
4158	{
4159	case 'X' :
4160	case 'A' :
4161	case 'C' :
4162	case 'G' :
4163	case 'T' :
4164	case 'M' :
4165	case 'R' :
4166	case 'W' :
4167	case 'S' :
4168	case 'Y' :
4169	case 'K' :
4170	case 'B' :
4171	case 'D' :
4172	case 'H' :
4173	case 'V' : {b=b; break;}
4174	default : return 0;
4175	}
4176	break;
4177	}
4178	default :
4179	{
4180	PhyML_Printf("\n. Err. in Are_Compatible\n");
4181	PhyML_Printf("\n. Please check that characters `%c` and `%c`\n",a,b);
4182	PhyML_Printf(" correspond to existing nucleotides.\n");
4183	Warn_And_Exit("\n");
4184	return 0;
4185	}
4186	}
4187	}
4188	}
4189	}
4190	else if(datatype == AA)
4191	{
4192	a = statea[0]; b = stateb[0];
4193	switch(a)
4194	{
4195	case 'A' :
4196	{
4197	switch(b)
4198	{
4199	case 'A' :
4200	case 'X' : {b=b; break;}
4201	default : return 0;
4202	}
4203	break;
4204	}
4205	case 'R' :
4206	{
4207	switch(b)
4208	{
4209	case 'R' :
4210	case 'X' : {b=b; break;}
4211	default : return 0;
4212	}
4213	break;
4214	}
4215	case 'N' :
4216	{
4217	switch(b)
4218	{
4219	case 'N' :
4220	case 'B' :
4221	case 'X' : {b=b; break;}
4222	default : return 0;
4223	}
4224	break;
4225	}
4226	case 'B' :
4227	{
4228	switch(b)
4229	{
4230	case 'N' :
4231	case 'B' :
4232	case 'X' : {b=b; break;}
4233	default : return 0;
4234	}
4235	break;
4236	}
4237	case 'D' :
4238	{
4239	switch(b)
4240	{
4241	case 'D' :
4242	case 'X' : {b=b; break;}
4243	default : return 0;
4244	}
4245	break;
4246	}
4247	case 'C' :
4248	{
4249	switch(b)
4250	{
4251	case 'C' :
4252	case 'X' : {b=b; break;}
4253	default : return 0;
4254	}
4255	break;
4256	}
4257	case 'Q' :
4258	{
4259	switch(b)
4260	{
4261	case 'Q' :
4262	case 'Z' :
4263	case 'X' : {b=b; break;}
4264	default : return 0;
4265	}
4266	break;
4267	}
4268	case 'Z' :
4269	{
4270	switch(b)
4271	{
4272	case 'Q' :
4273	case 'Z' :
4274	case 'X' : {b=b; break;}
4275	default : return 0;
4276	}
4277	break;
4278	}
4279	case 'E' :
4280	{
4281	switch(b)
4282	{
4283	case 'E' :
4284	case 'X' : {b=b; break;}
4285	default : return 0;
4286	}
4287	break;
4288	}
4289	case 'G' :
4290	{
4291	switch(b)
4292	{
4293	case 'G' :
4294	case 'X' : {b=b; break;}
4295	default : return 0;
4296	}
4297	break;
4298	}
4299	case 'H' :
4300	{
4301	switch(b)
4302	{
4303	case 'H' :
4304	case 'X' : {b=b; break;}
4305	default : return 0;
4306	}
4307	break;
4308	}
4309	case 'I' :
4310	{
4311	switch(b)
4312	{
4313	case 'I' :
4314	case 'X' : {b=b; break;}
4315	default : return 0;
4316	}
4317	break;
4318	}
4319	case 'L' :
4320	{
4321	switch(b)
4322	{
4323	case 'L' :
4324	case 'X' : {b=b; break;}
4325	default : return 0;
4326	}
4327	break;
4328	}
4329	case 'K' :
4330	{
4331	switch(b)
4332	{
4333	case 'K' :
4334	case 'X' : {b=b; break;}
4335	default : return 0;
4336	}
4337	break;
4338	}
4339	case 'M' :
4340	{
4341	switch(b)
4342	{
4343	case 'M' :
4344	case 'X' : {b=b; break;}
4345	default : return 0;
4346	}
4347	break;
4348	}
4349	case 'F' :
4350	{
4351	switch(b)
4352	{
4353	case 'F' :
4354	case 'X' : {b=b; break;}
4355	default : return 0;
4356	}
4357	break;
4358	}
4359	case 'P' :
4360	{
4361	switch(b)
4362	{
4363	case 'P' :
4364	case 'X' : {b=b; break;}
4365	default : return 0;
4366	}
4367	break;
4368	}
4369	case 'S' :
4370	{
4371	switch(b)
4372	{
4373	case 'S' :
4374	case 'X' : {b=b; break;}
4375	default : return 0;
4376	}
4377	break;
4378	}
4379	case 'T' :
4380	{
4381	switch(b)
4382	{
4383	case 'T' :
4384	case 'X' : {b=b; break;}
4385	default : return 0;
4386	}
4387	break;
4388	}
4389	case 'W' :
4390	{
4391	switch(b)
4392	{
4393	case 'W' :
4394	case 'X' : {b=b; break;}
4395	default : return 0;
4396	}
4397	break;
4398	}
4399	case 'Y' :
4400	{
4401	switch(b)
4402	{
4403	case 'Y' :
4404	case 'X' : {b=b; break;}
4405	default : return 0;
4406	}
4407	break;
4408	}
4409	case 'V' :
4410	{
4411	switch(b)
4412	{
4413	case 'V' :
4414	case 'X' : {b=b; break;}
4415	default : return 0;
4416	}
4417	break;
4418	}
4419	case 'X' :
4420	{
4421	switch(b)
4422	{
4423	case 'A':case 'R':case 'N' :case 'B' :case 'D' :
4424	case 'C':case 'Q':case 'Z' :case 'E' :case 'G' :
4425	case 'H':case 'I':case 'L' :case 'K' :case 'M' :
4426	case 'F':case 'P':case 'S' :case 'T' :case 'W' :
4427	case 'Y':case 'V': case 'X' : {b=b; break;}
4428	default : return 0;
4429	}
4430	break;
4431	}
4432	default :
4433	{
4434	PhyML_Printf("\n. Err. in Are_Compatible\n");
4435	PhyML_Printf("\n. Please check that characters `%c` and `%c`\n",a,b);
4436	PhyML_Printf(" correspond to existing amino-acids.\n");
4437	Warn_And_Exit("\n");
4438	return 0;
4439	}
4440	}
4441	}
4442	else if(datatype == GENERIC)
4443	{
4444	if(Is_Ambigu(statea,GENERIC,stepsize) \|\| Is_Ambigu(stateb,GENERIC,stepsize)) return 1;
4445	else
4446	{
4447	int a,b;
4448	char format[6];
4449
4450	sprintf(format,"%%%dd",stepsize);
4451
4452	if(!sscanf(statea,format,&a))
4453	{
4454	PhyML_Printf("\n. statea = %s",statea);
4455	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
4456	Warn_And_Exit("");
4457	}
4458	if(!sscanf(stateb,format,&b))
4459	{
4460	PhyML_Printf("\n. statea = %s",stateb);
4461	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
4462	Warn_And_Exit("");
4463	}
4464
4465	/* PhyML_Printf("\n. %s %d a=%d b=%d ",__FILE__,__LINE__,a,b); */
4466
4467	if(a == b) return 1;
4468	}
4469	return 0;
4470	}
4471
4472	return 1;
4473	}
4474
4475	//////////////////////////////////////////////////////////////
4476	//////////////////////////////////////////////////////////////
4477
4478
4479	void Hide_Ambiguities(calign *data)
4480	{
4481	int i;
4482	For(i,data->crunch_len) if(data->ambigu[i]) data->wght[i] = 0;
4483	}
4484
4485	//////////////////////////////////////////////////////////////
4486	//////////////////////////////////////////////////////////////
4487
4488	void Copy_Tree(t_tree ori, t_tree cpy)
4489	{
4490	int i,j;
4491
4492	For(i,2*ori->n_otu-2)
4493	{
4494	For(j,3)
4495	{
4496	if(ori->a_nodes[i]->v[j])
4497	{
4498	cpy->a_nodes[i]->v[j] = cpy->a_nodes[ori->a_nodes[i]->v[j]->num];
4499	cpy->a_nodes[i]->l[j] = ori->a_nodes[i]->l[j];
4500	cpy->a_nodes[i]->b[j] = cpy->a_edges[ori->a_nodes[i]->b[j]->num];
4501	}
4502	else
4503	{
4504	cpy->a_nodes[i]->v[j] = NULL;
4505	cpy->a_nodes[i]->b[j] = NULL;
4506	}
4507	}
4508	}
4509
4510	For(i,2*ori->n_otu-3)
4511	{
4512	cpy->a_edges[i]->l->v = ori->a_edges[i]->l->v;
4513	cpy->a_edges[i]->left = cpy->a_nodes[ori->a_edges[i]->left->num];
4514	cpy->a_edges[i]->rght = cpy->a_nodes[ori->a_edges[i]->rght->num];
4515	cpy->a_edges[i]->l_v1 = ori->a_edges[i]->l_v1;
4516	cpy->a_edges[i]->l_v2 = ori->a_edges[i]->l_v2;
4517	cpy->a_edges[i]->r_v1 = ori->a_edges[i]->r_v1;
4518	cpy->a_edges[i]->r_v2 = ori->a_edges[i]->r_v2;
4519	cpy->a_edges[i]->l_r = ori->a_edges[i]->l_r;
4520	cpy->a_edges[i]->r_l = ori->a_edges[i]->r_l;
4521	cpy->a_edges[i]->does_exist = ori->a_edges[i]->does_exist;
4522	}
4523
4524
4525	For(i,ori->n_otu)
4526	{
4527	cpy->a_nodes[i]->tax = YES;
4528
4529	Free(cpy->a_nodes[i]->name);
4530
4531	cpy->a_nodes[i]->name = (char *)mCalloc(strlen(ori->a_nodes[i]->name)+1,sizeof(char));
4532	cpy->a_nodes[i]->ori_name = cpy->a_nodes[i]->name ;
4533
4534	strcpy(cpy->a_nodes[i]->name,ori->a_nodes[i]->name);
4535	}
4536
4537	if(ori->n_root)
4538	{
4539	cpy->e_root = cpy->a_edges[ori->e_root->num];
4540	cpy->n_root = cpy->a_nodes[ori->n_root->num];
4541	Add_Root(cpy->e_root,cpy);
4542	}
4543
4544	cpy->num_curr_branch_available = 0;
4545	cpy->t_beg = ori->t_beg;
4546
4547	/* Connect_Edges_To_Nodes_Recur(cpy->a_nodes[0],cpy->a_nodes[0]->v[0],cpy); */
4548	/* Update_Dirs(cpy); */
4549	}
4550
4551	//////////////////////////////////////////////////////////////
4552	//////////////////////////////////////////////////////////////
4553
4554	void Prune_Subtree(t_node a, t_node d, t_edge target, t_edge residual, t_tree *tree)
4555	{
4556	t_node v1, v2;
4557	t_edge b1, b2;
4558	int dir_v1, dir_v2;
4559	int i;
4560	/* phydbl **buff_p_lk; /
4561	phydbl *buff_p_lk;
4562	int *buff_scale;
4563	int buff_p_pars, buff_pars, buff_p_lk_loc, buff_patt_id;
4564	unsigned int *buff_ui;
4565	short int *buff_p_lk_tip;
4566
4567
4568	if(a->tax)
4569	{
4570	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
4571	Exit("\n");
4572	}
4573
4574	dir_v1 = dir_v2 = -1;
4575	For(i,3)
4576	{
4577	if(a->v[i] != d)
4578	{
4579	if(dir_v1 < 0) dir_v1 = i;
4580	else dir_v2 = i;
4581	}
4582	}
4583
4584	if(a->v[dir_v1]->num < a->v[dir_v2]->num)
4585	{
4586	v1 = a->v[dir_v1];
4587	v2 = a->v[dir_v2];
4588	b1 = a->b[dir_v1];
4589	b2 = a->b[dir_v2];
4590	}
4591	else
4592	{
4593	v1 = a->v[dir_v2];
4594	v2 = a->v[dir_v1];
4595	b1 = a->b[dir_v2];
4596	b2 = a->b[dir_v1];
4597	}
4598
4599	/* if(v1->tax && v2->tax) PhyML_Printf("\n. Pruning is meaningless here.\n"); */
4600
4601	a->v[dir_v1] = NULL;
4602	a->v[dir_v2] = NULL;
4603	a->b[dir_v1] = NULL;
4604	a->b[dir_v2] = NULL;
4605
4606	if(v1 == b1->left)
4607	{
4608	b1->rght = v2;
4609
4610	if(v2 == b2->left)
4611	{
4612	buff_p_lk = b1->p_lk_rght;
4613	b1->p_lk_rght = b2->p_lk_left;
4614	b2->p_lk_left = buff_p_lk;
4615
4616	buff_p_lk_tip = b1->p_lk_tip_r;
4617	b1->p_lk_tip_r = b2->p_lk_tip_l;
4618	b2->p_lk_tip_l = buff_p_lk_tip;
4619
4620	buff_scale = b1->sum_scale_rght;
4621	b1->sum_scale_rght = b2->sum_scale_left;
4622	b2->sum_scale_left = buff_scale;
4623
4624	buff_scale = b1->sum_scale_rght_cat;
4625	b1->sum_scale_rght_cat = b2->sum_scale_left_cat;
4626	b2->sum_scale_left_cat = buff_scale;
4627
4628	buff_pars = b1->pars_r;
4629	b1->pars_r = b2->pars_l;
4630	b2->pars_l = buff_pars;
4631
4632	buff_ui = b1->ui_r;
4633	b1->ui_r = b2->ui_l;
4634	b2->ui_l = buff_ui;
4635
4636	buff_p_pars = b1->p_pars_r;
4637	b1->p_pars_r = b2->p_pars_l;
4638	b2->p_pars_l = buff_p_pars;
4639
4640	buff_p_lk_loc = b1->p_lk_loc_rght;
4641	b1->p_lk_loc_rght = b2->p_lk_loc_left;
4642	b2->p_lk_loc_left = buff_p_lk_loc;
4643
4644	buff_patt_id = b1->patt_id_rght;
4645	b1->patt_id_rght = b2->patt_id_left;
4646	b2->patt_id_left = buff_patt_id;
4647
4648	}
4649	else
4650	{
4651	buff_p_lk = b1->p_lk_rght; /* b1->p_lk_rght = NULL if b1->rght->tax */
4652	b1->p_lk_rght = b2->p_lk_rght; /* b2->p_lk_rght = NULL if b2->rght->tax */
4653	b2->p_lk_rght = buff_p_lk;
4654
4655	buff_p_lk_tip = b1->p_lk_tip_r;
4656	b1->p_lk_tip_r = b2->p_lk_tip_r;
4657	b2->p_lk_tip_r = buff_p_lk_tip;
4658
4659	buff_scale = b1->sum_scale_rght;
4660	b1->sum_scale_rght = b2->sum_scale_rght;
4661	b2->sum_scale_rght = buff_scale;
4662
4663	buff_pars = b1->pars_r;
4664	b1->pars_r = b2->pars_r;
4665	b2->pars_r = buff_pars;
4666
4667	buff_ui = b1->ui_r;
4668	b1->ui_r = b2->ui_r;
4669	b2->ui_r = buff_ui;
4670
4671	buff_p_pars = b1->p_pars_r;
4672	b1->p_pars_r = b2->p_pars_r;
4673	b2->p_pars_r = buff_p_pars;
4674
4675	buff_p_lk_loc = b1->p_lk_loc_rght;
4676	b1->p_lk_loc_rght = b2->p_lk_loc_rght;
4677	b2->p_lk_loc_rght = buff_p_lk_loc;
4678
4679	buff_patt_id = b1->patt_id_rght;
4680	b1->patt_id_rght = b2->patt_id_rght;
4681	b2->patt_id_rght = buff_patt_id;
4682
4683	}
4684	}
4685	else
4686	{
4687	b1->left = v2;
4688
4689	if(v2 == b2->left)
4690	{
4691	buff_p_lk = b1->p_lk_left;
4692	b1->p_lk_left = b2->p_lk_left;
4693	b2->p_lk_left = buff_p_lk;
4694
4695	buff_p_lk_tip = b1->p_lk_tip_l;
4696	b1->p_lk_tip_l = b2->p_lk_tip_l;
4697	b2->p_lk_tip_l = buff_p_lk_tip;
4698
4699	buff_scale = b1->sum_scale_left;
4700	b1->sum_scale_left = b2->sum_scale_left;
4701	b2->sum_scale_left = buff_scale;
4702
4703	buff_scale = b1->sum_scale_left_cat;
4704	b1->sum_scale_left_cat = b2->sum_scale_left_cat;
4705	b2->sum_scale_left_cat = buff_scale;
4706
4707	buff_pars = b1->pars_l;
4708	b1->pars_l = b2->pars_l;
4709	b2->pars_l = buff_pars;
4710
4711	buff_ui = b1->ui_l;
4712	b1->ui_l = b2->ui_l;
4713	b2->ui_l = buff_ui;
4714
4715	buff_p_pars = b1->p_pars_l;
4716	b1->p_pars_l = b2->p_pars_l;
4717	b2->p_pars_l = buff_p_pars;
4718
4719	buff_p_lk_loc = b1->p_lk_loc_left;
4720	b1->p_lk_loc_left = b2->p_lk_loc_left;
4721	b2->p_lk_loc_left = buff_p_lk_loc;
4722
4723	buff_patt_id = b1->patt_id_left;
4724	b1->patt_id_left = b2->patt_id_left;
4725	b2->patt_id_left = buff_patt_id;
4726
4727	}
4728	else
4729	{
4730	buff_p_lk = b1->p_lk_left;
4731	b1->p_lk_left = b2->p_lk_rght; /* b2->p_lk_rght = NULL if b2->rght->tax */
4732	b2->p_lk_rght = buff_p_lk;
4733
4734	buff_p_lk_tip = b1->p_lk_tip_l;
4735	b1->p_lk_tip_l = b2->p_lk_tip_r;
4736	b2->p_lk_tip_r = buff_p_lk_tip;
4737
4738	buff_scale = b1->sum_scale_left;
4739	b1->sum_scale_left = b2->sum_scale_rght;
4740	b2->sum_scale_rght = buff_scale;
4741
4742	buff_scale = b1->sum_scale_left_cat;
4743	b1->sum_scale_left_cat = b2->sum_scale_rght_cat;
4744	b2->sum_scale_rght_cat = buff_scale;
4745
4746	buff_pars = b1->pars_l;
4747	b1->pars_l = b2->pars_r;
4748	b2->pars_r = buff_pars;
4749
4750	buff_ui = b1->ui_l;
4751	b1->ui_l = b2->ui_r;
4752	b2->ui_r = buff_ui;
4753
4754	buff_p_pars = b1->p_pars_l;
4755	b1->p_pars_l = b2->p_pars_r;
4756	b2->p_pars_r = buff_p_pars;
4757
4758	buff_p_lk_loc = b1->p_lk_loc_left;
4759	b1->p_lk_loc_left = b2->p_lk_loc_rght;
4760	b2->p_lk_loc_rght = buff_p_lk_loc;
4761
4762	buff_patt_id = b1->patt_id_left;
4763	b1->patt_id_left = b2->patt_id_rght;
4764	b2->patt_id_rght = buff_patt_id;
4765	}
4766	}
4767
4768	For(i,3)
4769	if(v2->v[i] == a)
4770	{
4771	v2->v[i] = v1;
4772	v2->b[i] = b1;
4773	break;
4774	}
4775
4776	#ifdef DEBUG
4777	if(i == 3)
4778	{
4779	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
4780	Warn_And_Exit("");
4781	}
4782	#endif
4783
4784	For(i,3)
4785	if(v1->v[i] == a)
4786	{
4787	v1->v[i] = v2;
4788	break;
4789	}
4790
4791	#ifdef DEBUG
4792	if(i == 3)
4793	{
4794	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
4795	Warn_And_Exit("");
4796	}
4797	#endif
4798
4799	if(b1->l->onoff == ON)
4800	{
4801	b1->l->v += b2->l->v;
4802	}
4803
4804	(v1 == b1->left)?
4805	(Make_Edge_Dirs(b1,v1,v2,tree)):
4806	(Make_Edge_Dirs(b1,v2,v1,tree));
4807
4808	if(target) (*target) = b1;
4809	if(residual) (*residual) = b2;
4810
4811	if(tree->n_root)
4812	{
4813	if(tree->n_root->v[1] == a) tree->n_root->v[1] = NULL;
4814	if(tree->n_root->v[2] == a) tree->n_root->v[2] = NULL;
4815	}
4816
4817	/* if(tree->n_root) */
4818	/* { */
4819	/* tree->n_root->v[1] = tree->e_root->left; */
4820	/* tree->n_root->v[2] = tree->e_root->rght; */
4821	/* tree->n_root->b[1]->rght = tree->e_root->left; */
4822	/* tree->n_root->b[2]->rght = tree->e_root->rght; */
4823	/* } */
4824
4825	#ifdef DEBUG
4826	if(b1->left->tax == YES && b1->rght->tax == NO)
4827	{
4828	PhyML_Printf("\n== b1->left->num = %d",b1->left->num);
4829	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
4830	Warn_And_Exit("");
4831	}
4832	#endif
4833
4834	if(tree->is_mixt_tree == YES) MIXT_Prune_Subtree(a,d,target,residual,tree);
4835
4836	}
4837
4838	//////////////////////////////////////////////////////////////
4839	//////////////////////////////////////////////////////////////
4840
4841	void Graft_Subtree(t_edge target, t_node link, t_edge residual, t_tree tree)
4842	{
4843	t_node v1, v2;
4844	int i, dir_v1, dir_v2;
4845	phydbl *buff_p_lk;
4846	int *buff_scale;
4847	int buff_p_pars, buff_pars, buff_p_lk_loc, buff_patt_id;
4848	short int *buff_p_lk_tip;
4849	unsigned int *buff_ui;
4850	t_edge *b_up;
4851
4852	dir_v1 = dir_v2 = -1;
4853	b_up = NULL;
4854	For(i,3)
4855	{
4856	if(!link->v[i])
4857	{
4858	if(dir_v1 < 0) dir_v1 = i;
4859	else dir_v2 = i;
4860	}
4861	else b_up = link->b[i];
4862	}
4863
4864	if(target->left->num < target->rght->num)
4865	{
4866	v1 = target->left;
4867	v2 = target->rght;
4868
4869	buff_p_lk = residual->p_lk_rght;
4870	residual->p_lk_rght = target->p_lk_rght;
4871	target->p_lk_rght = buff_p_lk;
4872
4873	buff_p_lk_tip = residual->p_lk_tip_r;
4874	residual->p_lk_tip_r = target->p_lk_tip_r;
4875	target->p_lk_tip_r = buff_p_lk_tip;
4876
4877	buff_scale = residual->sum_scale_rght;
4878	residual->sum_scale_rght = target->sum_scale_rght;
4879	target->sum_scale_rght = buff_scale;
4880
4881	buff_pars = residual->pars_r;
4882	residual->pars_r = target->pars_r;
4883	target->pars_r = buff_pars;
4884
4885	buff_ui = residual->ui_r;
4886	residual->ui_r = target->ui_r;
4887	target->ui_r = buff_ui;
4888
4889	buff_p_pars = residual->p_pars_r;
4890	residual->p_pars_r = target->p_pars_r;
4891	target->p_pars_r = buff_p_pars;
4892
4893	buff_p_lk_loc = residual->p_lk_loc_rght;
4894	residual->p_lk_loc_rght = target->p_lk_loc_rght;
4895	target->p_lk_loc_rght = buff_p_lk_loc;
4896
4897	buff_patt_id = residual->patt_id_rght;
4898	residual->patt_id_rght = target->patt_id_rght;
4899	target->patt_id_rght = buff_patt_id;
4900	}
4901	else
4902	{
4903	v1 = target->rght;
4904	v2 = target->left;
4905
4906	buff_p_lk = residual->p_lk_rght;
4907	residual->p_lk_rght = target->p_lk_left;
4908	target->p_lk_left = buff_p_lk;
4909
4910	buff_p_lk_tip = residual->p_lk_tip_r;
4911	residual->p_lk_tip_r = target->p_lk_tip_l;
4912	target->p_lk_tip_l = buff_p_lk_tip;
4913
4914	buff_scale = residual->sum_scale_rght;
4915	residual->sum_scale_rght = target->sum_scale_left;
4916	target->sum_scale_left = buff_scale;
4917
4918	buff_scale = residual->sum_scale_rght_cat;
4919	residual->sum_scale_rght_cat = target->sum_scale_left_cat;
4920	target->sum_scale_left_cat = buff_scale;
4921
4922	buff_pars = residual->pars_r;
4923	residual->pars_r = target->pars_l;
4924	target->pars_l = buff_pars;
4925
4926	buff_ui = residual->ui_r;
4927	residual->ui_r = target->ui_l;
4928	target->ui_l = buff_ui;
4929
4930	buff_p_pars = residual->p_pars_r;
4931	residual->p_pars_r = target->p_pars_l;
4932	target->p_pars_l = buff_p_pars;
4933
4934	buff_p_lk_loc = residual->p_lk_loc_rght;
4935	residual->p_lk_loc_rght = target->p_lk_loc_left;
4936	target->p_lk_loc_left = buff_p_lk_loc;
4937
4938	buff_patt_id = residual->patt_id_rght;
4939	residual->patt_id_rght = target->patt_id_left;
4940	target->patt_id_left = buff_patt_id;
4941	}
4942
4943
4944	For(i,3)
4945	if(v2->b[i] == target)
4946	{
4947	v2->v[i] = link;
4948	v2->b[i] = residual;
4949	break;
4950	}
4951
4952	link->v[dir_v2] = v2;
4953	link->b[dir_v2] = residual;
4954
4955	residual->left = link;
4956	residual->rght = v2;
4957
4958	(v1 == target->left)?(target->rght = link):(target->left = link);
4959
4960	link->v[dir_v1] = v1;
4961	link->b[dir_v1] = target;
4962
4963	For(i,3)
4964	if(v1->v[i] == v2)
4965	{
4966	v1->v[i] = link;
4967	break;
4968	}
4969
4970	if(target->l->onoff == ON)
4971	target->l->v /= 2.;
4972
4973	if(residual->l->onoff == ON)
4974	residual->l->v = target->l->v;
4975
4976	Make_Edge_Dirs(target,target->left,target->rght,tree);
4977	Make_Edge_Dirs(residual,residual->left,residual->rght,tree);
4978	Make_Edge_Dirs(b_up,b_up->left,b_up->rght,tree);
4979
4980	/* if(tree->n_root) */
4981	/* { */
4982	/* tree->n_root->v[1] = tree->e_root->left; */
4983	/* tree->n_root->v[2] = tree->e_root->rght; */
4984	/* tree->n_root->b[1]->rght = tree->e_root->left; */
4985	/* tree->n_root->b[2]->rght = tree->e_root->rght; */
4986	/* } */
4987
4988
4989	if(tree->is_mixt_tree == YES) MIXT_Graft_Subtree(target,link,residual,tree);
4990
4991	}
4992
4993	//////////////////////////////////////////////////////////////
4994	//////////////////////////////////////////////////////////////
4995
4996
4997	void Reassign_Node_Nums(t_node a, t_node d, int curr_ext_node, int curr_int_node, t_tree *tree)
4998	{
4999	t_node *buff;
5000	int i;
5001
5002	if(a->tax)
5003	{
5004	buff = tree->a_nodes[*curr_ext_node];
5005	tree->a_nodes[*curr_ext_node] = a;
5006	tree->a_nodes[a->num] = buff;
5007	buff->num = a->num;
5008	a->num = *curr_ext_node;
5009	(*curr_ext_node)++;
5010	}
5011
5012	if(d->tax)
5013	{
5014	buff = tree->a_nodes[*curr_ext_node];
5015	tree->a_nodes[*curr_ext_node] = d;
5016	tree->a_nodes[d->num] = buff;
5017	buff->num = d->num;
5018	d->num = *curr_ext_node;
5019	(*curr_ext_node)++;
5020	return;
5021	}
5022	else
5023	{
5024	buff = tree->a_nodes[*curr_int_node];
5025	tree->a_nodes[*curr_int_node] = d;
5026	tree->a_nodes[d->num] = buff;
5027	buff->num = d->num;
5028	d->num = *curr_int_node;
5029	(*curr_int_node)++;
5030	}
5031
5032	For(i,3)
5033	{
5034	if(d->v[i] != a)
5035	Reassign_Node_Nums(d,d->v[i],curr_ext_node,curr_int_node,tree);
5036	}
5037	}
5038
5039	//////////////////////////////////////////////////////////////
5040	//////////////////////////////////////////////////////////////
5041
5042
5043	void Reassign_Edge_Nums(t_node a, t_node d, int curr_br, t_tree tree)
5044	{
5045	t_edge *buff;
5046	int i,j;
5047
5048	For(i,3)
5049	if(a->v[i] == d)
5050	{
5051	buff = tree->a_edges[*curr_br];
5052	For(j,2*N_MAX_OTU-3) if(tree->a_edges[j] == a->b[i]) break;
5053	if(j == 2*N_MAX_OTU-3)
5054	{
5055	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
5056	Warn_And_Exit("");
5057	}
5058	tree->a_edges[*curr_br] = a->b[i];
5059	tree->a_edges[j] = buff;
5060	a->b[i]->num = *curr_br;
5061	(*curr_br)++;
5062	break;
5063	}
5064
5065	if(d->tax) return;
5066	else
5067	{
5068	For(i,3)
5069	if(d->v[i] != a)
5070	Reassign_Edge_Nums(d,d->v[i],curr_br,tree);
5071	}
5072	}
5073
5074	//////////////////////////////////////////////////////////////
5075	//////////////////////////////////////////////////////////////
5076
5077
5078	void Find_Mutual_Direction(t_node n1, t_node n2, short int dir_n1_to_n2, short int dir_n2_to_n1)
5079	{
5080	int scores[3][3];
5081	int i,j,k,l;
5082
5083	if(n1 == n2) return;
5084
5085
5086	For(i,3)
5087	{
5088	For(j,3)
5089	{
5090	scores[i][j] = 0;
5091
5092	For(k,n1->bip_size[i])
5093	{
5094	For(l,n2->bip_size[j])
5095	{
5096	if(n1->bip_node[i][k] == n2->bip_node[j][l])
5097	{
5098	scores[i][j]++;
5099	break;
5100	}
5101	}
5102	}
5103	}
5104	}
5105
5106	For(i,3)
5107	{
5108	For(j,3)
5109	{
5110	if(!scores[i][j])
5111	{
5112	*dir_n1_to_n2 = i;
5113	*dir_n2_to_n1 = j;
5114	return;
5115	}
5116	}
5117	}
5118
5119	PhyML_Printf("\n. n1=%d n2=%d",n1->num,n2->num);
5120	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
5121	Warn_And_Exit("");
5122
5123
5124
5125	/* For(i,3) */
5126	/* { */
5127	/* n_zero_line = 0; */
5128	/* For(j,3) */
5129	/* { */
5130	/* if(!scores[i][j]) n_zero_line++; */
5131	/* } */
5132	/* if(n_zero_line != 2) {dir_n1_to_n2 = i; break;} /
5133	/* } */
5134
5135
5136	/* For(i,3) */
5137	/* { */
5138	/* n_zero_col = 0; */
5139	/* For(j,3) */
5140	/* { */
5141	/* if(!scores[j][i]) n_zero_col++; */
5142	/* } */
5143	/* if(n_zero_col != 2) {dir_n2_to_n1 = i; break;} /
5144	/* } */
5145
5146	}
5147
5148	//////////////////////////////////////////////////////////////
5149	//////////////////////////////////////////////////////////////
5150
5151
5152	void Update_Dir_To_Tips(t_node a, t_node d, t_tree *tree)
5153	{
5154	int i,j,k;
5155	short int *inout;
5156	int d_a;
5157	int dim;
5158
5159	dim = 2*tree->n_otu-2;
5160
5161	inout = (short int *)mCalloc(tree->n_otu,sizeof(short int));
5162
5163	For(i,3)
5164	{
5165	if(a->v[i] == d)
5166	{
5167	For(j,tree->n_otu) inout[j] = 1;
5168	For(k,a->bip_size[i]) inout[a->bip_node[i][k]->num] = 0;
5169	For(j,tree->n_otu) if(inout[tree->a_nodes[j]->num]) tree->t_dir[a->num*dim+tree->a_nodes[j]->num] = i;
5170	break;
5171	}
5172	}
5173
5174
5175	if(!d->tax)
5176	{
5177
5178	d_a = -1;
5179
5180	For(i,3)
5181	{
5182	if(d->v[i] != a) Update_Dir_To_Tips(d,d->v[i],tree);
5183	else if(d->v[i] == a) d_a = i;
5184	}
5185
5186	For(j,tree->n_otu) inout[j] = 1;
5187	For(k,d->bip_size[d_a]) inout[d->bip_node[d_a][k]->num] = 0;
5188	For(j,tree->n_otu) if(inout[tree->a_nodes[j]->num]) tree->t_dir[d->num*dim+tree->a_nodes[j]->num] = d_a;
5189	}
5190
5191	Free(inout);
5192
5193	}
5194
5195	//////////////////////////////////////////////////////////////
5196	//////////////////////////////////////////////////////////////
5197
5198
5199	void Fill_Dir_Table(t_tree *tree)
5200	{
5201	int i,j;
5202	int dim;
5203
5204	dim = 2*tree->n_otu-2;
5205	For(i,dim*dim) tree->t_dir[i] = 0;
5206	Free_Bip(tree);
5207	Alloc_Bip(tree);
5208	Get_Bip(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
5209	Update_Dir_To_Tips(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
5210
5211
5212	for(i=tree->n_otu;i<2*tree->n_otu-2;i++)
5213	for(j=i;j<2*tree->n_otu-2;j++)
5214	{
5215	Find_Mutual_Direction(tree->a_nodes[i],tree->a_nodes[j],
5216	&(tree->t_dir[i*dim+j]),
5217	&(tree->t_dir[j*dim+i]));
5218	}
5219	}
5220
5221	//////////////////////////////////////////////////////////////
5222	//////////////////////////////////////////////////////////////
5223
5224	//////////////////////////////////////////////////////////////
5225	//////////////////////////////////////////////////////////////
5226
5227	//////////////////////////////////////////////////////////////
5228	//////////////////////////////////////////////////////////////
5229
5230	//////////////////////////////////////////////////////////////
5231	//////////////////////////////////////////////////////////////
5232
5233
5234	int Get_Subtree_Size(t_node a, t_node d)
5235	{
5236	int size,i;
5237
5238	if(d->tax) return 1;
5239	else
5240	{
5241	size = 0;
5242	For(i,3)
5243	if(d->v[i] != a)
5244	size += Get_Subtree_Size(d,d->v[i]);
5245	}
5246	return size;
5247	}
5248
5249	//////////////////////////////////////////////////////////////
5250	//////////////////////////////////////////////////////////////
5251
5252	void Fast_Br_Len(t_edge b, t_tree tree, int approx)
5253	{
5254	/* phydbl sum; */
5255	/* phydbl prob, F; */
5256	/* int i, j, k, site; */
5257	/* phydbl v_rght; /
5258	/* int dim1,dim2,dim3; */
5259	/* int n_iter; */
5260	/* phydbl scale_rght; */
5261
5262	if(tree->is_mixt_tree)
5263	{
5264	if(approx == NO)
5265	MIXT_Br_Len_Brent(0.001,100.,b,tree);
5266	else
5267	{
5268	tree->mod->s_opt->brent_it_max = 10;
5269	MIXT_Br_Len_Brent(0.0001,1000.,b,tree);
5270	tree->mod->s_opt->brent_it_max = BRENT_IT_MAX;
5271	}
5272	return;
5273	}
5274
5275	/* n_iter = 0; */
5276	/* dim1 = tree->mod->ns * tree->mod->ras->n_catg; */
5277	/* dim2 = tree->mod->ns ; */
5278	/* dim3 = tree->mod->ns * tree->mod->ns; */
5279
5280	/* F = tree->triplet_struct->F_bc; */
5281	/* prob = tree->triplet_struct->F_cd; */
5282
5283	/* Update_PMat_At_Given_Edge(b,tree); */
5284
5285	/* For(i,dim1dim2) F[i] = .0; /
5286
5287	/* v_rght = (phydbl )mCalloc(tree->mod->ns,sizeof(phydbl)); /
5288
5289	/* For(site,tree->n_pattern) */
5290	/* { */
5291	/* /\* Joint probabilities of the states at the two ends of the t_edge \/ /
5292
5293	/* For(k,tree->mod->ras->n_catg) */
5294	/* { */
5295	/* if(b->rght->tax == YES) */
5296	/* For(i,tree->mod->ns) v_rght[i] = (phydbl)(b->p_lk_tip_r[sitedim2+i]); /
5297	/* else */
5298	/* For(i,tree->mod->ns) v_rght[i] = (phydbl)(b->p_lk_rght[sitedim1+kdim2+i]); */
5299
5300	/* scale_rght = (b->rght->tax)?(0.0):(b->sum_scale_rght[ktree->n_pattern+site]); /
5301
5302	/* Joint_Proba_States_Left_Right(b->Pij_rr + kdim3, /
5303	/* b->p_lk_left + sitedim1+kdim2, */
5304	/* v_rght, */
5305	/* tree->mod->e_frq->pi, */
5306	/* b->sum_scale_left[ktree->n_pattern+site], /
5307	/* scale_rght, */
5308	/* prob + dim3k, /
5309	/* tree->mod->ns,site,tree); */
5310
5311	/* /\* Scaling \/ /
5312	/* sum = .0; */
5313	/* For(i,tree->mod->ns) For(j,tree->mod->ns) sum += prob[dim3k+dim2i+j]; */
5314	/* For(i,tree->mod->ns) For(j,tree->mod->ns) prob[dim3k+dim2i+j] /= sum; */
5315	/* For(i,tree->mod->ns) For(j,tree->mod->ns) prob[dim3k+dim2i+j] = tree->mod->ras->gamma_r_proba->v[k]; /
5316	/* } */
5317
5318	/* /\* Expected number of each pair of states \/ /
5319	/* For(i,tree->mod->ns) For(j,tree->mod->ns) For(k,tree->mod->ras->n_catg) */
5320	/* F[dim3k+dim2i+j] += tree->data->wght[site] * prob[dim3k+dim2i+j]; */
5321
5322	/* } */
5323
5324	/* Free(v_rght); */
5325
5326	/* Opt_Dist_F(&(b->l->v),F,tree->mod); */
5327	/* n_iter++; */
5328
5329	if(approx == NO)
5330	Br_Len_Brent(0.001,100.,b,tree);
5331	else
5332	{
5333	tree->mod->s_opt->brent_it_max = 10;
5334	Br_Len_Brent(0.001,1000.,b,tree);
5335	tree->mod->s_opt->brent_it_max = BRENT_IT_MAX;
5336	}
5337	}
5338
5339	//////////////////////////////////////////////////////////////
5340	//////////////////////////////////////////////////////////////
5341	/*!
5342	Calculate the joint probability of states (nt or aa) at the
5343	two extremities of a given edge given the matrix of transition
5344	probabilities, the vector of conditional likelihoods on each
5345	side of the branch and the vector of equilibrium frequencies.
5346	*/
5347	void Joint_Proba_States_Left_Right(phydbl Pij, phydbl p_lk_left, phydbl *p_lk_rght,
5348	vect_dbl *pi, int scale_left, int scale_rght,
5349	phydbl F, int n, int site, t_tree tree)
5350	{
5351	int i,j;
5352	phydbl sum = 0.0;
5353
5354	For(i,n) F[i] = .0;
5355
5356	For(i,n)
5357	{
5358	For(j,n)
5359	{
5360	F[i*n+j] =
5361	pi->v[i] *
5362	Pij[in+j]
5363	p_lk_left[i] *
5364	p_lk_rght[j] *
5365	POW(2.,-(scale_left + scale_rght));
5366
5367	sum += F[i*n+j];
5368	}
5369	}
5370
5371	For(i,n*n)
5372	{
5373	F[i] /= sum;
5374	if(isnan(F[i]) \|\| isinf(F[i]))
5375	{
5376	For(i,n) For(j,n)
5377	PhyML_Printf("\n== %15G %15G %15G %15G %15G",
5378	pi->v[i] ,
5379	Pij[i*n+j] ,
5380	p_lk_left[i] ,
5381	p_lk_rght[j] ,
5382	POW(2.,-(scale_left + scale_rght)));
5383
5384	PhyML_Printf("\n== sum = %G",sum);
5385	Print_Site(tree->data,site,tree->n_otu,"\n",1,stderr);
5386	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
5387	Exit("\n");
5388	}
5389	}
5390
5391	}
5392
5393	//////////////////////////////////////////////////////////////
5394	//////////////////////////////////////////////////////////////
5395
5396	phydbl Triple_Dist(t_node a, t_tree tree, int approx)
5397	{
5398	if(a->tax) return UNLIKELY;
5399	else
5400	{
5401
5402	Update_PMat_At_Given_Edge(a->b[1],tree);
5403	Update_PMat_At_Given_Edge(a->b[2],tree);
5404
5405	Update_P_Lk(tree,a->b[0],a);
5406	Fast_Br_Len(a->b[0],tree,approx);
5407
5408	Update_P_Lk(tree,a->b[1],a);
5409	Fast_Br_Len(a->b[1],tree,approx);
5410
5411	Update_P_Lk(tree,a->b[2],a);
5412	Fast_Br_Len(a->b[2],tree,approx);
5413
5414	Update_P_Lk(tree,a->b[1],a);
5415	Update_P_Lk(tree,a->b[0],a);
5416	}
5417
5418	return tree->c_lnL;
5419
5420	}
5421
5422
5423	//////////////////////////////////////////////////////////////
5424	//////////////////////////////////////////////////////////////
5425
5426
5427	void Make_Symmetric(phydbl **F, int size)
5428	{
5429	int i,j;
5430
5431	For(i,size)
5432	{
5433	for(j=i+1;j<size;j++)
5434	{
5435	(F)[sizei+j] = ((F)[sizei+j] + (F)[sizej+i])/2.;
5436	(F)[sizej+i] = (F)[sizei+j];
5437	}
5438	}
5439	}
5440
5441	//////////////////////////////////////////////////////////////
5442	//////////////////////////////////////////////////////////////
5443
5444
5445	void Round_Down_Freq_Patt(phydbl *F, t_tree tree)
5446	{
5447	int i,j;
5448
5449	For(i,tree->mod->ns)
5450	{
5451	For(j,tree->mod->ns)
5452	{
5453	(F)[tree->mod->nsi+j] = RINT((F)[tree->mod->nsi+j]);
5454	}
5455	}
5456	}
5457
5458	//////////////////////////////////////////////////////////////
5459	//////////////////////////////////////////////////////////////
5460
5461
5462	phydbl Get_Sum_Of_Cells(phydbl F, t_tree tree)
5463	{
5464	int i,j;
5465	phydbl sum = .0;
5466
5467	For(i,tree->mod->ns)
5468	For(j,tree->mod->ns)
5469	sum += F[tree->mod->ns*i+j];
5470
5471	return sum;
5472	}
5473
5474
5475	//////////////////////////////////////////////////////////////
5476	//////////////////////////////////////////////////////////////
5477
5478
5479	void Divide_Cells(phydbl *F, phydbl div, t_tree tree)
5480	{
5481	int i,j;
5482
5483	For(i,tree->mod->ns)
5484	For(j,tree->mod->ns)
5485	(F)[tree->mod->nsi+j] /= div;
5486	}
5487
5488	//////////////////////////////////////////////////////////////
5489	//////////////////////////////////////////////////////////////
5490
5491
5492	void Divide_Mat_By_Vect(phydbl *F, phydbl vect, int size)
5493	{
5494	int i,j;
5495	For(i,size)
5496	For(j,size)
5497	(F)[sizei+j] = (F)[sizei+j] / vect[j];
5498	}
5499
5500	//////////////////////////////////////////////////////////////
5501	//////////////////////////////////////////////////////////////
5502
5503
5504	void Multiply_Mat_By_Vect(phydbl *F, phydbl vect, int size)
5505	{
5506	int i,j;
5507	For(i,size)
5508	For(j,size)
5509	(F)[sizei+j] = (F)[sizei+j] * vect[j];
5510	}
5511
5512	//////////////////////////////////////////////////////////////
5513	//////////////////////////////////////////////////////////////
5514
5515
5516	void Found_In_Subtree(t_node a, t_node d, t_node target, int match, t_tree *tree)
5517	{
5518	if(d->tax) return;
5519	else
5520	{
5521	int i;
5522	if(d == target) *match = 1;
5523	For(i,3)
5524	{
5525	if(d->v[i] != a)
5526	Found_In_Subtree(d,d->v[i],target,match,tree);
5527	}
5528	}
5529	}
5530
5531	//////////////////////////////////////////////////////////////
5532	//////////////////////////////////////////////////////////////
5533
5534
5535	void Get_List_Of_Target_Edges(t_node a, t_node d, t_edge *list, int list_size, t_tree *tree)
5536	{
5537	int i;
5538
5539	For(i,3)
5540	{
5541	if(a->v[i] && a->v[i] == d)
5542	{
5543	list[*list_size] = a->b[i];
5544	(*list_size)++;
5545	}
5546	}
5547
5548	if(d->tax) return;
5549	else
5550	{
5551	For(i,3)
5552	{
5553	if(d->v[i] != a)
5554	Get_List_Of_Target_Edges(d,d->v[i],list,list_size,tree);
5555	}
5556	}
5557	}
5558
5559	//////////////////////////////////////////////////////////////
5560	//////////////////////////////////////////////////////////////
5561
5562
5563	void Fix_All(t_tree *tree)
5564	{
5565	int i;
5566
5567	for(i=tree->n_otu;i<2*tree->n_otu-2;i++)
5568	{
5569	tree->a_nodes[i]->b[0]->l_old->v = tree->a_nodes[i]->b[0]->l->v;
5570	tree->a_nodes[i]->b[1]->l_old->v = tree->a_nodes[i]->b[1]->l->v;
5571	tree->a_nodes[i]->b[2]->l_old->v = tree->a_nodes[i]->b[2]->l->v;
5572	}
5573	}
5574
5575	//////////////////////////////////////////////////////////////
5576	//////////////////////////////////////////////////////////////
5577
5578
5579	void Record_Br_Len(t_tree *mixt_tree)
5580	{
5581	int i;
5582	t_tree *tree;
5583
5584	if(mixt_tree->br_len_recorded == YES)
5585	{
5586	PhyML_Printf("\n== Overwriting recorded edge lengths.\n");
5587	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
5588	Exit("\n");
5589	}
5590
5591	tree = mixt_tree;
5592
5593	do
5594	{
5595	For(i,2*tree->n_otu-1) tree->a_edges[i]->l_old->v = tree->a_edges[i]->l->v;
5596	For(i,2*tree->n_otu-1) tree->a_edges[i]->l_var_old->v = tree->a_edges[i]->l_var->v;
5597	tree = tree->next;
5598	}
5599	while(tree);
5600	}
5601
5602	//////////////////////////////////////////////////////////////
5603	//////////////////////////////////////////////////////////////
5604
5605
5606	void Restore_Br_Len(t_tree *mixt_tree)
5607	{
5608	int i;
5609	t_tree *tree;
5610
5611	mixt_tree->br_len_recorded = NO;
5612
5613	tree = mixt_tree;
5614
5615	do
5616	{
5617	For(i,2*tree->n_otu-1) tree->a_edges[i]->l->v = tree->a_edges[i]->l_old->v;
5618	For(i,2*tree->n_otu-1) tree->a_edges[i]->l_var->v = tree->a_edges[i]->l_var_old->v;
5619	tree = tree->next;
5620	}
5621	while(tree);
5622	}
5623
5624	//////////////////////////////////////////////////////////////
5625	//////////////////////////////////////////////////////////////
5626
5627
5628	void Get_Dist_Btw_Edges(t_node a, t_node d, t_tree *tree)
5629	{
5630	int i;
5631	t_edge *b_fcus;
5632
5633	b_fcus = NULL;
5634	For(i,3) if(a->v[i] == d) {b_fcus = a->b[i]; break;}
5635
5636	if(d->tax) return;
5637	else
5638	{
5639	For(i,3)
5640	if(d->v[i] != a)
5641	{
5642	d->b[i]->topo_dist_btw_edges = b_fcus->topo_dist_btw_edges + 1;
5643	d->b[i]->dist_btw_edges = b_fcus->dist_btw_edges + d->b[i]->l->v / 2.;
5644	Get_Dist_Btw_Edges(d,d->v[i],tree);
5645	}
5646	}
5647
5648
5649	}
5650
5651	//////////////////////////////////////////////////////////////
5652	//////////////////////////////////////////////////////////////
5653
5654
5655	void Detect_Polytomies(t_edge b, phydbl l_thresh, t_tree tree)
5656	{
5657	if((b->l->v < l_thresh) && (!b->left->tax) && (!b->rght->tax))
5658	{
5659	b->l->v = 0.0;
5660	b->has_zero_br_len = YES;
5661	}
5662	else b->has_zero_br_len = NO;
5663	}
5664
5665	//////////////////////////////////////////////////////////////
5666	//////////////////////////////////////////////////////////////
5667
5668
5669	void Get_List_Of_Nodes_In_Polytomy(t_node a, t_node d, t_node **list, int size_list)
5670	{
5671	if(d->tax) return;
5672	else
5673	{
5674	int i;
5675
5676	For(i,3)
5677	{
5678	if(d->v[i] != a)
5679	{
5680	if(!d->b[i]->has_zero_br_len)
5681	{
5682	(list)[size_list] = d->v[i];
5683	(*size_list)++;
5684	}
5685
5686	if(d->b[i]->has_zero_br_len)
5687	Get_List_Of_Nodes_In_Polytomy(d,d->v[i],list,size_list);
5688	}
5689	}
5690	}
5691
5692	}
5693
5694
5695	//////////////////////////////////////////////////////////////
5696	//////////////////////////////////////////////////////////////
5697
5698	void Path_Length(t_node dep, t_node arr, phydbl len, t_tree tree)
5699	{
5700	if(dep==arr) return;
5701	else
5702	{
5703	t_edge *next;
5704
5705	next = dep->b[tree->t_dir[dep->num(2tree->n_otu-2)+arr->num]];
5706
5707	if(next == tree->e_root)
5708	{
5709	(*len) += (tree->n_root->l[1] + tree->n_root->l[2]);
5710	}
5711	else
5712	{
5713	(*len) += next->l->v;
5714	}
5715	Path_Length(dep->v[tree->t_dir[dep->num(2tree->n_otu-2)+arr->num]],arr,len,tree);
5716	return;
5717	}
5718	}
5719
5720
5721	//////////////////////////////////////////////////////////////
5722	//////////////////////////////////////////////////////////////
5723
5724
5725	void Check_Path(t_node a, t_node d, t_node target, t_tree tree)
5726	{
5727	PhyML_Printf("path---------\n");
5728	if(d==target) return;
5729	else Check_Path(d,d->v[tree->t_dir[d->num(2tree->n_otu-2)+target->num]],target,tree);
5730	}
5731
5732
5733	//////////////////////////////////////////////////////////////
5734	//////////////////////////////////////////////////////////////
5735
5736
5737	void Connect_Two_Nodes(t_node a, t_node d)
5738	{
5739	a->v[0] = d;
5740	d->v[0] = a;
5741	}
5742
5743	//////////////////////////////////////////////////////////////
5744	//////////////////////////////////////////////////////////////
5745
5746
5747	void Get_List_Of_Adjacent_Targets(t_node a, t_node d, t_node *node_list, t_edge edge_list, int list_size)
5748	{
5749	int i;
5750
5751	For(i,3)
5752	if(a->v[i] == d)
5753	{
5754	(node_list)[list_size] = a;
5755	(edge_list)[list_size] = a->b[i];
5756	(*list_size)++;
5757	}
5758	if(d->tax) return;
5759	else
5760	For(i,3)
5761	if(d->v[i] != a) Get_List_Of_Adjacent_Targets(d,d->v[i],node_list,edge_list,list_size);
5762	}
5763
5764	//////////////////////////////////////////////////////////////
5765	//////////////////////////////////////////////////////////////
5766
5767
5768	void Sort_List_Of_Adjacent_Targets(t_edge ***list, int list_size)
5769	{
5770	t_edge *buff_edge;
5771	int i,j;
5772
5773	buff_edge = NULL;
5774
5775	For(i,list_size-1)
5776	{
5777	for(j=i+1;j<list_size;j++)
5778	if((list)[j]->topo_dist_btw_edges < (list)[i]->topo_dist_btw_edges)
5779	{
5780	buff_edge = (*list)[j];
5781	(list)[j] = (list)[i];
5782	(*list)[i] = buff_edge;
5783	}
5784	}
5785	}
5786
5787	//////////////////////////////////////////////////////////////
5788	//////////////////////////////////////////////////////////////
5789
5790	t_node Common_Nodes_Btw_Two_Edges(t_edge a, t_edge *b)
5791	{
5792	if(a->left == b->left) return b->left;
5793	else if(a->left == b->rght) return b->rght;
5794	else if(a->rght == b->left) return b->left;
5795	else if(a->rght == b->rght) return b->rght;
5796
5797	PhyML_Printf("\n. First t_edge = %d (%d %d); Second t_edge = %d (%d %d)\n",
5798	a->num,a->left->num,a->rght->num,
5799	b->num,b->left->num,b->rght->num);
5800	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
5801	Warn_And_Exit("");
5802
5803	return NULL;
5804	}
5805
5806	//////////////////////////////////////////////////////////////
5807	//////////////////////////////////////////////////////////////
5808
5809
5810	int KH_Test(phydbl site_lk_M1, phydbl site_lk_M2, t_tree *tree)
5811	{
5812	phydbl *delta,mean,sd,obs_stat,threshold;
5813	int i;
5814
5815
5816	delta = (phydbl *)mCalloc(tree->data->init_len,sizeof(phydbl));
5817
5818	threshold = .0;
5819	mean = .0;
5820	obs_stat = .0;
5821	For(i,tree->n_pattern)
5822	{
5823	delta[i] = site_lk_M1[i] - site_lk_M2[i];
5824	mean += ((int)tree->data->wght[i])*delta[i];
5825	}
5826
5827	obs_stat = mean;
5828
5829	mean /= tree->data->init_len;
5830
5831	For(i,tree->data->init_len) delta[i] -= mean;
5832
5833	sd = .0;
5834	For(i,tree->data->init_len) sd += POW(delta[i],2);
5835	sd /= (phydbl)(tree->data->init_len-1.);
5836
5837	/* threshold = tree->dnorm_threshSQRT(sdtree->data->init_len); */
5838
5839
5840	/* PhyML_Printf("\nObs stat = %f Threshold = %f\n",obs_stat,threshold); */
5841	Free(delta);
5842
5843	if(obs_stat > threshold) return 1;
5844	else return 0;
5845	}
5846
5847	//////////////////////////////////////////////////////////////
5848	//////////////////////////////////////////////////////////////
5849
5850
5851	//////////////////////////////////////////////////////////////
5852	//////////////////////////////////////////////////////////////
5853
5854
5855	void Random_Tree(t_tree *tree)
5856	{
5857	int is_available,list_of_nodes;
5858	int i,node_num,step,n_available;
5859	phydbl min_edge_len;
5860
5861	min_edge_len = 1.E-3;
5862
5863	if(tree->mod->s_opt && tree->mod->s_opt->print == YES)
5864	PhyML_Printf("\n\n. Randomising the tree...\n");
5865
5866	is_available = (int )mCalloc(2tree->n_otu-2,sizeof(int));
5867	list_of_nodes = (int *)mCalloc(tree->n_otu, sizeof(int));
5868
5869	For(i,tree->n_otu) is_available[i] = 1;
5870	For(i,tree->n_otu) list_of_nodes[i] = i;
5871
5872	step = 0;
5873	do
5874	{
5875	/* node_num = (int)RINT(rand()/(phydbl)(RAND_MAX+1.0)(tree->n_otu-1-step)); /
5876	node_num = Rand_Int(0,tree->n_otu-1-step);
5877	node_num = list_of_nodes[node_num];
5878	is_available[node_num] = 0;
5879	For(i,tree->n_otu) list_of_nodes[i] = -1;
5880	n_available = 0;
5881	For(i,2*tree->n_otu-2) if(is_available[i]) {list_of_nodes[n_available++] = i;}
5882
5883	tree->a_nodes[node_num]->v[0] = tree->a_nodes[tree->n_otu+step];
5884	tree->a_nodes[tree->n_otu+step]->v[1] = tree->a_nodes[node_num];
5885
5886	/* node_num = (int)RINT(rand()/(phydbl)(RAND_MAX+1.0)(tree->n_otu-2-step)); /
5887	node_num = Rand_Int(0,tree->n_otu-2-step);
5888	node_num = list_of_nodes[node_num];
5889	is_available[node_num] = 0;
5890	For(i,tree->n_otu) list_of_nodes[i] = -1;
5891	n_available = 0;
5892	For(i,2*tree->n_otu-2) if(is_available[i]) {list_of_nodes[n_available++] = i;}
5893
5894	tree->a_nodes[node_num]->v[0] = tree->a_nodes[tree->n_otu+step];
5895	tree->a_nodes[tree->n_otu+step]->v[2] = tree->a_nodes[node_num];
5896
5897	is_available[tree->n_otu+step] = 1;
5898	For(i,tree->n_otu) list_of_nodes[i] = -1;
5899	n_available = 0;
5900	For(i,2*tree->n_otu-2) if(is_available[i]) list_of_nodes[n_available++] = i;
5901
5902	step++;
5903	}while(step < tree->n_otu-2);
5904
5905	tree->a_nodes[list_of_nodes[0]]->v[0] = tree->a_nodes[list_of_nodes[1]];
5906	tree->a_nodes[list_of_nodes[1]]->v[0] = tree->a_nodes[list_of_nodes[0]];
5907
5908	tree->num_curr_branch_available = 0;
5909	Connect_Edges_To_Nodes_Recur(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
5910
5911	For(i,2*tree->n_otu-3) if(tree->a_edges[i]->l->v < min_edge_len) tree->a_edges[i]->l->v = min_edge_len;
5912
5913	Fill_Dir_Table(tree);
5914	Update_Dirs(tree);
5915
5916	Free(is_available);
5917	Free(list_of_nodes);
5918	}
5919
5920	//////////////////////////////////////////////////////////////
5921	//////////////////////////////////////////////////////////////
5922	// Make sure internal edges have likelihood vectors on both
5923	// sides and external edges have one likelihood vector on the
5924	// lefthand side only
5925
5926	void Reorganize_Edges_Given_Lk_Struct(t_tree *tree)
5927	{
5928	int j,i;
5929
5930	For(i,2*tree->n_otu-3)
5931	{
5932	if(tree->a_edges[i]->p_lk_left && tree->a_edges[i]->left->tax == YES)
5933	{
5934	For(j,2*tree->n_otu-3)
5935	{
5936	if(!tree->a_edges[j]->p_lk_left && tree->a_edges[j]->left->tax == NO)
5937	{
5938	Swap_Nodes_On_Edges(tree->a_edges[i],tree->a_edges[j],NO,tree);
5939	break;
5940	}
5941	if(!tree->a_edges[j]->p_lk_rght && tree->a_edges[j]->rght->tax == NO)
5942	{
5943	Swap_Nodes_On_Edges(tree->a_edges[i],tree->a_edges[j],YES,tree);
5944	break;
5945	}
5946	}
5947	}
5948
5949	if(tree->a_edges[i]->p_lk_rght && tree->a_edges[i]->rght->tax == YES)
5950	{
5951	For(j,2*tree->n_otu-3)
5952	{
5953	if(!tree->a_edges[j]->p_lk_left && tree->a_edges[j]->left->tax == NO)
5954	{
5955	Swap_Nodes_On_Edges(tree->a_edges[i],tree->a_edges[j],YES,tree);
5956	break;
5957	}
5958	if(!tree->a_edges[j]->p_lk_rght && tree->a_edges[j]->rght->tax == NO)
5959	{
5960	Swap_Nodes_On_Edges(tree->a_edges[i],tree->a_edges[j],NO,tree);
5961	break;
5962	}
5963	}
5964	}
5965	}
5966	}
5967
5968	//////////////////////////////////////////////////////////////
5969	//////////////////////////////////////////////////////////////
5970
5971	void Random_NNI(int n_moves, t_tree *tree)
5972	{
5973	int i,j;
5974	t_edge *b;
5975	t_node n1,n2,*n_target;
5976
5977	n1 = n2 = NULL;
5978	b = NULL;
5979	For(i,n_moves)
5980	{
5981	n_target = tree->a_nodes[tree->n_otu + (int)((phydbl)rand()/RAND_MAX * (2*tree->n_otu-3-tree->n_otu))];
5982	For(j,3) if(!n_target->v[j]->tax) {b = n_target->b[j]; break;}
5983
5984
5985	For(j,3) if(b->left->v[j] != b->rght) {n1 = b->left->v[j]; break;}
5986	For(j,3) if(b->rght->v[j] != b->left) {n2 = b->rght->v[j]; break;}
5987
5988
5989	Swap(n1,b->left,b->rght,n2,tree);
5990	}
5991	}
5992
5993	//////////////////////////////////////////////////////////////
5994	//////////////////////////////////////////////////////////////
5995
5996
5997	//////////////////////////////////////////////////////////////
5998	//////////////////////////////////////////////////////////////
5999
6000
6001	void Fill_Missing_Dist(matrix *mat)
6002	{
6003	int i,j;
6004	For(i,mat->n_otu)
6005	{
6006	for(j=i+1;j<mat->n_otu;j++)
6007	{
6008	if(i != j)
6009	{
6010	if(mat->dist[i][j] < .0)
6011	{
6012	Fill_Missing_Dist_XY(i,j,mat);
6013	mat->dist[j][i] = mat->dist[i][j];
6014	}
6015	}
6016	}
6017	}
6018	}
6019
6020	//////////////////////////////////////////////////////////////
6021	//////////////////////////////////////////////////////////////
6022
6023
6024	void Fill_Missing_Dist_XY(int x, int y, matrix *mat)
6025	{
6026
6027	int i,j;
6028	phydbl local_mins,*S1S2;
6029	int cpt;
6030	int pos_best_estimate;
6031	phydbl min_crit, curr_crit;
6032
6033	local_mins = (phydbl )mCalloc(mat->n_otumat->n_otu,sizeof(phydbl ));
6034	S1S2 = (phydbl *)mCalloc(mat->n_otumat->n_otu,sizeof(phydbl *));
6035	For(i,mat->n_otumat->n_otu) S1S2[i] = (phydbl )mCalloc(2,sizeof(phydbl));
6036
6037	cpt = 0;
6038	For(i,mat->n_otu)
6039	{
6040	if((mat->dist[i][x] > .0) && (mat->dist[i][y] > .0))
6041	{
6042	For(j,mat->n_otu)
6043	{
6044	if((mat->dist[j][x] > .0) && (mat->dist[j][y] > .0))
6045	{
6046	if((i != j) && (i != x) && (i != y) && (j != x) && (j != y))
6047	{
6048	S1S2[cpt][0] = MIN(mat->dist[i][x] + mat->dist[j][y] - mat->dist[i][j] , mat->dist[i][y] + mat->dist[j][x] - mat->dist[i][j]);
6049	S1S2[cpt][1] = MAX(mat->dist[i][x] + mat->dist[j][y] - mat->dist[i][j] , mat->dist[i][y] + mat->dist[j][x] - mat->dist[i][j]);
6050	cpt++;
6051	}
6052	}
6053	}
6054	}
6055	}
6056
6057	Qksort_Matrix(S1S2,0,0,cpt-1);
6058
6059	local_mins[0] = S1S2[0][1];
6060	for(i=1;i<cpt;i++) local_mins[i] = (i*local_mins[i-1] + S1S2[i][1])/(phydbl)(i+1);
6061
6062	pos_best_estimate = 0;
6063	min_crit = curr_crit = BIG;
6064
6065	For(i,cpt-1)
6066	{
6067	if((local_mins[i] < S1S2[i+1][0]) && (local_mins[i] > S1S2[i][0]))
6068	{
6069	curr_crit = Least_Square_Missing_Dist_XY(x,y,local_mins[i],mat);
6070	if(curr_crit < min_crit)
6071	{
6072	min_crit = curr_crit;
6073	pos_best_estimate = i;
6074	}
6075	}
6076	}
6077
6078	mat->dist[x][y] = local_mins[pos_best_estimate];
6079	mat->dist[y][x] = mat->dist[x][y];
6080
6081	For(i,mat->n_otu*mat->n_otu) Free(S1S2[i]);
6082	Free(S1S2);
6083	Free(local_mins);
6084	}
6085
6086	//////////////////////////////////////////////////////////////
6087	//////////////////////////////////////////////////////////////
6088
6089
6090	phydbl Least_Square_Missing_Dist_XY(int x, int y, phydbl dxy, matrix *mat)
6091	{
6092	int i,j;
6093	phydbl fit;
6094
6095	fit = .0;
6096	For(i,mat->n_otu)
6097	{
6098	if((mat->dist[i][x] > .0) && (mat->dist[i][y] > .0))
6099	{
6100	For(j,mat->n_otu)
6101	{
6102	if((mat->dist[j][x] > .0) && (mat->dist[j][y] > .0))
6103	{
6104	if((i != j) && (i != x) && (i != y) && (j != x) && (j != y))
6105	{
6106	if(dxy < MIN(mat->dist[i][x] + mat->dist[j][y] - mat->dist[i][j] , mat->dist[i][y] + mat->dist[j][x] - mat->dist[i][j]))
6107	{
6108	fit += POW((mat->dist[i][x] + mat->dist[j][y]) - (mat->dist[i][y] + mat->dist[j][x]),2);
6109	}
6110	else if((mat->dist[i][x] + mat->dist[j][y]) < (mat->dist[i][y] + mat->dist[j][x]))
6111	{
6112	fit += POW(dxy - (mat->dist[i][y] + mat->dist[j][x] - mat->dist[i][j]),2);
6113	}
6114	else
6115	{
6116	fit += POW(dxy - (mat->dist[i][x] + mat->dist[j][y] - mat->dist[i][j]),2);
6117	}
6118	}
6119	}
6120	}
6121	}
6122	}
6123	return fit;
6124	}
6125
6126	//////////////////////////////////////////////////////////////
6127	//////////////////////////////////////////////////////////////
6128
6129	void Check_Memory_Amount(t_tree *tree)
6130	{
6131	/* Rough estimate of the amount of memory that has to be used */
6132
6133	long int nbytes;
6134	int n_otu;
6135	t_mod *mod;
6136
6137	mod = tree->mod;
6138	n_otu = tree->io->n_otu;
6139	nbytes = 0;
6140
6141	/* Partial Pars */
6142	nbytes += (2n_otu-3) 2 * tree->data->crunch_len * sizeof(int);
6143	nbytes += (2n_otu-3) 2 * tree->data->crunch_len * sizeof(unsigned int);
6144	nbytes += (2n_otu-3) 2 * tree->data->crunch_len * mod->ns * sizeof(int);
6145
6146	/* Pmat */
6147	nbytes += (2n_otu-3) mod->ras->n_catg * mod->ns * mod->ns * sizeof(phydbl);
6148
6149
6150	/* Partial Lk */
6151	nbytes += ((2n_otu-3) 2 - tree->n_otu) * tree->data->crunch_len * mod->ras->n_catg * mod->ns * sizeof(phydbl);
6152
6153
6154	/* Scaling factors */
6155	nbytes += ((2n_otu-3) 2 - tree->n_otu) * tree->data->crunch_len * sizeof(int);
6156
6157
6158
6159	if(((phydbl)nbytes/(1.E+06)) > 256.)
6160	/* if(((phydbl)nbytes/(1.E+06)) > 0.) */
6161	{
6162	PhyML_Printf("\n\n. WARNING: this analysis requires at least %.0f MB of memory space.\n",(phydbl)nbytes/(1.E+06));
6163	#ifndef BATCH
6164
6165	char answer;
6166	if((!tree->io->quiet) && (tree->io->mem_question == YES))
6167	{
6168	PhyML_Printf("\n. Do you really want to proceed? [Y/n] ");
6169	if(scanf("%c", &answer))
6170	{
6171	if(answer == '\n') answer = 'Y';
6172	else if(answer == 'n' \|\| answer == 'N') Warn_And_Exit("\n");
6173	else getchar();
6174	}
6175	else
6176	{
6177	Warn_And_Exit("\n\n");
6178	}
6179	}
6180	#endif
6181	}
6182	else if(((phydbl)nbytes/(1.E+06)) > 100.)
6183	{
6184	if(!tree->io->quiet) PhyML_Printf("\n\n. WARNING: this analysis will use at least %.0f Mo of memory space...\n",(phydbl)nbytes/(1.E+06));
6185	}
6186	else if(((phydbl)nbytes/(1.E+06)) > 1.)
6187	{
6188	if(!tree->io->quiet) PhyML_Printf("\n\n. This analysis requires at least %.0f Mo of memory space.\n",(phydbl)nbytes/(1.E+06));
6189	}
6190	}
6191
6192	//////////////////////////////////////////////////////////////
6193	//////////////////////////////////////////////////////////////
6194
6195
6196	int Get_State_From_P_Lk(phydbl p_lk, int pos, t_tree tree)
6197	{
6198	int i;
6199	For(i,tree->mod->ns) if(p_lk[pos+i] > .0) return i;
6200	return -1;
6201	}
6202
6203	//////////////////////////////////////////////////////////////
6204	//////////////////////////////////////////////////////////////
6205
6206
6207	int Get_State_From_P_Pars(short int p_pars, int pos, t_tree tree)
6208	{
6209	int i;
6210	For(i,tree->mod->ns) if(p_pars[pos+i] > .0) return i;
6211	return -1;
6212	}
6213
6214	//////////////////////////////////////////////////////////////
6215	//////////////////////////////////////////////////////////////
6216
6217
6218	//////////////////////////////////////////////////////////////
6219	//////////////////////////////////////////////////////////////
6220
6221	void Check_Dirs(t_tree *tree)
6222	{
6223	int i;
6224
6225	For(i,2*tree->n_otu-3)
6226	{
6227	if(!tree->a_edges[i]->left->tax)
6228	{
6229	if(tree->a_edges[i]->left->v[tree->a_edges[i]->l_v1]->num <
6230	tree->a_edges[i]->left->v[tree->a_edges[i]->l_v2]->num)
6231	{
6232	PhyML_Printf("\n. Edge %d ; v1=%d v2=%d",
6233	tree->a_edges[i]->num,
6234	tree->a_edges[i]->left->v[tree->a_edges[i]->l_v1]->num,
6235	tree->a_edges[i]->left->v[tree->a_edges[i]->l_v2]->num);
6236	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
6237	Exit("\n");
6238	}
6239	}
6240
6241	if(!tree->a_edges[i]->rght->tax)
6242	{
6243	if(tree->a_edges[i]->rght->v[tree->a_edges[i]->r_v1]->num <
6244	tree->a_edges[i]->rght->v[tree->a_edges[i]->r_v2]->num)
6245	{
6246	PhyML_Printf("\n. Edge %d ; v3=%d v4=%d",
6247	tree->a_edges[i]->num,
6248	tree->a_edges[i]->rght->v[tree->a_edges[i]->r_v1]->num,
6249	tree->a_edges[i]->rght->v[tree->a_edges[i]->r_v2]->num);
6250	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
6251	Warn_And_Exit("");
6252	}
6253	}
6254	}
6255	}
6256
6257	//////////////////////////////////////////////////////////////
6258	//////////////////////////////////////////////////////////////
6259
6260	void Warn_And_Exit(char *s)
6261	{
6262	PhyML_Fprintf(stdout,"%s",s);
6263	fflush(NULL);
6264	#ifndef BATCH
6265	/* if (! tree->io->quiet) { */
6266	/* char c; */
6267	PhyML_Fprintf(stdout,"\n. Type enter to exit.\n");
6268	/* if(!fscanf(stdin,"%c",&c)) */
6269	Exit("");
6270	/* } */
6271	#endif
6272	Exit("\n");
6273	}
6274
6275	//////////////////////////////////////////////////////////////
6276	//////////////////////////////////////////////////////////////
6277
6278	void Randomize_Sequence_Order(calign *cdata)
6279	{
6280	int i,exchange_with;
6281	phydbl buff_dbl;
6282	char buff_name,buff_state;
6283	short int *buff_ambigu;
6284
6285	exchange_with = -1;
6286	For(i,cdata->n_otu)
6287	{
6288	buff_dbl = rand();
6289	buff_dbl /= (RAND_MAX+1.);
6290	buff_dbl *= cdata->n_otu;
6291	exchange_with = (int)FLOOR(buff_dbl);
6292
6293	buff_name = cdata->c_seq[i]->name;
6294	cdata->c_seq[i]->name = cdata->c_seq[exchange_with]->name;
6295	cdata->c_seq[exchange_with]->name = buff_name;
6296
6297	buff_state = cdata->c_seq[i]->state;
6298	cdata->c_seq[i]->state = cdata->c_seq[exchange_with]->state;
6299	cdata->c_seq[exchange_with]->state = buff_state;
6300
6301	buff_ambigu = cdata->c_seq[i]->is_ambigu;
6302	cdata->c_seq[i]->is_ambigu = cdata->c_seq[exchange_with]->is_ambigu;
6303	cdata->c_seq[exchange_with]->is_ambigu = buff_ambigu;
6304	}
6305	}
6306
6307	//////////////////////////////////////////////////////////////
6308	//////////////////////////////////////////////////////////////
6309
6310
6311	void Update_Root_Pos(t_tree *tree)
6312	{
6313	if(tree->n_root_pos > -1.0)
6314	{
6315	tree->n_root->l[2] = tree->e_root->l->v * tree->n_root_pos;
6316	tree->n_root->l[1] = tree->e_root->l->v * (1.-tree->n_root_pos);
6317	}
6318	else
6319	{
6320	/* tree->n_root->l[0] = tree->e_root->l->v / 2.; */
6321	/* tree->n_root->l[1] = tree->e_root->l->v / 2.; */
6322	}
6323	}
6324
6325	//////////////////////////////////////////////////////////////
6326	//////////////////////////////////////////////////////////////
6327
6328
6329	void Add_Root(t_edge target, t_tree tree)
6330	{
6331	t_edge b1, b2;
6332
6333	#ifndef PHYML
6334	PhyML_Printf("\n. Adding root on t_edge %d left = %d right = %d\n.",target->num,target->left->num,target->rght->num); fflush(NULL);
6335	#endif
6336
6337	tree->e_root = target;
6338
6339	/* Create the root t_node if it does not exist yet */
6340	if(!tree->a_nodes[2*tree->n_otu-2])
6341	{
6342	tree->n_root = (t_node )Make_Node_Light(2tree->n_otu-2);
6343	}
6344	else
6345	{
6346	tree->n_root = tree->a_nodes[2*tree->n_otu-2];
6347	}
6348
6349	tree->a_nodes[2*tree->n_otu-2] = tree->n_root;
6350
6351	tree->n_root->tax = 0;
6352
6353	/* Set the position of the root */
6354	tree->n_root->v[0] = NULL;
6355	tree->n_root->v[1] = tree->e_root->left;
6356	tree->n_root->v[2] = tree->e_root->rght;
6357
6358	/* tree->n_root->b[2] = tree->e_root; */
6359	/* tree->n_root->b[1] = tree->e_root; */
6360
6361	if(tree->n_root_pos > -1.0)
6362	{
6363	if(tree->n_root_pos < 1.E-6 && tree->n_root_pos > -1.E-6)
6364	printf("\n. WARNING: you put the root at a weird position...");
6365
6366	/* tree->n_root->l[0] = tree->e_root->l->v * (tree->n_root_pos/(1.+tree->n_root_pos)); */
6367	/* tree->n_root->l[1] = tree->e_root->l->v - tree->n_root->l[0]; */
6368
6369	tree->n_root->l[2] = tree->e_root->l->v * tree->n_root_pos;
6370	tree->n_root->l[1] = tree->e_root->l->v * (1. - tree->n_root_pos);
6371	}
6372	else
6373	{
6374	tree->n_root->l[2] = tree->e_root->l->v / 2.;
6375	tree->n_root->l[1] = tree->e_root->l->v / 2.;
6376	tree->n_root_pos = 0.5;
6377	}
6378
6379	b1 = tree->a_edges[2*tree->n_otu-3];
6380	b2 = tree->a_edges[2*tree->n_otu-2];
6381
6382	tree->n_root->b[0] = NULL;
6383	tree->n_root->b[1] = b1;
6384	tree->n_root->b[2] = b2;
6385
6386	b1->num = tree->num_curr_branch_available;
6387	b2->num = tree->num_curr_branch_available+1;
6388	b1->left = tree->n_root;
6389	b1->rght = tree->n_root->v[1];
6390	b2->left = tree->n_root;
6391	b2->rght = tree->n_root->v[2];
6392
6393	b1->l->v = tree->n_root->l[1];
6394	b2->l->v = tree->n_root->l[2];
6395	b1->l_old->v = tree->n_root->l[1];
6396	b2->l_old->v = tree->n_root->l[2];
6397
6398	b1->l_r = 1;
6399	b2->l_r = 2;
6400
6401	b1->r_l = 0;
6402	b2->r_l = 0;
6403
6404	b1->l_v1 = 0;
6405	b1->l_v2 = 2;
6406
6407	b2->l_v1 = 0;
6408	b2->l_v2 = 1;
6409
6410	b1->r_v1 = 1;
6411	b1->r_v2 = 2;
6412
6413	b2->r_v1 = 1;
6414	b2->r_v2 = 2;
6415
6416
6417	/* WARNING: make sure you have freed the memory for p_lk_rght on b1 and b2 */
6418
6419	b1->p_lk_rght = tree->e_root->p_lk_left;
6420	b2->p_lk_rght = tree->e_root->p_lk_rght;
6421
6422	b1->p_lk_tip_r = tree->e_root->p_lk_tip_l;
6423	b2->p_lk_tip_r = tree->e_root->p_lk_tip_r;
6424
6425	b1->sum_scale_rght = tree->e_root->sum_scale_left;
6426	b2->sum_scale_rght = tree->e_root->sum_scale_rght;
6427
6428	b1->sum_scale_rght_cat = tree->e_root->sum_scale_left_cat;
6429	b2->sum_scale_rght_cat = tree->e_root->sum_scale_rght_cat;
6430
6431	b1->p_lk_loc_rght = tree->e_root->p_lk_loc_left;
6432	b2->p_lk_loc_rght = tree->e_root->p_lk_loc_rght;
6433
6434	b1->pars_r = tree->e_root->pars_l;
6435	b2->pars_r = tree->e_root->pars_r;
6436
6437	b1->ui_r = tree->e_root->ui_l;
6438	b2->ui_r = tree->e_root->ui_r;
6439
6440	b1->p_pars_r = tree->e_root->p_pars_l;
6441	b2->p_pars_r = tree->e_root->p_pars_r;
6442
6443	b1->p_lk_loc_rght = tree->e_root->p_lk_loc_left;
6444	b2->p_lk_loc_rght = tree->e_root->p_lk_loc_rght;
6445
6446	b1->patt_id_rght = tree->e_root->patt_id_left;
6447	b2->patt_id_rght = tree->e_root->patt_id_rght;
6448
6449	Update_Ancestors(tree->n_root,tree->n_root->v[2],tree);
6450	Update_Ancestors(tree->n_root,tree->n_root->v[1],tree);
6451	tree->n_root->anc = NULL;
6452	}
6453
6454	//////////////////////////////////////////////////////////////
6455	//////////////////////////////////////////////////////////////
6456
6457
6458	void Update_Ancestors(t_node a, t_node d, t_tree *tree)
6459	{
6460	if(a == tree->n_root) a->anc = NULL;
6461	d->anc = a;
6462	if(d->tax) return;
6463	else
6464	{
6465	int i;
6466	For(i,3)
6467	if((d->v[i] != d->anc) && (d->b[i] != tree->e_root))
6468	Update_Ancestors(d,d->v[i],tree);
6469	}
6470	}
6471
6472	//////////////////////////////////////////////////////////////
6473	//////////////////////////////////////////////////////////////
6474
6475	/* Generate a random unrooted tree with 'n_otu' OTUs */
6476	#if (defined PHYTIME \|\| defined SERGEII)
6477	t_tree *Generate_Random_Tree_From_Scratch(int n_otu, int rooted)
6478	{
6479	t_tree *tree;
6480	int connected,nonconnected,*available_nodes;
6481	int i,n_connected,n_nonconnected,n1,n2,new_n,n_internal,n_external,n_available;
6482	t_node root,curr_n,internal_nodes, external_nodes;
6483	phydbl t,tmp;
6484
6485	tree = Make_Tree_From_Scratch(n_otu,NULL);
6486
6487	tree->rates = RATES_Make_Rate_Struct(tree->n_otu);
6488	RATES_Init_Rate_Struct(tree->rates,tree->io->rates,tree->n_otu);
6489
6490	For(i,2*tree->n_otu-2)
6491	{
6492	tree->a_nodes[i]->v[1] = NULL;
6493	tree->a_nodes[i]->v[2] = NULL;
6494	}
6495
6496	root = (t_node )Make_Node_Light(2tree->n_otu-2);
6497
6498	connected = (int )mCalloc(2tree->n_otu-2,sizeof(int));
6499	nonconnected = (int )mCalloc(2tree->n_otu-2,sizeof(int));
6500	available_nodes = (int )mCalloc(2tree->n_otu-2,sizeof(int));
6501	internal_nodes = (t_node *)mCalloc(tree->n_otu-2,sizeof(t_node ));
6502	external_nodes = (t_node *)mCalloc(tree->n_otu, sizeof(t_node ));
6503	t = (phydbl *)mCalloc(tree->n_otu-1,sizeof(phydbl ));
6504	tmp = (phydbl )mCalloc(2tree->n_otu-2,sizeof(phydbl ));
6505
6506	n_nonconnected = 2*n_otu-2;
6507
6508	For(i,2*tree->n_otu-2) nonconnected[i] = i;
6509
6510	available_nodes[0] = 2*n_otu-2;
6511
6512	/* Node times are generated according to a Birth-death process.
6513	Formulae are as described by Yang and Rannala (1997) */
6514	phydbl phi;
6515	phydbl rho; /* sampling intensity */
6516	phydbl mu; /* birth rate */
6517	phydbl lambda; /* death rate */
6518	phydbl u; /* random U[0,1] */
6519	phydbl expval;
6520
6521	/* rho = 1.0 and mu = 0.0 correspond to the Yule process */
6522
6523	lambda = 6.7;
6524	mu = 2.5;
6525	rho = 9./150.;
6526
6527	expval = EXP(MIN(1.E+2,mu-lambda));
6528	phi = (rholambda(expval-1.) + (mu-lambda)expval)/(expval-1.); / Equation 16 */
6529
6530	For(i,tree->n_otu-1)
6531	{
6532	u = rand();
6533	u /= RAND_MAX;
6534
6535	if(FABS(lambda - mu) > 1.E-4)
6536	t[i] = (LOG(phi-urholambda) - LOG(phi-urholambda + u(lambda-mu)))/(mu-lambda); / Equation 15 */
6537	else
6538	t[i] = u / (1.+lambdarho(1-u)); /* Equation 17 */
6539	}
6540
6541	Qksort(t,NULL,0,tree->n_otu-2); /* Node times ordering in ascending order */
6542
6543	For(i,tree->n_otu-1) tmp[i] = t[tree->n_otu-2-i];
6544	For(i,tree->n_otu-1) t[i] = -tmp[i];
6545
6546
6547	/* Rescale t_node times such that the time at the root t_node is -100 */
6548	for(i=1;i<tree->n_otu-1;i++)
6549	{
6550	t[i] /= -t[0];
6551	t[i] *= 1.E+02;
6552	}
6553	t[0] = -1.E+02;
6554
6555
6556	n_available = 1;
6557	curr_n = root;
6558	n_connected = 0;
6559	do
6560	{
6561	n1 = Rand_Int(0,n_nonconnected-1);
6562	n1 = nonconnected[n1];
6563	connected[n1] = 1;
6564
6565	n_nonconnected = 0;
6566	For(i,2*tree->n_otu-2) if(!connected[i]) {nonconnected[n_nonconnected++] = i;}
6567
6568	n2 = Rand_Int(0,n_nonconnected-1);
6569	n2 = nonconnected[n2];
6570	connected[n2] = 1;
6571
6572	n_nonconnected = 0;
6573	For(i,2*tree->n_otu-2) if(!connected[i]) {nonconnected[n_nonconnected++] = i;}
6574
6575	curr_n->v[1] = tree->a_nodes[n1];
6576	curr_n->v[2] = tree->a_nodes[n2];
6577	tree->a_nodes[n1]->v[0] = curr_n;
6578	tree->a_nodes[n2]->v[0] = curr_n;
6579
6580	tree->rates->nd_t[curr_n->num] = t[n_connected/2];
6581
6582	available_nodes[n_available] = tree->a_nodes[n1]->num;
6583	For(i,n_available)
6584	if(available_nodes[i] == curr_n->num)
6585	{
6586	available_nodes[i] = tree->a_nodes[n2]->num;
6587	break;
6588	}
6589	n_available++;
6590
6591	new_n = Rand_Int(0,n_available-1);
6592	curr_n = tree->a_nodes[available_nodes[new_n]];
6593
6594	n_connected+=2;
6595
6596	}while(n_connected < 2*tree->n_otu-2);
6597
6598	For(i,2*tree->n_otu-2) tmp[i] = tree->rates->nd_t[i];
6599
6600	/* Unroot the tree */
6601	root->v[2]->v[0] = root->v[2];
6602	root->v[1]->v[0] = root->v[1];
6603
6604	n_internal = n_external = 0;
6605	For(i,2*tree->n_otu-2)
6606	{
6607	if(tree->a_nodes[i]->v[1]) internal_nodes[n_internal++] = tree->a_nodes[i];
6608	else external_nodes[n_external++] = tree->a_nodes[i];
6609	}
6610
6611
6612	n_internal = n_external = 0;
6613	For(i,2*tree->n_otu-2)
6614	{
6615	if(i < tree->n_otu)
6616	{
6617	tree->a_nodes[i] = external_nodes[n_external++];
6618	tree->a_nodes[i]->tax = 1;
6619	}
6620	else
6621	{
6622	tree->rates->nd_t[i] = tmp[internal_nodes[n_internal]->num];
6623	tree->a_nodes[i] = internal_nodes[n_internal++];
6624	tree->a_nodes[i]->tax = 0;
6625	}
6626
6627	tree->a_nodes[i]->num = i;
6628	}
6629
6630	For(i,tree->n_otu) tree->rates->nd_t[i] = 0.0;
6631
6632	For(i,tree->n_otu)
6633	{
6634	if(!tree->a_nodes[i]->name) tree->a_nodes[i]->name = (char *)mCalloc(T_MAX_NAME,sizeof(char));
6635	strcpy(tree->a_nodes[i]->name,"x");
6636	sprintf(tree->a_nodes[i]->name+1,"%d",i);
6637	}
6638
6639
6640	tree->num_curr_branch_available = 0;
6641	Connect_Edges_To_Nodes_Recur(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
6642	Fill_Dir_Table(tree);
6643	Update_Dirs(tree);
6644
6645
6646	/* Add root */
6647	if(rooted)
6648	{
6649	For(i,2*tree->n_otu-3)
6650	{
6651	if(((tree->a_edges[i]->left == root->v[1]) \|\| (tree->a_edges[i]->rght == root->v[1])) &&
6652	((tree->a_edges[i]->left == root->v[2]) \|\| (tree->a_edges[i]->rght == root->v[2])))
6653	{
6654	Add_Root(tree->a_edges[i],tree);
6655	break;
6656	}
6657	}
6658	}
6659	/* Or not... */
6660	else
6661	{
6662	Free_Node(root);
6663	}
6664
6665	RATES_Random_Branch_Lengths(tree);
6666
6667	Free(available_nodes);
6668	Free(connected);
6669	Free(nonconnected);
6670	Free(external_nodes);
6671	Free(internal_nodes);
6672	Free(t);
6673	Free(tmp);
6674
6675	return tree;
6676	}
6677	#endif
6678	//////////////////////////////////////////////////////////////
6679	//////////////////////////////////////////////////////////////
6680
6681
6682	void Random_Lineage_Rates(t_node a, t_node d, t_edge b, phydbl stick_prob, phydbl rates, int curr_rate, int n_rates, t_tree *tree)
6683	{
6684	phydbl uni;
6685	int new_rate;
6686	int i;
6687
6688
6689	if(b)
6690	{
6691	uni = rand();
6692	uni /= RAND_MAX;
6693
6694	if(uni > stick_prob) /* Randomly pick a new rate */
6695	{
6696	uni = rand();
6697	uni /= RAND_MAX;
6698	uni = (phydbl)(uni * (n_rates-1));
6699	if(uni-(int)(uni) > 0.5-BIG) new_rate = (int)(uni)+1;
6700	else new_rate = (int)(uni);
6701	}
6702	else
6703	{
6704	new_rate = curr_rate;
6705	}
6706
6707	For(i,3)
6708	if(a->v[i] == d)
6709	{
6710	a->b[i]->l->v *= rates[new_rate];
6711	break;
6712	}
6713
6714	For(i,3)
6715	if(a->v[i] == d)
6716	{
6717	if(!(a->b[i]->n_labels%BLOCK_LABELS)) Make_New_Edge_Label(a->b[i]);
6718	if(rates[new_rate] > 1.0) strcpy(a->b[i]->labels[a->b[i]->n_labels],"FAST");
6719	else if(rates[new_rate] < 1.0) strcpy(a->b[i]->labels[a->b[i]->n_labels],"SLOW");
6720	else strcpy(a->b[i]->labels[a->b[i]->n_labels],"MEDIUM");
6721	a->b[i]->n_labels++;
6722	break;
6723	}
6724	curr_rate = new_rate;
6725	}
6726
6727	if(d->tax) return;
6728	else
6729	{
6730	For(i,3)
6731	if(d->v[i] != a)
6732	Random_Lineage_Rates(d,d->v[i],d->b[i],stick_prob,rates,curr_rate,n_rates,tree);
6733	}
6734	}
6735
6736	//////////////////////////////////////////////////////////////
6737	//////////////////////////////////////////////////////////////
6738
6739
6740	t_edge Find_Edge_With_Label(char label, t_tree *tree)
6741	{
6742	int i,j;
6743
6744	For(i,2*tree->n_otu-3)
6745	{
6746	For(j,tree->a_edges[i]->n_labels)
6747	{
6748	if(!strcmp(tree->a_edges[i]->labels[j],label)) return tree->a_edges[i];
6749	}
6750	}
6751	return NULL;
6752	}
6753
6754	//////////////////////////////////////////////////////////////
6755	//////////////////////////////////////////////////////////////
6756
6757	void Evolve(calign data, t_mod mod, t_tree *tree)
6758	{
6759	int root_state, root_rate_class;
6760	int site,i;
6761	phydbl *orig_l;
6762	phydbl shape,scale,var,mean;
6763
6764	orig_l = (phydbl )mCalloc(2tree->n_otu-3,sizeof(phydbl));
6765	For(i,2*tree->n_otu-3) orig_l[i] = tree->a_edges[i]->l->v;
6766
6767	data->n_otu = tree->n_otu;
6768
6769	if(mod->use_m4mod) tree->write_labels = YES;
6770
6771
6772	For(site,data->init_len)
6773	{
6774	/* Get the change probability matrices */
6775	For(i,2*tree->n_otu-3)
6776	{
6777	/* var = mod->l_var ; */
6778
6779	/* shape = POW(MAX(orig_l[i],1.E-6),2) / var; */
6780	/* scale = var / MAX(orig_l[i],1.E-6); */
6781
6782	/* tree->a_edges[i]->l->v = Rgamma(shape,scale); */
6783
6784	var = mod->l_var_sigma;
6785	mean = 1.0;
6786
6787	shape = mean * mean / var;
6788	scale = var / mean;
6789
6790	tree->a_edges[i]->l->v = orig_l[i] * Rgamma(shape,scale);
6791	}
6792
6793	Set_Model_Parameters(mod);
6794	For(i,2*tree->n_otu-3) Update_PMat_At_Given_Edge(tree->a_edges[i],tree);
6795
6796	root_state = root_rate_class = -1;
6797
6798	/* Pick the root nucleotide/aa */
6799	root_state = Pick_State(mod->ns,mod->e_frq->pi->v);
6800	data->c_seq[0]->state[site] = Reciproc_Assign_State(root_state,tree->io->datatype);
6801
6802	/* Pick the rate class */
6803	root_rate_class = Pick_State(mod->ras->n_catg,mod->ras->gamma_r_proba->v);
6804
6805	/* tree->a_nodes[0] is considered as the root t_node */
6806	Evolve_Recur(tree->a_nodes[0],
6807	tree->a_nodes[0]->v[0],
6808	tree->a_nodes[0]->b[0],
6809	root_state,
6810	root_rate_class,
6811	site,
6812	data,
6813	mod,
6814	tree);
6815
6816	/* PhyML_Printf("%s\n",Write_Tree(tree,NO)); */
6817
6818	data->wght[site] = 1;
6819	}
6820	data->crunch_len = data->init_len;
6821	Print_CSeq(stdout,NO,data);
6822	}
6823
6824	//////////////////////////////////////////////////////////////
6825	//////////////////////////////////////////////////////////////
6826
6827
6828	int Pick_State(int n, phydbl *prob)
6829	{
6830	int pos;
6831	phydbl uni;
6832
6833	do
6834	{
6835	pos = rand();
6836	pos = (pos % n);
6837	uni = (phydbl)rand();
6838	uni /= (phydbl)RAND_MAX;
6839	if(uni < prob[pos]) break;
6840	}
6841	while(1);
6842
6843	return (int)pos;
6844	}
6845
6846	//////////////////////////////////////////////////////////////
6847	//////////////////////////////////////////////////////////////
6848
6849
6850	void Evolve_Recur(t_node a, t_node d, t_edge b, int a_state, int r_class, int site_num, calign gen_data, t_mod mod, t_tree tree)
6851	{
6852	int d_state;
6853	int dim1,dim2;
6854
6855	dim1 = tree->mod->ns * tree->mod->ns;
6856	dim2 = tree->mod->ns;
6857
6858	d_state = Pick_State(mod->ns,b->Pij_rr+r_classdim1+a_statedim2);
6859
6860	/* PhyML_Printf("\n>> %c (%d,%d)",Reciproc_Assign_State(d_state,mod->io->datatype),d_state,(int)d_state/mod->m4mod->n_o); */
6861
6862	if(mod->use_m4mod)
6863	{
6864	phydbl rrate; /* relative rate of substitutions */
6865
6866	rrate = mod->m4mod->multipl[(int)d_state/mod->m4mod->n_o];
6867	if(!(b->n_labels%BLOCK_LABELS)) Make_New_Edge_Label(b);
6868	if(rrate > 1.0) strcpy(b->labels[b->n_labels],"FASTER");
6869	else strcpy(b->labels[b->n_labels],"SLOWER");
6870	b->n_labels++;
6871	}
6872
6873	if(d->tax)
6874	{
6875	gen_data->c_seq[d->num]->state[site_num] = Reciproc_Assign_State(d_state,tree->io->datatype);
6876	return;
6877	}
6878	else
6879	{
6880	int i;
6881	For(i,3)
6882	if(d->v[i] != a)
6883	Evolve_Recur(d,d->v[i],d->b[i],
6884	d_state,r_class,site_num,gen_data,
6885	mod,tree);
6886	}
6887	}
6888
6889	//////////////////////////////////////////////////////////////
6890	//////////////////////////////////////////////////////////////
6891
6892
6893	void Site_Diversity(t_tree *tree)
6894	{
6895	int i,j,k,ns;
6896	int *div,sum;
6897
6898	ns = tree->mod->ns;
6899
6900	div = (int *)mCalloc(ns,sizeof(int));
6901
6902	Site_Diversity_Post(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree->a_nodes[0]->b[0],tree);
6903	Site_Diversity_Pre (tree->a_nodes[0],tree->a_nodes[0]->v[0],tree->a_nodes[0]->b[0],tree);
6904
6905	For(i,2*tree->n_otu-3)
6906	{
6907	For(j,ns)
6908	{
6909	tree->a_edges[i]->div_post_pred_left[j] = 0;
6910	tree->a_edges[i]->div_post_pred_rght[j] = 0;
6911	}
6912	}
6913
6914	For(i,tree->n_pattern)
6915	{
6916	For(j,2*tree->n_otu-3)
6917	{
6918	Binary_Decomposition(tree->a_edges[j]->ui_l[i],div,ns);
6919	sum = 0;
6920	For(k,ns) sum += div[k];
6921	tree->a_edges[j]->div_post_pred_left[sum-1] += tree->data->wght[i];
6922
6923	Binary_Decomposition(tree->a_edges[j]->ui_r[i],div,ns);
6924	sum = 0;
6925	For(k,ns) sum += div[k];
6926	tree->a_edges[j]->div_post_pred_rght[sum-1] += tree->data->wght[i];
6927	}
6928	}
6929
6930	/* For(j,2tree->n_otu-3) /
6931	/* { */
6932	/* PhyML_Printf("\n. Edge %4d div_left = %4d %4d %4d %4d -- div_rght = %4d %4d %4d %4d", */
6933	/* j, */
6934	/* tree->a_edges[j]->div_post_pred_left[0], */
6935	/* tree->a_edges[j]->div_post_pred_left[1], */
6936	/* tree->a_edges[j]->div_post_pred_left[2], */
6937	/* tree->a_edges[j]->div_post_pred_left[3], */
6938	/* tree->a_edges[j]->div_post_pred_rght[0], */
6939	/* tree->a_edges[j]->div_post_pred_rght[1], */
6940	/* tree->a_edges[j]->div_post_pred_rght[2], */
6941	/* tree->a_edges[j]->div_post_pred_rght[3]); */
6942	/* } */
6943
6944	Free(div);
6945	}
6946
6947	//////////////////////////////////////////////////////////////
6948	//////////////////////////////////////////////////////////////
6949
6950
6951	void Site_Diversity_Post(t_node a, t_node d, t_edge b, t_tree tree)
6952	{
6953	if(d->tax) return;
6954	else
6955	{
6956	int i;
6957
6958	For(i,3)
6959	if(d->v[i] != a)
6960	Site_Diversity_Post(d,d->v[i],d->b[i],tree);
6961
6962	Subtree_Union(d,b,tree);
6963	}
6964	}
6965
6966	//////////////////////////////////////////////////////////////
6967	//////////////////////////////////////////////////////////////
6968
6969
6970	void Site_Diversity_Pre(t_node a, t_node d, t_edge b, t_tree tree)
6971	{
6972	if(d->tax) return;
6973	else
6974	{
6975	int i;
6976
6977	For(i,3)
6978	if(d->v[i] != a)
6979	{
6980	Subtree_Union(d,d->b[i],tree);
6981	Site_Diversity_Pre(d,d->v[i],d->b[i],tree);
6982	}
6983	}
6984	}
6985
6986	//////////////////////////////////////////////////////////////
6987	//////////////////////////////////////////////////////////////
6988
6989
6990	void Subtree_Union(t_node n, t_edge b_fcus, t_tree *tree)
6991	{
6992	/*
6993	\|
6994	\|<- b_cus
6995	\|
6996	n
6997	/ \
6998	/ \
6999	/ \
7000	*/
7001
7002	int site;
7003	unsigned int ui, ui_v1, *ui_v2;
7004
7005	ui = ui_v1 = ui_v2 = NULL;
7006
7007	if(n == b_fcus->left)
7008	{
7009	ui = b_fcus->ui_l;
7010
7011	ui_v1 =
7012	(n == n->b[b_fcus->l_v1]->left)?
7013	(n->b[b_fcus->l_v1]->ui_r):
7014	(n->b[b_fcus->l_v1]->ui_l);
7015
7016	ui_v2 =
7017	(n == n->b[b_fcus->l_v2]->left)?
7018	(n->b[b_fcus->l_v2]->ui_r):
7019	(n->b[b_fcus->l_v2]->ui_l);
7020	}
7021	else
7022	{
7023	ui = b_fcus->ui_r;
7024
7025	ui_v1 =
7026	(n == n->b[b_fcus->r_v1]->left)?
7027	(n->b[b_fcus->r_v1]->ui_r):
7028	(n->b[b_fcus->r_v1]->ui_l);
7029
7030	ui_v2 =
7031	(n == n->b[b_fcus->r_v2]->left)?
7032	(n->b[b_fcus->r_v2]->ui_r):
7033	(n->b[b_fcus->r_v2]->ui_l);
7034	}
7035
7036	For(site,tree->n_pattern) ui[site] = ui_v1[site] \| ui_v2[site];
7037
7038	}
7039
7040	//////////////////////////////////////////////////////////////
7041	//////////////////////////////////////////////////////////////
7042
7043
7044	void Binary_Decomposition(int value, int *bit_vect, int size)
7045	{
7046	int i,cumul;
7047
7048	For(i,size) bit_vect[i] = 0;
7049
7050	cumul = 0;
7051	for(i=size-1;i>=0;i--)
7052	{
7053	if(value - cumul < (int)POW(2,i))
7054	{
7055	bit_vect[i] = 0;
7056	}
7057	else
7058	{
7059	bit_vect[i] = 1;
7060	cumul += (int)POW(2,i);
7061	}
7062	}
7063	}
7064
7065	//////////////////////////////////////////////////////////////
7066	//////////////////////////////////////////////////////////////
7067
7068
7069	void Print_Diversity_Header(FILE fp, t_tree tree)
7070	{
7071	/* PhyML_Fprintf(fp,"t_edge side mean\n"); */
7072	PhyML_Fprintf(fp,"t_edge side diversity count\n");
7073	}
7074
7075	//////////////////////////////////////////////////////////////
7076	//////////////////////////////////////////////////////////////
7077
7078
7079
7080	//////////////////////////////////////////////////////////////
7081	//////////////////////////////////////////////////////////////
7082
7083	/* Estimation of density using kernel smoothing.
7084	- where : point where I want to estimate the density,
7085	- x : data vector,
7086	- sample_size : number of data points in x
7087	*/
7088	phydbl Univariate_Kernel_Density_Estimate(phydbl where, phydbl *x, int sample_size)
7089	{
7090	phydbl sd,h;
7091	phydbl density,sqrt2pi,cons;
7092	int i;
7093
7094	sqrt2pi = 2.506628;
7095
7096	sd = SQRT(Var(x,sample_size));
7097	h = 1.06 * sd * POW(sample_size,-1./5.); /* Quick and dirty way to set the bandwidth */
7098
7099	cons = (1./sample_size) * (1./h) * (1./sqrt2pi);
7100
7101	density = .0;
7102	For(i,sample_size) density += EXP(-0.5 * POW((x[i] - where)/h,2));
7103	density *= cons;
7104
7105	return density;
7106	}
7107
7108	//////////////////////////////////////////////////////////////
7109	//////////////////////////////////////////////////////////////
7110
7111
7112	/* Estimation of a multivariate density using kernel smoothing.
7113
7114	- where : vector where I want to estimate the density,
7115	- x : data matrix, i.e., sample of vectors,
7116	- sample_size : number of vectors,
7117	- vect_size : vector length.
7118
7119	See "Multivariate Density Estimation" by David Scott. pp 150.
7120	*/
7121	phydbl Multivariate_Kernel_Density_Estimate(phydbl where, phydbl *x, int sample_size, int vect_size)
7122	{
7123	phydbl sd,*h,cons,density,tmp;
7124	phydbl _2pi;
7125	int i,j;
7126
7127	h = (phydbl *)mCalloc(vect_size,sizeof(phydbl));
7128
7129	_2pi = 6.283185;
7130
7131	For(i,vect_size)
7132	{
7133	sd = SQRT(Var(x[i],sample_size));
7134	/* h[i] = POW(4./(vect_size+2.),1./(vect_size+4)) * sd * POW(sample_size,-1./(vect_size+4)); */
7135	h[i] = sd * POW(sample_size,-1./(vect_size+4));
7136	/* PhyML_Printf("\n. sd = %f, h[i] = %f",sd,h[i]); */
7137	}
7138
7139	cons = sample_size;
7140	For(i,vect_size) cons *= h[i];
7141	cons *= POW(_2pi,vect_size/2.);
7142	cons = 1./cons;
7143
7144	density = .0;
7145	For(i,sample_size)
7146	{
7147	tmp = 1.0;
7148	For(j,vect_size)
7149	{
7150	tmp = EXP(-0.5 POW((x[j][i] - where[j])/h[j],2));
7151	}
7152	density += tmp;
7153	}
7154
7155	density *= cons;
7156
7157	Free(h);
7158
7159	return density;
7160	}
7161
7162	//////////////////////////////////////////////////////////////
7163	//////////////////////////////////////////////////////////////
7164
7165
7166	phydbl Var(phydbl *x, int n)
7167	{
7168	phydbl mean, sum2;
7169	int i;
7170
7171	mean = Mean(x,n);
7172
7173	sum2 = .0;
7174	For(i,n) sum2 += x[i] * x[i];
7175
7176	return (1./n) * (sum2 - n * POW(mean,2));
7177	}
7178
7179	//////////////////////////////////////////////////////////////
7180	//////////////////////////////////////////////////////////////
7181
7182
7183	phydbl Mean(phydbl *x, int n)
7184	{
7185	int i;
7186	phydbl sum;
7187
7188	sum = .0;
7189
7190	For(i,n) sum += x[i];
7191
7192	return sum / n;
7193	}
7194
7195	//////////////////////////////////////////////////////////////
7196	//////////////////////////////////////////////////////////////
7197
7198
7199	void Best_Of_NNI_And_SPR(t_tree *tree)
7200	{
7201	if(tree->mod->s_opt->random_input_tree) Speed_Spr_Loop(tree); /* Don't do simultaneous NNIs if starting tree is random */
7202	else
7203	{
7204	t_tree ori_tree,best_tree;
7205	t_mod ori_mod,best_mod;
7206	phydbl ori_bl,best_bl;
7207	phydbl best_lnL,ori_lnL,nni_lnL,spr_lnL;
7208	int i;
7209
7210	ori_bl = (phydbl )mCalloc(2tree->n_otu-3,sizeof(phydbl));
7211	best_bl = (phydbl )mCalloc(2tree->n_otu-3,sizeof(phydbl));
7212
7213	ori_mod = Copy_Model(tree->mod);
7214	best_mod = Copy_Model(tree->mod);
7215
7216	ori_tree = Make_Tree_From_Scratch(tree->n_otu,tree->data);
7217
7218	/* ori_tree = Make_Tree(tree->n_otu); */
7219	/* Init_Tree(ori_tree,ori_tree->n_otu); */
7220	/* Make_All_Tree_Nodes(ori_tree); */
7221	/* Make_All_Tree_Edges(ori_tree); */
7222
7223	best_tree = Make_Tree_From_Scratch(tree->n_otu,tree->data);
7224
7225	/* best_tree = Make_Tree(tree->n_otu); */
7226	/* Init_Tree(best_tree,best_tree->n_otu); */
7227	/* Make_All_Tree_Nodes(best_tree); */
7228	/* Make_All_Tree_Edges(best_tree); */
7229
7230	Copy_Tree(tree,ori_tree);
7231	Record_Br_Len(tree);
7232	For(i,2*tree->n_otu-3) ori_bl[i] = tree->a_edges[i]->l->v;
7233
7234
7235	best_lnL = UNLIKELY;
7236	Lk(NULL,tree);
7237	ori_lnL = tree->c_lnL; /* Record likelihood of the starting tree */
7238
7239
7240
7241	Simu_Loop(tree); /* Perform simultaneous NNIs */
7242	best_lnL = tree->c_lnL; /* Record the likelihood */
7243	nni_lnL = tree->c_lnL;
7244	Copy_Tree(tree,best_tree); /* Record the tree topology and branch lengths */
7245	Record_Br_Len(tree);
7246	For(i,2*tree->n_otu-3) best_bl[i] = tree->a_edges[i]->l->v;
7247	For(i,2*tree->n_otu-3) best_tree->a_edges[i]->l->v = best_bl[i];
7248	Record_Model(tree->mod,best_mod);
7249
7250	Copy_Tree(ori_tree,tree); /* Back to the original tree topology */
7251	For(i,2tree->n_otu-3) tree->a_edges[i]->l->v = ori_bl[i]; / Back to the original branch lengths */
7252	Record_Model(ori_mod,tree->mod); /* Back to the original model */
7253
7254	/* Make sure the tree is in its original form */
7255	Lk(NULL,tree);
7256
7257
7258	if(FABS(tree->c_lnL - ori_lnL) > tree->mod->s_opt->min_diff_lk_local)
7259	{
7260	PhyML_Printf("\n== ori_lnL = %f, c_lnL = %f",ori_lnL,tree->c_lnL);
7261	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
7262	Warn_And_Exit("");
7263	}
7264
7265	Speed_Spr_Loop(tree);
7266	spr_lnL = tree->c_lnL;
7267	if(tree->c_lnL > best_lnL)
7268	{
7269	best_lnL = tree->c_lnL;
7270	Copy_Tree(tree,best_tree); /* Record tree topology, branch lengths and model parameters */
7271	Record_Br_Len(tree);
7272	For(i,2*tree->n_otu-3) best_bl[i] = tree->a_edges[i]->l->v;
7273	For(i,2*tree->n_otu-3) best_tree->a_edges[i]->l->v = best_bl[i];
7274	Record_Model(tree->mod,best_mod);
7275	}
7276
7277	Copy_Tree(best_tree,tree);
7278	Fill_Dir_Table(tree);
7279	Update_Dirs(tree);
7280	Init_P_Lk_Tips_Int(tree);
7281	Init_Ui_Tips(tree);
7282	Init_P_Pars_Tips(tree);
7283	For(i,2*tree->n_otu-3) tree->a_edges[i]->l->v = best_bl[i];
7284	Record_Model(best_mod,tree->mod);
7285
7286	/* Make sure the current tree has the best topology, branch lengths and model parameters */
7287	Lk(NULL,tree);
7288	if(FABS(tree->c_lnL - best_lnL) > tree->mod->s_opt->min_diff_lk_local)
7289	{
7290	PhyML_Printf("\n. best_lnL = %f, c_lnL = %f",best_lnL,tree->c_lnL);
7291	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
7292	Warn_And_Exit("");
7293	}
7294
7295	if(tree->mod->s_opt->print)
7296	{
7297	PhyML_Printf("\n\n. Log likelihood obtained after NNI moves : %f",nni_lnL);
7298	PhyML_Printf("\n. Log likelihood obtained after SPR moves : %f",spr_lnL);
7299	}
7300
7301	Free(ori_bl);
7302	Free(best_bl);
7303
7304	Free_Tree(ori_tree);
7305	Free_Tree(best_tree);
7306
7307	Free_Model_Complete(ori_mod);
7308	Free_Model_Complete(best_mod);
7309
7310	M4_Free_M4_Model(ori_mod->m4mod);
7311	M4_Free_M4_Model(best_mod->m4mod);
7312
7313	Free_Model_Basic(ori_mod);
7314	Free_Model_Basic(best_mod);
7315	}
7316	}
7317
7318	//////////////////////////////////////////////////////////////
7319	//////////////////////////////////////////////////////////////
7320
7321
7322	/* Polynomial interpolation. Adapted from "Numerical Recipes in C".
7323	Press, Flannery, Teukolsky, Vetterling, 1988.
7324	*/
7325	int Polint(phydbl xa, phydbl ya, int n, phydbl x, phydbl y, phydbl dy)
7326	{
7327	int i,m,ns=1;
7328	phydbl den,dif,dift,ho,hp,w;
7329	phydbl c,d;
7330
7331	dif=FABS(x-xa[1]);
7332
7333	c = (phydbl *)mCalloc(n,sizeof(phydbl));
7334	d = (phydbl *)mCalloc(n,sizeof(phydbl));
7335
7336	for(i=1;i<=n;i++)
7337	{
7338	if((dift=FABS(x-xa[i])) < dif)
7339	{
7340	ns=i;
7341	dif=dift;
7342	}
7343	c[i]=ya[i];
7344	d[i]=ya[i];
7345	}
7346
7347	*y=ya[ns--];
7348
7349	for (m=1;m<n;m++)
7350	{
7351	for (i=1;i<=n-m;i++)
7352	{
7353	ho=xa[i]-x;
7354	hp=xa[i+m]-x;
7355	w=c[i+1]-d[i];
7356	if((den=ho-hp) < SMALL && (den=ho-hp) > -SMALL )
7357	{
7358	/* Rprintf("\n. Error in routine POLINT.\n"); */
7359	Exit("\n. Error in routine POLINT.\n");
7360	return(-1);
7361	}
7362	den=w/den;
7363	d[i]=hp*den;
7364	c[i]=ho*den;
7365	}
7366	y += (dy=(2*ns < (n-m) ? c[ns+1] : d[ns--]));
7367	}
7368
7369	Free(d);
7370	Free(c);
7371	return(0);
7372	}
7373
7374	//////////////////////////////////////////////////////////////
7375	//////////////////////////////////////////////////////////////
7376
7377
7378	void JF(t_tree *tree)
7379	{
7380	//printing loglk for each site, to compute SH-like tests */
7381	phydbl sum=0.0;
7382	PhyML_Printf("\n\nSITES LKS:\n");
7383	int n_patterns = (int)FLOOR(tree->n_pattern);
7384	int site=0;
7385	For(site,n_patterns) {
7386	int wei=0;
7387	For(wei,tree->data->wght[site]) {
7388	PhyML_Printf("%f\n",tree->c_lnL_sorted[site] / tree->data->wght[site]);
7389	sum+=tree->c_lnL_sorted[site] / tree->data->wght[site];
7390	}
7391	}
7392
7393	PhyML_Printf("\n\nsum=%f\n\n",sum);
7394	int i=0;
7395	For(i,2*tree->n_otu-3)
7396	{
7397	if((!tree->a_edges[i]->left->tax) && (!tree->a_edges[i]->rght->tax))
7398	{
7399	PhyML_Printf("%3d %f %f %f\n",
7400	tree->a_edges[i]->bip_score,tree->a_edges[i]->alrt_statistic, tree->a_edges[i]->ratio_test,tree->a_edges[i]->l->v);
7401	}
7402	}
7403
7404
7405	/* //printing loglk for each site, to compute SH-like tests */
7406	/* phydbl sum=0.0; */
7407	/* PhyML_Printf("\n\nSITES LKS:\n"); */
7408	/* int n_patterns = (int)FLOOR(tree->n_pattern); */
7409	/* int site=0; */
7410	/* For(site,n_patterns) { */
7411	/* int wei=0; */
7412	/* For(wei,tree->data->wght[site]) { */
7413	/* PhyML_Printf("%f\n",tree->c_lnL_sorted[site] / tree->data->wght[site]); */
7414	/* sum+=tree->c_lnL_sorted[site] / tree->data->wght[site]; */
7415	/* } */
7416	/* } */
7417
7418	/* PhyML_Printf("\n\nsum=%f\n\n",sum); */
7419
7420	/* int i=0; */
7421	/* For(i,2tree->n_otu-3) /
7422	/* { */
7423	/* if((!tree->a_edges[i]->left->tax) && (!tree->a_edges[i]->rght->tax)) */
7424	/* { */
7425	/* PhyML_Printf("%3d %f %f %f\n", */
7426	/* tree->a_edges[i]->bip_score,tree->a_edges[i]->alrt_statistic, tree->a_edges[i]->ratio_test,tree->a_edges[i]->l->v); */
7427	/* } */
7428	/* } */
7429	}
7430
7431	//////////////////////////////////////////////////////////////
7432	//////////////////////////////////////////////////////////////
7433
7434
7435	t_tree Dist_And_BioNJ(calign cdata, t_mod mod, option io)
7436	{
7437	t_tree *tree;
7438	matrix *mat;
7439
7440	if(!io->quiet) PhyML_Printf("\n. Computing pairwise distances...");
7441
7442	mat = ML_Dist(cdata,mod);
7443	Fill_Missing_Dist(mat);
7444
7445	if(!io->quiet) PhyML_Printf("\n\n. Building BioNJ tree...");
7446
7447	mat->tree = Make_Tree_From_Scratch(cdata->n_otu,cdata);
7448
7449	Bionj(mat);
7450	tree = mat->tree;
7451	tree->mat = mat;
7452
7453	return tree;
7454	}
7455
7456	//////////////////////////////////////////////////////////////
7457	//////////////////////////////////////////////////////////////
7458
7459
7460	void Add_BioNJ_Branch_Lengths(t_tree tree, calign cdata, t_mod *mod)
7461	{
7462	matrix *mat;
7463
7464	PhyML_Printf("\n");
7465	PhyML_Printf("\n. Computing branch length estimates...\n");
7466
7467	Connect_CSeqs_To_Nodes(cdata,tree);
7468	mat = ML_Dist(cdata,mod);
7469	mat->tree = tree;
7470	mat->method = 0;
7471	Bionj_Br_Length(mat);
7472
7473	Free_Mat(mat);
7474	}
7475
7476	//////////////////////////////////////////////////////////////
7477	//////////////////////////////////////////////////////////////
7478
7479	char Bootstrap_From_String(char s_tree, calign cdata, t_mod mod, option *io)
7480	{
7481	t_tree *tree;
7482
7483	tree = Read_Tree(&s_tree);
7484
7485	tree->n_root = NULL;
7486	tree->e_root = NULL;
7487
7488	if(!tree)
7489	{
7490	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
7491	Exit("");
7492	}
7493
7494	tree->mod = mod;
7495	tree->io = io;
7496	tree->data = cdata;
7497	tree->n_pattern = tree->data->crunch_len;
7498
7499	Connect_CSeqs_To_Nodes(cdata,tree);
7500	if(tree->mod->s_opt->random_input_tree) Random_Tree(tree);
7501	Fill_Dir_Table(tree);
7502	Update_Dirs(tree);
7503	Make_Tree_4_Pars(tree,cdata,cdata->init_len);
7504	Make_Tree_4_Lk(tree,cdata,cdata->init_len);
7505	tree->triplet_struct = Make_Triplet_Struct(mod);
7506	Init_Triplet_Struct(tree->triplet_struct);
7507	Unscale_Br_Len_Multiplier_Tree(tree);
7508	Br_Len_Not_Involving_Invar(tree);
7509	Make_Spr_List(tree);
7510	Make_Best_Spr(tree);
7511
7512
7513	Set_Both_Sides(YES,tree);
7514	Lk(NULL,tree);
7515
7516	#ifdef MPI
7517	Bootstrap_MPI(tree);
7518	#else
7519	Bootstrap(tree);
7520	#endif
7521
7522	Free(s_tree);
7523	s_tree = Write_Tree(tree,NO);
7524
7525	Free_Spr_List(tree);
7526	Free_Triplet(tree->triplet_struct);
7527	Free_Tree_Pars(tree);
7528	Free_Tree_Lk(tree);
7529	Free_Tree(tree);
7530
7531	return s_tree;
7532	}
7533
7534	//////////////////////////////////////////////////////////////
7535	//////////////////////////////////////////////////////////////
7536
7537
7538	char aLRT_From_String(char s_tree, calign cdata, t_mod mod, option *io)
7539	{
7540	t_tree *tree;
7541
7542	tree = Read_Tree(&s_tree);
7543
7544	tree->n_root = NULL;
7545	tree->e_root = NULL;
7546
7547	if(!tree)
7548	{
7549	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
7550	Warn_And_Exit("");
7551	}
7552
7553	tree->mod = mod;
7554	tree->io = io;
7555	tree->data = cdata;
7556	tree->n_pattern = tree->data->crunch_len;
7557
7558	Connect_CSeqs_To_Nodes(cdata,tree);
7559	if(tree->mod->s_opt->random_input_tree) Random_Tree(tree);
7560	Fill_Dir_Table(tree);
7561	Update_Dirs(tree);
7562	Make_Tree_4_Pars(tree,cdata,cdata->init_len);
7563	Make_Tree_4_Lk(tree,cdata,cdata->init_len);
7564	tree->triplet_struct = Make_Triplet_Struct(mod);
7565	Init_Triplet_Struct(tree->triplet_struct);
7566	Make_Spr_List(tree);
7567	Make_Best_Spr(tree);
7568
7569	Set_Both_Sides(YES,tree);
7570	Lk(NULL,tree);
7571
7572
7573	aLRT(tree);
7574
7575
7576	Free(s_tree);
7577	s_tree = Write_Tree(tree,NO);
7578
7579	Free_Spr_List(tree);
7580	Free_Triplet(tree->triplet_struct);
7581	Free_Tree_Pars(tree);
7582	Free_Tree_Lk(tree);
7583	Free_Tree(tree);
7584
7585	return s_tree;
7586	}
7587
7588	//////////////////////////////////////////////////////////////
7589	//////////////////////////////////////////////////////////////
7590
7591	void Prepare_Tree_For_Lk(t_tree *tree)
7592	{
7593	Connect_CSeqs_To_Nodes(tree->data,tree);
7594	Fill_Dir_Table(tree);
7595	Update_Dirs(tree);
7596	Make_Tree_4_Pars(tree,tree->data,tree->data->init_len);
7597	Make_Tree_4_Lk(tree,tree->data,tree->data->init_len);
7598	tree->triplet_struct = Make_Triplet_Struct(tree->mod);
7599	Init_Triplet_Struct(tree->triplet_struct);
7600	Make_Spr_List(tree);
7601	Make_Best_Spr(tree);
7602
7603	if(tree->is_mixt_tree) MIXT_Prepare_Tree_For_Lk(tree);
7604	}
7605
7606	//////////////////////////////////////////////////////////////
7607	//////////////////////////////////////////////////////////////
7608
7609	void Find_Common_Tips(t_tree tree1, t_tree tree2)
7610	{
7611	int i,j;
7612
7613	For(i,tree1->n_otu) tree1->a_nodes[i]->common = 0;
7614	For(i,tree2->n_otu) tree2->a_nodes[i]->common = 0;
7615
7616	For(i,tree1->n_otu)
7617	{
7618	For(j,tree2->n_otu)
7619	{
7620	if(!strcmp(tree1->a_nodes[i]->name,tree2->a_nodes[j]->name))
7621	{
7622	tree1->a_nodes[i]->common = 1;
7623	tree2->a_nodes[j]->common = 1;
7624	break;
7625	}
7626	}
7627	}
7628	}
7629
7630	//////////////////////////////////////////////////////////////
7631	//////////////////////////////////////////////////////////////
7632
7633	phydbl Get_Tree_Size(t_tree *tree)
7634	{
7635	int i;
7636	phydbl tree_size;
7637
7638	tree_size = 0.0;
7639	For(i,2*tree->n_otu-3) tree_size += tree->a_edges[i]->l->v;
7640
7641	if(tree->n_root)
7642	{
7643	tree_size += tree->n_root->b[1]->l->v;
7644	tree_size += tree->n_root->b[2]->l->v;
7645	}
7646
7647
7648	/* For(i,2tree->n_otu-3) /
7649	/* tree_size += */
7650	/* FABS(tree->rates->nd_t[tree->a_edges[i]->left->num] - */
7651	/* tree->rates->nd_t[tree->a_edges[i]->rght->num]); */
7652
7653	tree->size = tree_size;
7654	return tree_size;
7655	}
7656
7657	//////////////////////////////////////////////////////////////
7658	//////////////////////////////////////////////////////////////
7659
7660
7661	void Dist_To_Root_Pre(t_node a, t_node d, t_edge b, t_tree tree)
7662	{
7663	int i;
7664
7665	if(b) d->dist_to_root = a->dist_to_root + b->l->v;
7666	/* if(b) d->dist_to_root = a->dist_to_root + tree->rates->cur_l[d->num]; */
7667
7668	if(d->tax) return;
7669	else
7670	{
7671	For(i,3)
7672	if((d->v[i] != a) && (d->b[i] != tree->e_root))
7673	Dist_To_Root_Pre(d,d->v[i],d->b[i],tree);
7674	}
7675	}
7676
7677	//////////////////////////////////////////////////////////////
7678	//////////////////////////////////////////////////////////////
7679
7680
7681	void Dist_To_Root(t_node n_root, t_tree tree)
7682	{
7683	/* n_root->v[2]->dist_to_root = tree->rates->cur_l[n_root->v[2]->num]; */
7684	/* n_root->v[1]->dist_to_root = tree->rates->cur_l[n_root->v[1]->num]; */
7685	n_root->v[2]->dist_to_root = tree->e_root->l->v * tree->n_root_pos;
7686	n_root->v[1]->dist_to_root = tree->e_root->l->v * (1. - tree->n_root_pos);
7687	Dist_To_Root_Pre(n_root,n_root->v[2],NULL,tree);
7688	Dist_To_Root_Pre(n_root,n_root->v[1],NULL,tree);
7689	}
7690
7691	//////////////////////////////////////////////////////////////
7692	//////////////////////////////////////////////////////////////
7693
7694	/* 'Borrowed' fromn libgen */
7695	char Basename(char path)
7696	{
7697	char *p;
7698
7699	if( path == NULL \|\| *path == '\0' ) return ".";
7700
7701	p = path + strlen(path) - 1;
7702
7703	while( *p == '/' )
7704	{
7705	if( p == path ) return path;
7706	*p-- = '\0';
7707	}
7708
7709	while( p >= path && *p != '/' ) p--;
7710
7711	return p + 1;
7712	}
7713
7714	//////////////////////////////////////////////////////////////
7715	//////////////////////////////////////////////////////////////
7716
7717	/* Find the Last Common Ancestor of n1 and n2 */
7718	t_node Find_Lca_Pair_Of_Nodes(t_node n1, t_node n2, t_tree tree)
7719	{
7720	t_node list1, list2, *lca;
7721	int size1, size2;
7722
7723	if(!tree->n_root)
7724	{
7725	PhyML_Printf("\n. The tree must be rooted in this function.");
7726	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
7727	Warn_And_Exit("");
7728	}
7729
7730	list1 = (t_node *)mCalloc(2tree->n_otu-1,sizeof(t_node *));
7731	list2 = (t_node *)mCalloc(2tree->n_otu-1,sizeof(t_node *));
7732
7733	Get_List_Of_Ancestors(n1,list1,&size1,tree);
7734	Get_List_Of_Ancestors(n2,list2,&size2,tree);
7735
7736	while(list1[size1] == list2[size2])
7737	{
7738	size1--;
7739	size2--;
7740
7741	if(size1 < 0 \|\| size2 < 0) break;
7742	}
7743
7744	lca = list1[size1+1];
7745
7746	Free(list1);
7747	Free(list2);
7748
7749	return lca;
7750	}
7751
7752	//////////////////////////////////////////////////////////////
7753	//////////////////////////////////////////////////////////////
7754
7755	/* Find the Last Common Ancestor of all the nodes in node_list */
7756	t_node Find_Lca_Clade(t_node node_list, int node_list_size, t_tree tree)
7757	{
7758	t_node **list, lca;
7759	int *size;
7760	int i;
7761
7762	if(!tree->n_root)
7763	{
7764	PhyML_Printf("\n== The tree must be rooted in this function.");
7765	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
7766	Warn_And_Exit("");
7767	}
7768
7769	list = (t_node *)mCalloc(node_list_size,sizeof(t_node ));
7770	For(i,node_list_size) list[i] = (t_node *)mCalloc(2tree->n_otu-1,sizeof(t_node *));
7771	size = (int *)mCalloc(node_list_size,sizeof(int));
7772
7773	For(i,node_list_size)
7774	{
7775	if(!Get_List_Of_Ancestors(node_list[i],list[i],size+i,tree))
7776	{
7777	For(i,node_list_size) PhyML_Printf("\n== %s",node_list[i]->name);
7778	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
7779	Exit("\n");
7780	}
7781	}
7782	do
7783	{
7784	For(i,node_list_size-1)
7785	if(list[i][size[i]] != list[i+1][size[i+1]])
7786	break;
7787
7788	if(i != node_list_size-1) break;
7789
7790	For(i,node_list_size)
7791	{
7792	size[i]--;
7793	if(size[i] == 1) break; // We have reached the tip corresponding to node_list[i]
7794	}
7795
7796	if(node_list_size == 1) break;
7797
7798	}while(1);
7799
7800
7801	lca = list[0][size[0]+1];
7802
7803	For(i,node_list_size) Free(list[i]);
7804	Free(list);
7805	Free(size);
7806
7807	return lca;
7808	}
7809
7810	//////////////////////////////////////////////////////////////
7811	//////////////////////////////////////////////////////////////
7812
7813	/* Returns the list of the ancestors of ref_t_node from ref_t_node to the root included */
7814	int Get_List_Of_Ancestors(t_node ref_node, t_node list, int size, t_tree *tree)
7815	{
7816	t_node *n;
7817
7818	*size = 1;
7819	n = ref_node;
7820	list[0] = n;
7821
7822	if(!n)
7823	{
7824	PhyML_Printf("\n== There seems to be a problem with the calibration file.\n");
7825	return 0;
7826	}
7827
7828	while(n != tree->n_root)
7829	{
7830	n = n->anc;
7831	if(!n)
7832	{
7833	PhyML_Printf("\n== n->anc has not been set properly (call Update_Ancestors first...)\n");
7834	return 0;
7835	}
7836	size = size+1;
7837	list[*size] = n;
7838	}
7839	return 1;
7840	}
7841
7842	//////////////////////////////////////////////////////////////
7843	//////////////////////////////////////////////////////////////
7844
7845
7846	int Edge_Num_To_Node_Num(int edge_num, t_tree *tree)
7847	{
7848	int node_num;
7849	t_edge *b;
7850
7851	b = tree->a_edges[edge_num];
7852
7853	node_num = (b->left == b->rght->anc)?(b->rght->num):(b->left->num);
7854
7855	return node_num;
7856	}
7857
7858	//////////////////////////////////////////////////////////////
7859	//////////////////////////////////////////////////////////////
7860
7861	void Time_To_Branch(t_tree *tree)
7862	{
7863	Time_To_Branch_Pre(tree->n_root,tree->n_root->v[2],tree);
7864	Time_To_Branch_Pre(tree->n_root,tree->n_root->v[1],tree);
7865	tree->n_root->l[1] = tree->rates->nd_t[tree->n_root->v[1]->num] - tree->rates->nd_t[tree->n_root->num];
7866	tree->n_root->l[2] = tree->rates->nd_t[tree->n_root->v[1]->num] - tree->rates->nd_t[tree->n_root->num];
7867	tree->e_root->l->v = tree->n_root->l[1] + tree->n_root->l[2];
7868
7869	}
7870
7871	//////////////////////////////////////////////////////////////
7872	//////////////////////////////////////////////////////////////
7873
7874
7875	void Time_To_Branch_Pre(t_node a, t_node d, t_tree *tree)
7876	{
7877	int i;
7878
7879	/* tree->rates->cur_l[d->num] = FABS(tree->rates->nd_t[d->num] - tree->rates->nd_t[a->num]); */
7880	tree->rates->cur_l[d->num] = tree->rates->nd_t[d->num] - tree->rates->nd_t[a->num];
7881
7882	if(d->tax) return;
7883	else
7884	{
7885	For(i,3)
7886	if((d->v[i] != a) && (d->b[i] != tree->e_root))
7887	Time_To_Branch_Pre(d,d->v[i],tree);
7888	}
7889	}
7890
7891	//////////////////////////////////////////////////////////////
7892	//////////////////////////////////////////////////////////////
7893
7894	//////////////////////////////////////////////////////////////
7895	//////////////////////////////////////////////////////////////
7896
7897	// Assume an ultrametric tree.
7898	void Branch_To_Time(t_tree *tree)
7899	{
7900	Branch_To_Time_Pre(tree->n_root,tree->n_root->v[2],tree);
7901	Branch_To_Time_Pre(tree->n_root,tree->n_root->v[1],tree);
7902
7903	tree->rates->nd_t[tree->n_root->num] =
7904	tree->rates->nd_t[tree->n_root->v[1]->num] -
7905	tree->n_root->l[1];
7906	}
7907
7908	//////////////////////////////////////////////////////////////
7909	//////////////////////////////////////////////////////////////
7910
7911	void Branch_To_Time_Pre(t_node a, t_node d, t_tree *tree)
7912	{
7913	int i;
7914
7915	if(d->tax)
7916	{
7917	tree->rates->nd_t[d->num] = 0.0;
7918	return;
7919	}
7920	else
7921	{
7922	For(i,3)
7923	if((d->v[i] != a) && (d->b[i] != tree->e_root))
7924	{
7925	Branch_To_Time_Pre(d,d->v[i],tree);
7926	}
7927
7928	For(i,3)
7929	if((d->v[i] != a) && (d->b[i] != tree->e_root))
7930	{
7931	tree->rates->nd_t[d->num] = tree->rates->nd_t[d->v[i]->num] - d->b[i]->l->v;
7932	break;
7933	}
7934	}
7935	}
7936
7937	//////////////////////////////////////////////////////////////
7938	//////////////////////////////////////////////////////////////
7939
7940
7941	void Branch_Lengths_To_Rate_Lengths(t_tree *tree)
7942	{
7943	Branch_Lengths_To_Rate_Lengths_Pre(tree->n_root,tree->n_root->v[2],tree);
7944	Branch_Lengths_To_Rate_Lengths_Pre(tree->n_root,tree->n_root->v[1],tree);
7945	}
7946
7947	//////////////////////////////////////////////////////////////
7948	//////////////////////////////////////////////////////////////
7949
7950
7951	void Branch_Lengths_To_Rate_Lengths_Pre(t_node a, t_node d, t_tree *tree)
7952	{
7953	int i;
7954
7955	tree->rates->cur_l[d->num] =
7956	tree->rates->br_r[d->num] *
7957	tree->rates->clock_r *
7958	tree->rates->norm_fact;
7959
7960	if(d->tax) return;
7961	else
7962	{
7963	For(i,3)
7964	if((d->v[i] != a) && (d->b[i] != tree->e_root))
7965	Branch_Lengths_To_Rate_Lengths_Pre(d,d->v[i],tree);
7966	}
7967	}
7968
7969	//////////////////////////////////////////////////////////////
7970	//////////////////////////////////////////////////////////////
7971
7972
7973	int Find_Clade(char *tax_name_list, int list_size, t_tree tree)
7974	{
7975	int *tax_num_list;
7976	t_node **tax_node_list;
7977	int i,j;
7978	int n_matches;
7979	t_node *lca;
7980
7981	tax_num_list = (int *)mCalloc(list_size,sizeof(int));
7982	tax_node_list = (t_node *)mCalloc(list_size,sizeof(t_node ));
7983
7984	For(i,list_size) tax_num_list[i] = -1;
7985
7986	n_matches = 0;
7987
7988	For(i,list_size)
7989	{
7990	For(j,tree->n_otu)
7991	{
7992	if(!strcmp(tax_name_list[i],tree->a_nodes[j]->name))
7993	{
7994	tax_num_list[i] = tree->a_nodes[j]->num;
7995	tax_node_list[i] = tree->a_nodes[j];
7996	n_matches++;
7997	break;
7998	}
7999	}
8000	if(j == tree->n_otu)
8001	{
8002	PhyML_Printf("\n== Problem with the calibration file.");
8003	PhyML_Printf("\n== Could not find taxon with name '%s' in the sequence or tree file.",tax_name_list[i]);
8004	Exit("\n");
8005	}
8006	}
8007
8008	lca = Find_Lca_Clade(tax_node_list,n_matches,tree);
8009	if(lca) return lca->num;
8010	else return -1;
8011
8012	/* if(list_size == tree->n_otu) /\* Root node \/ /
8013	/* { */
8014	/* int i,j; */
8015	/* int score; */
8016
8017	/* score = 0; */
8018	/* For(i,list_size) */
8019	/* { */
8020	/* For(j,tree->n_otu) */
8021	/* { */
8022	/* /\* if(!strcmp(tax_name_list[i],tree->a_nodes[j]->name)) score++; \/ /
8023	/* if(tax_num_list[i] == tree->a_nodes[j]->num) score++; */
8024	/* } */
8025	/* } */
8026
8027	/* Free(tax_num_list); */
8028	/* if(score == tree->n_otu) return tree->n_root->num; */
8029	/* else return -1; */
8030	/* } */
8031	/* else */
8032	/* { */
8033	/* int num; */
8034	/* num = -1; */
8035	/* Free_Bip(tree); */
8036	/* Alloc_Bip(tree); */
8037	/* Get_Bip(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree); */
8038	/* Find_Clade_Pre(tree->n_root,tree->n_root->v[2],tax_num_list,list_size,&num,tree); */
8039	/* Find_Clade_Pre(tree->n_root,tree->n_root->v[1],tax_num_list,list_size,&num,tree); */
8040	/* Free(tax_num_list); */
8041	/* return num; */
8042	/* } */
8043
8044	Free(tax_node_list);
8045	Free(tax_num_list);
8046	return -1;
8047	}
8048
8049	//////////////////////////////////////////////////////////////
8050	//////////////////////////////////////////////////////////////
8051
8052
8053	void Find_Clade_Pre(t_node a, t_node d, int tax_num_list, int list_size, int num, t_tree *tree)
8054	{
8055	int i,j,k;
8056	int score;
8057
8058
8059	For(i,3)
8060	if((d->v[i] == a) \|\| (d->b[i] == tree->e_root))
8061	{
8062	if(list_size == d->bip_size[i])
8063	{
8064	score = 0;
8065	For(j,d->bip_size[i])
8066	{
8067	For(k,list_size)
8068	{
8069	if(tax_num_list[k] == d->bip_node[i][j]->num)
8070	{
8071	score++;
8072	break;
8073	}
8074	}
8075	}
8076	if(score == list_size) *num = d->num;
8077	}
8078	break;
8079	}
8080
8081	if(d->tax) return;
8082	else
8083	For(i,3)
8084	if((d->v[i] != a) && (d->b[i] != tree->e_root))
8085	Find_Clade_Pre(d,d->v[i],tax_num_list,list_size,num,tree);
8086	}
8087
8088	//////////////////////////////////////////////////////////////
8089	//////////////////////////////////////////////////////////////
8090
8091	t_edge Find_Root_Edge(FILE fp_input_tree, t_tree *tree)
8092	{
8093	char **subs;
8094	int degree;
8095	int i,j;
8096	t_node left, rght;
8097	int l_r, r_l;
8098	int score;
8099	char *line;
8100	char c;
8101	t_edge *root_edge;
8102
8103	line = (char *)mCalloc(T_MAX_LINE,sizeof(char));
8104
8105	rewind(fp_input_tree);
8106
8107	do c=fgetc(fp_input_tree);
8108	while((c != '(') && (c != EOF));
8109
8110	if(c==EOF)
8111	{
8112	Free(line);
8113	return NULL;
8114	}
8115
8116	i=0;
8117	for(;;)
8118	{
8119	if((c == ' ') \|\| (c == '\n'))
8120	{
8121	c=fgetc(fp_input_tree);
8122	if(c==EOF) break;
8123	else continue;
8124	}
8125
8126	line[i]=c;
8127	i++;
8128	c=fgetc(fp_input_tree);
8129	if(c==EOF \|\| c==';') break;
8130	}
8131
8132
8133	Free_Bip(tree);
8134	Alloc_Bip(tree);
8135	Get_Bip(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
8136
8137	subs = Sub_Trees(line,&degree);
8138	Clean_Multifurcation(subs,degree,3);
8139	if(degree != 2)
8140	{
8141	PhyML_Printf("\n== The tree does not seem to be rooted...");
8142	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
8143	Warn_And_Exit("");
8144	}
8145
8146	left = rght = NULL;
8147	l_r = r_l = -1;
8148
8149	For(i,2*tree->n_otu-3)
8150	{
8151	left = tree->a_edges[i]->left;
8152	rght = tree->a_edges[i]->rght;
8153	l_r = tree->a_edges[i]->l_r;
8154	r_l = tree->a_edges[i]->r_l;
8155
8156	score = 0;
8157	For(j,left->bip_size[l_r]) if(strstr(subs[1],left->bip_node[l_r][j]->name)) score++;
8158	if(score == left->bip_size[l_r]) break;
8159
8160	score = 0;
8161	For(j,rght->bip_size[r_l]) if(strstr(subs[1],rght->bip_node[r_l][j]->name)) score++;
8162	if(score == rght->bip_size[r_l]) break;
8163	}
8164
8165	root_edge = tree->a_edges[i];
8166
8167	For(i,NODE_DEG_MAX) Free(subs[i]);
8168	Free(subs);
8169	Free(line);
8170
8171	if(i == 2*tree->n_otu-3)
8172	{
8173	PhyML_Printf("\n== Could not find the root edge...");
8174	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
8175	Warn_And_Exit("");
8176	}
8177
8178	return root_edge;
8179	}
8180
8181	//////////////////////////////////////////////////////////////
8182	//////////////////////////////////////////////////////////////
8183
8184	void Copy_Tree_Topology_With_Labels(t_tree ori, t_tree cpy)
8185	{
8186	int i,j;
8187
8188	For(i,2*ori->n_otu-2)
8189	{
8190	For(j,3)
8191	{
8192	if(ori->a_nodes[i]->v[j])
8193	{
8194	cpy->a_nodes[i]->v[j] = cpy->a_nodes[ori->a_nodes[i]->v[j]->num];
8195	cpy->a_nodes[i]->l[j] = ori->a_nodes[i]->l[j];
8196	}
8197	else
8198	cpy->a_nodes[i]->v[j] = NULL;
8199	}
8200	cpy->a_nodes[i]->num = ori->a_nodes[i]->num;
8201	cpy->a_nodes[i]->tax = 0;
8202	}
8203
8204	For(i,2*ori->n_otu-3)
8205	{
8206	cpy->a_edges[i]->l->v = ori->a_edges[i]->l->v;
8207	}
8208
8209	For(i,ori->n_otu)
8210	{
8211	cpy->a_nodes[i]->tax = 1;
8212	strcpy(cpy->a_nodes[i]->name,ori->a_nodes[i]->name);
8213	}
8214
8215	}
8216
8217	//////////////////////////////////////////////////////////////
8218	//////////////////////////////////////////////////////////////
8219
8220	void Set_Model_Name(t_mod *mod)
8221	{
8222	switch(mod->whichmodel)
8223	{
8224	case JC69:
8225	{
8226	strcpy(mod->modelname->s, "JC69");
8227	break;
8228	}
8229	case K80:
8230	{
8231	strcpy(mod->modelname->s, "K80");
8232	break;
8233	}
8234	case F81:
8235	{
8236	strcpy(mod->modelname->s, "F81");
8237	break;
8238	}
8239	case HKY85:
8240	{
8241	strcpy(mod->modelname->s, "HKY85");
8242	break;
8243	}
8244	case F84:
8245	{
8246	strcpy(mod->modelname->s, "F84");
8247	break;
8248	}
8249	case TN93:
8250	{
8251	strcpy(mod->modelname->s, "TN93");
8252	break;
8253	}
8254	case GTR:
8255	{
8256	strcpy(mod->modelname->s, "GTR");
8257	break;
8258	}
8259	case CUSTOM:
8260	{
8261	strcpy(mod->modelname->s, "Custom");
8262	break;
8263	}
8264	case DAYHOFF:
8265	{
8266	strcpy(mod->modelname->s, "Dayhoff");
8267	break;
8268	}
8269	case JTT:
8270	{
8271	strcpy(mod->modelname->s, "JTT");
8272	break;
8273	}
8274	case MTREV:
8275	{
8276	strcpy(mod->modelname->s, "MtREV");
8277	break;
8278	}
8279	case LG:
8280	{
8281	strcpy(mod->modelname->s, "LG");
8282	break;
8283	}
8284	case WAG:
8285	{
8286	strcpy(mod->modelname->s, "WAG");
8287	break;
8288	}
8289	case DCMUT:
8290	{
8291	strcpy(mod->modelname->s, "DCMut");
8292	break;
8293	}
8294	case RTREV:
8295	{
8296	strcpy(mod->modelname->s, "RtREV");
8297	break;
8298	}
8299	case CPREV:
8300	{
8301	strcpy(mod->modelname->s, "CpREV");
8302	break;
8303	}
8304	case VT:
8305	{
8306	strcpy(mod->modelname->s, "VT");
8307	break;
8308	}
8309	case BLOSUM62:
8310	{
8311	strcpy(mod->modelname->s, "Blosum62");
8312	break;
8313	}
8314	case MTMAM:
8315	{
8316	strcpy(mod->modelname->s, "MtMam");
8317	break;
8318	}
8319	case MTART:
8320	{
8321	strcpy(mod->modelname->s, "MtArt");
8322	break;
8323	}
8324	case HIVW:
8325	{
8326	strcpy(mod->modelname->s, "HIVw");
8327	break;
8328	}
8329	case HIVB:
8330	{
8331	strcpy(mod->modelname->s, "HIVb");
8332	break;
8333	}
8334	case CUSTOMAA:
8335	{
8336	strcpy(mod->modelname->s, "Custom");
8337	break;
8338	}
8339	default:
8340	{
8341	PhyML_Printf("\n== Unknown model name.\n");
8342	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
8343	Warn_And_Exit("");
8344	break;
8345	}
8346	}
8347	}
8348
8349	//////////////////////////////////////////////////////////////
8350	//////////////////////////////////////////////////////////////
8351
8352
8353	void Adjust_Min_Diff_Lk(t_tree *tree)
8354	{
8355	int exponent;
8356
8357	exponent = (int)FLOOR(log10(FABS(tree->c_lnL)));
8358
8359	if(sizeof(phydbl) == 4)
8360	{
8361	tree->mod->s_opt->min_diff_lk_local = POW(10.,exponent - FLT_DIG + 1);
8362	tree->mod->s_opt->min_diff_lk_local = tree->mod->s_opt->min_diff_lk_local;
8363	tree->mod->s_opt->min_diff_lk_move = tree->mod->s_opt->min_diff_lk_local;
8364	}
8365	/* PhyML_Printf("\n. Exponent = %d Precision = %E DIG = %d",exponent,tree->mod->s_opt->min_diff_lk_local,FLT_DIG); */
8366	}
8367
8368	//////////////////////////////////////////////////////////////
8369	//////////////////////////////////////////////////////////////
8370
8371
8372	/*!
8373	tree->a_nodes[i]->name is initially a number. It is translated into
8374	a string of characters using the names provided in the tax_name
8375	array.
8376	*/
8377	void Translate_Tax_Names(char *tax_names, t_tree tree)
8378	{
8379	int i;
8380	int tax_num;
8381
8382	For(i,tree->n_otu)
8383	{
8384	tax_num = strtol(tree->a_nodes[i]->name,NULL,10);
8385	tree->a_nodes[i]->name = tax_names[tax_num-1];
8386	}
8387	}
8388
8389	//////////////////////////////////////////////////////////////
8390	//////////////////////////////////////////////////////////////
8391
8392
8393	/*!
8394	Skip coment in NEXUS file.
8395	*/
8396	void Skip_Comment(FILE *fp)
8397	{
8398	int in_comment;
8399	char c;
8400
8401	in_comment = 1;
8402	do
8403	{
8404	c = fgetc(fp);
8405	if(c == EOF) break;
8406	if(c == '[') in_comment++;
8407	else if(c == ']') in_comment--;
8408	}
8409	while(in_comment);
8410	}
8411
8412	//////////////////////////////////////////////////////////////
8413	//////////////////////////////////////////////////////////////
8414
8415	/*!
8416	Determine the most appropriate position of the root if outgroup taxa are specified.
8417	*/
8418
8419	void Get_Best_Root_Position(t_tree *tree)
8420	{
8421	int i,j;
8422	phydbl eps;
8423	phydbl s, s_max;
8424	t_edge *best_edge;
8425	int has_outgrp;
8426
8427	best_edge = NULL;
8428
8429	if(tree->n_root)
8430	{
8431	PhyML_Printf("\n== Tree already has a root.");
8432	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
8433	Warn_And_Exit("");
8434	}
8435
8436	if(strstr(tree->a_nodes[0]->name,"*"))
8437	{
8438	/* PhyML_Printf("\n. Found outgroup taxon: %s",tree->a_nodes[0]->name); */
8439	tree->a_nodes[0]->s_ingrp[0] = 0;
8440	tree->a_nodes[0]->s_outgrp[0] = 1;
8441	}
8442	else
8443	{
8444	tree->a_nodes[0]->s_ingrp[0] = 1;
8445	tree->a_nodes[0]->s_outgrp[0] = 0;
8446	}
8447
8448	has_outgrp = NO;
8449	Get_Best_Root_Position_Post(tree->a_nodes[0],tree->a_nodes[0]->v[0],&has_outgrp,tree);
8450	Get_Best_Root_Position_Pre(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
8451
8452	if(has_outgrp == YES)
8453	{
8454	eps = 1.E-10;
8455	s = s_max = 0.0;
8456	For(i,2*tree->n_otu-2)
8457	{
8458	For(j,3)
8459	{
8460	s = (tree->a_nodes[i]->s_outgrp[j]+eps) / (tree->a_nodes[i]->s_ingrp[j] + eps) ;
8461	/* printf("\n. [%d %d] %d %d",i,j,tree->a_nodes[i]->s_outgrp[j],tree->a_nodes[i]->s_ingrp[j]); */
8462	if(s > s_max)
8463	{
8464	s_max = s;
8465	best_edge = tree->a_nodes[i]->b[j];
8466	}
8467	}
8468	}
8469
8470	Add_Root(best_edge,tree);
8471	}
8472	}
8473
8474	//////////////////////////////////////////////////////////////
8475	//////////////////////////////////////////////////////////////
8476
8477
8478	/*!
8479	Determine the most appropriate position of the root if outgroup taxa are specified.
8480	Post-traversal.
8481	*/
8482	void Get_Best_Root_Position_Post(t_node a, t_node d, int has_outgrp, t_tree tree)
8483	{
8484	if(d->tax)
8485	{
8486	if(strstr(d->name,"*"))
8487	{
8488	*has_outgrp = YES;
8489	/* PhyML_Printf("\n. Found outgroup taxon: %s",d->name); */
8490	d->s_ingrp[0] = 0;
8491	d->s_outgrp[0] = 1;
8492	}
8493	else
8494	{
8495	d->s_ingrp[0] = 1;
8496	d->s_outgrp[0] = 0;
8497	}
8498	return;
8499	}
8500	else
8501	{
8502	int i;
8503
8504	For(i,3)
8505	if(d->v[i] != a && (d->b[i] != tree->e_root))
8506	Get_Best_Root_Position_Post(d,d->v[i],has_outgrp,tree);
8507
8508	Get_OutIn_Scores(a,d);
8509
8510	}
8511	}
8512
8513	//////////////////////////////////////////////////////////////
8514	//////////////////////////////////////////////////////////////
8515
8516
8517	/*!
8518	Determine the most appropriate position of the root if outgroup taxa are specified.
8519	Pre-traversal.
8520	*/
8521	void Get_Best_Root_Position_Pre(t_node a, t_node d, t_tree *tree)
8522	{
8523	if(d->tax)
8524	{
8525	return;
8526	}
8527	else
8528	{
8529	int i;
8530
8531	For(i,3)
8532	if(d->v[i] != a && (d->b[i] != tree->e_root))
8533	{
8534	Get_OutIn_Scores(d->v[i],d);
8535	Get_Best_Root_Position_Pre(d,d->v[i],tree);
8536	}
8537	}
8538	}
8539
8540	//////////////////////////////////////////////////////////////
8541	//////////////////////////////////////////////////////////////
8542
8543
8544	/*!
8545	Determine the most appropriate position of the root if outgroup taxa are specified.
8546	Core.
8547	*/
8548	void Get_OutIn_Scores(t_node a, t_node d)
8549	{
8550	int i,d_v1,d_v2,v1_d,v2_d,d_a;
8551
8552	d_a = v1_d = v2_d = -1;
8553	d_v1 = d_v2 = -1;
8554	For(i,3)
8555	{
8556	if(d->v[i] != a)
8557	{
8558	if(d_v1 < 0) d_v1 = i;
8559	else d_v2 = i;
8560	}
8561	}
8562
8563	For(i,3) if(d->v[i] == a) { d_a = i; break; }
8564	For(i,3) if(d->v[d_v1]->v[i] == d) { v1_d = i; break; }
8565	For(i,3) if(d->v[d_v2]->v[i] == d) { v2_d = i; break; }
8566
8567	d->s_ingrp[d_a] =
8568	d->v[d_v1]->s_ingrp[v1_d] +
8569	d->v[d_v2]->s_ingrp[v2_d] ;
8570
8571	d->s_outgrp[d_a] =
8572	d->v[d_v1]->s_outgrp[v1_d] +
8573	d->v[d_v2]->s_outgrp[v2_d] ;
8574	}
8575
8576	//////////////////////////////////////////////////////////////
8577	//////////////////////////////////////////////////////////////
8578
8579	int Check_Sequence_Name(char *s)
8580	{
8581	int i;
8582	/* if(rindex(s,':')) */
8583	For(i,strlen(s))
8584	{
8585	if(s[i] == ':')
8586	{
8587	PhyML_Printf("\n== Character ':' is not permitted in sequence name (%s).",s);
8588	PhyML_Printf("\n== Err. in file %s at line %d",__FILE__,__LINE__);
8589	Warn_And_Exit("");
8590	}
8591	}
8592	/* if(rindex(s,',')) */
8593	For(i,strlen(s))
8594	{
8595	if(s[i] == ',')
8596	{
8597	PhyML_Printf("\n== Character ',' is not permitted in sequence name (%s).",s);
8598	PhyML_Printf("\n== Err in file %s at line %d",__FILE__,__LINE__);
8599	Warn_And_Exit("");
8600	}
8601	}
8602	/* if(rindex(s,' ')) */
8603	For(i,strlen(s))
8604	{
8605	if(s[i] == ' ')
8606	{
8607	PhyML_Printf("\n== Character ' ' is not permitted in sequence name (%s).",s);
8608	PhyML_Printf("\n== Err in file %s at line %d",__FILE__,__LINE__);
8609	Warn_And_Exit("");
8610	}
8611	}
8612
8613	return 1;
8614	}
8615
8616	//////////////////////////////////////////////////////////////
8617	//////////////////////////////////////////////////////////////
8618
8619
8620	int Scale_Subtree_Height(t_node a, phydbl K, phydbl floor, int n_nodes, t_tree *tree)
8621	{
8622	phydbl new_height;
8623
8624	*n_nodes = 0;
8625
8626	new_height = .0;
8627
8628
8629	if(!(tree->rates->nd_t[a->num] > floor))
8630	new_height = K*(tree->rates->nd_t[a->num]-floor)+floor;
8631
8632	if(a == tree->n_root)
8633	{
8634	tree->rates->nd_t[tree->n_root->num] = new_height;
8635	*n_nodes = 1;
8636
8637	Scale_Node_Heights_Post(tree->n_root,tree->n_root->v[2],K,floor,n_nodes,tree);
8638	Scale_Node_Heights_Post(tree->n_root,tree->n_root->v[1],K,floor,n_nodes,tree);
8639	}
8640	else
8641	{
8642	int i;
8643
8644	if(new_height < tree->rates->nd_t[a->anc->num]) return 0;
8645	else
8646	{
8647	tree->rates->nd_t[a->num] = new_height;
8648	*n_nodes = 1;
8649	}
8650
8651	For(i,3)
8652	if(a->v[i] != a->anc && a->b[i] != tree->e_root)
8653	{
8654	Scale_Node_Heights_Post(a,a->v[i],K,floor,n_nodes,tree);
8655	}
8656	}
8657
8658	return 1;
8659	}
8660
8661	//////////////////////////////////////////////////////////////
8662	//////////////////////////////////////////////////////////////
8663
8664
8665	void Scale_Node_Heights_Post(t_node a, t_node d, phydbl K, phydbl floor, int n_nodes, t_tree tree)
8666	{
8667	if(d == tree->n_root)
8668	{
8669	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
8670	Warn_And_Exit("");
8671	}
8672
8673	if(d->tax)
8674	{
8675	if(!(tree->rates->nd_t[d->num] > floor))
8676	{
8677	/* Scaling does not change the node height here
8678	but, in theory this tip is among the scaled
8679	nodes. Therefore needs to count it in for
8680	working out correct Hastings ratios
8681	*/
8682	/* n_nodes = n_nodes+1; */
8683	}
8684	return;
8685	}
8686	else
8687	{
8688	int i;
8689
8690	/* It is tempting to set floor = tree->rates->t_prior_max[d->num]; but
8691	it then becomes possible for nodes with different floor values
8692	to have their orders interverted (i.e., ancestor below descendant)
8693	*/
8694	if(!(tree->rates->nd_t[d->num] > floor))
8695	{
8696	tree->rates->nd_t[d->num] = K*(tree->rates->nd_t[d->num]-floor)+floor;
8697	n_nodes = n_nodes+1;
8698	}
8699
8700	if(tree->rates->nd_t[d->num] < tree->rates->nd_t[a->num])
8701	{
8702	PhyML_Printf("\n. K = %f floor = %f t_prior_max(a) = %f t_prior_max(d) = %f a->t = %f d->t %f",
8703	K,floor,tree->rates->t_prior_max[a->num],tree->rates->t_prior_max[d->num],
8704	tree->rates->nd_t[a->num],tree->rates->nd_t[d->num]);
8705	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
8706	Warn_And_Exit("");
8707	}
8708
8709	For(i,3)
8710	if(d->v[i] != a && d->b[i] != tree->e_root)
8711	Scale_Node_Heights_Post(d,d->v[i],K,floor,n_nodes,tree);
8712
8713	}
8714	}
8715
8716	//////////////////////////////////////////////////////////////
8717	//////////////////////////////////////////////////////////////
8718
8719	int Scale_Subtree_Rates(t_node a, phydbl mult, int n_nodes, t_tree *tree)
8720	{
8721	int res;
8722	int i;
8723
8724	*n_nodes = 0;
8725	res = 1;
8726
8727	if(a == tree->n_root)
8728	{
8729	res = Scale_Subtree_Rates_Post(a,a->v[2],mult,n_nodes,tree);
8730	if(res) res = Scale_Subtree_Rates_Post(a,a->v[1],mult,n_nodes,tree);
8731	return res;
8732	}
8733	else
8734	{
8735	For(i,3) if((a->v[i] != a->anc) &&
8736	(a->b[i] != tree->e_root) &&
8737	(res == 1)) res = Scale_Subtree_Rates_Post(a,a->v[i],mult,n_nodes,tree);
8738	return res;
8739	}
8740	}
8741
8742	//////////////////////////////////////////////////////////////
8743	//////////////////////////////////////////////////////////////
8744
8745	int Scale_Subtree_Rates_Post(t_node a, t_node d, phydbl mult, int n_nodes, t_tree tree)
8746	{
8747
8748	if(tree->rates->model_log_rates == YES)
8749	{
8750	tree->rates->br_r[d->num] += LOG(mult);
8751	}
8752	else
8753	{
8754	tree->rates->br_r[d->num] *= mult;
8755	}
8756
8757	n_nodes = n_nodes+1;
8758
8759	if(tree->rates->br_r[d->num] < tree->rates->min_rate) return 0;
8760	if(tree->rates->br_r[d->num] > tree->rates->max_rate) return 0;
8761
8762	if(d->tax) return 1;
8763	else
8764	{
8765	int i,res;
8766
8767	res = 1;
8768	For(i,3)
8769	{
8770	if((d->v[i] != a) &&
8771	(d->b[i] != tree->e_root) &&
8772	(res == 1))
8773	{
8774	res = Scale_Subtree_Rates_Post(d,d->v[i],mult,n_nodes,tree);
8775	}
8776	}
8777	return res;
8778	}
8779	}
8780
8781	//////////////////////////////////////////////////////////////
8782	//////////////////////////////////////////////////////////////
8783
8784	//////////////////////////////////////////////////////////////
8785	//////////////////////////////////////////////////////////////
8786
8787	void Get_Node_Ranks(t_tree *tree)
8788	{
8789	tree->n_root->rank = 1;
8790	Get_Node_Ranks_Pre(tree->n_root,tree->n_root->v[2],tree);
8791	Get_Node_Ranks_Pre(tree->n_root,tree->n_root->v[1],tree);
8792	}
8793
8794	//////////////////////////////////////////////////////////////
8795	//////////////////////////////////////////////////////////////
8796
8797
8798	void Get_Node_Ranks_Pre(t_node a, t_node d,t_tree *tree)
8799	{
8800	d->rank = a->rank+1;
8801
8802	if(d->tax) return;
8803	else
8804	{
8805	int i;
8806
8807	For(i,3)
8808	{
8809	if(d->v[i] != a && d->b[i] != tree->e_root)
8810	{
8811	Get_Node_Ranks_Pre(d,d->v[i],tree);
8812	}
8813	}
8814	}
8815	}
8816
8817	//////////////////////////////////////////////////////////////
8818	//////////////////////////////////////////////////////////////
8819
8820	void Log_Br_Len(t_tree *tree)
8821	{
8822	int i;
8823	For(i,2*tree->n_otu-3) tree->a_edges[i]->l->v = LOG(tree->a_edges[i]->l->v);
8824	}
8825
8826	//////////////////////////////////////////////////////////////
8827	//////////////////////////////////////////////////////////////
8828
8829	phydbl Diff_Lk_Norm_At_Given_Edge(t_edge b, t_tree tree)
8830	{
8831	int i,dim,err;
8832	phydbl lk_exact,lk_norm,sum;
8833
8834	Record_Br_Len(tree);
8835
8836	dim = 2*tree->n_otu-3;
8837	sum = 0.0;
8838
8839	For(i,tree->n_short_l)
8840	{
8841	b->l->v = tree->short_l[i];
8842
8843	lk_exact = Lk(b,tree);
8844	lk_norm = tree->norm_scale + Log_Dnorm(b->l->v,tree->rates->mean_l[b->num],
8845	tree->rates->cov_l[b->num*dim+b->num],&err);
8846
8847	if(err)
8848	{
8849	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
8850	Warn_And_Exit("");
8851	}
8852
8853	sum += pow(lk_exact - lk_norm,2);
8854	}
8855
8856	Restore_Br_Len(tree);
8857	Lk(b,tree);
8858
8859	return(sum);
8860	}
8861
8862
8863	//////////////////////////////////////////////////////////////
8864	//////////////////////////////////////////////////////////////
8865
8866
8867	void Adjust_Variances(t_tree *tree)
8868	{
8869	int i;
8870	phydbl new_diff,curr_diff;
8871
8872	Make_Short_L(tree);
8873	For(i,tree->n_short_l)
8874	{
8875	tree->short_l[i] = tree->mod->l_min + i*(0.1 - tree->mod->l_min)/tree->n_short_l;
8876	}
8877
8878
8879	For(i,2*tree->n_otu-3)
8880	{
8881	if(tree->a_edges[i]->l->v < 1.1*tree->mod->l_min)
8882	{
8883	tree->rates->mean_l[i] = -1.00;
8884	tree->rates->cov_l[i(2tree->n_otu-3)+i] = 0.1;
8885	tree->norm_scale = -100;
8886
8887
8888	new_diff = curr_diff = 10.0;
8889	do
8890	{
8891	curr_diff = new_diff;
8892
8893	Generic_Brent_Lk(&(tree->norm_scale),
8894	-1E+6,
8895	0.0,
8896	1.E-10,
8897	10000,
8898	NO,
8899	Wrap_Diff_Lk_Norm_At_Given_Edge,tree->a_edges[i],tree,NULL,NO);
8900
8901	/* Generic_Brent_Lk(&(tree->rates->mean_l[0]), */
8902	/* -100., */
8903	/* 10tree->mod->l_min, /
8904	/* 1.E-3, */
8905	/* 10000, */
8906	/* NO, */
8907	/* Wrap_Diff_Lk_Norm_At_Given_Edge,tree->a_edges[0],tree,NULL); */
8908
8909	Generic_Brent_Lk(&(tree->rates->cov_l[i(2tree->n_otu-3)+i]),
8910	0.0,
8911	10.0,
8912	1.E-10,
8913	10000,
8914	NO,
8915	Wrap_Diff_Lk_Norm_At_Given_Edge,tree->a_edges[i],tree,NULL,NO);
8916
8917	new_diff = Diff_Lk_Norm_At_Given_Edge(tree->a_edges[i],tree);
8918	}while(FABS(new_diff-curr_diff) > 1.E-3);
8919	}
8920	}
8921	}
8922
8923	//////////////////////////////////////////////////////////////
8924	//////////////////////////////////////////////////////////////
8925
8926
8927	phydbl Effective_Sample_Size(phydbl first_val, phydbl last_val, phydbl sum, phydbl sumsq, phydbl sumcurnext, int n)
8928	{
8929	phydbl numerator,denom;
8930	phydbl mean;
8931	phydbl r;
8932
8933	mean = sum / n;
8934	denom = sumsq - n * POW(mean,2);
8935	numerator = sumcurnext - (n+1.)POW(mean,2) + (first_val+last_val)mean;
8936
8937	r = numerator/denom;
8938
8939	return (phydbl)n * (1.-r)/(1.+r);
8940	}
8941
8942	//////////////////////////////////////////////////////////////
8943	//////////////////////////////////////////////////////////////
8944
8945	phydbl Rescale_Br_Len_Multiplier_Tree(t_tree *tree)
8946	{
8947	int i;
8948
8949	if(tree->is_mixt_tree)
8950	{
8951	MIXT_Rescale_Br_Len_Multiplier_Tree(tree);
8952	return(-1.);
8953	}
8954
8955	For(i,2tree->n_otu-1) tree->a_edges[i]->l->v = tree->mod->br_len_multiplier->v;
8956	return(-1.);
8957	}
8958
8959	//////////////////////////////////////////////////////////////
8960	//////////////////////////////////////////////////////////////
8961
8962	phydbl Unscale_Br_Len_Multiplier_Tree(t_tree *tree)
8963	{
8964	int i;
8965
8966	if(tree->is_mixt_tree)
8967	{
8968	MIXT_Unscale_Br_Len_Multiplier_Tree(tree);
8969	return(-1.);
8970	}
8971
8972	For(i,2*tree->n_otu-1) tree->a_edges[i]->l->v /= tree->mod->br_len_multiplier->v;
8973	return(-1.);
8974	}
8975
8976	//////////////////////////////////////////////////////////////
8977	//////////////////////////////////////////////////////////////
8978
8979
8980	phydbl Reflect(phydbl x, phydbl l, phydbl u)
8981	{
8982	int rounds;
8983	phydbl tmp;
8984	int k;
8985
8986	if(u < l)
8987	{
8988	tmp = u;
8989	u = l;
8990	l = tmp;
8991	}
8992
8993	if(x < l) x = x + 2.*(l - x);
8994
8995	if(((x-u) > (u-l)) && (x > u))
8996	{
8997	k = (x - (2.u-l))/(2.(u-l));
8998	x = x - 2.k(u-l);
8999	}
9000
9001	rounds = 0;
9002	do
9003	{
9004	rounds++;
9005	/* printf("\n. l=%f u=%f x=%f",l,u,x); */
9006	if(x > u \|\| x < l)
9007	{
9008	if(x > u) x = x - 2.*(x - u);
9009	else x = x + 2.*(l - x);
9010	}
9011	else break;
9012	/* printf(" x'=%f",x); */
9013	}
9014	while(rounds < 100);
9015
9016	if(rounds == 100 && (x > u \|\| x < l))
9017	{
9018	PhyML_Printf("\n. u=%f l=%f x=%f",u,l,x);
9019	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
9020	Exit("\n");
9021	}
9022
9023	return x;
9024	}
9025
9026	//////////////////////////////////////////////////////////////
9027	//////////////////////////////////////////////////////////////
9028
9029
9030	int Are_Equal(phydbl a, phydbl b, phydbl eps)
9031	{
9032	if(FABS(a-b) < eps) return TRUE; /* a==b */
9033	else return FALSE;
9034	}
9035
9036	//////////////////////////////////////////////////////////////
9037	//////////////////////////////////////////////////////////////
9038
9039	/* Returns 1 if small_tree is displayed by big_tree, 0 otherwise
9040	Does not account for the root positions, if any.
9041	*/
9042	int Check_Topo_Constraints(t_tree big_tree, t_tree small_tree)
9043	{
9044	if(!small_tree) return 1;
9045
9046	if(small_tree->n_otu < 4) return 1;
9047
9048	if(small_tree->n_otu > big_tree->n_otu)
9049	{
9050	PhyML_Printf("\n");
9051	PhyML_Printf("\n. The tree that defines the topological constraints can not");
9052	PhyML_Printf("\n. display more taxa than %d",big_tree->n_otu);
9053	Exit("\n");
9054	}
9055
9056	t_tree *big_tree_cpy;
9057	int diffs,i;
9058
9059	big_tree_cpy = Make_Tree_From_Scratch(big_tree->n_otu,NULL);
9060	Copy_Tree(big_tree,big_tree_cpy);
9061
9062	Prune_Tree(big_tree_cpy,small_tree);
9063
9064	/* For(i,2small_tree->n_otu-3) printf("\nz %d . %d . %d", /
9065	/* big_tree->a_edges[i]->does_exist, */
9066	/* big_tree_cpy->a_edges[i]->does_exist, */
9067	/* small_tree->a_edges[i]->does_exist); */
9068
9069	Free_Bip(small_tree);
9070	Alloc_Bip(small_tree);
9071	Get_Bip(small_tree->a_nodes[0],small_tree->a_nodes[0]->v[0],small_tree);
9072
9073	Free_Bip(big_tree_cpy);
9074	Alloc_Bip(big_tree_cpy);
9075	Match_Tip_Numbers(small_tree,big_tree_cpy);
9076	Get_Bip(big_tree_cpy->a_nodes[0],big_tree_cpy->a_nodes[0]->v[0],big_tree_cpy);
9077
9078	For(i,2*big_tree_cpy->n_otu-3) big_tree_cpy->a_edges[i]->bip_score = 0;
9079	For(i,2*small_tree->n_otu-3) small_tree->a_edges[i]->bip_score = 0;
9080
9081	diffs = Compare_Bip(small_tree,big_tree_cpy,YES);
9082
9083	/* printf("\n"); */
9084	/* printf("\n. %s",Write_Tree(big_tree_cpy,NO)); */
9085	/* printf("\n. %s",Write_Tree(small_tree,NO)); */
9086	/* printf("\n. diffs=%d",diffs); */
9087
9088	Free_Tree(big_tree_cpy);
9089
9090	t_tree *big_tree_cpy_bis;
9091	big_tree_cpy_bis = Make_Tree_From_Scratch(big_tree->n_otu,NULL);
9092	Copy_Tree(big_tree,big_tree_cpy_bis);
9093	Free_Tree(big_tree_cpy_bis);
9094
9095	if(diffs == 0) return 1; /* Constraint is satisfied */
9096	else return 0;
9097	}
9098
9099	//////////////////////////////////////////////////////////////
9100	//////////////////////////////////////////////////////////////
9101
9102	void Prune_Tree(t_tree big_tree, t_tree small_tree)
9103	{
9104	int i,j;
9105	int curr_ext_node, curr_int_node, curr_br, n_pruned_nodes;;
9106	t_node **pruned_nodes;
9107	t_edge **residual_edges;
9108
9109	pruned_nodes = (t_node *)mCalloc(big_tree->n_otu,sizeof(t_node ));
9110	residual_edges = (t_edge *)mCalloc(big_tree->n_otu,sizeof(t_edge ));
9111
9112	n_pruned_nodes = 0;
9113	For(i,big_tree->n_otu)
9114	{
9115	For(j,small_tree->n_otu)
9116	if(!strcmp(small_tree->a_nodes[j]->name,big_tree->a_nodes[i]->name))
9117	break;
9118
9119	if(j == small_tree->n_otu)
9120	{
9121	Prune_Subtree(big_tree->a_nodes[i]->v[0],
9122	big_tree->a_nodes[i],
9123	NULL,&(residual_edges[n_pruned_nodes]),
9124	big_tree);
9125
9126	pruned_nodes[n_pruned_nodes] = big_tree->a_nodes[i];
9127	n_pruned_nodes++;
9128	}
9129	}
9130
9131	if(!n_pruned_nodes)
9132	{
9133	Free(pruned_nodes);
9134	Free(residual_edges);
9135	return;
9136	}
9137
9138	Free(big_tree->t_dir);
9139
9140	big_tree->n_otu -= n_pruned_nodes;
9141
9142	curr_ext_node = 0;
9143	curr_int_node = big_tree->n_otu;
9144	curr_br = 0;
9145	For(i,big_tree->n_otu+n_pruned_nodes)
9146	{
9147	For(j,n_pruned_nodes)
9148	if(!strcmp(pruned_nodes[j]->name,big_tree->a_nodes[i]->name))
9149	break;
9150
9151	if(j == n_pruned_nodes) /* That t_node still belongs to the tree */
9152	{
9153	Reassign_Node_Nums(big_tree->a_nodes[i],big_tree->a_nodes[i]->v[0],
9154	&curr_ext_node,&curr_int_node,big_tree);
9155	break;
9156	}
9157	}
9158
9159	Reassign_Edge_Nums(big_tree->a_nodes[0],big_tree->a_nodes[0]->v[0],&curr_br,big_tree);
9160
9161	big_tree->t_dir = (short int )mCalloc((2big_tree->n_otu-2)(2big_tree->n_otu-2),sizeof(short int));
9162
9163	For(i,n_pruned_nodes)
9164	{
9165	Free_Edge(residual_edges[i]);
9166	Free_Edge(pruned_nodes[i]->b[0]);
9167	Free_Node(pruned_nodes[i]->v[0]);
9168	Free_Node(pruned_nodes[i]);
9169	}
9170
9171	Free(pruned_nodes);
9172	Free(residual_edges);
9173	big_tree->a_edges[2big_tree->n_otu-3] = big_tree->a_edges[2(big_tree->n_otu+n_pruned_nodes)-3];
9174	big_tree->a_nodes[2big_tree->n_otu-2] = big_tree->a_nodes[2(big_tree->n_otu+n_pruned_nodes)-2];
9175
9176	}
9177
9178	//////////////////////////////////////////////////////////////
9179	//////////////////////////////////////////////////////////////
9180
9181	/* For every node in small_tree, find which node in big_tree
9182	it corresponds to and initialize the variable match_node
9183	accordingly (vice versa for big_tree)
9184	*/
9185	void Match_Nodes_In_Small_Tree(t_tree small_tree, t_tree big_tree)
9186	{
9187	int i,j,k,l,m,n,identical;
9188	int *score;
9189
9190	if(small_tree->n_otu > big_tree->n_otu)
9191	{
9192	PhyML_Printf("\n. small_tree->n_otu=%d big_tree->n_otu=%d",small_tree->n_otu,big_tree->n_otu);
9193	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
9194	Exit("\n");
9195	}
9196
9197	Free_Bip(big_tree);
9198	Alloc_Bip(big_tree);
9199	Get_Bip(big_tree->a_nodes[0],big_tree->a_nodes[0]->v[0],big_tree);
9200
9201	Free_Bip(small_tree);
9202	Alloc_Bip(small_tree);
9203	Get_Bip(small_tree->a_nodes[0],small_tree->a_nodes[0]->v[0],small_tree);
9204
9205	if(!Check_Topo_Constraints(big_tree,small_tree))
9206	{
9207	PhyML_Printf("\n. small_tree and big_tree cannot have distinct topologies.");
9208	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
9209	Exit("\n");
9210	}
9211
9212	For(i,2*small_tree->n_otu-1) small_tree->a_nodes[i]->match_node = NULL;
9213	For(i,2*big_tree->n_otu-1) big_tree->a_nodes[i]->match_node = NULL;
9214
9215	score = (int *)mCalloc(3,sizeof(int));
9216
9217	For(i,small_tree->n_otu)
9218	{
9219	For(j,big_tree->n_otu)
9220	{
9221	if(!strcmp(small_tree->a_nodes[i]->name,big_tree->a_nodes[j]->name))
9222	{
9223	small_tree->a_nodes[i]->match_node = big_tree->a_nodes[j];
9224	big_tree->a_nodes[j]->match_node = small_tree->a_nodes[i];
9225	break;
9226	}
9227	}
9228	}
9229
9230	For(i,2*small_tree->n_otu-2)
9231	{
9232	if(small_tree->a_nodes[i]->tax == NO)
9233	{
9234	For(j,2*big_tree->n_otu-2)
9235	{
9236	if(big_tree->a_nodes[j]->tax == NO)
9237	{
9238	For(k,3) score[k] = 0;
9239
9240	For(k,3)
9241	{
9242	For(l,3)
9243	{
9244	identical = 0;
9245	For(m,small_tree->a_nodes[i]->bip_size[k])
9246	{
9247	For(n,big_tree->a_nodes[j]->bip_size[l])
9248	{
9249	if(!strcmp(small_tree->a_nodes[i]->bip_node[k][m]->name,big_tree->a_nodes[j]->bip_node[l][n]->name))
9250	{
9251	identical++;
9252	break;
9253	}
9254	}
9255	}
9256	if(identical == small_tree->a_nodes[i]->bip_size[k])
9257	{
9258	score[k]++;
9259	}
9260	}
9261	}
9262
9263	/* printf("\n. [%d] [%d] %d %d %d -- %d %d %d",i,j, */
9264	/* score[0],score[1],score[2], */
9265	/* small_tree->a_nodes[i]->bip_size[0], */
9266	/* small_tree->a_nodes[i]->bip_size[1], */
9267	/* small_tree->a_nodes[i]->bip_size[2]); */
9268
9269	if(
9270	score[0] == 1 &&
9271	score[1] == 1 &&
9272	score[2] == 1
9273	)
9274	{
9275	small_tree->a_nodes[i]->match_node = big_tree->a_nodes[j];
9276	big_tree->a_nodes[j]->match_node = small_tree->a_nodes[i];
9277	break;
9278	}
9279	}
9280	}
9281	}
9282	}
9283
9284	Free(score);
9285	}
9286
9287	//////////////////////////////////////////////////////////////
9288	//////////////////////////////////////////////////////////////
9289
9290
9291	void Find_Surviving_Edges_In_Small_Tree(t_tree small_tree, t_tree big_tree)
9292	{
9293	int i;
9294
9295	Match_Nodes_In_Small_Tree(small_tree,big_tree);
9296
9297	For(i,2*small_tree->n_otu-1) small_tree->rates->has_survived[i] = NO;
9298
9299	Find_Surviving_Edges_In_Small_Tree_Post(big_tree->n_root,big_tree->n_root->v[2],small_tree,big_tree);
9300	Find_Surviving_Edges_In_Small_Tree_Post(big_tree->n_root,big_tree->n_root->v[1],small_tree,big_tree);
9301	}
9302
9303	//////////////////////////////////////////////////////////////
9304	//////////////////////////////////////////////////////////////
9305
9306
9307	void Find_Surviving_Edges_In_Small_Tree_Post(t_node a, t_node d, t_tree small_tree, t_tree big_tree)
9308	{
9309	if(d->match_node && !a->match_node)
9310	{
9311	small_tree->rates->has_survived[d->match_node->num] = YES;
9312	}
9313
9314	if(d->tax == YES) return;
9315	else
9316	{
9317	int i;
9318
9319	For(i,3)
9320	{
9321	if(d->v[i] != a && d->b[i] != big_tree->e_root)
9322	{
9323	Find_Surviving_Edges_In_Small_Tree_Post(d,d->v[i],small_tree,big_tree);
9324	}
9325	}
9326	}
9327	}
9328
9329	//////////////////////////////////////////////////////////////
9330	//////////////////////////////////////////////////////////////
9331
9332
9333	void Set_Taxa_Id_Ranking(t_tree *tree)
9334	{
9335	int i,j;
9336
9337	For(i,tree->n_otu) tree->a_nodes[i]->id_rank = 0;
9338
9339	For(i,tree->n_otu)
9340	{
9341	for(j=i+1;j<tree->n_otu;j++)
9342	{
9343	if(strcmp(tree->a_nodes[i]->name,tree->a_nodes[j]->name) > 0)
9344	tree->a_nodes[i]->id_rank++;
9345	else
9346	tree->a_nodes[j]->id_rank++;
9347	}
9348	}
9349	/* For(i,tree->n_otu) PhyML_Printf("\n. %20s %4d",tree->a_nodes[i]->name,tree->a_nodes[i]->id_rank); */
9350	}
9351
9352	//////////////////////////////////////////////////////////////
9353	//////////////////////////////////////////////////////////////
9354
9355
9356	void Get_Edge_Binary_Coding_Number(t_tree *tree)
9357	{
9358	int i,j;
9359	int list_size;
9360	t_node **list;
9361	t_edge *b;
9362	int max_left,max_rght;
9363
9364	if(tree->n_otu > 1000)
9365	{
9366	PhyML_Printf("\n. Can't work out edge binary code if the number of taxa >1000.");
9367	PhyML_Printf("\n. Err in file %s at line %d\n",__FILE__,__LINE__);
9368	Warn_And_Exit("");
9369	}
9370
9371	Free_Bip(tree);
9372	Alloc_Bip(tree);
9373	Get_Bip(tree->a_nodes[0],tree->a_nodes[0]->v[0],tree);
9374
9375	Set_Taxa_Id_Ranking(tree);
9376
9377	b = NULL;
9378	For(i,2*tree->n_otu-3)
9379	{
9380	b = tree->a_edges[i];
9381
9382	max_left = 0;
9383	For(j,b->left->bip_size[b->l_r])
9384	if(b->left->bip_node[b->l_r][j]->id_rank > max_left)
9385	max_left = b->left->bip_node[b->l_r][j]->id_rank;
9386
9387	max_rght = 0;
9388	For(j,b->rght->bip_size[b->r_l])
9389	if(b->rght->bip_node[b->r_l][j]->id_rank > max_rght)
9390	max_rght = b->rght->bip_node[b->r_l][j]->id_rank;
9391
9392
9393	if(max_left < max_rght)
9394	{
9395	list = b->left->bip_node[b->l_r];
9396	list_size = b->left->bip_size[b->l_r];
9397	}
9398	else
9399	{
9400	list = b->rght->bip_node[b->r_l];
9401	list_size = b->rght->bip_size[b->r_l];
9402	}
9403
9404	b->bin_cod_num = 0.;
9405	For(j,list_size) b->bin_cod_num += POW(2,list[j]->id_rank);
9406	/* printf("\n. %f",b->bin_cod_num); */
9407	}
9408	}
9409
9410	//////////////////////////////////////////////////////////////
9411	//////////////////////////////////////////////////////////////
9412
9413
9414	void Make_Ancestral_Seq(t_tree *tree)
9415	{
9416	int i;
9417	char **sp_names;
9418
9419	sp_names = (char *)mCalloc(tree->n_otu,sizeof(char ));
9420	For(i,tree->n_otu-1)
9421	{
9422	sp_names[i] = (char *)mCalloc(10,sizeof(char));
9423	sprintf(sp_names[i],"anc%d",i+tree->n_otu);
9424	}
9425
9426	tree->anc_data = Make_Cseq(tree->n_otu-1,
9427	tree->data->init_len,
9428	tree->mod->io->state_len,
9429	tree->data->init_len,
9430	sp_names);
9431
9432	For(i,tree->n_otu-1) Free(sp_names[i]);
9433	Free(sp_names);
9434	}
9435
9436	//////////////////////////////////////////////////////////////
9437	//////////////////////////////////////////////////////////////
9438
9439	void Make_MutMap(t_tree *tree)
9440	{
9441	// (# of edges) X (# of sites) X (# mutation types: A<->C A<->G A<->T C<->G C<->T G<->T)
9442	tree->mutmap = (int )mCalloc((2tree->n_otu-3)(tree->n_pattern)6,sizeof(int));
9443	}
9444
9445	//////////////////////////////////////////////////////////////
9446	//////////////////////////////////////////////////////////////
9447
9448	int Get_Mutmap_Val(int edge, int site, int mut, t_tree *tree)
9449	{
9450	int dim1,dim2;
9451
9452	dim1 = (tree->n_pattern)(2tree->n_otu-3);
9453	dim2 = (tree->n_pattern);
9454
9455	return tree->mutmap[mutdim1 + edgedim2 + site];
9456	}
9457
9458	//////////////////////////////////////////////////////////////
9459	//////////////////////////////////////////////////////////////
9460
9461	void Get_Mutmap_Coord(int idx, int edge, int site, int mut, t_tree tree)
9462	{
9463	int dim1,dim2;
9464
9465	dim1 = (tree->n_pattern)(2tree->n_otu-3);
9466	dim2 = (tree->n_pattern);
9467
9468	(*mut) = (int)idx/dim1;
9469	(edge) = (int)(idx - (mut)*dim1)/dim2;
9470	(site) = (int)(idx - (mut)dim1 - (edge)*dim2);
9471	}
9472
9473	//////////////////////////////////////////////////////////////
9474	//////////////////////////////////////////////////////////////
9475
9476	//////////////////////////////////////////////////////////////
9477	//////////////////////////////////////////////////////////////
9478
9479	void Copy_Edge_Lengths(t_tree to, t_tree from)
9480	{
9481	int i;
9482	For(i,2*from->n_otu-1) to->a_edges[i]->l->v = from->a_edges[i]->l->v;
9483	}
9484
9485	//////////////////////////////////////////////////////////////
9486	//////////////////////////////////////////////////////////////
9487	//////////////////////////////////////////////////////////////
9488	//////////////////////////////////////////////////////////////
9489
9490	char To_Lower_String(char in)
9491	{
9492	char *out;
9493	int i;
9494	int len;
9495
9496	len = (int)strlen(in);
9497
9498	out = (char *)mCalloc(len+1,sizeof(char));
9499
9500	For(i,len) out[i] = (char)tolower(in[i]);
9501
9502	out[len] = '\0';
9503	return(out);
9504	}
9505
9506	//////////////////////////////////////////////////////////////
9507	//////////////////////////////////////////////////////////////
9508
9509	char To_Upper_String(char in)
9510	{
9511	char *out;
9512	int i;
9513	int len;
9514
9515	len = (int)strlen(in);
9516
9517	out = (char *)mCalloc(len+1,sizeof(char));
9518
9519	For(i,len)
9520	{
9521	out[i] = (char)toupper(in[i]);
9522	}
9523
9524	out[len] = '\0';
9525	return(out);
9526	}
9527
9528	//////////////////////////////////////////////////////////////
9529	//////////////////////////////////////////////////////////////
9530
9531	void Connect_CSeqs_To_Nodes(calign cdata, t_tree tree)
9532	{
9533	int i,j,n_otu_tree,n_otu_cdata;
9534
9535	n_otu_tree = tree->n_otu;
9536	n_otu_cdata = cdata->n_otu;
9537
9538	if((n_otu_tree != n_otu_cdata) && (tree->io->fp_in_constraint_tree == NULL))
9539	{
9540	PhyML_Printf("\n== Number of taxa in the tree: %d, number of sequences: %d.",n_otu_tree,n_otu_cdata);
9541	Warn_And_Exit("\n== The number of tips in the tree is not the same as the number of sequences\n");
9542	}
9543
9544	For(i,MAX(n_otu_tree,n_otu_cdata))
9545	{
9546	For(j,MIN(n_otu_tree,n_otu_cdata))
9547	{
9548	if(!strcmp(tree->a_nodes[i]->name,cdata->c_seq[j]->name))
9549	break;
9550	}
9551
9552	if(j==MIN(n_otu_tree,n_otu_cdata))
9553	{
9554	PhyML_Printf("\n== Taxon '%s' was not found in sequence file '%s'.\n",
9555	tree->a_nodes[i]->name,
9556	tree->io->in_align_file);
9557	Exit("\n");
9558	}
9559
9560	tree->a_nodes[i]->c_seq = cdata->c_seq[j];
9561
9562	}
9563	}
9564
9565	//////////////////////////////////////////////////////////////
9566	//////////////////////////////////////////////////////////////
9567
9568	void Switch_Eigen(int state, t_mod *mod)
9569	{
9570	t_mod *buff;
9571
9572	buff = mod;
9573	do
9574	{
9575	buff->update_eigen = state;
9576	buff = buff->next;
9577	if(!buff) break;
9578	}
9579	while(1);
9580	}
9581
9582	//////////////////////////////////////////////////////////////
9583	//////////////////////////////////////////////////////////////
9584
9585	void Set_Both_Sides(int yesno, t_tree *mixt_tree)
9586	{
9587	t_tree *tree;
9588
9589	tree = mixt_tree;
9590
9591	do
9592	{
9593	tree->both_sides = yesno;
9594	tree = tree->next;
9595	}
9596	while(tree);
9597
9598	}
9599
9600	//////////////////////////////////////////////////////////////
9601	//////////////////////////////////////////////////////////////
9602	// Returns the matrix of pairwise distances between tips
9603	phydbl Dist_Btw_Tips(t_tree tree)
9604	{
9605	int i,j;
9606	phydbl *dist;
9607
9608	dist = (phydbl )mCalloc(tree->n_otutree->n_otu,sizeof(phydbl));
9609
9610	Fill_Dir_Table(tree);
9611	Update_Dirs(tree);
9612
9613	For(i,tree->n_otu-1)
9614	{
9615	for(j=i+1;j<tree->n_otu;j++)
9616	{
9617	Path_Length(tree->a_nodes[i],tree->a_nodes[j],dist+i*tree->n_otu+j,tree);
9618	dist[jtree->n_otu+i] = dist[itree->n_otu+j];
9619	}
9620	}
9621
9622
9623	return(dist);
9624
9625	}
9626
9627	//////////////////////////////////////////////////////////////
9628	//////////////////////////////////////////////////////////////
9629
9630	void Random_SPRs_On_Rooted_Tree(t_tree *tree)
9631	{
9632	int i,j;
9633	t_node a, d, v1, v2,*target_nd;
9634	phydbl u;
9635	phydbl lim_sup,lim_inf;
9636	t_edge residual,nouse;
9637	phydbl new_t;
9638	int err;
9639	int ok_dir,dir12,dir21;
9640
9641	/* printf("\n. >>>>>>>>>>>>>>.\n"); */
9642	/* Print_Node(tree->n_root,tree->n_root->v[1],tree); */
9643	/* Print_Node(tree->n_root,tree->n_root->v[2],tree); */
9644	/* printf("\n. >>>>>>>>>>>>>>."); */
9645	/* GEO_Update_Occup(tree->geo,tree); */
9646	/* GEO_Lk(tree->geo,tree); */
9647	/* PhyML_Printf("\n>> Init loglk: %f",tree->geo->c_lnL); */
9648
9649
9650	target_nd = NULL;
9651	residual = NULL;
9652	nouse = NULL;
9653	a = d = v1 = v2 = NULL;
9654	For(i,tree->n_otu) // We will perform tree->n_otu random SPRs
9655	{
9656	a = tree->a_nodes[Rand_Int(tree->n_otu,2*tree->n_otu-3)];
9657
9658	if(a == tree->n_root)
9659	{
9660	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
9661	Exit("\n");
9662	}
9663	/* if(a == tree->n_root->v[1] \|\| a == tree->n_root->v[2]) continue; */
9664
9665	v1 = v2 = NULL;
9666	For(j,3)
9667	{
9668	if(a->v[j] != a->anc && a->b[j] != tree->e_root)
9669	{
9670	if(!v1) v1 = a->v[j];
9671	else v2 = a->v[j];
9672	}
9673	}
9674
9675	u = Uni();
9676	if(u < .5) d = v1;
9677	else d = v2;
9678
9679
9680	For(j,3) if(a->v[j] == d && a->b[j] == tree->e_root) break;
9681	if(j != 3) continue;
9682
9683	lim_sup = tree->rates->nd_t[d->num];
9684	lim_inf = tree->rates->nd_t[tree->n_root->num];
9685
9686	phydbl scale = Uni()*(50.-5.)+5.;
9687	scale = 50;
9688	err = NO;
9689	new_t = Rnorm_Trunc(tree->rates->nd_t[a->num],
9690	FABS(tree->rates->nd_t[tree->n_root->num]/scale),
9691	lim_inf,
9692	lim_sup,
9693	&err);
9694
9695
9696	if(err == YES)
9697	{
9698	PhyML_Printf("\n== Err in file %s at line %d\n",__FILE__,__LINE__);
9699	Exit("\n");
9700	}
9701
9702	if(new_t < tree->rates->nd_t[a->num])
9703	{
9704	target_nd = a;
9705	do
9706	{
9707	if(tree->rates->nd_t[target_nd->anc->num] < new_t)
9708	{
9709	if(target_nd == a)
9710	{
9711	if(v1 == d) target_nd = v2;
9712	else target_nd = v1;
9713	}
9714	break;
9715	}
9716	else
9717	{
9718	target_nd = target_nd->anc;
9719	}
9720	}
9721	while(1);
9722	}
9723	else
9724	{
9725	if(v1 == d) target_nd = v2;
9726	else target_nd = v1;
9727
9728	do
9729	{
9730	if(tree->rates->nd_t[target_nd->num] > new_t)
9731	{
9732	break;
9733	}
9734	else
9735	{
9736	v1 = v2 = NULL;
9737	For(j,3)
9738	{
9739	if(target_nd->v[j] != target_nd->anc)
9740	{
9741	if(!v1) v1 = target_nd->v[j];
9742	else v2 = target_nd->v[j];
9743	}
9744	}
9745	u = Uni();
9746	if(u < 0.5) target_nd = v1;
9747	else target_nd = v2;
9748	}
9749	}while(1);
9750	}
9751
9752	ok_dir = -1;
9753	For(j,3) if(target_nd->v[j] == target_nd->anc \|\| target_nd->b[j] == tree->e_root) ok_dir = j;
9754
9755	dir12 = -1;
9756	For(j,3) if(tree->n_root->v[1]->v[j] == tree->n_root->v[2]) dir12 = j;
9757
9758	if(dir12 == -1)
9759	{
9760	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
9761	Exit("\n");
9762	}
9763
9764	dir21 = -1;
9765	For(j,3) if(tree->n_root->v[2]->v[j] == tree->n_root->v[1]) dir21 = j;
9766
9767	if(dir21 == -1)
9768	{
9769	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
9770	Exit("\n");
9771	}
9772
9773
9774
9775	/* a = tree->a_nodes[101]; */
9776	/* d = tree->a_nodes[105]; */
9777	/* target_nd = tree->a_nodes[105]; */
9778	/* printf("\n pull %d %d target %d",a->num,d->num,target_nd->num); */
9779	/* printf("\n. %d %d %d",tree->n_root->num,tree->n_root->v[1]->num,tree->n_root->v[2]->num); */
9780	/* printf("\n. %d %d",tree->e_root->num,target_nd->b[ok_dir]->num); */
9781
9782	Prune_Subtree(a,d,&nouse,&residual,tree);
9783
9784	Graft_Subtree(target_nd->b[ok_dir],a,residual,tree);
9785
9786	tree->rates->nd_t[a->num] = new_t;
9787
9788	if(target_nd == tree->n_root->v[1])
9789	{
9790	tree->n_root->v[1] = a;
9791	tree->e_root = tree->n_root->v[2]->b[dir21];
9792	}
9793
9794	if(target_nd == tree->n_root->v[2])
9795	{
9796	tree->n_root->v[2] = a;
9797	tree->e_root = tree->n_root->v[1]->b[dir12];
9798	}
9799
9800	if(tree->n_root->v[1] == NULL)
9801	{
9802	tree->n_root->v[1] = tree->n_root->v[2]->v[dir21];
9803	tree->e_root = tree->n_root->v[2]->b[dir21];
9804	}
9805
9806	if(tree->n_root->v[2] == NULL)
9807	{
9808	tree->n_root->v[2] = tree->n_root->v[1]->v[dir12];
9809	tree->e_root = tree->n_root->v[1]->b[dir12];
9810	}
9811
9812	Update_Ancestors(tree->n_root,tree->n_root->v[2],tree);
9813	Update_Ancestors(tree->n_root,tree->n_root->v[1],tree);
9814	tree->n_root->anc = NULL;
9815
9816	/* Print_Node(tree->n_root,tree->n_root->v[1],tree); */
9817	/* Print_Node(tree->n_root,tree->n_root->v[2],tree); */
9818
9819	Time_To_Branch(tree);
9820
9821	/* GEO_Update_Occup(tree->geo,tree); */
9822	/* GEO_Lk(tree->geo,tree); */
9823	/* PhyML_Printf("\nxx Init loglk: %f",tree->geo->c_lnL); */
9824
9825	}
9826
9827
9828	}
9829
9830	//////////////////////////////////////////////////////////////
9831	//////////////////////////////////////////////////////////////
9832
9833	/* \|
9834	\|
9835	\|d
9836	/ \
9837	/ \
9838	/ \b
9839	/ \
9840	/ \x
9841
9842	Returns p_lk and sum_scale for subtree with x as root, Pij for edge b
9843	*/
9844
9845	void Set_P_Lk_One_Side(phydbl Pij, phydbl p_lk, int *sum_scale, t_node d, t_edge b, t_tree tree)
9846	{
9847	if(Pij) *Pij = b->Pij_rr;
9848
9849	if(!d->tax)
9850	{
9851	if(d == b->left)
9852	{
9853	*p_lk = b->p_lk_rght;
9854	*sum_scale = b->sum_scale_rght;
9855	}
9856	else
9857	{
9858	*p_lk = b->p_lk_left;
9859	*sum_scale = b->sum_scale_left;
9860	}
9861	}
9862	else
9863	{
9864
9865	*p_lk = NULL;
9866	*sum_scale = NULL;
9867	}
9868	}
9869
9870	//////////////////////////////////////////////////////////////
9871	//////////////////////////////////////////////////////////////
9872
9873	/* \|
9874	\|
9875	\|b
9876	\|
9877	\|d
9878	/ \
9879	/ \
9880	/ \
9881	/ \
9882	/v1 \v2
9883
9884	Set p_lk and sum_scale for subtrees with d, v1 and v2 as root,
9885	Pij for edges b, and the two edges connecting d to v1 and d to
9886	v2;
9887	Account for rooted trees.
9888	*/
9889
9890	void Set_All_P_Lk(t_node n_v1, t_node n_v2,
9891	phydbl p_lk , int sum_scale , int **p_lk_loc,
9892	phydbl Pij1, phydbl p_lk_v1, int **sum_scale_v1,
9893	phydbl Pij2, phydbl p_lk_v2, int **sum_scale_v2,
9894	t_node d, t_edge b, t_tree *tree)
9895	{
9896	int i;
9897
9898
9899	if(!tree->n_root)
9900	{
9901	if(d == b->left)
9902	{
9903	*p_lk = b->p_lk_left;
9904	*sum_scale = b->sum_scale_left;
9905	*p_lk_loc = b->p_lk_loc_left;
9906	}
9907	else
9908	{
9909	*p_lk = b->p_lk_rght;
9910	*sum_scale = b->sum_scale_rght;
9911	*p_lk_loc = b->p_lk_loc_rght;
9912	}
9913
9914	n_v1 = n_v2 = NULL;
9915	For(i,3)
9916	{
9917	if(d->b[i] != b)
9918	{
9919	if(!(*n_v1))
9920	{
9921	*n_v1 = d->v[i];
9922	Set_P_Lk_One_Side(Pij1,p_lk_v1,sum_scale_v1,d,d->b[i],tree);
9923	}
9924	else
9925	{
9926	*n_v2 = d->v[i];
9927	Set_P_Lk_One_Side(Pij2,p_lk_v2,sum_scale_v2,d,d->b[i],tree);
9928	}
9929	}
9930	}
9931	}
9932	else
9933	{
9934	if(b == tree->e_root)
9935	{
9936	if(d == tree->n_root->v[1]) b = tree->n_root->b[1];
9937	else if(d == tree->n_root->v[2]) b = tree->n_root->b[2];
9938	else
9939	{
9940	PhyML_Printf("\n== Err. in file %s at line %d.",__FILE__,__LINE__);
9941	Warn_And_Exit("\n");
9942	}
9943	}
9944
9945	if(d == tree->n_root)
9946	{
9947	if(b == tree->n_root->b[1])
9948	{
9949	*p_lk = tree->n_root->b[1]->p_lk_left;
9950	*sum_scale = tree->n_root->b[1]->sum_scale_left;
9951	*p_lk_loc = tree->n_root->b[1]->p_lk_loc_left;
9952	}
9953	else
9954	{
9955	*p_lk = tree->n_root->b[2]->p_lk_left;
9956	*sum_scale = tree->n_root->b[2]->sum_scale_left;
9957	*p_lk_loc = tree->n_root->b[2]->p_lk_loc_left;
9958	}
9959
9960	*n_v1 = NULL;
9961	*Pij1 = NULL;
9962	*p_lk_v1 = NULL;
9963	*sum_scale_v1 = NULL;
9964
9965	if(b == tree->n_root->b[1])
9966	{
9967	*n_v2 = tree->n_root->v[2];
9968	*Pij2 = tree->n_root->b[2]->Pij_rr;
9969	*p_lk_v2 = tree->n_root->b[2]->p_lk_rght;
9970	*sum_scale_v2 = tree->n_root->b[2]->sum_scale_rght;
9971	}
9972	else if(b == tree->n_root->b[2])
9973	{
9974	*n_v2 = tree->n_root->v[1];
9975	*Pij2 = tree->n_root->b[1]->Pij_rr;
9976	*p_lk_v2 = tree->n_root->b[1]->p_lk_rght;
9977	*sum_scale_v2 = tree->n_root->b[1]->sum_scale_rght;
9978	}
9979	else
9980	{
9981	PhyML_Printf("\n== Err. in file %s at line %d.",__FILE__,__LINE__);
9982	Warn_And_Exit("\n");
9983	}
9984	}
9985	else if(d == tree->n_root->v[1] \|\| d == tree->n_root->v[2])
9986	{
9987	if(b == tree->n_root->b[1] \|\| b == tree->n_root->b[2])
9988	{
9989	if(b == tree->n_root->b[1])
9990	{
9991	*p_lk = tree->n_root->b[1]->p_lk_rght;
9992	*sum_scale = tree->n_root->b[1]->sum_scale_rght;
9993	*p_lk_loc = tree->n_root->b[1]->p_lk_loc_left;
9994	}
9995	else
9996	{
9997	*p_lk = tree->n_root->b[2]->p_lk_rght;
9998	*sum_scale = tree->n_root->b[2]->sum_scale_rght;
9999	*p_lk_loc = tree->n_root->b[2]->p_lk_loc_rght;
10000	}
10001
10002
10003	n_v1 = n_v2 = NULL;
10004	For(i,3)
10005	{
10006	if(d->b[i] != tree->e_root)
10007	{
10008	if(!(*n_v1))
10009	{
10010	*n_v1 = d->v[i];
10011	Set_P_Lk_One_Side(Pij1,p_lk_v1,sum_scale_v1,d,d->b[i],tree);
10012	}
10013	else
10014	{
10015	*n_v2 = d->v[i];
10016	Set_P_Lk_One_Side(Pij2,p_lk_v2,sum_scale_v2,d,d->b[i],tree);
10017	}
10018	}
10019	}
10020	}
10021	else
10022	{
10023	if(d == b->left)
10024	{
10025	*p_lk = b->p_lk_left;
10026	*sum_scale = b->sum_scale_left;
10027	*p_lk_loc = b->p_lk_loc_left;
10028	}
10029	else
10030	{
10031	*p_lk = b->p_lk_rght;
10032	*sum_scale = b->sum_scale_rght;
10033	*p_lk_loc = b->p_lk_loc_rght;
10034	}
10035
10036
10037	*n_v1 = tree->n_root;
10038	Set_P_Lk_One_Side(Pij1,p_lk_v1,sum_scale_v1,d,
10039	(d == tree->n_root->v[1])?
10040	(tree->n_root->b[1]):
10041	(tree->n_root->b[2]),
10042	tree);
10043
10044	For(i,3)
10045	{
10046	if(d->b[i] != tree->e_root && d->b[i] != b)
10047	{
10048	*n_v2 = d->v[i];
10049	Set_P_Lk_One_Side(Pij2,p_lk_v2,sum_scale_v2,d,d->b[i],tree);
10050	break;
10051	}
10052	}
10053
10054	}
10055	}
10056	else
10057	{
10058	if(d == b->left)
10059	{
10060	*p_lk = b->p_lk_left;
10061	*sum_scale = b->sum_scale_left;
10062	*p_lk_loc = b->p_lk_loc_left;
10063	}
10064	else
10065	{
10066	*p_lk = b->p_lk_rght;
10067	*sum_scale = b->sum_scale_rght;
10068	*p_lk_loc = b->p_lk_loc_rght;
10069	}
10070
10071	n_v1 = n_v2 = NULL;
10072	For(i,3)
10073	{
10074	if(d->b[i] != b)
10075	{
10076	if(!(*n_v1))
10077	{
10078	*n_v1 = d->v[i];
10079	Set_P_Lk_One_Side(Pij1,p_lk_v1,sum_scale_v1,d,d->b[i],tree);
10080	}
10081	else
10082	{
10083	*n_v2 = d->v[i];
10084	Set_P_Lk_One_Side(Pij2,p_lk_v2,sum_scale_v2,d,d->b[i],tree);
10085	}
10086	}
10087	}
10088	}
10089	}
10090	}
10091
10092	//////////////////////////////////////////////////////////////
10093	//////////////////////////////////////////////////////////////
10094
10095	void Optimum_Root_Position_IL_Model(t_tree *tree)
10096	{
10097
10098	if(tree->n_root)
10099	{
10100	PhyML_Printf("\n== The tree already has a root node");
10101	PhyML_Printf("\n== Err. in file %s at line %d\n",__FILE__,__LINE__);
10102	Exit("\n");
10103	}
10104	else
10105	{
10106	int i;
10107	t_edge *best_edge;
10108	phydbl best_lnL;
10109
10110	Free_Edge_Lk_Rght(tree->a_edges[2*tree->n_otu-3]);
10111	Free_Edge_Lk_Rght(tree->a_edges[2*tree->n_otu-2]);
10112	Free_Edge_Pars_Rght(tree->a_edges[2*tree->n_otu-3]);
10113	Free_Edge_Pars_Rght(tree->a_edges[2*tree->n_otu-2]);
10114
10115	best_edge = NULL;
10116	best_lnL = UNLIKELY;
10117	For(i,2*tree->n_otu-3)
10118	{
10119	PhyML_Printf("\n. Positionning root node on edge %4d",tree->a_edges[i]->num);
10120	Add_Root(tree->a_edges[i],tree);
10121	Set_Both_Sides(YES,tree);
10122	Lk(NULL,tree);
10123
10124	/* Optimize_Br_Len_Serie(tree); */
10125
10126	Update_P_Lk(tree,tree->n_root->b[1],tree->n_root);
10127	Br_Len_Brent(tree->mod->l_min,tree->mod->l_max,tree->n_root->b[1],tree);
10128	Update_P_Lk(tree,tree->n_root->b[2],tree->n_root);
10129	Br_Len_Brent(tree->mod->l_min,tree->mod->l_max,tree->n_root->b[2],tree);
10130
10131	PhyML_Printf(" -- lnL: %20f",tree->c_lnL);
10132	if(tree->c_lnL > best_lnL)
10133	{
10134	best_lnL = tree->c_lnL;
10135	best_edge = tree->a_edges[i];
10136	}
10137	}
10138
10139	Add_Root(best_edge,tree);
10140	Set_Both_Sides(YES,tree);
10141	Lk(NULL,tree);
10142	Update_P_Lk(tree,tree->n_root->b[1],tree->n_root);
10143	Br_Len_Brent(tree->mod->l_min,tree->mod->l_max,tree->n_root->b[1],tree);
10144	Update_P_Lk(tree,tree->n_root->b[2],tree->n_root);
10145	Br_Len_Brent(tree->mod->l_min,tree->mod->l_max,tree->n_root->b[2],tree);
10146	}
10147	}
10148
10149	//////////////////////////////////////////////////////////////
10150	//////////////////////////////////////////////////////////////
10151
10152	void Set_Br_Len_Var(t_tree *tree)
10153	{
10154	if(tree->is_mixt_tree)
10155	{
10156	MIXT_Set_Br_Len_Var(tree);
10157	return;
10158	}
10159
10160	if(!tree->rates)
10161	{
10162	int i;
10163	phydbl len;
10164
10165	For(i,2*tree->n_otu-1)
10166	{
10167	/* len = MAX(tree->mod->l_min,tree->a_edges[i]->l->v); */
10168	/* len = MIN(tree->mod->l_max,len); */
10169	len = MAX(0.0,tree->a_edges[i]->l->v);
10170	tree->a_edges[i]->l_var->v = POW(len,2)*tree->mod->l_var_sigma;
10171	}
10172	}
10173	}
10174
10175	//////////////////////////////////////////////////////////////
10176	//////////////////////////////////////////////////////////////
10177
10178	void Check_Br_Lens(t_tree *tree)
10179	{
10180	int i;
10181	scalar_dbl *l;
10182
10183	For(i,2*tree->n_otu-1)
10184	{
10185	l = tree->a_edges[i]->l;
10186	do
10187	{
10188	/* if(l->v < tree->mod->l_min) l->v = tree->mod->l_min; */
10189	/* if(l->v > tree->mod->l_max) l->v = tree->mod->l_max; */
10190	if(l->v < 0.0) l->v = 0.0;
10191	l = l->next;
10192	}
10193	while(l);
10194	}
10195	}
10196
10197	//////////////////////////////////////////////////////////////
10198	//////////////////////////////////////////////////////////////
10199
10200	//////////////////////////////////////////////////////////////
10201	//////////////////////////////////////////////////////////////
10202
10203	//////////////////////////////////////////////////////////////
10204	//////////////////////////////////////////////////////////////
10205
10206	//////////////////////////////////////////////////////////////
10207	//////////////////////////////////////////////////////////////
10208
10209	//////////////////////////////////////////////////////////////
10210	//////////////////////////////////////////////////////////////
10211
10212	//////////////////////////////////////////////////////////////
10213	//////////////////////////////////////////////////////////////
10214
10215	//////////////////////////////////////////////////////////////
10216	//////////////////////////////////////////////////////////////
10217
10218

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: branches/species/GDE/PHYML20130708/phyml/src/utilities.c

Download in other formats: