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 "free.h"
14
15
16 //////////////////////////////////////////////////////////////
17 //////////////////////////////////////////////////////////////
18
Free_Clade(t_clad * this)19 void Free_Clade(t_clad *this)
20 {
21 Free(this);
22 }
23
24 //////////////////////////////////////////////////////////////
25 //////////////////////////////////////////////////////////////
26
Free_All_Nodes_Light(t_tree * mixt_tree)27 void Free_All_Nodes_Light(t_tree *mixt_tree)
28 {
29 int i;
30 t_tree *tree;
31
32 tree = mixt_tree;
33 do
34 {
35 for(i=0;i<2*tree->n_otu-1;++i) if(tree->a_nodes[i] != NULL) Free_Node(tree->a_nodes[i]);
36 Free(tree->a_nodes);
37 tree = tree->next;
38 }
39 while(tree);
40
41 }
42
43 //////////////////////////////////////////////////////////////
44 //////////////////////////////////////////////////////////////
45
Free_All_Edges_Light(t_tree * mixt_tree)46 void Free_All_Edges_Light(t_tree *mixt_tree)
47 {
48 int i;
49 t_tree *tree;
50
51 tree = mixt_tree;
52
53 for(i=0;i<2*tree->n_otu-1;++i)
54 {
55 if(tree->a_edges[i] != NULL)
56 {
57 Free_Scalar_Dbl(tree->a_edges[i]->l);
58 Free_Scalar_Dbl(tree->a_edges[i]->l_old);
59 Free_Scalar_Dbl(tree->a_edges[i]->l_var);
60 Free_Scalar_Dbl(tree->a_edges[i]->l_var_old);
61 }
62 }
63
64 do
65 {
66 for(i=0;i<2*tree->n_otu-1;++i)
67 if(tree->a_edges[i] != NULL)
68 Free_Edge(tree->a_edges[i]);
69 Free(tree->a_edges);
70 tree = tree->next;
71 }
72 while(tree);
73 }
74
75 //////////////////////////////////////////////////////////////
76 //////////////////////////////////////////////////////////////
77
Free_Edge_Length(t_edge * b)78 void Free_Edge_Length(t_edge *b)
79 {
80 if(b->l) Free_Scalar_Dbl(b->l);
81 if(b->l_old) Free_Scalar_Dbl(b->l_old);
82 if(b->l_var) Free_Scalar_Dbl(b->l_var);
83 if(b->l_var_old) Free_Scalar_Dbl(b->l_var_old);
84 }
85
86 //////////////////////////////////////////////////////////////
87 //////////////////////////////////////////////////////////////
88
Free_Edge(t_edge * b)89 void Free_Edge(t_edge *b)
90 {
91 Free_Label(b->label);
92 Free_Edge_Core(b);
93 }
94
95 //////////////////////////////////////////////////////////////
96 //////////////////////////////////////////////////////////////
97
Free_Edge_Core(t_edge * b)98 void Free_Edge_Core(t_edge *b)
99 {
100 Free(b);
101 }
102
103 //////////////////////////////////////////////////////////////
104 //////////////////////////////////////////////////////////////
105
Free_Node(t_node * n)106 void Free_Node(t_node *n)
107 {
108 Free(n->b);
109 Free(n->v);
110 Free(n->score);
111 Free(n->s_ingrp);
112 Free(n->s_outgrp);
113 Free(n->cal);
114 Free_Label(n->label);
115
116 if(n->c_seq_anc != NULL)
117 {
118 Free(n->c_seq_anc->state);
119 Free(n->c_seq_anc);
120 }
121
122 if(n->ori_name) { Free(n->ori_name); n->ori_name = NULL; }
123
124 /* if(n->name) { Free(n->name); n->name = NULL; } */
125 /* Don't do that: see Copy_Tax_Names_To_Tip_Labels
126 tree->a_nodes[i]->ori_name = tree->a_nodes[i]->name; */
127
128 Free(n);
129 }
130
131 //////////////////////////////////////////////////////////////
132 //////////////////////////////////////////////////////////////
133
Free_Mat(matrix * mat)134 void Free_Mat(matrix *mat)
135 {
136 int i;
137
138 for(i=0;i<mat->n_otu;i++)
139 {
140 Free(mat->P[i]);
141 Free(mat->Q[i]);
142 Free(mat->dist[i]);
143 Free(mat->name[i]);
144 }
145
146 Free(mat->P);
147 Free(mat->Q);
148 Free(mat->dist);
149 Free(mat->name);
150 Free(mat->tip_node);
151
152 Free(mat->on_off);
153 Free(mat);
154 }
155
156 //////////////////////////////////////////////////////////////
157 //////////////////////////////////////////////////////////////
158
159
Free_Partial_Lk(phydbl * p_lk,int len,int n_catg)160 void Free_Partial_Lk(phydbl *p_lk, int len, int n_catg)
161 {
162 Free(p_lk);
163
164 /* int i,j; */
165 /* for(i=0;i<len;i++) */
166 /* { */
167 /* for(j=0;j<n_catg;j++) Free((*p_lk)[i][j]); */
168 /* Free((*p_lk)[i]); */
169 /* } */
170 /* Free((*p_lk)); */
171 /* (*p_lk) = NULL; */
172 }
173
174 //////////////////////////////////////////////////////////////
175 //////////////////////////////////////////////////////////////
176
Free_Tree(t_tree * mixt_tree)177 void Free_Tree(t_tree *mixt_tree)
178 {
179 t_tree *tree;
180 t_tree *next;
181
182 tree = mixt_tree;
183 do
184 {
185 if(tree->mat) Free_Mat(tree->mat);
186 Free(tree->t_dir);
187 if(tree->short_l) Free(tree->short_l);
188 if(tree->mutmap) Free(tree->mutmap);
189 Free_Bip(tree);
190 Free(tree->curr_path);
191 tree = tree->next;
192 }
193 while(tree);
194
195 Free_All_Edges_Light(mixt_tree);
196 Free_All_Nodes_Light(mixt_tree);
197
198 tree = mixt_tree;
199 next = mixt_tree->next;
200 do
201 {
202 Free(tree);
203 tree = next;
204 if(!tree) break;
205 next = next->next;
206 }
207 while(tree);
208
209 }
210
211 //////////////////////////////////////////////////////////////
212 //////////////////////////////////////////////////////////////
213
214
Free_Bip(t_tree * tree)215 void Free_Bip(t_tree *tree)
216 {
217 int i,j;
218
219 if(tree->has_bip)
220 {
221 For(i,2*tree->n_otu-2)
222 {
223 Free(tree->a_nodes[i]->bip_size);
224 for(j=0;j<3;j++) Free(tree->a_nodes[i]->bip_node[j]);
225 Free(tree->a_nodes[i]->bip_node);
226 }
227 }
228 tree->has_bip = NO;
229 }
230
231 //////////////////////////////////////////////////////////////
232 //////////////////////////////////////////////////////////////
233
Free_Calign(calign * data)234 void Free_Calign(calign *data)
235 {
236 int i;
237
238 if(data->io_wght) Free_Scalar_Dbl(data->io_wght);
239 Free(data->invar);
240 Free(data->wght);
241 Free(data->ambigu);
242 Free(data->obs_state_frq);
243 Free(data->sitepatt);
244 for(i=0;i<data->n_otu;i++)
245 {
246 Free(data->c_seq[i]->name);
247 if(data->c_seq[i]->state)
248 {
249 Free(data->c_seq[i]->state);
250 Free(data->c_seq[i]->d_state);
251 if(data->c_seq[i]->is_ambigu) Free(data->c_seq[i]->is_ambigu);
252 }
253 Free(data->c_seq[i]);
254 }
255
256
257 for(i=0;i<data->n_rm;i++)
258 {
259 Free(data->c_seq_rm[i]->name);
260 if(data->c_seq_rm[i]->state)
261 {
262 Free(data->c_seq_rm[i]->state);
263 Free(data->c_seq_rm[i]->d_state);
264 if(data->c_seq_rm[i]->is_ambigu) Free(data->c_seq_rm[i]->is_ambigu);
265 }
266 Free(data->c_seq_rm[i]);
267 }
268
269 if(data->c_seq_rm != NULL) Free(data->c_seq_rm);
270 if(data->c_seq != NULL) Free(data->c_seq);
271
272 Free(data);
273 }
274
275 //////////////////////////////////////////////////////////////
276 //////////////////////////////////////////////////////////////
277
Free_Seq(align ** d,int n_otu)278 void Free_Seq(align **d, int n_otu)
279 {
280 int i;
281 for(i=0;i<n_otu;i++)
282 {
283 Free(d[i]->name);
284 Free(d[i]->state);
285 Free(d[i]->d_state);
286 if(d[i]->is_ambigu) Free(d[i]->is_ambigu);
287 Free(d[i]);
288 }
289 Free(d);
290 }
291
292
293 //////////////////////////////////////////////////////////////
294 //////////////////////////////////////////////////////////////
295
296
Free_All(align ** d,calign * cdata,t_tree * tree)297 void Free_All(align **d, calign *cdata, t_tree *tree)
298 {
299 Free_Calign(cdata);
300 Free_Seq(d,tree->n_otu);
301 Free_Tree(tree);
302 }
303
304 //////////////////////////////////////////////////////////////
305 //////////////////////////////////////////////////////////////
306
Free_SubTree(t_edge * b_fcus,t_node * a,t_node * d,t_tree * tree)307 void Free_SubTree(t_edge *b_fcus, t_node *a, t_node *d, t_tree *tree)
308 {
309 int i;
310
311 if(d->tax) return;
312 else
313 {
314 for(i=0;i<3;i++)
315 {
316 if(d->v[i] != a)
317 {
318 Free_SubTree(d->b[i],d,d->v[i],tree);
319 Free_Edge(d->b[i]);
320 Free_Node(d->v[i]);
321 }
322 }
323 }
324 }
325
326 //////////////////////////////////////////////////////////////
327 //////////////////////////////////////////////////////////////
328
Free_Tree_Ins_Tar(t_tree * tree)329 void Free_Tree_Ins_Tar(t_tree *tree)
330 {
331 return;
332 }
333
334 //////////////////////////////////////////////////////////////
335 //////////////////////////////////////////////////////////////
336
Free_Tree_Pars(t_tree * mixt_tree)337 void Free_Tree_Pars(t_tree *mixt_tree)
338 {
339 int i;
340 t_tree *tree;
341
342 tree = mixt_tree;
343 do
344 {
345 Free(tree->step_mat);
346 Free(tree->site_pars);
347
348 for(i=0;i<2*tree->n_otu-3;++i)
349 {
350 Free_Edge_Pars(tree->a_edges[i]);
351 }
352
353 if(tree->n_root)
354 {
355 Free_Edge_Pars_Left(tree->n_root->b[1]);
356 Free_Edge_Pars_Left(tree->n_root->b[2]);
357 }
358 else
359 {
360 Free_Edge_Pars(tree->a_edges[2*tree->n_otu-3]);
361 Free_Edge_Pars(tree->a_edges[2*tree->n_otu-2]);
362 }
363
364 tree = tree->next;
365 }
366 while(tree);
367 }
368
369 //////////////////////////////////////////////////////////////
370 //////////////////////////////////////////////////////////////
371
Free_Edge_Pars_Left(t_edge * b)372 void Free_Edge_Pars_Left(t_edge *b)
373 {
374 if(b->pars_l) Free(b->pars_l);
375 if(b->ui_l) Free(b->ui_l);
376 if(b->p_pars_l) Free(b->p_pars_l);
377 if(b->n_diff_states_l) Free(b->n_diff_states_l);
378 }
379
380 //////////////////////////////////////////////////////////////
381 //////////////////////////////////////////////////////////////
382
Free_Edge_Pars_Rght(t_edge * b)383 void Free_Edge_Pars_Rght(t_edge *b)
384 {
385 if(b->pars_r) Free(b->pars_r);
386 if(b->ui_r) Free(b->ui_r);
387 if(b->p_pars_r) Free(b->p_pars_r);
388 if(b->n_diff_states_r) Free(b->n_diff_states_r);
389 }
390
391 //////////////////////////////////////////////////////////////
392 //////////////////////////////////////////////////////////////
393
Free_Edge_Pars(t_edge * b)394 void Free_Edge_Pars(t_edge *b)
395 {
396 Free_Edge_Pars_Left(b);
397 Free_Edge_Pars_Rght(b);
398 }
399
400 //////////////////////////////////////////////////////////////
401 //////////////////////////////////////////////////////////////
402
Free_Tree_Lk(t_tree * mixt_tree)403 void Free_Tree_Lk(t_tree *mixt_tree)
404 {
405 int i;
406 t_tree *tree;
407
408 tree = mixt_tree;
409 do
410 {
411 Free(tree->c_lnL_sorted);
412 Free(tree->cur_site_lk);
413 Free(tree->old_site_lk);
414 Free(tree->site_lk_cat);
415 Free(tree->fact_sum_scale);
416 Free(tree->unscaled_site_lk_cat);
417 Free(tree->expl);
418
419 if(tree->is_mixt_tree == NO)
420 {
421 Free(tree->eigen_lr_left);
422 Free(tree->eigen_lr_rght);
423 Free(tree->dot_prod);
424
425 for(i=0;i<3;i++) Free(tree->log_lks_aLRT[i]);
426 Free(tree->log_lks_aLRT);
427
428 Free(tree->div_post_pred_extra_0);
429 Free(tree->sum_scale_cat_extra_0);
430 Free(tree->sum_scale_extra_0);
431 Free(tree->patt_id_extra_0);
432 Free(tree->p_lk_extra_0);
433 Free(tree->p_lk_tip_extra_0);
434
435 Free(tree->div_post_pred_extra_1);
436 Free(tree->sum_scale_cat_extra_1);
437 Free(tree->sum_scale_extra_1);
438 Free(tree->patt_id_extra_1);
439 Free(tree->p_lk_extra_1);
440 Free(tree->p_lk_tip_extra_1);
441
442 for(i=0;i<2*tree->n_otu-1;++i) Free_NNI(tree->a_edges[i]->nni);
443 for(i=0;i<2*tree->n_otu-3;++i) Free_Edge_Lk(tree->a_edges[i]);
444 for(i=0;i<2*tree->n_otu-3;++i) Free_Edge_Loc(tree->a_edges[i]);
445
446 if(tree->n_root != NULL)
447 {
448 Free(tree->n_root->b[1]->Pij_rr);
449 Free(tree->n_root->b[2]->Pij_rr);
450 Free(tree->n_root->b[1]->tPij_rr);
451 Free(tree->n_root->b[2]->tPij_rr);
452 Free_Edge_Lk_Left(tree->n_root->b[1]);
453 Free_Edge_Lk_Left(tree->n_root->b[2]);
454 Free_Edge_Loc_Left(tree->n_root->b[1]);
455 Free_Edge_Loc_Left(tree->n_root->b[2]);
456 }
457 else
458 {
459 Free_Edge_Lk(tree->a_edges[2*tree->n_otu-3]);
460 Free_Edge_Lk(tree->a_edges[2*tree->n_otu-2]);
461 Free_Edge_Loc(tree->a_edges[2*tree->n_otu-3]);
462 Free_Edge_Loc(tree->a_edges[2*tree->n_otu-2]);
463 }
464 }
465
466 tree = tree->next;
467
468 }
469 while(tree);
470
471 }
472
473 //////////////////////////////////////////////////////////////
474 //////////////////////////////////////////////////////////////
475
476
Free_Node_Lk(t_node * n)477 void Free_Node_Lk(t_node *n)
478 {
479 /* Free(n->n_ex_nodes); */
480 }
481
482 //////////////////////////////////////////////////////////////
483 //////////////////////////////////////////////////////////////
484
Free_Extra_Edge_Lk(t_tree * tree)485 void Free_Extra_Edge_Lk(t_tree *tree)
486 {
487 if(tree->div_post_pred_extra_0) Free(tree->div_post_pred_extra_0);
488 if(tree->sum_scale_cat_extra_0) Free(tree->sum_scale_cat_extra_0);
489 if(tree->sum_scale_extra_0) Free(tree->sum_scale_extra_0);
490 if(tree->p_lk_extra_0) Free(tree->p_lk_extra_0);
491 if(tree->p_lk_tip_extra_0) Free(tree->p_lk_tip_extra_0);
492 if(tree->patt_id_extra_0) Free(tree->patt_id_extra_0);
493
494 if(tree->div_post_pred_extra_1) Free(tree->div_post_pred_extra_1);
495 if(tree->sum_scale_cat_extra_1) Free(tree->sum_scale_cat_extra_1);
496 if(tree->sum_scale_extra_1) Free(tree->sum_scale_extra_1);
497 if(tree->p_lk_extra_1) Free(tree->p_lk_extra_1);
498 if(tree->p_lk_tip_extra_1) Free(tree->p_lk_tip_extra_1);
499 if(tree->patt_id_extra_1) Free(tree->patt_id_extra_1);
500 }
501
502 //////////////////////////////////////////////////////////////
503 //////////////////////////////////////////////////////////////
504
Free_Edge_Lk_Rght(t_edge * b)505 void Free_Edge_Lk_Rght(t_edge *b)
506 {
507 assert(b);
508
509 Free(b->div_post_pred_rght);
510
511 if(b->p_lk_rght)
512 {
513 Free(b->p_lk_rght);
514 if(b->sum_scale_rght) Free(b->sum_scale_rght);
515 }
516
517 if(b->p_lk_tip_r) Free(b->p_lk_tip_r);
518 if(b->sum_scale_rght_cat) Free(b->sum_scale_rght_cat);
519 if(b->patt_id_rght) Free(b->patt_id_rght);
520 }
521
522 //////////////////////////////////////////////////////////////
523 //////////////////////////////////////////////////////////////
524
Free_Edge_Lk_Left(t_edge * b)525 void Free_Edge_Lk_Left(t_edge *b)
526 {
527
528 Free(b->div_post_pred_left);
529
530 if(b->p_lk_left)
531 {
532 Free(b->p_lk_left);
533 if(b->sum_scale_left) Free(b->sum_scale_left);
534 }
535
536 if(b->p_lk_tip_l) Free(b->p_lk_tip_l);
537 if(b->sum_scale_left_cat) Free(b->sum_scale_left_cat);
538 if(b->patt_id_left) Free(b->patt_id_left);
539 }
540
541 //////////////////////////////////////////////////////////////
542 //////////////////////////////////////////////////////////////
543
Free_Edge_Lk(t_edge * b)544 void Free_Edge_Lk(t_edge *b)
545 {
546 Free(b->tPij_rr);
547 Free(b->Pij_rr);
548
549 Free_Edge_Lk_Left(b);
550 Free_Edge_Lk_Rght(b);
551 }
552
553 //////////////////////////////////////////////////////////////
554 //////////////////////////////////////////////////////////////
555
Free_Edge_Loc_Rght(t_edge * b)556 void Free_Edge_Loc_Rght(t_edge *b)
557 {
558 if(b->p_lk_loc_rght) Free(b->p_lk_loc_rght);
559 }
560
561 //////////////////////////////////////////////////////////////
562 //////////////////////////////////////////////////////////////
563
Free_Edge_Loc_Left(t_edge * b)564 void Free_Edge_Loc_Left(t_edge *b)
565 {
566 if(b->p_lk_loc_left) Free(b->p_lk_loc_left);
567 }
568
569 //////////////////////////////////////////////////////////////
570 //////////////////////////////////////////////////////////////
571
Free_Edge_Loc(t_edge * b)572 void Free_Edge_Loc(t_edge *b)
573 {
574 Free_Edge_Loc_Left(b);
575 Free_Edge_Loc_Rght(b);
576 }
577
578 //////////////////////////////////////////////////////////////
579 //////////////////////////////////////////////////////////////
580
Free_Model_Complete(t_mod * mixt_mod)581 void Free_Model_Complete(t_mod *mixt_mod)
582 {
583 Free_Eigen(mixt_mod->eigen);
584 Free_Rmat(mixt_mod->r_mat);
585 Free_Efrq(mixt_mod->e_frq);
586 Free_Vect_Dbl(mixt_mod->Pij_rr);
587 mixt_mod->r_mat = NULL;
588 mixt_mod->e_frq = NULL;
589 }
590
591 //////////////////////////////////////////////////////////////
592 //////////////////////////////////////////////////////////////
593
Free_Rmat_Weights(t_mod * mixt_mod)594 void Free_Rmat_Weights(t_mod *mixt_mod)
595 {
596 t_mod *mod;
597
598 mod = mixt_mod;
599
600 do
601 {
602 Free(mod->r_mat_weight);
603 mod = mod->next_mixt;
604 }
605 while(mod);
606
607 if(mixt_mod->next) Free_Scalar_Dbl(mixt_mod->next->r_mat_weight);
608
609 }
610
611 //////////////////////////////////////////////////////////////
612 //////////////////////////////////////////////////////////////
613
Free_Efrq_Weights(t_mod * mixt_mod)614 void Free_Efrq_Weights(t_mod *mixt_mod)
615 {
616 t_mod *mod;
617
618 mod = mixt_mod;
619
620 do
621 {
622 Free(mod->e_frq_weight);
623 mod = mod->next_mixt;
624 }
625 while(mod);
626
627 if(mixt_mod->next) Free_Scalar_Dbl(mixt_mod->next->e_frq_weight);
628
629 }
630
631 //////////////////////////////////////////////////////////////
632 //////////////////////////////////////////////////////////////
633
Free_Model_Basic(t_mod * mixt_mod)634 void Free_Model_Basic(t_mod *mixt_mod)
635 {
636 t_mod *mod;
637
638 Free_RAS(mixt_mod->ras);
639 Free_Scalar_Dbl(mixt_mod->mr);
640 Free_Scalar_Dbl(mixt_mod->kappa);
641 Free_Scalar_Dbl(mixt_mod->lambda);
642 Free_Scalar_Dbl(mixt_mod->br_len_mult);
643 Free_Scalar_Dbl(mixt_mod->br_len_mult_unscaled);
644
645 Free_Rmat_Weights(mixt_mod);
646 Free_Efrq_Weights(mixt_mod);
647
648 Free_String(mixt_mod->modelname);
649 Free_String(mixt_mod->custom_mod_string);
650 Free_String(mixt_mod->aa_rate_mat_file);
651
652 mod = mixt_mod;
653 do
654 {
655 if(mod->next)
656 {
657 mod = mod->next;
658 Free(mod->prev);
659 }
660 else
661 {
662 Free(mod);
663 break;
664 }
665 }
666 while(mod);
667
668 }
669
670 //////////////////////////////////////////////////////////////
671 //////////////////////////////////////////////////////////////
672
Free_Vect_Dbl(vect_dbl * v)673 void Free_Vect_Dbl(vect_dbl *v)
674 {
675 vect_dbl *next;
676
677 assert(v);
678
679 next = v->next;
680 do
681 {
682 Free(v->v);
683 Free(v);
684
685 v = next;
686 if(v) next = v->next;
687 }
688 while(v);
689 }
690
691 //////////////////////////////////////////////////////////////
692 //////////////////////////////////////////////////////////////
693
Free_Vect_Int(vect_int * v)694 void Free_Vect_Int(vect_int *v)
695 {
696 vect_int *next;
697
698 assert(v);
699
700 next = v->next;
701 do
702 {
703 Free(v->v);
704 Free(v);
705
706 v = next;
707 if(v) next = v->next;
708 }
709 while(v);
710 }
711
712 //////////////////////////////////////////////////////////////
713 //////////////////////////////////////////////////////////////
714
Free_Scalar_Dbl(scalar_dbl * v)715 void Free_Scalar_Dbl(scalar_dbl *v)
716 {
717 scalar_dbl *next;
718
719 assert(v);
720
721 next = v->next;
722 do
723 {
724 Free(v);
725 v = next;
726 if(v) next = v->next;
727 }
728 while(v);
729 }
730
731 //////////////////////////////////////////////////////////////
732 //////////////////////////////////////////////////////////////
733
Free_Scalar_Int(scalar_int * v)734 void Free_Scalar_Int(scalar_int *v)
735 {
736 scalar_int *next;
737
738 assert(v);
739
740 next = v->next;
741 do
742 {
743 Free(v);
744 v = next;
745 if(v) next = v->next;
746 }
747 while(v);
748 }
749
750
751 //////////////////////////////////////////////////////////////
752 //////////////////////////////////////////////////////////////
753
Free_Linked_List(t_ll * t)754 void Free_Linked_List(t_ll *t)
755 {
756 t_ll *next,*ll;
757
758 if(t == NULL) return;
759
760 ll = t->head;
761 next = ll->next;
762 do
763 {
764 /* t_node *n = ll->v; */
765 /* printf("\n. free node %d",n?n->num:-1); */
766 /* printf(" ll: %p",ll); */
767 /* printf(" hd: %p",ll?ll->head:NULL); fflush(NULL); */
768 Free(ll);
769 ll = next;
770 if(ll) next = ll->next;
771 }
772 while(ll);
773 }
774
775 //////////////////////////////////////////////////////////////
776 //////////////////////////////////////////////////////////////
777
Free_String(t_string * ts)778 void Free_String(t_string *ts)
779 {
780 t_string *next;
781
782 next = ts->next;
783 do
784 {
785 Free(ts->s);
786 Free(ts);
787
788 ts = next;
789 if(ts) next = ts->next;
790 }
791 while(ts);
792 }
793
794 //////////////////////////////////////////////////////////////
795 //////////////////////////////////////////////////////////////
796
Free_Custom_Model(t_mod * mod)797 void Free_Custom_Model(t_mod *mod)
798 {
799 }
800
801 //////////////////////////////////////////////////////////////
802 //////////////////////////////////////////////////////////////
803
Free_Efrq(t_efrq * e_frq)804 void Free_Efrq(t_efrq *e_frq)
805 {
806 Free(e_frq->pi->v);
807 Free(e_frq->pi);
808
809 Free(e_frq->pi_unscaled->v);
810 Free(e_frq->pi_unscaled);
811
812 Free(e_frq->user_b_freq->v);
813 Free(e_frq->user_b_freq);
814
815 if(e_frq->next) Free_Efrq(e_frq->next);
816
817 Free(e_frq);
818 }
819
820 //////////////////////////////////////////////////////////////
821 //////////////////////////////////////////////////////////////
822
Free_Rmat(t_rmat * r_mat)823 void Free_Rmat(t_rmat *r_mat)
824 {
825
826 Free(r_mat->rr->v);
827 Free(r_mat->rr);
828
829 Free(r_mat->rr_num->v);
830
831 Free(r_mat->rr_val->v);
832 Free(r_mat->rr_val);
833
834 Free(r_mat->n_rr_per_cat->v);
835 Free(r_mat->n_rr_per_cat);
836
837 Free(r_mat->rr_num);
838
839 Free(r_mat->qmat->v);
840 Free(r_mat->qmat);
841
842 Free(r_mat->qmat_buff->v);
843 Free(r_mat->qmat_buff);
844
845 if(r_mat->next) Free_Rmat(r_mat->next);
846
847 Free(r_mat);
848 }
849
850 //////////////////////////////////////////////////////////////
851 //////////////////////////////////////////////////////////////
852
Free_RAS(t_ras * ras)853 void Free_RAS(t_ras *ras)
854 {
855 if(ras->gamma_r_proba->v)
856 {
857 Free(ras->gamma_r_proba->v);
858 Free(ras->gamma_r_proba_unscaled->v);
859 Free(ras->gamma_rr->v);
860 Free(ras->gamma_rr_unscaled->v);
861 }
862
863 Free(ras->gamma_r_proba);
864 Free(ras->skip_rate_cat);
865
866 Free(ras->gamma_r_proba_unscaled);
867 Free(ras->gamma_rr);
868 Free(ras->gamma_rr_unscaled);
869 Free_Scalar_Dbl(ras->pinvar);
870 Free_Scalar_Dbl(ras->alpha);
871 Free_Scalar_Dbl(ras->free_rate_mr);
872
873 if(ras->next) Free_RAS(ras->next);
874
875 Free(ras);
876 }
877
878
879 //////////////////////////////////////////////////////////////
880 //////////////////////////////////////////////////////////////
881
Free_Model(t_mod * mod)882 void Free_Model(t_mod *mod)
883 {
884 Free_Custom_Model(mod);
885 Free_Model_Complete(mod);
886 Free_Model_Basic(mod);
887 /* Free(mod); */
888 }
889
890 //////////////////////////////////////////////////////////////
891 //////////////////////////////////////////////////////////////
892
Free(void * p)893 void Free(void *p)
894 {
895 #if (defined(__AVX__) || defined(__SSE3__))
896 #ifndef WIN32
897 free(p);
898 #else
899 _aligned_free(p);
900 #endif
901 #else
902 free(p);
903 #endif
904
905 p = NULL;
906 }
907
908 //////////////////////////////////////////////////////////////
909 //////////////////////////////////////////////////////////////
910
Free_Input(option * io)911 void Free_Input(option *io)
912 {
913 int i;
914
915 do
916 {
917 RATES_Free_Rates(io->rates);
918 TIMES_Free_Times(io->times);
919 MCMC_Free_MCMC(io->mcmc);
920 Free(io->in_align_file);
921 Free(io->in_tree_file);
922 Free(io->in_constraint_tree_file);
923 Free(io->in_coord_file);
924 Free(io->out_file);
925 Free(io->out_tree_file);
926 Free(io->out_trees_file);
927 Free(io->out_boot_tree_file);
928 Free(io->out_boot_stats_file);
929 Free(io->out_stats_file);
930 Free(io->weight_file);
931 Free(io->out_lk_file);
932 Free(io->out_summary_file);
933 Free(io->out_ps_file);
934 Free(io->out_trace_file);
935 Free(io->out_json_trace_file);
936 Free(io->out_ancestral_seq_file);
937 Free(io->out_ancestral_tree_file);
938 Free(io->nt_or_cd);
939 Free(io->run_id_string);
940 Free(io->clade_list_file);
941 for(i=0;i<T_MAX_ALPHABET;i++) Free(io->alphabet[i]);
942 Free(io->alphabet);
943 if(io->short_tax_names)
944 {
945 for(i=0;i<io->size_tax_names;i++)
946 {
947 Free(io->short_tax_names[i]);
948 Free(io->long_tax_names[i]);
949 }
950 Free(io->long_tax_names);
951 Free(io->short_tax_names);
952 }
953 Free_Tree_List(io->treelist);
954
955 if(io->lon) Free(io->lon);
956 if(io->lat) Free(io->lat);
957
958 if(io->next)
959 {
960 io = io->next;
961 Free(io->prev);
962 }
963 else
964 {
965 Free(io);
966 break;
967 }
968
969 }while(1);
970 }
971
972 //////////////////////////////////////////////////////////////
973 //////////////////////////////////////////////////////////////
974
Free_Tree_List(t_treelist * list)975 void Free_Tree_List(t_treelist *list)
976 {
977 Free(list->tree);
978 Free(list);
979 }
980
981 //////////////////////////////////////////////////////////////
982 //////////////////////////////////////////////////////////////
983
984
Free_St(supert_tree * st)985 void Free_St(supert_tree *st)
986 {
987 int i;
988
989 For(i,2*st->tree->n_otu-1)
990 Free_NNI(st->tree->a_edges[i]->nni);
991
992 for(i=0;i<st->n_part;i++) Free(st->match_st_node_in_gt[i]);
993
994 Free(st->match_st_node_in_gt);
995
996 Free_Tree(st->tree);
997
998 Free(st);
999 }
1000
1001 //////////////////////////////////////////////////////////////
1002 //////////////////////////////////////////////////////////////
1003
1004
Free_Eigen(eigen * eigen_struct)1005 void Free_Eigen(eigen *eigen_struct)
1006 {
1007 Free(eigen_struct->space_int);
1008 Free(eigen_struct->space);
1009 Free(eigen_struct->e_val);
1010 Free(eigen_struct->e_val_im);
1011 Free(eigen_struct->r_e_vect_im);
1012 Free(eigen_struct->l_e_vect);
1013 Free(eigen_struct->r_e_vect);
1014 Free(eigen_struct->dum);
1015 Free(eigen_struct->q);
1016
1017 if(eigen_struct->next) Free_Eigen(eigen_struct->next);
1018
1019 Free(eigen_struct);
1020 }
1021
1022 //////////////////////////////////////////////////////////////
1023 //////////////////////////////////////////////////////////////
1024
1025
Free_One_Spr(t_spr * this_spr)1026 void Free_One_Spr(t_spr *this_spr)
1027 {
1028 Free(this_spr->path);
1029 if(this_spr->l0) Free_Scalar_Dbl(this_spr->l0);
1030 if(this_spr->l1) Free_Scalar_Dbl(this_spr->l1);
1031 if(this_spr->l2) Free_Scalar_Dbl(this_spr->l2);
1032 if(this_spr->v0) Free_Scalar_Dbl(this_spr->v0);
1033 if(this_spr->v1) Free_Scalar_Dbl(this_spr->v1);
1034 if(this_spr->v2) Free_Scalar_Dbl(this_spr->v2);
1035
1036 if(this_spr->init_target_l) Free_Scalar_Dbl(this_spr->init_target_l);
1037 if(this_spr->init_target_v) Free_Scalar_Dbl(this_spr->init_target_v);
1038
1039 Free(this_spr);
1040 }
1041
1042 //////////////////////////////////////////////////////////////
1043 //////////////////////////////////////////////////////////////
1044
Free_Spr_List_One_Edge(t_tree * mixt_tree)1045 void Free_Spr_List_One_Edge(t_tree *mixt_tree)
1046 {
1047 int i;
1048 t_tree *tree;
1049
1050 tree = mixt_tree;
1051 do
1052 {
1053 for(i=0;i<tree->size_spr_list_one_edge+1;++i) Free_One_Spr(tree->spr_list_one_edge[i]);
1054 Free(tree->spr_list_one_edge);
1055 tree = tree->next;
1056 }
1057 while(tree);
1058
1059 }
1060
1061 //////////////////////////////////////////////////////////////
1062 //////////////////////////////////////////////////////////////
1063
Free_Spr_List_All_Edge(t_tree * mixt_tree)1064 void Free_Spr_List_All_Edge(t_tree *mixt_tree)
1065 {
1066 int i;
1067 t_tree *tree;
1068
1069 tree = mixt_tree;
1070 do
1071 {
1072 for(i=0;i<tree->size_spr_list_all_edge+1;++i) Free_One_Spr(tree->spr_list_all_edge[i]);
1073 Free(tree->spr_list_all_edge);
1074 tree = tree->next;
1075 }
1076 while(tree);
1077
1078 }
1079
1080 //////////////////////////////////////////////////////////////
1081 //////////////////////////////////////////////////////////////
1082
Free_Actual_CSeq(calign * data)1083 void Free_Actual_CSeq(calign *data)
1084 {
1085 int i;
1086 for(i=0;i<data->n_otu;i++)
1087 {
1088 Free(data->c_seq[i]->state);
1089 Free(data->c_seq[i]->d_state);
1090 data->c_seq[i]->state = NULL;
1091 }
1092 }
1093
1094 //////////////////////////////////////////////////////////////
1095 //////////////////////////////////////////////////////////////
1096
1097
Free_Prefix_Tree(pnode * n,int size)1098 void Free_Prefix_Tree(pnode *n, int size)
1099 {
1100 int i;
1101
1102 for(i=0;i<size;i++)
1103 {
1104 if(n->next[i])
1105 {
1106 Free_Prefix_Tree(n->next[i],size);
1107 }
1108 }
1109 Free_Pnode(n);
1110 }
1111
1112 //////////////////////////////////////////////////////////////
1113 //////////////////////////////////////////////////////////////
1114
1115
Free_Pnode(pnode * n)1116 void Free_Pnode(pnode *n)
1117 {
1118 Free(n->next);
1119 Free(n);
1120 }
1121
1122 //////////////////////////////////////////////////////////////
1123 //////////////////////////////////////////////////////////////
1124
Free_Optimiz(t_opt * s_opt)1125 void Free_Optimiz(t_opt *s_opt)
1126 {
1127 Free(s_opt);
1128 }
1129
1130 //////////////////////////////////////////////////////////////
1131 //////////////////////////////////////////////////////////////
1132
Free_Nexus(option * io)1133 void Free_Nexus(option *io)
1134 {
1135 int i,j;
1136
1137 for(i=0;i<N_MAX_NEX_COM;i++)
1138 {
1139 For(j,io->nex_com_list[i]->nparm) Free_Nexus_Parm(io->nex_com_list[i]->parm[j]);
1140 Free(io->nex_com_list[i]->parm);
1141 Free(io->nex_com_list[i]->name);
1142 Free(io->nex_com_list[i]);
1143 }
1144 Free(io->nex_com_list);
1145 }
1146
1147 //////////////////////////////////////////////////////////////
1148 //////////////////////////////////////////////////////////////
1149
1150
Free_Nexus_Com(nexcom ** com)1151 void Free_Nexus_Com(nexcom **com)
1152 {
1153 int i;
1154
1155 for(i=0;i<N_MAX_NEX_COM;i++)
1156 {
1157 Free(com[i]->parm);
1158 Free(com[i]->name);
1159 Free(com[i]);
1160 }
1161 Free(com);
1162 }
1163
1164 //////////////////////////////////////////////////////////////
1165 //////////////////////////////////////////////////////////////
1166
Free_Nexus_Parm(nexparm * parm)1167 void Free_Nexus_Parm(nexparm *parm)
1168 {
1169 Free(parm->value);
1170 Free(parm->name);
1171 Free(parm);
1172 }
1173
1174 //////////////////////////////////////////////////////////////
1175 //////////////////////////////////////////////////////////////
1176
XML_Free_XML_Tree(xml_node * node)1177 void XML_Free_XML_Tree(xml_node *node)
1178 {
1179 if(!node) return;
1180 if(node->child) XML_Free_XML_Tree(node->child);
1181 if(node->next) XML_Free_XML_Tree(node->next);
1182 XML_Free_XML_Node(node);
1183 }
1184
1185 //////////////////////////////////////////////////////////////
1186 //////////////////////////////////////////////////////////////
1187
XML_Free_XML_Node(xml_node * node)1188 void XML_Free_XML_Node(xml_node *node)
1189 {
1190 Free(node->id);
1191 Free(node->name);
1192 Free(node->value);
1193 XML_Free_XML_Ds(node->ds);
1194 XML_Free_XML_Attr(node->attr);
1195 Free(node);
1196 }
1197
1198 //////////////////////////////////////////////////////////////
1199 //////////////////////////////////////////////////////////////
1200
XML_Free_XML_Attr(xml_attr * attr)1201 void XML_Free_XML_Attr(xml_attr *attr)
1202 {
1203 if(attr)
1204 {
1205 Free(attr->name);
1206 Free(attr->value);
1207 if(attr->next) XML_Free_XML_Attr(attr->next);
1208 Free(attr);
1209 }
1210 }
1211
1212 //////////////////////////////////////////////////////////////
1213 //////////////////////////////////////////////////////////////
1214
XML_Free_XML_Ds(t_ds * ds)1215 void XML_Free_XML_Ds(t_ds *ds)
1216 {
1217 if(ds->next) XML_Free_XML_Ds(ds->next);
1218 Free(ds);
1219 }
1220
1221 //////////////////////////////////////////////////////////////
1222 //////////////////////////////////////////////////////////////
1223
MCMC_Free_MCMC(t_mcmc * mcmc)1224 void MCMC_Free_MCMC(t_mcmc *mcmc)
1225 {
1226 int i;
1227
1228 Free(mcmc->move_type);
1229 Free(mcmc->adjust_tuning);
1230 Free(mcmc->out_filename);
1231 Free(mcmc->move_weight);
1232 Free(mcmc->acc_move);
1233 Free(mcmc->run_move);
1234 Free(mcmc->prev_acc_move);
1235 Free(mcmc->prev_run_move);
1236 Free(mcmc->acc_rate);
1237 Free(mcmc->tune_move);
1238 for(i=0;i<mcmc->n_moves;i++) Free(mcmc->move_name[i]);
1239 Free(mcmc->move_name);
1240 Free(mcmc->ess_run);
1241 Free(mcmc->start_ess);
1242 Free(mcmc->ess);
1243 Free(mcmc->sampled_val);
1244 Free(mcmc->mode);
1245 Free(mcmc);
1246 }
1247
1248 //////////////////////////////////////////////////////////////
1249 //////////////////////////////////////////////////////////////
1250
TIMES_Free_Times(t_time * times)1251 void TIMES_Free_Times(t_time *times)
1252 {
1253 Free(times->buff_t);
1254 Free(times->nd_t);
1255 Free(times->true_t);
1256 Free(times->t_prior);
1257 Free(times->t_mean);
1258 Free(times->t_prior_min);
1259 Free(times->t_prior_max);
1260 Free(times->t_floor);
1261 Free(times->t_has_prior);
1262 Free(times->t_rank);
1263 Free(times->mean_t);
1264 Free(times->t_prior_min_ori);
1265 Free(times->t_prior_max_ori);
1266 Free(times->times_partial_proba);
1267 Free(times->calib_prob);
1268 Free(times->numb_calib_chosen);
1269 for(int i=0;i<times->n_cal;i++) Free_Calib(times->a_cal[i]);
1270 Free(times->a_cal);
1271 Free(times->has_survived);
1272 Free(times->n_jps);
1273 Free(times->t_jps);
1274 Free(times->time_slice_lims);
1275 Free(times->n_time_slice_spans);
1276 Free(times->curr_slice);
1277 Free(times->has_survived);
1278 Free(times);
1279 }
1280
1281 //////////////////////////////////////////////////////////////
1282 //////////////////////////////////////////////////////////////
1283
RATES_Free_Rates(t_rate * rates)1284 void RATES_Free_Rates(t_rate *rates)
1285 {
1286 if(rates->is_allocated == YES)
1287 {
1288 Free(rates->nd_r);
1289 Free(rates->br_r);
1290 Free(rates->buff_nd_r);
1291 Free(rates->buff_br_r);
1292 Free(rates->true_r);
1293 Free(rates->dens);
1294 Free(rates->triplet);
1295 Free(rates->cond_var);
1296 Free(rates->invcov);
1297 Free(rates->ml_l);
1298 Free(rates->cur_l);
1299 Free(rates->u_ml_l);
1300 Free(rates->u_cur_l);
1301 Free(rates->cov_r);
1302 Free(rates->lca);
1303 Free(rates->trip_cond_cov);
1304 Free(rates->trip_reg_coeff);
1305 Free(rates->_2n_vect1);
1306 Free(rates->_2n_vect2);
1307 Free(rates->_2n_vect3);
1308 Free(rates->_2n_vect4);
1309 Free(rates->_2n_vect5);
1310 Free(rates->_2n2n_vect1);
1311 Free(rates->_2n2n_vect2);
1312 Free(rates->cov_l);
1313 Free(rates->mean_l);
1314 Free(rates->mean_r);
1315 Free(rates->grad_l);
1316 Free(rates->reg_coeff);
1317 Free(rates->br_do_updt);
1318 Free(rates->cur_gamma_prior_mean);
1319 Free(rates->cur_gamma_prior_var);
1320 Free(rates->n_tips_below);
1321 Free(rates->model_name);
1322 }
1323 Free(rates);
1324 }
1325
1326 //////////////////////////////////////////////////////////////
1327 //////////////////////////////////////////////////////////////
1328
Free_Calib(t_cal * cal)1329 void Free_Calib(t_cal *cal)
1330 {
1331 if(!cal) return;
1332 else
1333 {
1334 int i;
1335 for(i=0;i<cal->clade_list_size;i++) Free(cal->clade_list[i]);
1336 Free(cal->clade_list);
1337 Free(cal->id);
1338 Free(cal->alpha_proba_list);
1339 Free(cal);
1340 }
1341 }
1342
1343 /*////////////////////////////////////////////////////////////
1344 ////////////////////////////////////////////////////////////*/
1345
Free_Geo(t_geo * t)1346 void Free_Geo(t_geo *t)
1347 {
1348 int i;
1349 Free(t->f_mat);
1350 Free(t->r_mat);
1351 Free(t->occup);
1352 Free(t->idx_loc);
1353 Free(t->sorted_nd);
1354 Free(t->cov);
1355 Free(t->idx_loc_beneath);
1356 for(i=0;i<t->ldscape_sz;i++) Free_Geo_Coord(t->coord_loc[i]);
1357 Free(t->coord_loc);
1358 Free(t);
1359 }
1360
1361 /*////////////////////////////////////////////////////////////
1362 ////////////////////////////////////////////////////////////*/
1363
Free_Geo_Coord(t_geo_coord * t)1364 void Free_Geo_Coord(t_geo_coord *t)
1365 {
1366 Free(t->cpy->lonlat);
1367 Free(t->cpy->id);
1368 Free(t->cpy);
1369
1370 Free(t->lonlat);
1371 Free(t->id);
1372 Free(t);
1373 }
1374
1375 /*////////////////////////////////////////////////////////////
1376 ////////////////////////////////////////////////////////////*/
1377
Free_Disk(t_dsk * t)1378 void Free_Disk(t_dsk *t)
1379 {
1380 Free_Geo_Coord(t->centr);
1381 Free(t->ldsk_a);
1382 Free(t->id);
1383 Free(t);
1384 }
1385
1386 /*////////////////////////////////////////////////////////////
1387 ////////////////////////////////////////////////////////////*/
1388
Free_Ldisk(t_ldsk * t)1389 void Free_Ldisk(t_ldsk *t)
1390 {
1391 if(t == NULL) return;
1392 else
1393 {
1394 Free(t->next);
1395 Free_Geo_Coord(t->coord);
1396 if(t->cpy_coord) Free_Geo_Coord(t->cpy_coord);
1397 Free(t);
1398 }
1399
1400 }
1401
1402 //////////////////////////////////////////////////////////////
1403 //////////////////////////////////////////////////////////////
1404
Free_Poly(t_poly * p)1405 void Free_Poly(t_poly *p)
1406 {
1407 int i;
1408 for(i=0;i<p->n_poly_vert;i++) Free_Geo_Coord(p->poly_vert[i]);
1409 Free(p->poly_vert);
1410 Free(p);
1411 }
1412
1413 //////////////////////////////////////////////////////////////
1414 //////////////////////////////////////////////////////////////
1415
Free_Mmod(t_phyrex_mod * mmod)1416 void Free_Mmod(t_phyrex_mod *mmod)
1417 {
1418 if(mmod == NULL) return;
1419 Free_Geo_Coord(mmod->lim_up);
1420 Free_Geo_Coord(mmod->lim_do);
1421 Free(mmod->sigsq_scale);
1422 Free(mmod);
1423 }
1424
1425 //////////////////////////////////////////////////////////////
1426 //////////////////////////////////////////////////////////////
1427
JSON_Free_Array(json_a * a)1428 void JSON_Free_Array(json_a *a)
1429 {
1430 if(a->object) JSON_Free_Object(a->object);
1431 Free(a);
1432 }
1433
1434 //////////////////////////////////////////////////////////////
1435 //////////////////////////////////////////////////////////////
1436
JSON_Free_Object(json_o * o)1437 void JSON_Free_Object(json_o *o)
1438 {
1439 if(o->kv) JSON_Free_KeyVal(o->kv);
1440 if(o->next) JSON_Free_Object(o->next);
1441 Free(o);
1442 }
1443
1444 //////////////////////////////////////////////////////////////
1445 //////////////////////////////////////////////////////////////
1446
JSON_Free_KeyVal(json_kv * kv)1447 void JSON_Free_KeyVal(json_kv *kv)
1448 {
1449 if(kv->key) Free(kv->key);
1450 if(kv->value) Free(kv->value);
1451 if(kv->object) JSON_Free_Object(kv->object);
1452 if(kv->array) JSON_Free_Array(kv->array);
1453 if(kv->next) JSON_Free_KeyVal(kv->next);
1454 Free(kv);
1455 }
1456
1457 //////////////////////////////////////////////////////////////
1458 //////////////////////////////////////////////////////////////
1459
Free_NNI(t_nni * t)1460 void Free_NNI(t_nni *t)
1461 {
1462 if(t->init_l) Free_Scalar_Dbl(t->init_l);
1463 if(t->init_v) Free_Scalar_Dbl(t->init_v);
1464
1465 if(t->best_l) Free_Scalar_Dbl(t->best_l);
1466 if(t->best_v) Free_Scalar_Dbl(t->best_v);
1467
1468 if(t->l0) Free_Scalar_Dbl(t->l0);
1469 if(t->v0) Free_Scalar_Dbl(t->v0);
1470
1471 if(t->l1) Free_Scalar_Dbl(t->l1);
1472 if(t->v1) Free_Scalar_Dbl(t->v1);
1473
1474 if(t->l2) Free_Scalar_Dbl(t->l2);
1475 if(t->v2) Free_Scalar_Dbl(t->v2);
1476
1477 Free(t);
1478 }
1479
1480 //////////////////////////////////////////////////////////////
1481 //////////////////////////////////////////////////////////////
1482
1483 /* Matrices used in transfer bootstrap computation (tbe.c) */
Free_TBE_Matrices(int n_otu,short unsigned *** i_matrix,short unsigned *** c_matrix,short unsigned *** hamming,short unsigned ** min_dist,short unsigned ** min_dist_edge,int ** cluster_sizes)1484 void Free_TBE_Matrices(int n_otu, short unsigned*** i_matrix, short unsigned*** c_matrix,
1485 short unsigned*** hamming, short unsigned** min_dist,
1486 short unsigned** min_dist_edge, int** cluster_sizes){
1487 int i;
1488 int nb_edges = 2*n_otu-3;
1489 for (i=0; i<nb_edges; i++) {
1490 free((*c_matrix)[i]);
1491 free((*i_matrix)[i]);
1492 free((*hamming)[i]);
1493 }
1494 free((*c_matrix));
1495 free((*i_matrix));
1496 free((*hamming));
1497 free((*min_dist));
1498 free((*min_dist_edge));
1499 free((*cluster_sizes));
1500 }
1501
1502 //////////////////////////////////////////////////////////////
1503 //////////////////////////////////////////////////////////////
1504
Free_Label(t_label * lab)1505 void Free_Label(t_label *lab)
1506 {
1507 if(lab == NULL) return;
1508 Free(lab->key);
1509 Free(lab->val);
1510 if(lab->next != NULL) Free_Label(lab->next);
1511 Free(lab);
1512 }
1513
1514 //////////////////////////////////////////////////////////////
1515 //////////////////////////////////////////////////////////////
1516
Free_Contrasts(t_ctrst * ctrst)1517 void Free_Contrasts(t_ctrst *ctrst)
1518 {
1519 Free(ctrst->x);
1520 Free(ctrst->tprime);
1521 Free(ctrst);
1522 }
1523
1524 //////////////////////////////////////////////////////////////
1525 //////////////////////////////////////////////////////////////
1526 //////////////////////////////////////////////////////////////
1527 //////////////////////////////////////////////////////////////
1528 //////////////////////////////////////////////////////////////
1529 //////////////////////////////////////////////////////////////
1530 //////////////////////////////////////////////////////////////
1531 //////////////////////////////////////////////////////////////
1532 //////////////////////////////////////////////////////////////
1533 //////////////////////////////////////////////////////////////
1534 //////////////////////////////////////////////////////////////
1535 //////////////////////////////////////////////////////////////
1536