← Back to branch summary

~ubuntu-branches/debian/jessie/arb/jessie

« back to all changes in this revision

Viewing changes to GDE/PHYML20130708/phyml/src/free.c

  • Committer: Package Import Robot
  • Author(s): Elmar Pruesse, Andreas Tille, Elmar Pruesse
  • Date: 2014-09-02 15:15:06 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20140902151506-jihq58b3iz342wif
Tags: 6.0.2-1
http://bugs.debian.org/741890
http://bugs.debian.org/757497
[ Andreas Tille ]
* New upstream version
  Closes: #741890
* debian/upstream -> debian/upstream/metadata
* debian/control:
   - Build-Depends: added libglib2.0-dev
   - Depends: added mafft, mrbayes
* debian/rules
   - Add explicite --remove-section=.comment option to manual strip call
* cme fix dpkg-control
* arb-common.dirs: Do not create unneeded lintian dir
* Add turkish debconf translation (thanks for the patch to Mert Dirik
  <mertdirik@gmail.com>)
  Closes: #757497

[ Elmar Pruesse ]
* patches removed:
   - 10_config.makefiles.patch,
     80_no_GL.patch
       removed in favor of creating file from config.makefile.template via 
       sed in debian/control
   - 20_Makefile_main.patch
       merged upstream
   - 21_Makefiles.patch
       no longer needed
   - 30_tmpfile_CVE-2008-5378.patch: 
       merged upstream
   - 50_fix_gcc-4.8.patch:
       merged upstream
   - 40_add_libGLU.patch:
       libGLU not needed for arb_ntree)
   - 60_use_debian_packaged_raxml.patch:
       merged upstream
   - 70_hardening.patch
       merged upstream
   - 72_add_math_lib_to_linker.patch
       does not appear to be needed
* patches added:
   - 10_upstream_r12793__show_db_load_progress:
       backported patch showing progress while ARB is loading a database
       (needed as indicator/splash screen while ARB is launching)
   - 20_upstream_r12794__socket_permissions:
       backported security fix
   - 30_upstream_r12814__desktop_keywords:
       backported add keywords to desktop (fixes lintian warning)
   - 40_upstream_r12815__lintian_spelling:
       backported fix for lintian reported spelling errors
   - 50_private_nameservers
       change configuration to put nameservers into users home dirs
       (avoids need for shared writeable directory)
   - 60_use_debian_phyml
       use phyml from debian package for both interfaces in ARB
* debian/rules:
   - create config.makefile from override_dh_configure target
   - use "make tarfile" in override_dh_install
   - remove extra cleaning not needed for ARB 6
   - use "dh_install --list-missing" to avoid missing files
   - added override_dh_fixperms target
* debian/control:
   - added libarb-dev package
   - Depends: added phyml, xdg-utils
   - Suggests: removed phyml
   - fix lintian duplicate-short-description (new descriptions)
* debian/*.install:
   - "unrolled" confusing globbing to select files
   - pick files from debian/tmp
   - moved all config files to /etc/arb
* debian/arb-common.templates: updated
* scripts:
   - removed arb-add-pt-server
   - launch-wrapper: 
     - only add demo.arb to newly created $ARBUSERDATA
     - pass commandline arguments through bin/arb wrapper
   - preinst: removing old PT server index files on upgrade from 5.5*
   - postinst: set setgid on shared PT dir
* rewrote arb.1 manfile
* added file icon for ARB databases
* using upstream arb_tcp.dat

Show diffs side-by-side

added added

removed removed

Lines of Context:
GDE/PHYML20130708/phyml/src/free.c
 
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
 
 
19
void Free_All_Nodes_Light(t_tree *mixt_tree)
 
20
{
 
21
  int i;
 
22
  t_tree *tree;
 
23
 
 
24
  tree = mixt_tree;
 
25
  do
 
26
    {
 
27
      For(i,2*tree->n_otu-1) Free_Node(tree->a_nodes[i]);
 
28
      Free(tree->a_nodes);
 
29
      tree = tree->next;
 
30
    }
 
31
  while(tree);
 
32
 
 
33
}
 
34
 
 
35
//////////////////////////////////////////////////////////////
 
36
//////////////////////////////////////////////////////////////
 
37
 
 
38
void Free_All_Edges_Light(t_tree *mixt_tree)
 
39
{
 
40
  int i;
 
41
  t_tree *tree;
 
42
 
 
43
  tree = mixt_tree;
 
44
 
 
45
  For(i,2*tree->n_otu-1) 
 
46
    {
 
47
      Free_Scalar_Dbl(tree->a_edges[i]->l);
 
48
      Free_Scalar_Dbl(tree->a_edges[i]->l_old);
 
49
      Free_Scalar_Dbl(tree->a_edges[i]->l_var);
 
50
      Free_Scalar_Dbl(tree->a_edges[i]->l_var_old);
 
51
    }
 
52
  do
 
53
    {
 
54
      For(i,2*tree->n_otu-1) Free_Edge(tree->a_edges[i]);
 
55
      Free(tree->a_edges);
 
56
      tree = tree->next;
 
57
    }
 
58
  while(tree);
 
59
}
 
60
 
 
61
//////////////////////////////////////////////////////////////
 
62
//////////////////////////////////////////////////////////////
 
63
 
 
64
void Free_Edge_Labels(t_edge *b)
 
65
{
 
66
  int i;
 
67
  
 
68
  if(b->labels)
 
69
    {
 
70
      For(i,b->n_labels-(b->n_labels%BLOCK_LABELS)+BLOCK_LABELS) Free(b->labels[i]);
 
71
      Free(b->labels);
 
72
      b->labels = NULL;
 
73
    }
 
74
}
 
75
 
 
76
//////////////////////////////////////////////////////////////
 
77
//////////////////////////////////////////////////////////////
 
78
 
 
79
void Free_Edge(t_edge *b)
 
80
{
 
81
  Free_Edge_Labels(b);
 
82
  Free_Edge_Core(b);
 
83
}
 
84
 
 
85
//////////////////////////////////////////////////////////////
 
86
//////////////////////////////////////////////////////////////
 
87
 
 
88
void Free_Edge_Core(t_edge *b)
 
89
{
 
90
  Free(b);
 
91
}
 
92
 
 
93
//////////////////////////////////////////////////////////////
 
94
//////////////////////////////////////////////////////////////
 
95
 
 
96
 
 
97
void Free_Node(t_node *n)
 
98
{
 
99
  Free(n->b);
 
100
  Free(n->v);
 
101
  Free(n->l);
 
102
  Free(n->score);
 
103
  Free(n->s_ingrp);
 
104
  Free(n->s_outgrp);
 
105
  if(n->ori_name) { Free(n->ori_name); n->ori_name = NULL; }
 
106
 
 
107
  /* if(n->name)     { Free(n->name);     n->name     = NULL; }  */
 
