64 std::vector<size_t> visited_indices;
76 if( it.is_first_iteration() ) {
82 auto const node_id = it.node().index();
83 auto const upper_id = it.node().primary_link().outer().node().index();
85 assert( node_id == it.edge().secondary_node().index() );
86 assert( upper_id == it.edge().primary_node().index() );
92 for(
auto const& cur_id : visited_indices ) {
96 assert( cur_id != node_id );
100 auto const upper_br_len = result( upper_id, cur_id );
101 assert( upper_br_len == result( cur_id, upper_id ));
107 assert( result( node_id, cur_id ) == 0.0 );
108 assert( result( cur_id, node_id ) == 0.0 );
109 result( node_id, cur_id ) = upper_br_len + br_len;
110 result( cur_id, node_id ) = upper_br_len + br_len;
115 visited_indices.push_back( node_id );
130 auto vec = std::vector<double>(tree.
node_count(), -1.0);
131 vec[node->
index()] = 0.0;
136 if (it.is_first_iteration()) {
142 assert(vec[it.node().index()] == -1.0);
143 assert(vec[it.link().outer().node().index()] > -1.0);
147 vec[it.node().index()]
148 = vec[it.link().outer().node().index()]
169 #pragma omp parallel for 170 for(
size_t i = 0; i < tree.
edge_count(); ++i ) {
171 auto const& row_edge = tree.
edge_at(i);
173 for(
auto const& col_edge : tree.
edges() ) {
178 if (row_edge.index() == col_edge.index()) {
179 mat(row_edge.index(), row_edge.index()) = 0.0;
184 double pp = node_dist_mat(
185 row_edge.primary_node().index(),
186 col_edge.primary_node().index()
190 double ps = node_dist_mat(
191 row_edge.primary_node().index(),
192 col_edge.secondary_node().index()
196 double sp = node_dist_mat(
197 row_edge.secondary_node().index(),
198 col_edge.primary_node().index()
203 double dist = std::min(pp, std::min(ps, sp));
204 assert(dist <= node_dist_mat(
205 row_edge.secondary_node().index(),
206 col_edge.secondary_node().index()
210 mat(row_edge.index(), col_edge.index())
227 if( edge ==
nullptr ) {
228 throw std::runtime_error(
"Cannot use nullptr edge for distance calulcation." );
237 #pragma omp parallel for 238 for(
size_t i = 0; i < tree.
edge_count(); ++i ) {
239 auto const& col_edge = tree.
edge_at(i);
241 if (edge->
index() == col_edge.index()) {
242 vec[ edge->
index() ] = 0.0;
247 double pp = p_node_dist[ col_edge.primary_node().index() ];
250 double ps = p_node_dist[ col_edge.secondary_node().index() ];
253 double sp = s_node_dist[ col_edge.primary_node().index() ];
257 double dist = std::min(pp, std::min(ps, sp));
258 assert(dist <= s_node_dist[ col_edge.secondary_node().index() ]);
261 vec[ col_edge.index() ]
280 for(
auto const& e : tree.
edges() ) {
281 auto idx_p = e.primary_node().index();
282 auto idx_s = e.secondary_node().index();
284 double d = (leaf_dist[idx_p].second
286 + leaf_dist[ idx_s ].second) / 2.0;
299 template<
class Comparator >
306 std::vector<std::pair< TreeNode const*, double>> vec;
307 vec.resize(tree.
node_count(), {
nullptr, 0.0});
310 throw std::runtime_error(
"Invalid node_branch_length_distance_matrix." );
316 for(
auto const& node : tree.
nodes() ) {
319 assert( vec[ node.index() ].first == nullptr );
322 double res_dist = 0.0;
325 for(
auto const& other : tree.
nodes() ) {
331 double dist = node_distances( node.index(), other.index() );
332 if( res_node ==
nullptr || comp( dist, res_dist )) {
338 vec[ node.index() ].first = res_node;
339 vec[ node.index() ].second = res_dist;
double deepest_distance(Tree const &tree)
Return the longest distance from any point in the tree (on the edges) to any leaf.
Header of CommonTree distance methods.
utils::Range< IteratorLevelorder< true > > levelorder(ElementType const &element)
size_t edge_count() const
Return the number of TreeEdges of the Tree.
size_t index() const
Return the index of this Edge.
TreeNode & secondary_node()
Return the TreeNode of this TreeEdge that points away from the root.
Container namespace for all symbols of genesis in order to keep them separate when used as a library...
container_type const & data() const
utils::Matrix< double > edge_branch_length_distance_matrix(Tree const &tree)
TreeNode & primary_node()
Return the TreeNode of this TreeEdge that points towards the root.
std::vector< std::pair< TreeNode const *, double > > closest_leaf_distance_vector(Tree const &tree)
Return a vector containing the closest leaf node for each node, using the branch_length as distance m...
std::vector< std::pair< TreeNode const *, double > > leaf_distance_vector(Tree const &tree, utils::Matrix< double > const &node_distances, Comparator comp)
Local helper function to calculate either closest_leaf_distance_vector() or furthest_leaf_distance_ve...
utils::Range< IteratorNodes > nodes()
Class for representing phylogenetic trees.
std::vector< double > node_branch_length_distance_vector(Tree const &tree, TreeNode const *node)
Return a vector containing the distance of all nodes with respect to the given start node...
utils::Range< IteratorEdges > edges()
TreeEdge & edge_at(size_t index)
Return the TreeEdge at a certain index.
std::vector< double > edge_branch_length_distance_vector(Tree const &tree, TreeEdge const *edge)
size_t node_count() const
Return the number of TreeNodes of the Tree.
double branch_length
Branch length of the edge.
utils::Range< IteratorPreorder< true > > preorder(ElementType const &element)
std::vector< std::pair< TreeNode const *, double > > furthest_leaf_distance_vector(Tree const &tree)
Opposite of closest_leaf_distance_vector().
TreeNode & root_node()
Return the TreeNode at the current root of the Tree.
size_t index() const
Return the index of this Node.
Common class containing the commonly needed data for tree edges.
utils::Matrix< double > node_branch_length_distance_matrix(Tree const &tree)
Return a distance matrix containing pairwise distances between all Nodes, using the branch_length of ...
bool is_leaf(TreeLink const &link)
Return true iff the node of the given link is a leaf node.