void to_newick(std::ostream& out, treetree::const_subtree<T> tr) {
if (!tr.childless()) {
out << "(";
for (typename treetree::const_subtree<T>::const_sub_child_iterator
it=tr.begin_sub_child(); it != tr.end_sub_child(); ++it) {
to_newick(out, *it);
out << (boost::next(it) == tr.end_sub_child() ? ")" : ",");
}
}
to_newick(out, tr.root());
}
int test_reroot_2()
{
const char *test_name = "test_reroot_2";
/* A tree whose root has 3 children:
* (A:3,B:3,(C:2,(D:1,E:1)f:1)g:1)h; */
struct rooted_tree tree = tree_5();
struct hash *map = create_label2node_map(tree.nodes_in_order);
struct rnode *node_f = hash_get(map, "f");
const char *exp = "((D:1,E:1)f:0.5,(C:2,(A:3,B:3)h:1)g:0.5);";
reroot_tree(&tree, node_f);
const char *obt = to_newick(tree.root);
if (strcmp (exp, obt) != 0) {
printf ("%s: expected '%s', got '%s'.\n", test_name,
exp, obt);
return 1;
}
printf ("%s: ok.\n", test_name);
return 0;
}
std::string to_newick_string(treetree::tree<T> tr, int digits) {
std::stringstream out;
out << std::setprecision(digits);
to_newick(out, tr);
out << ";";
return out.str();
}
int test_collapse_pure_clades()
{
char *test_name = "test_collapse_pure_clade";
char *exp = "((A:1,B:1.0)f:2.0,C:3)i;";
struct rooted_tree tree = tree_4();
collapse_pure_clades(&tree);
char *obt = to_newick(tree.root);
if (0 != strcmp(exp, obt)) {
printf ("%s: expected %s, got %s.\n", test_name,
exp, obt);
return 1;
}
printf ("%s: ok.\n", test_name);
return 0;
}
int test_reroot()
{
const char *test_name = "test_reroot";
struct rooted_tree tree = tree_3(); /* ((A:1,B:1.0)f:2.0,(C:1,(D:1,E:1)g:2)h:3)i; */
struct hash *map = create_label2node_map(tree.nodes_in_order);
struct rnode *node_g = hash_get(map, "g");
const char *exp = "((D:1,E:1)g:1,(C:1,(A:1,B:1.0)f:5)h:1);";
reroot_tree(&tree, node_g);
const char *obt = to_newick(tree.root);
if (strcmp (exp, obt) != 0) {
printf ("%s: expected '%s', got '%s'.\n", test_name,
exp, obt);
return 1;
}
printf ("%s: ok.\n", test_name);
return 0;
}
int test_clone_subtree()
{
const char *test_name = "test_clone_subtree";
/* ((HRV_A1:1,HRV_A2:1.0)HRV_A:2.0,(HRV_C:1,(HRV_B1:1,HRV_B2:1)HRV_B:2):3)HRV; */
struct rooted_tree tree = tree_8();
struct rooted_tree *clone = clone_subtree(tree.root);
char *orig_newick = to_newick(tree.root);
char *clone_newick = to_newick(clone->root);
struct list_elem *orig_el, *clone_el;
struct rnode *orig_node, *clone_node;
if (strcmp(orig_newick, clone_newick) != 0) {
printf ("%s: Newick strings are different ('%s' != '%s').\n",
test_name, orig_newick, clone_newick);
return 1;
}
/* Check all nodes */
for (orig_el = tree.nodes_in_order->head,
clone_el = clone->nodes_in_order->head;
NULL != orig_el;
orig_el = orig_el->next, clone_el = clone_el->next) {
orig_node = orig_el->data;
clone_node = clone_el->data;
if (orig_node == clone_node) {
printf ("%s: nodes %p and %p are the same object.\n",
test_name, orig_node, clone_node);
return 1;
}
if (strcmp(orig_node->label, clone_node->label) != 0) {
printf ("%s: nodes have different labels ('%s'"
" vs '%s')\n",
test_name, orig_node->label, clone_node->label);
return 1;
}
if (NULL == orig_node->parent) {
if (NULL != clone_node->parent) {
printf ("%s: original's parent is NULL,"
" but clone's is not (%p).\n",
test_name, clone_node->parent);
return 1;
}
}
else {
if (orig_node->parent == clone_node->parent) {
printf ("%s: parent edges are non-NULL yet "
"identical (%p, %p).\n", test_name,
orig_node->parent,
clone_node->parent);
return 1;
}
if (strcmp(orig_node->edge_length_as_string,
clone_node->edge_length_as_string)
!= 0) {
printf ("%s: parent edges have different "
"lengths (%s, %s)\n", test_name,
orig_node->edge_length_as_string,
clone_node->edge_length_as_string);
return 1;
}
}
}
if (NULL != clone_el) {
printf ("%s: clone's children list is not terminated.\n",
test_name);
return 1;
}
printf ("%s: ok.\n", test_name);
return 0;
}
void to_newick(std::ostream& out,const treetree::tree<T>& tr) {
if (!tr.empty())
to_newick(out, treetree::const_subtree<T>(tr));
}
void to_newick(std::ostream& out, treetree::subtree<T> tr) {
to_newick(out, treetree::const_subtree<T>(tr));
}
void process_tree(struct rooted_tree *tree, struct parameters params)
{
struct llist *descendants;
switch (params.mode) {
case EXACT:
descendants = nodes_from_labels(tree, params.labels);
if (NULL == descendants) { perror(NULL); exit(EXIT_FAILURE); }
if (0 == descendants->count) {
fprintf (stderr, "WARNING: no label matches.\n");
/* I don't consider this a failure: it is just the case
* that the tree does not contain the specified labels.
* */
exit(EXIT_SUCCESS);
}
break;
case REGEXP:
descendants = nodes_from_regexp(tree, params.regexp);
if (NULL == descendants) { perror(NULL); exit(EXIT_FAILURE); }
if (0 == descendants->count) {
fprintf (stderr, "WARNING: no match for regexp /%s/\n",
params.regexp_string);
exit(EXIT_SUCCESS); /** see above */
}
break;
default:
fprintf (stderr, "Unknown mode %d\n", params.mode);
exit(EXIT_FAILURE);
}
/* We need a copy b/c lca() modifies its arg */
struct llist *desc_clone = shallow_copy(descendants);
if (NULL == desc_clone) { perror(NULL); exit(EXIT_FAILURE); }
struct rnode *subtree_root = lca(tree, desc_clone);
if (NULL == subtree_root) { perror(NULL); exit(EXIT_FAILURE); }
free(desc_clone); /* elems freed in lca() */
/* Jump up tree to get context, if any was required ('context' > 0) */
int context;
for (context = params.context; context > 0; context--)
if (! is_root(subtree_root))
subtree_root = subtree_root->parent;
// TODO: could not replace to_newick() by dump_newick() due to side
// effects. Investigate.
if (NULL != subtree_root) {
if ((! params.check_monophyly) ||
(is_monophyletic(descendants, subtree_root))) {
/* monophyly of input labels is verified or not
* requested */
char *newick;
if (params.siblings) {
struct llist *sibs = siblings(subtree_root);
if (NULL == sibs) {
perror(NULL);
exit(EXIT_FAILURE);
}
struct list_elem *el;
for (el=sibs->head;NULL!=el;el=el->next) {
struct rnode *sib;
sib = el->data;
newick = to_newick(sib);
printf ("%s\n", newick);
free(newick);
}
destroy_llist(sibs);
} else {
/* normal operation: print clade defined by
* labels. */
newick = to_newick(subtree_root);
printf ("%s\n", newick);
free(newick);
}
}
} else {
fprintf (stderr, "WARNING: LCA not found\n");
}
destroy_llist(descendants);
}