108
  /* Don't do that: see Copy_Tax_Names_To_Tip_Labels       
 
109
     tree->a_nodes[i]->ori_name = tree->a_nodes[i]->name; */  
 
110
 
 
111
  Free(n);
 
112
}
 
113
 
 
114
//////////////////////////////////////////////////////////////
 
115
//////////////////////////////////////////////////////////////
 
116
 
 
117
 
 
118
void Free_Mat(matrix *mat)
 
119
{
 
120
  int i;
 
121
 
 
122
  For(i,mat->n_otu)
 
123
    {
 
124
      Free(mat->P[i]);
 
125
      Free(mat->Q[i]);
 
126
      Free(mat->dist[i]);
 
127
      Free(mat->name[i]);
 
128
    }
 
129
 
 
130
  Free(mat->P);
 
131
  Free(mat->Q);
 
132
  Free(mat->dist);
 
133
  Free(mat->name);
 
134
  Free(mat->tip_node);
 
135
      
 
136
  Free(mat->on_off);
 
137
  Free(mat);
 
138
}
 
139
 
 
140
//////////////////////////////////////////////////////////////
 
141
//////////////////////////////////////////////////////////////
 
142
 
 
143
 
 
144
void Free_Partial_Lk(phydbl *p_lk, int len, int n_catg)
 
145
{
 
146
  Free(p_lk);
 
147
 
 
148
/*   int i,j; */
 
149
/*   For(i,len) */
 
150
/*     { */
 
151
/*       For(j,n_catg) Free((*p_lk)[i][j]); */
 
152
/*       Free((*p_lk)[i]); */
 
153
/*     } */
 
154
/*   Free((*p_lk)); */
 
155
/*   (*p_lk) = NULL; */
 
156
}
 
157
 
 
158
//////////////////////////////////////////////////////////////
 
159
//////////////////////////////////////////////////////////////
 
160
 
 
161
 
 
162
void Free_Tree(t_tree *mixt_tree)
 
163
{
 
164
  t_tree *tree;
 
165
  t_tree *next;
 
166
 
 
167
  tree = mixt_tree;
 
168
  do
 
169
    {
 
170
      if(tree->mat) Free_Mat(tree->mat);
 
171
      Free(tree->t_dir);
 
172
      if(tree->short_l) Free(tree->short_l);
 
173
      if(tree->mutmap)  Free(tree->mutmap);
 
174
      Free_Bip(tree);
 
175
      Free(tree->curr_path);
 
176
      tree = tree->next;
 
177
    }
 
178
  while(tree);
 
179
  
 
180
  Free_All_Edges_Light(mixt_tree);
 
181
  Free_All_Nodes_Light(mixt_tree);
 
182
 
 
183
  tree = mixt_tree;
 
184
  next = mixt_tree->next;
 
185
  do
 
186
    {
 
187
      Free(tree);
 
188
      tree = next;
 
189
      if(!tree) break;
 
190
      next = next->next;
 
191
    }
 
192
  while(tree);
 
193
 
 
194
}
 
195
 
 
196
//////////////////////////////////////////////////////////////
 
197
//////////////////////////////////////////////////////////////
 
198
 
 
199
 
 
200
void Free_Bip(t_tree *tree)
 
201
{
 
202
  int i,j;
 
203
 
 
204
  if(tree->has_bip)
 
205
    {
 
206
      For(i,2*tree->n_otu-2)
 
207
        {
 
208
          Free(tree->a_nodes[i]->bip_size);
 
209
          For(j,3) Free(tree->a_nodes[i]->bip_node[j]);
 
210
          Free(tree->a_nodes[i]->bip_node);
 
211
        }
 
212
    }
 
213
  tree->has_bip = NO;
 
214
}
 
215
 
 
216
//////////////////////////////////////////////////////////////
 
217
//////////////////////////////////////////////////////////////
 
218
 
 
219
 
 
220
void Free_Cseq(calign *data)
 
221
{
 
222
  int i;
 
223
  
 
224
  Free(data->invar);
 
225
  Free(data->wght);
 
226
  Free(data->ambigu);
 
227
  Free(data->b_frq);
 
228
  Free(data->sitepatt);
 
229
  For(i,data->n_otu)
 
230
    {
 
231
      Free(data->c_seq[i]->name);
 
232
      if(data->c_seq[i]->state) 
 
233
        {
 
234
          Free(data->c_seq[i]->state);
 
235
          Free(data->c_seq[i]->d_state);
 
236
          if(data->c_seq[i]->is_ambigu) Free(data->c_seq[i]->is_ambigu);
 
237
        }
 
238
      Free(data->c_seq[i]);
 
239
    }
 
240
  Free(data->c_seq);
 
241
  Free(data);
 
242
}
 
