Getting tree attributes

ntrees(tree::AbstractTree)

Returns the number of trees in a tree object, 1 for a OneTree tree type, and the count of trees for a ManyTrees type.

gettree(tree::AbstractTree, label)

Returns a single OneTree object tree corresponding to the label given.

gettrees(tree::AbstractTree)

Returns an iterable of trees.

nroots(::AbstractTree)

Returns the number of roots in a tree. For OneTree types, Unrooted trees will return 0, OneRoot trees should return 1, and manyroots tree (ones with multiple subtrees) will return the number of subtrees. ManyTrees types will return a Dict of counts of the number of roots for each tree in the set.

getroots(::AbstractTree)
getroots(::AbstractTree, id)

Returns a vector containing the root(s) of a single (OneTree) tree or a set of (ManyTrees) trees.

gettreenames(tree::AbstractTree)

Returns the names of the trees.

mrca(tree::AbstractTree, target)

Returns the node within tree that is the Most Recent Common Ancestor of the leaves (or internal nodes) defined by target. target can be an iterator over nodes or an AbstractArray of nodes. The return value has the same node type as the elements of target.

Examples

≡≡≡≡≡≡≡≡≡≡≡

julia> tree = open(parsenewick, Phylo.path("H1N1.newick")) RootedTree with 507 tips, 1013 nodes and 1012 branches. Leaf names are 227, 294, 295, 110, 390, ... [501 omitted] ... and 418

julia> tips = rand(collect(nodefilter(isleaf, tree)), 3) 3-element Vector{LinkNode{OneRoot, String, Dict{String, Any}, LinkBranch{OneRoot, String, Dict{String, Any}, Float64}}}: LinkNode 153, a tip of the tree with an incoming connection (branch 888).

LinkNode 120, a tip of the tree with an incoming connection (branch 195).

LinkNode 504, a tip of the tree with an incoming connection (branch 44).

julia> mrca(tree, tips) LinkNode Node 1003, an internal node with 1 inbound and 2 outbound connections (branches 1001 and 999, 1000)

nodeheights(tree::Phylo.AbstractTree; onlyleaves = false, noleaves = false)

Returns an AxisArray of the height of all nodes in tree over the root node. onlyleaves and noleaves filter the nodes for leaves and internal nodes, respectively

getleafnames(::AbstractTree[, ::TraversalOrder])

Retrieve the leaf names from the tree (in some specific order).

getleaves(::AbstractTree[, ::TraversalOrder])

Retrieve the leaves from the tree.

nleaves(::AbstractTree)

Returns the number of leaves (tips) in a tree.

nnodes(::AbstractTree)

Returns the number of nodes of a single tree, or a Dict of numbers of nodes for multiple trees.

ninternal(::AbstractTree)

Returns the number of internal nodes of a single tree, or a Dict of numbers of nodes for multiple trees.

nbranches(::AbstractTree)

Returns the number of branches of a single tree, or a Dict of numbers of branches for multiple trees.

distance(tree::AbstractTree, node1, node2)

Distance between two nodes on a tree

distances(tree::AbstractTree)

Pairwise distances between all leaf nodes on a tree

heighttoroot(tree::AbstractTree, node)

Height of a node of the tree above the root

heightstoroot(tree::AbstractTree)

Height of all of the leaves of the tree above the root

getroot(::AbstractTree)

Returns the root of a single tree (must be only one tree for a ManyTrees tree).

treenametype(::Type{AbstractTree})

Returns the name type for a tree type.

gettreename(tree::AbstractTree)

Returns the name of the single tree.

roottype(::Type{AbstractTree})
roottype(::Type{AbstractElt})

Returns root type from a tree, node, branch or other element type.

nodetype(::Type{AbstractTree})

Returns type of nodes from a tree type.

nodedatatype(::Type{<: AbstractTree})

retrieve the node info type of a tree.

nodenametype(::Type{AbstractTree})
nodenametype(::Type{AbstractElt})

Returns type of node names from a tree type.

branchtype(::Type{AbstractTree})

Returns type of branches from a tree type.

branchdatatype(::Type{<: AbstractTree})

retrieve the branch info type of a tree.

branchnametype(::AbstractTree)

Returns type of branch names from a branch type.

getnodenames(::AbstractTree[, ::TraversalOrder])

Return a vector of node names of a single tree (identified by id for a ManyTrees tree), or a Dict of vectors of node names for multiple trees.

getnodename(::AbstractTree, node)

Returns the node name associated with a node from a tree. For some node types, it will be able to extract the node name without reference to the tree.

hasnode(tree::AbstractTree, node)

Returns whether a tree has a given node (or node name) or not.

getnode(tree::AbstractTree, nodename)

Returns a node from a tree.

getnodes(::AbstractTree[, ::TraversalOrder])

Returns the vector of nodes of a single tree, or a Dict of vectors of nodes for multiple trees.

getinternalnodes(t::AbstractTree)

Function to retrieve only the internal nodes from a tree, t, which does not include tips or root.