243
 
 
244
//////////////////////////////////////////////////////////////
 
245
//////////////////////////////////////////////////////////////
 
246
 
 
247
 
 
248
void Free_Seq(align **d, int n_otu)
 
249
{
 
250
  int i;
 
251
  For(i,n_otu)
 
252
    {
 
253
      Free(d[i]->name);
 
254
      Free(d[i]->state);
 
255
      Free(d[i]->d_state);
 
256
      if(d[i]->is_ambigu) Free(d[i]->is_ambigu);
 
257
      Free(d[i]);
 
258
    }
 
259
  Free(d);
 
260
}
 
261
 
 
262
 
 
263
//////////////////////////////////////////////////////////////
 
264
//////////////////////////////////////////////////////////////
 
265
 
 
266
 
 
267
void Free_All(align **d, calign *cdata, t_tree *tree)
 
268
{
 
269
  Free_Cseq(cdata);
 
270
  Free_Seq(d,tree->n_otu);
 
271
  Free_Tree(tree);
 
272
}      
 
273
 
 
274
//////////////////////////////////////////////////////////////
 
275
//////////////////////////////////////////////////////////////
 
276
 
 
277
void Free_SubTree(t_edge *b_fcus, t_node *a, t_node *d, t_tree *tree)
 
278
{
 
279
  int i;
 
280
 
 
281
  if(d->tax) return;
 
282
  else
 
283
    {
 
284
      For(i,3)
 
285
        {
 
286
          if(d->v[i] != a)
 
287
            {
 
288
              Free_SubTree(d->b[i],d,d->v[i],tree);
 
289
              Free_Edge(d->b[i]);
 
290
              Free_Node(d->v[i]);
 
291
            }
 
292
        }
 
293
    }
 
294
}
 
295
 
 
296
//////////////////////////////////////////////////////////////
 
297
//////////////////////////////////////////////////////////////
 
298
 
 
299
void Free_Tree_Ins_Tar(t_tree *tree)
 
300
{
 
301
  return;
 
302
}
 
303
 
 
304
//////////////////////////////////////////////////////////////
 
305
//////////////////////////////////////////////////////////////
 
306
 
 
307
void Free_Tree_Pars(t_tree *mixt_tree)
 
308
{
 
309
  int i;
 
310
  t_tree *tree;
 
311
 
 
312
  tree = mixt_tree;
 
313
  do
 
314
    {
 
315
      Free(tree->step_mat);
 
316
      Free(tree->site_pars);
 
317
      
 
318
      For(i,2*tree->n_otu-3) Free_Edge_Pars(tree->a_edges[i]);           
 
319
      
 
320
      if(tree->n_root)
 
321
        {
 
322
          Free_Edge_Pars_Left(tree->n_root->b[1]);
 
323
          Free_Edge_Pars_Left(tree->n_root->b[2]);
 
324
        }
 
325
      else
 
326
        {
 
327
          Free_Edge_Pars(tree->a_edges[2*tree->n_otu-3]);
 
328
          Free_Edge_Pars(tree->a_edges[2*tree->n_otu-2]);
 
329
        }
 
330
      
 
331
      tree = tree->next;
 
332
    }
 
333
  while(tree);
 
334
}
 
335
 
 
336
//////////////////////////////////////////////////////////////
 
337
//////////////////////////////////////////////////////////////
 
338
 
 
339
void Free_Edge_Pars_Left(t_edge *b)
 
340
{
 
341
  if(b->pars_l)   Free(b->pars_l);
 
342
  if(b->ui_l)     Free(b->ui_l);
 
343
  if(b->p_pars_l) Free(b->p_pars_l);
 
344
}
 
345
 
 
346
//////////////////////////////////////////////////////////////
 
347
//////////////////////////////////////////////////////////////
 
348
 
 
349
void Free_Edge_Pars_Rght(t_edge *b)
 
350
{
 
351
  if(b->pars_r)   Free(b->pars_r);    
 
352
  if(b->ui_r)     Free(b->ui_r);
 
353
  if(b->p_pars_r) Free(b->p_pars_r);
 
354
}
 
355
 
 
356
//////////////////////////////////////////////////////////////
 
357
//////////////////////////////////////////////////////////////
 
358
 
 
359
void Free_Edge_Pars(t_edge *b)
 
360
{
 
361
  Free_Edge_Pars_Left(b);
 
362
  Free_Edge_Pars_Rght(b);
 
363
}
 
364
 
 
365
//////////////////////////////////////////////////////////////
 
366
//////////////////////////////////////////////////////////////
 
367
 
 
368
 
 
369
void Free_Tree_Lk(t_tree *mixt_tree)
 
370
{
 
371
  int i;
 
372
  t_tree *tree;
 
373
 
 
374
  tree = mixt_tree;
 
375
  do
 
376
    {
 
377
      Free(tree->c_lnL_sorted);
 
378
      Free(tree->cur_site_lk);
 
379
      Free(tree->old_site_lk);
 
380
      Free(tree->site_lk_cat);
 
381
 
 
382
      For(i,3) Free(tree->log_lks_aLRT[i]);
 
383
      Free(tree->log_lks_aLRT);
 
384
            
 
385
      For(i,MAX(tree->mod->ras->n_catg,tree->mod->n_mixt_classes)) 
 
386
        Free(tree->log_site_lk_cat[i]);
 
387
      Free(tree->log_site_lk_cat);
 
388
 
 
389
      For(i,2*tree->n_otu-3) Free_Edge_Lk(tree->a_edges[i]);
 
390
      
 
391
      if(tree->n_root)
 
392
        {
 
393
          Free(tree->n_root->b[1]->nni);
 
394
          Free(tree->n_root->b[2]->nni);
 
395
          Free(tree->n_root->b[1]->Pij_rr);
 
396
          Free(tree->n_root->b[2]->Pij_rr);
 
397
          Free_Edge_Lk_Left(tree->n_root->b[1]);
 
398
          Free_Edge_Lk_Left(tree->n_root->b[2]);
 
399
        }
 
400
      else
 
401
        {
 
402
          Free_Edge_Lk(tree->a_edges[2*tree->n_otu-3]);
 
403
          Free_Edge_Lk(tree->a_edges[2*tree->n_otu-2]);
 
404
        }
 
405
      tree = tree->next;
 
406
    }
 
407
  while(tree);
 
408
 
 
409
}  
 
410
  
 
411
//////////////////////////////////////////////////////////////
 
412
//////////////////////////////////////////////////////////////
 
413
 
 
414
 
 
415
void Free_Node_Lk(t_node *n)
 
416
{
 
417
/*   Free(n->n_ex_nodes); */
 
418
}
 
419
 
 
420
//////////////////////////////////////////////////////////////
 
421
//////////////////////////////////////////////////////////////
 
422
 
 
423
void Free_Edge_Lk_Rght(t_edge *b)
 
424
{
 
425
  Free(b->div_post_pred_rght);
 
426
 
 
427
  if(b->p_lk_rght)
 
428
    {
 
429
      Free(b->p_lk_rght);
 
430
      if(b->sum_scale_rght) Free(b->sum_scale_rght);
 
431
    }
 
432
  
 
433
  if(b->p_lk_tip_r) Free(b->p_lk_tip_r);
 
434
 
 
435
  Free(b->sum_scale_rght_cat);
 
436
  Free(b->patt_id_rght);
 
437
  Free(b->p_lk_loc_rght);
 
438
  
 
439
}
 
440
 
 
441
//////////////////////////////////////////////////////////////
 
442
//////////////////////////////////////////////////////////////
 
443
 
 
444
void Free_Edge_Lk_Left(t_edge *b)
 
445
{
 
446
 
 
447
  Free(b->div_post_pred_left);
 
448
 
 
449
  if(b->p_lk_left)
 
450
    {
 
451
      Free(b->p_lk_left);
 
452
      if(b->sum_scale_left) Free(b->sum_scale_left);
 
453
    }
 
454
 
 
455
  if(b->p_lk_tip_l) Free(b->p_lk_tip_l);
 
456
 
 
457
  Free(b->sum_scale_left_cat);
 
458
  Free(b->patt_id_left);
 
459
  Free(b->p_lk_loc_left);
 
460
  
 
461
}
 
462
 
 
463
//////////////////////////////////////////////////////////////
 
464
//////////////////////////////////////////////////////////////
 
465
 
 
466
void Free_Edge_Lk(t_edge *b)
 
467
{
 
468
  Free(b->nni);
 
469
  Free(b->Pij_rr);
 
470
  Free_Edge_Lk_Left(b);
 
471
  Free_Edge_Lk_Rght(b);
 
472
}
 
473
 
 
474
//////////////////////////////////////////////////////////////
 
475
//////////////////////////////////////////////////////////////
 
476
 
 
477
void Free_Model_Complete(t_mod *mixt_mod)
 
478
{
 
479
  Free_Eigen(mixt_mod->eigen);
 
480
  Free_Rmat(mixt_mod->r_mat);
 
481
  Free_Efrq(mixt_mod->e_frq); 
 
482
  Free_Vect_Dbl(mixt_mod->Pij_rr);
 
483
  mixt_mod->r_mat = NULL;
 
484
  mixt_mod->e_frq = NULL;
 
485
}
 
486
 
 
487
//////////////////////////////////////////////////////////////
 
488
//////////////////////////////////////////////////////////////
 
489
 
 
490
void Free_Model_Basic(t_mod *mixt_mod)
 
491
{
 
492
  t_mod *mod;
 
493
 
 
494
  Free_RAS(mixt_mod->ras);      
 
495
  Free_Vect_Dbl(mixt_mod->user_b_freq);
 
496
  Free_Scalar_Dbl(mixt_mod->mr);
 
497
  Free_Scalar_Dbl(mixt_mod->kappa);
 
498
  Free_Scalar_Dbl(mixt_mod->lambda);
 
499
  Free_Scalar_Dbl(mixt_mod->br_len_multiplier);
 
500
  Free_Scalar_Dbl(mixt_mod->e_frq_weight);
 
501
  Free_Scalar_Dbl(mixt_mod->r_mat_weight);
 
502
  Free_String(mixt_mod->modelname);
 
503
  Free_String(mixt_mod->custom_mod_string);
 
504
  Free_String(mixt_mod->aa_rate_mat_file);
 
505
 
 
506
  mod = mixt_mod;
 
507
  do
 
508
    {
 
509
      if(mod->next)
 
510
        {
 
511
          mod = mod->next;
 
512
          Free(mod->prev);
 
513
        }
 
514
      else
 
515
        {
 
516
          Free(mod);
 
517
          break;
 
518
        }
 
519
    }
 
520
  while(mod);
 
521
 
 
522
}
 
523
 
 
524
//////////////////////////////////////////////////////////////
 
525
//////////////////////////////////////////////////////////////
 
526
 
 
527
void Free_Vect_Dbl(vect_dbl *v)
 