getbranchnames(tree::AbstractTree)

Return a vector of branch names of a single tree, or a Dict of vectors of branch names for multiple trees.

getbranchname(::AbstractTree, branch)
getbranchname(branch)

Returns the branch name associated with a branch from a tree. For some branch types, it will be able to extract the branch name without reference to the tree.

hasbranch(tree::AbstractTree, branch)
hasbranch(tree::AbstractTree, source, dest)

Does tree have a branch branch or a branch from source to dest?

getbranch(tree::AbstractTree, branch)
getbranch(tree::AbstractTree, source, dest)

Returns a branch from a tree by name or by source and destination node.

getbranches(::AbstractTree)

Returns the vector of branches of a single tree, or a Dict of vectors of branches for multiple trees.

gettreeinfo(tree::AbstractTree)
gettreeinfo(tree::AbstractTree, treename)

Returns the info data associated with the tree(s).

validate!(tree::AbstractTree)

Validate the tree by making sure that it is connected up correctly.

invalidate!(tree::AbstractTree, state = missing)

Confirm that the tree is no longer necessarily valid, and remove cache information.

branchdims(::Type{<: AbstractTree})

retrieve the dimensions of the branch lengths for the tree.

treetype(::Type{AbstractTree})

Returns tree number (OneTree, ManyTrees) from a tree type.

treesettype(::Type{AbstractTree}, ::Type{LABEL} = String)

Returns type of a TreeSet containing a collection of trees, from those trees' type and the type of label used to identify trees.

isleaf(tree::AbstractTree, node)

Is the node (referenced by name or node object) a leaf of the tree?

isroot(tree::AbstractTree, node)

Is the node (referenced by name or node object) a root of the tree?

isinternal(tree::AbstractTree, node)

Is the node (referenced by name or node object) internal to the tree (neither root nor leaf)?

isunattached(tree::AbstractTree, node)

Is the node (referenced by name or node object) unattached (i.e. not connected to other nodes)?

degree(tree::AbstractTree, node)

Return the degree of a node including all connections.

indegree(tree::AbstractTree, node)

Return in degree of node.

outdegree(tree::AbstractTree, node)

Return out degree of node.

hasinbound(tree::AbstractTree, node)

Does the node have an inbound connection?

getinbound(tree::AbstractTree, node)

return the inbound branch to this node (returns name for node name, branch for node).

getoutbounds(tree::AbstractTree, nodename)

Return the names of the outbound branches from this node.

getconnections(tree::AbstractTree, node, exclude = [])

Returns all of the branches connected to a node.

hasoutboundspace(tree::AbstractTree, node)

Does the node have space for an[other] outbound connection?

hasinboundspace(tree::AbstractTree, node)

Does the node have space for an inbound connection?

getleafinfo(::AbstractTree[, label])

retrieve the leaf info for a leaf of the tree.

setleafinfo!(::AbstractTree, table)

Set the leaf info for the leaves of the tree.

leafinfotype(::Type{<: AbstractTree})

retrieve the leaf info type of a tree.

getnodedata(::AbstractTree, node)

retrieve the node data for a node of the tree.

setnodedata!(::AbstractTree, node, label, value)
setnodedata!(::AbstractTree, node, data)

Set the node data for a node of the tree.

hasheight(tree::AbstractTree, node)

Does the node have a height defined?

getheight(tree::AbstractTree, node)

Return the height of the node.

setheight!(tree::AbstractTree, nodename, height)

Set the height of the node.

getparent(tree::AbstractTree, node)

Return [the name of] the parent node for this node [name]. Second method may not be implemented for some node types.

getancestors(tree::AbstractTree, node)

Return the name of all of the nodes that are ancestral to this node.

getchildren(tree::AbstractTree, node)

Return the [name(s) of] the child node(s) for this node [name].

getdescendants(tree::AbstractTree, node)

Return the names of all of the nodes that descend from this node.

getsiblings(tree::AbstractTree, node)

Returns all of the siblings of a node. Must be implemented for any unrooted AbstractNode subtype, can be inferred from _getparent and _getchildren for a rooted node.

src(tree::AbstractTree, branch)

Return the source node for this branch.

dst(tree::AbstractTree, branch)

Return the destination node for this branch.

conn(tree::AbstractTree, branch, exclude)

Return the other node connected to branch that is not exclude.

conns(tree::AbstractTree, branch)

Return the nodes connected to branch.

haslength(tree::AbstractTree, branch)

Return whether the branch has a length.

getlength(tree::AbstractTree, branch)

Return the length of this branch.

hasrootheight(tree::AbstractTree)

Does the tree have an explicit root height

getrootheight(tree::AbstractTree)

Get the tree's root height.

setrootheight!(tree::AbstractTree, height)

Set the tree's root height.

getbranchdata(::AbstractTree, label)

retrieve the branch data for a leaf of the tree.

setbranchdata!(::AbstractTree, branch, label, value)
setbranchdata!(::AbstractTree, branch, data)

Set the branch data for a branch of the tree.