528
{
 
529
  vect_dbl *next;
 
530
 
 
531
  next = v->next;
 
532
  do
 
533
    {
 
534
      Free(v->v);
 
535
      Free(v);
 
536
 
 
537
      v = next;
 
538
      if(v) next = v->next;
 
539
    }
 
540
  while(v);
 
541
}
 
542
 
 
543
//////////////////////////////////////////////////////////////
 
544
//////////////////////////////////////////////////////////////
 
545
 
 
546
void Free_Scalar_Dbl(scalar_dbl *v)
 
547
{
 
548
  scalar_dbl *next;
 
549
 
 
550
  next = v->next;
 
551
  do
 
552
    {
 
553
      Free(v);
 
554
      v = next;
 
555
      if(v) next = v->next;
 
556
    }
 
557
  while(v);
 
558
}
 
559
 
 
560
//////////////////////////////////////////////////////////////
 
561
//////////////////////////////////////////////////////////////
 
562
 
 
563
void Free_String(t_string *ts)
 
564
{
 
565
  t_string *next;
 
566
 
 
567
  next = ts->next;
 
568
  do
 
569
    {
 
570
      Free(ts->s);      
 
571
      Free(ts);
 
572
 
 
573
      ts = next;
 
574
      if(ts) next = ts->next;
 
575
    }
 
576
  while(ts);
 
577
}
 
578
 
 
579
//////////////////////////////////////////////////////////////
 
580
//////////////////////////////////////////////////////////////
 
581
 
 
582
void Free_Custom_Model(t_mod *mod)
 
583
{
 
584
  if(mod->r_mat->rr->v)
 
585
    {
 
586
      Free(mod->r_mat->rr_num->v);
 
587
      Free(mod->r_mat->rr->v);
 
588
      Free(mod->r_mat->rr_val->v);
 
589
      Free(mod->r_mat->n_rr_per_cat->v);
 
590
    }
 
591
}
 
592
 
 
593
//////////////////////////////////////////////////////////////
 
594
//////////////////////////////////////////////////////////////
 
595
 
 
596
void Free_Efrq(t_efrq *e_frq)
 
597
{
 
598
  Free(e_frq->pi->v);
 
599
  Free(e_frq->pi);
 
600
  
 
601
  Free(e_frq->pi_unscaled->v);
 
602
  Free(e_frq->pi_unscaled);
 
603
  
 
604
  if(e_frq->next) Free_Efrq(e_frq->next);
 
605
 
 
606
  Free(e_frq);
 
607
}
 
608
 
 
609
//////////////////////////////////////////////////////////////
 
610
//////////////////////////////////////////////////////////////
 
611
 
 
612
void Free_Rmat(t_rmat *r_mat)
 
613
{
 
614
  Free(r_mat->rr->v);
 
615
  Free(r_mat->rr);
 
616
  
 
617
  Free(r_mat->rr_num->v);
 
618
  
 
619
  Free(r_mat->rr_val->v);
 
620
  Free(r_mat->rr_val);
 
621
  
 
622
  Free(r_mat->n_rr_per_cat->v);      
 
623
  Free(r_mat->n_rr_per_cat);
 
624
  
 
625
  Free(r_mat->rr_num);
 
626
  
 
627
  Free(r_mat->qmat->v);
 
628
  Free(r_mat->qmat);
 
629
  
 
630
  Free(r_mat->qmat_buff->v);
 
631
  Free(r_mat->qmat_buff);
 
632
  
 
633
  if(r_mat->next) Free_Rmat(r_mat->next);
 
634
 
 
635
  Free(r_mat);
 
636
}
 
637
 
 
638
//////////////////////////////////////////////////////////////
 
639
//////////////////////////////////////////////////////////////
 
640
 
 
641
void Free_RAS(t_ras *ras)
 
642
{
 
643
  if(ras->gamma_r_proba->v)
 
644
    {
 
645
      Free(ras->gamma_r_proba->v);
 
646
      Free(ras->gamma_r_proba_unscaled->v);
 
647
      Free(ras->gamma_rr->v);
 
648
      Free(ras->gamma_rr_unscaled->v);
 
649
    }
 
650
  
 
651
  Free(ras->gamma_r_proba);
 
652
  Free(ras->skip_rate_cat);
 
653
  
 
654
  Free(ras->gamma_r_proba_unscaled);
 
655
  Free(ras->gamma_rr);
 
656
  Free(ras->gamma_rr_unscaled);
 
657
  Free_Scalar_Dbl(ras->pinvar);
 
658
  Free_Scalar_Dbl(ras->alpha);
 
659
  Free_Scalar_Dbl(ras->free_rate_mr);
 
660
  
 
661
  if(ras->next) Free_RAS(ras->next);
 
662
 
 
663
  Free(ras);
 
664
}
 
665
 
 
666
 
 
667
//////////////////////////////////////////////////////////////
 
668
//////////////////////////////////////////////////////////////
 
669
 
 
670
void Free_Model(t_mod *mod)
 
671
{
 
672
  Free_Custom_Model(mod);
 
673
  Free_Model_Complete(mod);
 
674
  if(mod->m4mod) M4_Free_M4_Model(mod->m4mod);
 
675
  Free_Model_Basic(mod);
 
676
  /* Free(mod); */
 
677
}
 
678
 
 
679
//////////////////////////////////////////////////////////////
 
680
//////////////////////////////////////////////////////////////
 
681
 
 
682
 
 
683
void Free(void *p)
 
684
{  
 
685
  free(p);
 
686
  p = NULL;
 
687
}
 
688
 
 
689
//////////////////////////////////////////////////////////////
 
690
//////////////////////////////////////////////////////////////
 
691
 
 
692
 
 
693
void Free_Input(option *io)
 
694
{
 
695
  int i;
 
696
  
 
697
  do
 
698
    {
 
699
      RATES_Free_Rates(io->rates);
 
700
      MCMC_Free_MCMC(io->mcmc);
 
701
      Free(io->in_align_file);
 
702
      Free(io->in_tree_file);
 
703
      Free(io->in_constraint_tree_file);
 
704
      Free(io->out_tree_file);
 
705
      Free(io->out_trees_file);
 
706
      Free(io->out_boot_tree_file);
 
707
      Free(io->out_boot_stats_file);
 
708
      Free(io->out_stats_file);
 
709
      Free(io->out_lk_file); 
 
710
      Free(io->out_ps_file);
 
711
      Free(io->out_trace_file);
 
712
      Free(io->nt_or_cd);
 
713
      Free(io->run_id_string);
 
714
      Free(io->clade_list_file);
 
715
      For(i,T_MAX_ALPHABET) Free(io->alphabet[i]);
 
716
      Free(io->alphabet);
 
717
      if(io->short_tax_names)
 
718
        {
 
719
          For(i,io->size_tax_names) 
 
720
            {
 
721
              Free(io->short_tax_names[i]);
 
722
              Free(io->long_tax_names[i]);
 
723
            }
 
724
          Free(io->long_tax_names);
 
725
          Free(io->short_tax_names);
 
726
        }
 
727
      Free_Tree_List(io->treelist);
 
728
 
 
729
      if(io->lon) Free(io->lon);
 
730
      if(io->lat) Free(io->lat);
 
731
 
 
732
      if(io->next) 
 
733
        {
 
734
          io = io->next;      
 
735
          Free(io->prev);
 
736
        }
 
737
      else
 
738
        {
 
739
          Free(io);
 
740
          break;
 
741
        }
 
742
 
 
743
    }while(1);
 
744
}
 
745
 
 
746
//////////////////////////////////////////////////////////////
 
747
//////////////////////////////////////////////////////////////
 
748
 
 
749
void Free_Tree_List(t_treelist *list)
 
750
{
 
751
  Free(list->tree);
 
752
  Free(list);
 
753
}
 
754
 
 
755
//////////////////////////////////////////////////////////////
 
756
//////////////////////////////////////////////////////////////
 
757
 
 
758
void Free_St(supert_tree *st)
 
759
{
 
760
  int i;
 
761
 
 
762
  For(i,2*st->tree->n_otu-1) 
 
763
    Free(st->tree->a_edges[i]->nni);
 
764
 
 
765
  For(i,st->n_part) Free(st->match_st_node_in_gt[i]);
 
766
 
 
767
  Free(st->match_st_node_in_gt);
 
768
 
 
769
  Free_Tree(st->tree);
 
770
  
 
771
  Free(st);
 
772
}
 
773
 
 
774
//////////////////////////////////////////////////////////////
 
775
//////////////////////////////////////////////////////////////
 
776
 
 
777
 
 
778
void Free_Eigen(eigen *eigen_struct)
 
779
{
 
780
  Free(eigen_struct->space_int);
 
781
  Free(eigen_struct->space);
 
782
  Free(eigen_struct->e_val);
 
783
  Free(eigen_struct->e_val_im);
 
784
  Free(eigen_struct->r_e_vect);
 
785
  Free(eigen_struct->r_e_vect_im);
 
786
  Free(eigen_struct->l_e_vect);
 
787
  Free(eigen_struct->q);
 
788
 
 
789
  if(eigen_struct->next) Free_Eigen(eigen_struct->next);
 
790
 
 
791
  Free(eigen_struct);
 
792
}
 
793
 
 
794
//////////////////////////////////////////////////////////////
 
795
//////////////////////////////////////////////////////////////
 
796
 
 
797
 
 
798
void Free_One_Spr(t_spr *this_spr)
 
799
{
 
800
  Free(this_spr->path);
 
801
  Free(this_spr);
 
802
}
 
803
 
 
804
//////////////////////////////////////////////////////////////
 
805
//////////////////////////////////////////////////////////////
 
806
 
 
807
void Free_Spr_List(t_tree *mixt_tree)
 
808
{
 
809
  int i;
 
810
  t_tree *tree;
 
811
 
 
812
  tree = mixt_tree;
 
813
  do
 
814
    {
 
815
      For(i,tree->size_spr_list+1) Free_One_Spr(tree->spr_list[i]);  
 
816
      Free(tree->spr_list);
 
817
      Free_One_Spr(tree->best_spr);
 
818
      tree = tree->next;
 
819
    }
 
820
  while(tree);
 
821
 
 
822
}
 
823
 
 
824
//////////////////////////////////////////////////////////////
 
825
//////////////////////////////////////////////////////////////
 
826
 
 
827
void Free_Triplet(triplet *t)
 
828
{
 
829
  int i,j,k;
 
830
 
 
831
  Free(t->F_bc);
 
832
  Free(t->F_cd);
 
833
  Free(t->F_bd);
 
834
  Free(t->pi_bc);
 
835
  Free(t->pi_cd);
 
836
  Free(t->pi_bd);
 
837
 
 
838
  For(k,t->mod->ras->n_catg) 
 
839
    {
 
840
      For(i,t->size) 
 
841
        {
 
842
          For(j,t->size) Free(t->core[k][i][j]);  
 
843
          Free(t->core[k][i]);
 
844
        }
 
845
      Free(t->core[k]);   
 
846
    }
 
847
  Free(t->core);
 
848
 
 
849
  For(i,t->size) 
 
850
    {
 
851
      For(j,t->size) Free(t->p_one_site[i][j]);  
 
852
      Free(t->p_one_site[i]);
 
853
    }
 
854
  Free(t->p_one_site);
 
855
 
 
856
  For(i,t->size) 
 
857
    {
 
858
      For(j,t->size) Free(t->sum_p_one_site[i][j]);  
 
859
      Free(t->sum_p_one_site[i]);
 
860
    }
 
861
  Free(t->sum_p_one_site);
 
862
 
 
863
  Free_Eigen(t->eigen_struct);
 
864
 
 
865
  if(t->next) Free_Triplet(t->next);
 
866
  
 
867
  Free(t);
 
868
}
 
869
 
 
870
//////////////////////////////////////////////////////////////
 
871
//////////////////////////////////////////////////////////////
 
872
 
 
873
 
 
874
void Free_Actual_CSeq(calign *data)
 
875
{
 
876
  int i;
 
877
  For(i,data->n_otu)
 
878
    {
 
879
      Free(data->c_seq[i]->state);
 
880
      Free(data->c_seq[i]->d_state);
 
881
      data->c_seq[i]->state = NULL;
 
882
    }
 
883
}
 
884
 
 
885
//////////////////////////////////////////////////////////////
 
886
//////////////////////////////////////////////////////////////
 
887
 
 
888
 
 
889
void Free_Prefix_Tree(pnode *n, int size)
 
890
{
 
891
  int i;
 
892
  
 
893
  For(i,size)
 
894
    {
 
895
      if(n->next[i])
 
896
        {
 
897
          Free_Prefix_Tree(n->next[i],size);
 
898
        }
 
899
    }
 
900
  Free_Pnode(n);
 
901
}
 
902
 
 
903
//////////////////////////////////////////////////////////////
 
904
//////////////////////////////////////////////////////////////
 
905
 
 
906
 
 
907
void Free_Pnode(pnode *n)
 
908
{
 
909
  Free(n->next);
 
910
  Free(n);
 
911
}
 
912
 
 
913
//////////////////////////////////////////////////////////////
 
914
//////////////////////////////////////////////////////////////
 
915
 
 
916
void Free_Optimiz(t_opt *s_opt)
 
917
{
 
918
  Free(s_opt);
 
919
}
 
920
 
 
921
//////////////////////////////////////////////////////////////
 
922
//////////////////////////////////////////////////////////////
 
923
 
 
924
void Free_Nexus(option *io)
 
925
{
 
926
  int i,j;
 
927
  
 
928
  For(i,N_MAX_NEX_COM)
 
929
    {
 
930
      For(j,io->nex_com_list[i]->nparm) Free_Nexus_Parm(io->nex_com_list[i]->parm[j]);
 
931
      Free(io->nex_com_list[i]->parm);
 
932
      Free(io->nex_com_list[i]->name);
 
933
      Free(io->nex_com_list[i]);      
 
934
    }
 
935
  Free(io->nex_com_list);
 
936
}
 
937
 
 
938
//////////////////////////////////////////////////////////////
 
939
//////////////////////////////////////////////////////////////
 
940
 
 
941
 
 
942
void Free_Nexus_Com(nexcom **com)
 
943
{
 
944
  int i;
 
945
 
 
946
  For(i,N_MAX_NEX_COM)
 
947
    {
 
948
      Free(com[i]->parm);
 
949
      Free(com[i]->name);
 
950
      Free(com[i]);
 
951
    }
 
952
  Free(com);
 
953
}
 
954
 
 
955
//////////////////////////////////////////////////////////////
 
956
//////////////////////////////////////////////////////////////
 
957
 
 
958
void Free_Nexus_Parm(nexparm *parm)
 
959
{
 
960
  Free(parm->value);
 
961
  Free(parm->name);
 
962
  Free(parm);
 
963
}
 
964
 
 
965
//////////////////////////////////////////////////////////////
 
966
//////////////////////////////////////////////////////////////
 
967
 
 
968
void XML_Free_XML_Tree(xml_node *node)
 
969
{
 
970
  if(node->child) XML_Free_XML_Tree(node->child);
 
971
  if(node->next)  XML_Free_XML_Tree(node->next);
 
972
  XML_Free_XML_Node(node);
 
973
}
 
974
 
 
975
//////////////////////////////////////////////////////////////
 
976
//////////////////////////////////////////////////////////////
 
977
 
 
978
void XML_Free_XML_Node(xml_node *node)
 
979
{
 
980
  Free(node->id);
 
981
  Free(node->name);
 
982
  Free(node->value);
 
983
  XML_Free_XML_Ds(node->ds);
 
984
  XML_Free_XML_Attr(node->attr);
 
985
  Free(node);
 
986
}
 
987
 
 
988
//////////////////////////////////////////////////////////////
 
989
//////////////////////////////////////////////////////////////
 
990
 
 
991
void XML_Free_XML_Attr(xml_attr *attr)
 
992
{
 
993
  if(attr)
 
994
    {
 
995
      Free(attr->name);
 
996
      Free(attr->value);
 
997
      if(attr->next) XML_Free_XML_Attr(attr->next);
 
998
      Free(attr);
 
999
    }
 
1000
}
 
1001
 
 
1002
//////////////////////////////////////////////////////////////
 
1003
//////////////////////////////////////////////////////////////
 
1004
 
 
1005
void XML_Free_XML_Ds(t_ds *ds)
 
1006
{
 
1007
  if(ds->next) XML_Free_XML_Ds(ds->next);
 
1008
  Free(ds);
 
1009
}
 
1010
 
 
1011
//////////////////////////////////////////////////////////////
 
1012
//////////////////////////////////////////////////////////////
 
1013
 
 
1014
//////////////////////////////////////////////////////////////
 
1015
//////////////////////////////////////////////////////////////
 
1016
 
 
1017
void MCMC_Free_MCMC(t_mcmc *mcmc)
 
1018
{
 
1019
  int i;
 
1020
  
 
1021
  Free(mcmc->move_type);
 
1022
  Free(mcmc->adjust_tuning);
 
1023
  Free(mcmc->out_filename);
 
1024
  Free(mcmc->move_weight);
 
1025
  Free(mcmc->acc_move);
 
1026
  Free(mcmc->run_move);
 
1027
  Free(mcmc->prev_acc_move);
 
1028
  Free(mcmc->prev_run_move);
 
1029
  Free(mcmc->acc_rate);
 
1030
  Free(mcmc->tune_move);
 
1031
  For(i,mcmc->n_moves) Free(mcmc->move_name[i]);
 
1032
  Free(mcmc->move_name);
 
1033
  Free(mcmc->ess_run);
 
1034
  Free(mcmc->start_ess);
 
1035
  Free(mcmc->ess);
 
1036
  Free(mcmc->sum_val);
 
1037
  Free(mcmc->sum_valsq);
 
1038
  Free(mcmc->sum_curval_nextval);
 
1039
  Free(mcmc->first_val);
 
1040
  Free(mcmc->old_param_val);
 
1041
  Free(mcmc->new_param_val);
 
1042
  Free(mcmc);
 
1043
}
 
1044
 
 
1045
//////////////////////////////////////////////////////////////
 
1046
//////////////////////////////////////////////////////////////
 
1047
 
 
1048
 
 
1049
//////////////////////////////////////////////////////////////
 
1050
//////////////////////////////////////////////////////////////
 
1051
 
 
1052
void M4_Free_M4_Model(m4 *m4mod)
 
1053
{
 
1054
  int i;
 
1055
  
 
1056
  if(m4mod->o_mats)
 
1057
    {
 
1058
      For(i,m4mod->n_h) Free(m4mod->o_mats[i]);
 
1059
      Free(m4mod->o_mats);      
 
1060
      Free(m4mod->h_mat);
 
1061
      Free(m4mod->o_rr);
 
1062
      Free(m4mod->h_rr);
 
1063
      Free(m4mod->o_fq);
 
1064
      Free(m4mod->h_fq);
 
1065
      Free(m4mod->multipl);
 
1066
      Free(m4mod->multipl_unscaled);
 
1067
      Free(m4mod->h_fq_unscaled);
 
1068
    }
 
1069
 
 
1070
  Free(m4mod);
 
1071
}
 
1072
 
 
1073
//////////////////////////////////////////////////////////////
 
1074
//////////////////////////////////////////////////////////////
 
1075
 
 
1076
void RATES_Free_Rates(t_rate *rates)
 
1077
{
 
1078
  if(rates->is_allocated == YES)
 
1079
    {
 
1080
      Free(rates->nd_r);
 
1081
      Free(rates->br_r);
 
1082
      Free(rates->buff_r);
 
1083
      Free(rates->true_r);
 
1084
      Free(rates->buff_t);
 
1085
      Free(rates->nd_t);
 
1086
      Free(rates->true_t);
 
1087
      Free(rates->t_prior);
 
1088
      Free(rates->t_mean);
 
1089
      Free(rates->t_prior_min);
 
1090
      Free(rates->t_prior_max);
 
1091
      Free(rates->t_floor);
 
1092
      Free(rates->t_has_prior);
 
1093
      Free(rates->t_ranked);
 
1094
      Free(rates->dens);   
 
1095
      Free(rates->triplet);    
 
1096
      Free(rates->n_jps);  
 
1097
      Free(rates->t_jps);    
 
1098
      Free(rates->cond_var);
 
1099
      Free(rates->invcov);   
 
1100
      Free(rates->ml_l);
 
1101
      Free(rates->cur_l);
 
1102
      Free(rates->u_ml_l);
 
1103
      Free(rates->u_cur_l);
 
1104
      Free(rates->cov_r);
 
1105
      Free(rates->lca);
 
1106
      Free(rates->trip_cond_cov);
 
1107
      Free(rates->trip_reg_coeff);
 
1108
      Free(rates->_2n_vect1);
 
1109
      Free(rates->_2n_vect2);
 
1110
      Free(rates->_2n_vect3);
 
1111
      Free(rates->_2n_vect4);
 
1112
      Free(rates->_2n_vect5);
 
1113
      Free(rates->_2n2n_vect1);
 
1114
      Free(rates->_2n2n_vect2);
 
1115
      Free(rates->cov_l);
 
1116
      Free(rates->mean_l);
 
1117
      Free(rates->mean_t);
 
1118
      Free(rates->grad_l);
 
1119
      Free(rates->br_do_updt);
 
1120
      Free(rates->cur_gamma_prior_mean);
 
1121
      Free(rates->cur_gamma_prior_var);
 
1122
      Free(rates->n_tips_below);
 
1123
      Free(rates->time_slice_lims);
 
1124
      Free(rates->n_time_slice_spans);
 
1125
      Free(rates->curr_slice);
 
1126
      Free(rates->has_survived);
 
1127
      Free(rates->survival_rank);
 
1128
      Free(rates->survival_dur);
 
1129
      Free(rates->calib_prob);
 
1130
    }
 
1131
  Free_Calib(rates->calib);
 
1132
  Free(rates);
 
1133
}
 
1134
 
 
1135
//////////////////////////////////////////////////////////////
 
1136
//////////////////////////////////////////////////////////////
 
1137
 
 
1138
void Free_Calib(t_cal *cal)
 
1139
{
 
1140
  if(!cal) return;
 
1141
  else Free_Calib(cal->next);
 
1142
  Free(cal);
 
1143
}
 
1144