NAME

Bio::Phylo::Forest::TreeRole - Extra behaviours for a phylogenetic tree

SYNOPSIS

# some way to get a tree
use Bio::Phylo::IO;
my $string = '((A,B),C);';
my $forest = Bio::Phylo::IO->parse(
   -format => 'newick',
   -string => $string
);
my $tree = $forest->first;

# do something:
print $tree->calc_imbalance;

# prints "1"

DESCRIPTION

The object models a phylogenetic tree, a container of Bio::Phylo::Forest::Node objects. The tree object inherits from Bio::Phylo::Listable, so look there for more methods.

METHODS

CONSTRUCTORS

new()

Tree constructor.

Type    : Constructor
Title   : new
Usage   : my $tree = Bio::Phylo::Forest::Tree->new;
Function: Instantiates a Bio::Phylo::Forest::Tree object.
Returns : A Bio::Phylo::Forest::Tree object.
Args    : No required arguments.

new_from_bioperl()

Tree constructor from Bio::Tree::TreeI argument.

Type    : Constructor
Title   : new_from_bioperl
Usage   : my $tree = 
          Bio::Phylo::Forest::Tree->new_from_bioperl(
              $bptree           
          );
Function: Instantiates a 
          Bio::Phylo::Forest::Tree object.
Returns : A Bio::Phylo::Forest::Tree object.
Args    : A tree that implements Bio::Tree::TreeI

QUERIES

get_midpoint()

Gets node that divides tree into two distance-balanced partitions.

Type    : Query
Title   : get_midpoint
Usage   : my $midpoint = $tree->get_midpoint;
Function: Gets node nearest to the middle of the longest path
Returns : A Bio::Phylo::Forest::Node object.
Args    : NONE
Comments: This algorithm was ported from ETE. 
          It assumes the tree has branch lengths.

get_terminals()

Get terminal nodes.

Type    : Query
Title   : get_terminals
Usage   : my @terminals = @{ $tree->get_terminals };
Function: Retrieves all terminal nodes in
          the Bio::Phylo::Forest::Tree object.
Returns : An array reference of 
          Bio::Phylo::Forest::Node objects.
Args    : NONE
Comments: If the tree is valid, this method 
          retrieves the same set of nodes as 
          $node->get_terminals($root). However, 
          because there is no recursion it may 
          be faster. Also, the node method by 
          the same name does not see orphans.

get_internals()

Get internal nodes.

Type    : Query
Title   : get_internals
Usage   : my @internals = @{ $tree->get_internals };
Function: Retrieves all internal nodes 
          in the Bio::Phylo::Forest::Tree object.
Returns : An array reference of 
          Bio::Phylo::Forest::Node objects.
Args    : NONE
Comments: If the tree is valid, this method 
          retrieves the same set of nodes as 
          $node->get_internals($root). However, 
          because there is no recursion it may 
          be faster. Also, the node method by 
          the same name does not see orphans.

get_cherries()

Get all cherries, i.e. nodes that have two terminal children

Type    : Query
Title   : get_cherries
Usage   : my @cherries = @{ $tree->get_cherries };
Function: Returns an array ref of cherries
Returns : ARRAY
Args    : NONE

get_all_rootings()

Gets a forest of all rooted versions of the invocant tree.

Type    : Query
Title   : get_all_rootings
Usage   : my $forest = $tree->get_all_rootings;
Function: Returns an array ref of cherries
Returns : Bio::Phylo::Forest object
Args    : NONE
Comments: This method assumes the invocant tree has a basal trichotomy.
          "Rooted" trees with a basal bifurcation will give strange
          results.

get_root()

Get root node.

Type    : Query
Title   : get_root
Usage   : my $root = $tree->get_root;
Function: Returns the root node.
Returns : Bio::Phylo::Forest::Node
Args    : NONE

get_ntax()

Gets number of tips

Type    : Query
Title   : get_ntax
Usage   : my $ntax = $tree->get_ntax;
Function: Calculates the number of terminal nodes
Returns : Int
Args    : NONE

get_tallest_tip()

Retrieves the node furthest from the root.

Type    : Query
Title   : get_tallest_tip
Usage   : my $tip = $tree->get_tallest_tip;
Function: Retrieves the node furthest from the
          root in the current Bio::Phylo::Forest::Tree
          object.
Returns : Bio::Phylo::Forest::Node
Args    : NONE
Comments: If the tree has branch lengths, the tallest tip is
          based on root-to-tip path length, else it is based
          on number of nodes to root

get_nodes_for_taxa()

Gets node objects for the supplied taxon objects

Type    : Query
Title   : get_nodes_for_taxa
Usage   : my @nodes = @{ $tree->get_nodes_for_taxa(\@taxa) };
Function: Gets node objects for the supplied taxon objects
Returns : array ref of Bio::Phylo::Forest::Node objects
Args    : A reference to an array of Bio::Phylo::Taxa::Taxon objects
          or a Bio::Phylo::Taxa object

get_mrca()

Get most recent common ancestor of argument nodes.

Type    : Query
Title   : get_mrca
Usage   : my $mrca = $tree->get_mrca(\@nodes);
Function: Retrieves the most recent 
          common ancestor of \@nodes
Returns : Bio::Phylo::Forest::Node
Args    : A reference to an array of 
          Bio::Phylo::Forest::Node objects 
          in $tree.

TESTS

is_binary()

Test if tree is bifurcating.

Type    : Test
Title   : is_binary
Usage   : if ( $tree->is_binary ) {
             # do something
          }
Function: Tests whether the invocant 
          object is bifurcating.
Returns : BOOLEAN
Args    : NONE

is_ultrametric()

Test if tree is ultrametric.

Type    : Test
Title   : is_ultrametric
Usage   : if ( $tree->is_ultrametric(0.01) ) {
             # do something
          }
Function: Tests whether the invocant is 
          ultrametric.
Returns : BOOLEAN
Args    : Optional margin between pairwise 
          comparisons (default = 0).
Comments: The test is done by performing 
          all pairwise comparisons for
          root-to-tip path lengths. Since many 
          programs introduce rounding errors 
          in branch lengths the optional argument is
          available to test TRUE for nearly 
          ultrametric trees. For example, a value 
          of 0.01 indicates that no pairwise
          comparison may differ by more than 1%. 
          Note: behaviour is undefined for 
          negative branch lengths.

is_monophyletic()

Tests if first argument (node array ref) is monophyletic with respect to second argument.

Type    : Test
Title   : is_monophyletic
Usage   : if ( $tree->is_monophyletic(\@tips, $node) ) {
             # do something
          }
Function: Tests whether the set of \@tips is
          monophyletic w.r.t. $outgroup.
Returns : BOOLEAN
Args    : A reference to a list of nodes, and a node.
Comments: This method is essentially the
          same as 
          &Bio::Phylo::Forest::Node::is_outgroup_of.

is_paraphyletic()

Type    : Test
Title   : is_paraphyletic
Usage   : if ( $tree->is_paraphyletic(\@nodes,$node) ){ }
Function: Tests whether or not a given set of nodes are paraphyletic
          (representing the full clade) given an outgroup
Returns : [-1,0,1] , -1 if the group is not monophyletic
                      0 if the group is not paraphyletic
                      1 if the group is paraphyletic
Args    : Array ref of node objects which are in the tree,
          Outgroup to compare the nodes to

is_clade()

Tests if argument (node array ref) forms a clade.

 Type    : Test
 Title   : is_clade
 Usage   : if ( $tree->is_clade(\@tips) ) {
              # do something
           }
 Function: Tests whether the set of 
           \@tips forms a clade
 Returns : BOOLEAN
 Args    : A reference to an array of Bio::Phylo::Forest::Node objects, or a
           reference to an array of Bio::Phylo::Taxa::Taxon objects, or a
	   Bio::Phylo::Taxa object
 Comments:

is_cladogram()

Tests if tree is a cladogram (i.e. no branch lengths)

Type    : Test
Title   : is_cladogram
Usage   : if ( $tree->is_cladogram() ) {
             # do something
          }
Function: Tests whether the tree is a 
          cladogram (i.e. no branch lengths)
Returns : BOOLEAN
Args    : NONE
Comments:

CALCULATIONS

calc_branch_length_distance()

Calculates the Euclidean branch length distance between two trees. See Kuhner & Felsenstein (1994). A simulation comparison of phylogeny algorithms under equal and unequal evolutionary rates. MBE 11(3):459-468.

Type    : Calculation
Title   : calc_branch_length_distance
Usage   : my $distance = 
          $tree1->calc_branch_length_distance($tree2);
Function: Calculates the Euclidean branch length distance between two trees
Returns : SCALAR, number
Args    : NONE

calc_branch_length_score()

Calculates the squared Euclidean branch length distance between two trees.

Type    : Calculation
Title   : calc_branch_length_score
Usage   : my $score = 
          $tree1->calc_branch_length_score($tree2);
Function: Calculates the squared Euclidean branch
          length distance between two trees
Returns : SCALAR, number
Args    : A Bio::Phylo::Forest::Tree object,           
          Optional second argument flags that results should be normalized

calc_tree_length()

Calculates the sum of all branch lengths.

Type    : Calculation
Title   : calc_tree_length
Usage   : my $tree_length = 
          $tree->calc_tree_length;
Function: Calculates the sum of all branch 
          lengths (i.e. the tree length).
Returns : FLOAT
Args    : NONE

calc_tree_height()

Calculates the height of the tree.

Type    : Calculation
Title   : calc_tree_height
Usage   : my $tree_height = 
          $tree->calc_tree_height;
Function: Calculates the height 
          of the tree.
Returns : FLOAT
Args    : NONE
Comments: For ultrametric trees this 
          method returns the height, but 
          this is done by averaging over 
          all root-to-tip path lengths, so 
          for additive trees the result 
          should consequently be interpreted
          differently.

calc_number_of_nodes()

Calculates the number of nodes.

Type    : Calculation
Title   : calc_number_of_nodes
Usage   : my $number_of_nodes = 
          $tree->calc_number_of_nodes;
Function: Calculates the number of 
          nodes (internals AND terminals).
Returns : INT
Args    : NONE

calc_number_of_terminals()

Calculates the number of terminal nodes.

Type    : Calculation
Title   : calc_number_of_terminals
Usage   : my $number_of_terminals = 
          $tree->calc_number_of_terminals;
Function: Calculates the number 
          of terminal nodes.
Returns : INT
Args    : NONE

calc_number_of_internals()

Calculates the number of internal nodes.

Type    : Calculation
Title   : calc_number_of_internals
Usage   : my $number_of_internals = 
          $tree->calc_number_of_internals;
Function: Calculates the number 
          of internal nodes.
Returns : INT
Args    : NONE

calc_number_of_cherries()

Calculates the number of cherries, i.e. the number of nodes that subtend exactly two tips. See for applications of this metric: http://dx.doi.org/10.1016/S0025-5564(99)00060-7

Type    : Calculation
Title   : calc_number_of_cherries
Usage   : my $number_of_cherries = 
          $tree->calc_number_of_cherries;
Function: Calculates the number of cherries
Returns : INT
Args    : NONE

calc_total_paths()

Calculates the sum of all root-to-tip path lengths.

Type    : Calculation
Title   : calc_total_paths
Usage   : my $total_paths = 
          $tree->calc_total_paths;
Function: Calculates the sum of all 
          root-to-tip path lengths.
Returns : FLOAT
Args    : NONE

calc_redundancy()

Calculates the amount of shared (redundant) history on the total.

Type    : Calculation
Title   : calc_redundancy
Usage   : my $redundancy = 
          $tree->calc_redundancy;
Function: Calculates the amount of shared 
          (redundant) history on the total.
Returns : FLOAT
Args    : NONE
Comments: Redundancy is calculated as
1 / ( treelength - height / ( ntax * height - height ) )

calc_imbalance()

Calculates Colless' coefficient of tree imbalance.

Type    : Calculation
Title   : calc_imbalance
Usage   : my $imbalance = $tree->calc_imbalance;
Function: Calculates Colless' coefficient 
          of tree imbalance.
Returns : FLOAT
Args    : NONE
Comments: As described in Colless, D.H., 1982. 
          The theory and practice of phylogenetic 
          systematics. Systematic Zoology 31(1): 100-104

calc_i2()

Calculates I2 imbalance.

Type    : Calculation
Title   : calc_i2
Usage   : my $ci2 = $tree->calc_i2;
Function: Calculates I2 imbalance.
Returns : FLOAT
Args    : NONE
Comments:

calc_gamma()

Calculates the Pybus & Harvey (2000) gamma statistic.

Type    : Calculation
Title   : calc_gamma
Usage   : my $gamma = $tree->calc_gamma();
Function: Calculates the Pybus gamma statistic
Returns : FLOAT
Args    : NONE
Comments: As described in Pybus, O.G. and 
          Harvey, P.H., 2000. Testing
          macro-evolutionary models using 
          incomplete molecular phylogenies. 
          Proc. R. Soc. Lond. B 267, 2267-2272

calc_fiala_stemminess()

Calculates stemminess measure of Fiala and Sokal (1985).

Type    : Calculation
Title   : calc_fiala_stemminess
Usage   : my $fiala_stemminess = 
          $tree->calc_fiala_stemminess;
Function: Calculates stemminess measure 
          Fiala and Sokal (1985).
Returns : FLOAT
Args    : NONE
Comments: As described in Fiala, K.L. and 
          R.R. Sokal, 1985. Factors 
          determining the accuracy of 
          cladogram estimation: evaluation 
          using computer simulation. 
          Evolution, 39: 609-622

calc_rohlf_stemminess()

Calculates stemminess measure from Rohlf et al. (1990).

Type    : Calculation
Title   : calc_rohlf_stemminess
Usage   : my $rohlf_stemminess = 
          $tree->calc_rohlf_stemminess;
Function: Calculates stemminess measure 
          from Rohlf et al. (1990).
Returns : FLOAT
Args    : NONE
Comments: As described in Rohlf, F.J., 
          W.S. Chang, R.R. Sokal, J. Kim, 
          1990. Accuracy of estimated 
          phylogenies: effects of tree 
          topology and evolutionary model. 
          Evolution, 44(6): 1671-1684

calc_resolution()

Calculates tree resolution.

Type    : Calculation
Title   : calc_resolution
Usage   : my $resolution = 
          $tree->calc_resolution;
Function: Calculates the number 
          of internal nodes over the
          total number of internal nodes 
          on a fully bifurcating
          tree of the same size.
Returns : FLOAT
Args    : NONE

calc_branching_times()

Calculates cumulative branching times.

Type    : Calculation
Title   : calc_branching_times
Usage   : my $branching_times = 
          $tree->calc_branching_times;
Function: Returns a two-dimensional array. 
          The first dimension consists of 
          the "records", so that in the 
          second dimension $AoA[$first][0] 
          contains the internal node references, 
          and $AoA[$first][1] the branching 
          time of the internal node. The 
          records are orderered from root to 
          tips by time from the origin.
Returns : SCALAR[][] or FALSE
Args    : NONE

calc_waiting_times()

Calculates intervals between splits.

Type    : Calculation
Title   : calc_waiting_times
Usage   : my $waitings = 
          $tree->calc_waiting_times;
Function: Returns a two-dimensional array. 
          The first dimension consists of 
          the "records", so that in the 
          second dimension $AoA[$first][0] 
          contains the internal node references, 
          and $AoA[$first][1] the waiting 
          time of the internal node. The 
          records are orderered from root to 
          tips by time from the origin.
Returns : SCALAR[][] or FALSE
Args    : NONE

calc_node_ages()

Calculates node ages.

 Type    : Calculation
 Title   : calc_node_ages
 Usage   : $tree->calc_node_ages;
 Function: Calculates the age of all the nodes in the tree (i.e. the distance
           from the tips) and assigns these to the 'age' slot, such that,
	   after calling this method, the age of any one node can be retrieved
	   by calling $node->get_generic('age');
 Returns : The invocant
 Args    : NONE
 Comments: This method computes, in a sense, the opposite of
           calc_branching_times: here, we compute the distance from the tips
	   (i.e. how long ago the split occurred), whereas calc_branching_times
	   calculates the distance from the root.

calc_ltt()

Calculates lineage-through-time data points.

Type    : Calculation
Title   : calc_ltt
Usage   : my $ltt = $tree->calc_ltt;
Function: Returns a two-dimensional array. 
          The first dimension consists of the 
          "records", so that in the second 
          dimension $AoA[$first][0] contains 
          the internal node references, and
          $AoA[$first][1] the branching time 
          of the internal node, and $AoA[$first][2] 
          the cumulative number of lineages over
          time. The records are orderered from 
          root to tips by time from the origin.
Returns : SCALAR[][] or FALSE
Args    : NONE

calc_symdiff()

Calculates the symmetric difference metric between invocant and argument. This metric is identical to the Robinson-Foulds tree comparison distance. See http://dx.doi.org/10.1016/0025-5564(81)90043-2

Type    : Calculation
Title   : calc_symdiff
Usage   : my $symdiff = 
          $tree->calc_symdiff($other_tree);
Function: Returns the symmetric difference 
          metric between $tree and $other_tree, 
          sensu Penny and Hendy, 1985.
Returns : SCALAR
Args    : A Bio::Phylo::Forest::Tree object,
          Optional second argument flags that results should be normalized
Comments: Trees in comparison must span 
          the same set of terminal taxa
          or results are meaningless.

calc_avtd()

Calculates the average taxonomic distinctiveness. See Clarke KR, Warwick RM (1998) A taxonomic distinctness index and its statistical properties. J Appl Ecol 35:523-525 http://dx.doi.org/10.1046/j.1365-2664.1998.3540523.x

Type    : Calculation
Title   : calc_avtd
Usage   : my $avtd = $tree->calc_avtd;
Function: Returns the average taxonomic distinctiveness
Returns : SCALAR
Args    : A Bio::Phylo::Forest::Tree object
Comments:

calc_fp()

Calculates the Fair Proportion value for each terminal.

Type    : Calculation
Title   : calc_fp
Usage   : my $fp = $tree->calc_fp();
Function: Returns the Fair Proportion 
          value for each terminal
Returns : HASHREF
Args    : NONE

calc_fp_mean()

Calculates the mean Fair Proportion value over all terminals.

Type    : Calculation
Title   : calc_fp_mean
Usage   : my $fp = $tree->calc_fp_mean();
Function: Returns the mean Fair Proportion 
          value over all terminals
Returns : FLOAT
Args    : NONE

calc_es()

Calculates the Equal Splits value for each terminal

Type    : Calculation
Title   : calc_es
Usage   : my $es = $tree->calc_es();
Function: Returns the Equal Splits value for each terminal
Returns : HASHREF
Args    : NONE

calc_es_mean()

Calculates the mean Equal Splits value over all terminals

Type    : Calculation
Title   : calc_es_mean
Usage   : my $es = $tree->calc_es_mean();
Function: Returns the Equal Splits value over all terminals
Returns : FLOAT
Args    : NONE

calc_pe()

Calculates the Pendant Edge value for each terminal.

Type    : Calculation
Title   : calc_pe
Usage   : my $es = $tree->calc_pe();
Function: Returns the Pendant Edge value for each terminal
Returns : HASHREF
Args    : NONE

calc_pe_mean()

Calculates the mean Pendant Edge value over all terminals

Type    : Calculation
Title   : calc_pe_mean
Usage   : my $es = $tree->calc_pe_mean();
Function: Returns the mean Pendant Edge value over all terminals
Returns : FLOAT
Args    : NONE

calc_shapley()

Calculates the Shapley value for each terminal.

Type    : Calculation
Title   : calc_shapley
Usage   : my $es = $tree->calc_shapley();
Function: Returns the Shapley value for each terminal
Returns : HASHREF
Args    : NONE

calc_shapley_mean()

Calculates the mean Shapley value over all terminals

Type    : Calculation
Title   : calc_shapley_mean
Usage   : my $es = $tree->calc_shapley_mean();
Function: Returns the mean Shapley value over all terminals
Returns : HASHREF
Args    : NONE

VISITOR METHODS

The following methods are a - not entirely true-to-form - implementation of the Visitor design pattern: the nodes in a tree are visited, and rather than having an object operate on them, a set of code references is used. This can be used, for example, to serialize a tree to a string format. To create a newick string without branch lengths you would use something like this (there is a more powerful 'to_newick' method, so this is just an example):

 $tree->visit_depth_first(
	'-pre_daughter'   => sub { print '('             },	
	'-post_daughter'  => sub { print ')'             },	
	'-in'             => sub { print shift->get_name },
	'-pre_sister'     => sub { print ','             },	
 );
 print ';';

visit_depth_first()

Visits nodes depth first

 Type    : Visitor method
 Title   : visit_depth_first
 Usage   : $tree->visit_depth_first( -pre => sub{ ... }, -post => sub { ... } );
 Function: Visits nodes in a depth first traversal, executes subs
 Returns : $tree
  Args    : Optional handlers in the order in which they would be executed on an internal node:
			
			# first event handler, is executed when node is reached in recursion
			-pre            => sub { print "pre: ",            shift->get_name, "\n" },

			# is executed if node has a daughter, but before that daughter is processed
			-pre_daughter   => sub { print "pre_daughter: ",   shift->get_name, "\n" },
			
			# is executed if node has a daughter, after daughter has been processed	
			-post_daughter  => sub { print "post_daughter: ",  shift->get_name, "\n" },

			# is executed whether or not node has sisters, if it does have sisters
			# they're processed first	
			-in             => sub { print "in: ",             shift->get_name, "\n" },
			
			# is executed if node has a sister, before sister is processed
			-pre_sister     => sub { print "pre_sister: ",     shift->get_name, "\n" },	
			
			# is executed if node has a sister, after sister is processed
			-post_sister    => sub { print "post_sister: ",    shift->get_name, "\n" },							
			
			# is executed last			
			-post           => sub { print "post: ",           shift->get_name, "\n" },
			
			# specifies traversal order, default 'ltr' means first_daugher -> next_sister
			# traversal, alternate value 'rtl' means last_daughter -> previous_sister traversal
			-order          => 'ltr', # ltr = left-to-right, 'rtl' = right-to-left
 Comments:

visit_breadth_first()

Visits nodes breadth first

 Type    : Visitor method
 Title   : visit_breadth_first
 Usage   : $tree->visit_breadth_first( -pre => sub{ ... }, -post => sub { ... } );
 Function: Visits nodes in a breadth first traversal, executes handlers
 Returns : $tree
 Args    : Optional handlers in the order in which they would be executed on an internal node:
			
			# first event handler, is executed when node is reached in recursion
			-pre            => sub { print "pre: ",            shift->get_name, "\n" },
			
			# is executed if node has a sister, before sister is processed
			-pre_sister     => sub { print "pre_sister: ",     shift->get_name, "\n" },	
			
			# is executed if node has a sister, after sister is processed
			-post_sister    => sub { print "post_sister: ",    shift->get_name, "\n" },			
			
			# is executed whether or not node has sisters, if it does have sisters
			# they're processed first	
			-in             => sub { print "in: ",             shift->get_name, "\n" },			
			
			# is executed if node has a daughter, but before that daughter is processed
			-pre_daughter   => sub { print "pre_daughter: ",   shift->get_name, "\n" },
			
			# is executed if node has a daughter, after daughter has been processed	
			-post_daughter  => sub { print "post_daughter: ",  shift->get_name, "\n" },				
			
			# is executed last			
			-post           => sub { print "post: ",           shift->get_name, "\n" },
			
			# specifies traversal order, default 'ltr' means first_daugher -> next_sister
			# traversal, alternate value 'rtl' means last_daughter -> previous_sister traversal
			-order          => 'ltr', # ltr = left-to-right, 'rtl' = right-to-left
 Comments:

visit_level_order()

Visits nodes in a level order traversal.

Type    : Visitor method
Title   : visit_level_order
Usage   : $tree->visit_level_order( sub{...} );
Function: Visits nodes in a level order traversal, executes sub
Returns : $tree
Args    : A subroutine reference that operates on visited nodes.
Comments:

TREE MANIPULATION

chronompl()

Modifies branch lengths using the mean path lengths method of Britton et al. (2002). For more about this method, see: http://dx.doi.org/10.1016/S1055-7903(02)00268-3

Type    : Tree manipulator
Title   : chronompl
Usage   : $tree->chronompl;
Function: Makes tree ultrametric using MPL method
Returns : The modified, now ultrametric invocant.
Args    : NONE
Comments:

grafenbl()

Computes and assigns branch lengths using Grafen's method, which makes node ages proportional to clade size. For more about this method, see: http://dx.doi.org/10.1098/rstb.1989.0106

Type    : Tree manipulator
Title   : grafenbl
Usage   : $tree->grafenbl;
Function: Assigns branch lengths using Grafen's method
Returns : The modified, now ultrametric invocant.
Args    : Optional, a power ('rho') to which all node ages are raised
Comments:

agetobl()

Converts node ages to branch lengths

 Type    : Tree manipulator
 Title   : agetobl
 Usage   : $tree->agetobl;
 Function: Converts node ages to branch lengths
 Returns : The modified invocant.
 Args    : NONE
 Comments: This method uses ages as assigned to the generic 'age' slot
           on the nodes in the trees. I.e. for each node in the tree,
	   $node->get_generic('age') must return a number

rankprobbl()

Generates branch lengths by calculating the rank probabilities for each node and applying the expected waiting times under a pure birth process to these ranks. Uses Stadler's RANKPROB algorithm as described in:

Gernhard, T. et al., 2006. Estimating the relative order of speciation or coalescence events on a given phylogeny. Evolutionary Bioinformatics Online. 2:285. http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2674681/.

Type    : Tree manipulator
Title   : rankprobbl
Usage   : $tree->rankprobbl;
Function: Generates pure birth branch lengths
Returns : The modified invocant.
Args    : NONE
Comments: Tree must be fully bifurcating

ultrametricize()

Sets all root-to-tip path lengths equal.

Type    : Tree manipulator
Title   : ultrametricize
Usage   : $tree->ultrametricize;
Function: Sets all root-to-tip path 
          lengths equal by stretching
          all terminal branches to the 
          height of the tallest node.
Returns : The modified invocant.
Args    : NONE
Comments: This method is analogous to 
          the 'ultrametricize' command
          in Mesquite, i.e. no rate smoothing 
          or anything like that happens, just 
          a lengthening of terminal branches.

scale()

Scales the tree to the specified height.

Type    : Tree manipulator
Title   : scale
Usage   : $tree->scale($height);
Function: Scales the tree to the 
          specified height.
Returns : The modified invocant.
Args    : $height = a numerical value 
          indicating root-to-tip path length.
Comments: This method uses the 
          $tree->calc_tree_height method, and 
          so for additive trees the *average* 
          root-to-tip path length is scaled to
          $height (i.e. some nodes might be 
          taller than $height, others shorter).

resolve()

Randomly breaks polytomies.

Type    : Tree manipulator
Title   : resolve
Usage   : $tree->resolve;
Function: Randomly breaks polytomies by inserting 
          additional internal nodes.
Returns : The modified invocant.
Args    : Optionally, when passed a true value (e.g. '1'), the newly created nodes
          will be unnamed, otherwise they will be named 'r1', 'r2', 'r3' and so on.
Comments:

replicate()

Simulates tree(s) whose properties resemble that of the input tree in terms of birth/death rate, depth, and size/depth distribution of genera. This uses the R environment for statistics to get a maximum likelihood estimate of birth/death rates on the source tree and therefore requires the package Statistics::R to be installed, and the R package 'ape'. The idea is that this is used on a species tree that is ultrametric. To get simulated genera whose sizes and root depths approximate those of the source tree, annotate genus nodes in the source tree, e.g. using $tree->generize, and provide the optional -genera flag of replicate() with a true value.

This method uses the function birthdeath from the R package ape. If you use this method in a publication, you should therefore cite that package (in addition to Bio::Phylo). More information about ape can be found at http://ape-package.ird.fr/.

 Type    : Tree manipulator
 Title   : replicate
 Usage   : my $forest = $tree->replicate;
 Function: Simulates tree(s) whose properties resemble that of the invocant tree
 Returns : Bio::Phylo::Forest
 Args    : Optional: -trees    => number of replicates, default is 1
           Optional: -rootedge => keep the birth/death root branch, then scale the tree(s)
           Optional: -genera   => approximate distribution of source genus sizes and depths 
           (do this by tagging internal nodes: $node->set_rank('genus'))
		   Optional: -seed     => a random integer seed for generating the birth/death tree
 Comments: Requires Statistics::R, and an R environment with 'ape' installed
           Expects to operate on an ultrametric tree

generize()

Identifies monophyletic genera by traversing the tree, taking the first word of the tip names and finding the MRCA of each word. That MRCA is tagged as rank 'genus' and assigned the name.

Type    : Tree manipulator
Title   : generize
Usage   : $tree->generize(%args);
Function: Identifies monophyletic genera
Returns : Invocant
Args    : Optional: -delim => the delimiter that separates the genus name from any 
                              following (sub)specific epithets. Default is a space ' '.
          Optional: -monotypic => if true, also tags monotypic genera
          Optional: -polypara  => if true, also tags poly/paraphyletic genera. Any 
                                  putative genera nested within the largest of the 
                                  entangled, poly/paraphyletic genera will be ignored.
Comments:

prune_tips()

Prunes argument nodes from invocant.

Type    : Tree manipulator
Title   : prune_tips
Usage   : $tree->prune_tips(\@taxa);
Function: Prunes specified taxa from invocant.
Returns : A pruned Bio::Phylo::Forest::Tree object.
Args    : A reference to an array of taxon names, or a taxa block, or a
          reference to an array of taxon objects, or a reference to an
          array of node objects
Comments:

keep_tips()

Keeps argument nodes from invocant (i.e. prunes all others).

Type    : Tree manipulator
Title   : keep_tips
Usage   : $tree->keep_tips(\@taxa);
Function: Keeps specified taxa from invocant.
Returns : The pruned Bio::Phylo::Forest::Tree object.
Args    : Same as prune_tips, but with inverted meaning
Comments:

negative_to_zero()

Converts negative branch lengths to zero.

Type    : Tree manipulator
Title   : negative_to_zero
Usage   : $tree->negative_to_zero;
Function: Converts negative branch 
          lengths to zero.
Returns : The modified invocant.
Args    : NONE
Comments:

ladderize()

Sorts nodes in ascending (or descending) order of number of children. Tips are sorted alphabetically (ascending or descending) relative to their siblings.

Type    : Tree manipulator
Title   : ladderize
Usage   : $tree->ladderize(1);
Function: Sorts nodes
Returns : The modified invocant.
Args    : Optional, a true value to reverse the sort order

sort_tips()

Sorts nodes in (an approximation of) the provided ordering. Given an array reference of taxa, an array reference of name strings, or a taxa object, this method attempts to order the tips in the same way. It does this by recursively computing the rank for all internal nodes by taking the average rank of its children. This results in the following orderings:

(a,b,c,d,e,f); => $tree->sort_tips( [ qw(a c b f d e) ] ) => (a,c,b,f,d,e);

(a,b,(c,d),e,f); => $tree->sort_tips( [ qw(a b e d c f) ] ); => (a,b,(e,(d,c)),f);

((a,b),((c,d),e),f); => $tree->sort_tips( [ qw(a e d c b f) ] ); => ((e,(d,c)),(a,b),f);

Type    : Tree manipulator
Title   : sort_tips
Usage   : $tree->sort_tips($ordering);
Function: Sorts nodes
Returns : The modified invocant.
Args    : Required, an array reference (or taxa object) whose ordering to match

exponentiate()

Raises branch lengths to argument.

Type    : Tree manipulator
Title   : exponentiate
Usage   : $tree->exponentiate($power);
Function: Raises branch lengths to $power.
Returns : The modified invocant.
Args    : A $power in any of perl's number formats.

multiply()

Multiples branch lengths by argument.

Type    : Tree manipulator
Title   : multiply
Usage   : $tree->multiply($num);
Function: Multiplies branch lengths by $num.
Returns : The modified invocant.
Args    : A $number in any of perl's number formats.

log_transform()

Log argument base transform branch lengths.

Type    : Tree manipulator
Title   : log_transform
Usage   : $tree->log_transform($base);
Function: Log $base transforms branch lengths.
Returns : The modified invocant.
Args    : A $base in any of perl's number formats.

remove_unbranched_internals()

Collapses internal nodes with fewer than 2 children.

Type    : Tree manipulator
Title   : remove_unbranched_internals
Usage   : $tree->remove_unbranched_internals;
Function: Collapses internal nodes 
          with fewer than 2 children.
Returns : The modified invocant.
Args    : NONE
Comments:

remove_orphans()

Removes all unconnected nodes.

Type    : Tree manipulator
Title   : remove_orphans
Usage   : $tree->remove_orphans;
Function: Removes all unconnected nodes
Returns : The modified invocant.
Args    : NONE
Comments:

deroot()

Collapses one of the children of a basal bifurcation

Type    : Tree manipulator
Title   : deroot
Usage   : $tree->deroot;
Function: Removes root
Returns : The modified invocant.
Args    : Optional: node to collapse
Comments:

UTILITY METHODS

clone()

Clones invocant.

Type    : Utility method
Title   : clone
Usage   : my $clone = $object->clone;
Function: Creates a copy of the invocant object.
Returns : A copy of the invocant.
Args    : Optional: a hash of code references to 
          override reflection-based getter/setter copying

          my $clone = $object->clone(  
              'set_forest' => sub {
                  my ( $self, $clone ) = @_;
                  for my $forest ( @{ $self->get_forests } ) {
                      $clone->set_forest( $forest );
                  }
              },
              'set_matrix' => sub {
                  my ( $self, $clone ) = @_;
                  for my $matrix ( @{ $self->get_matrices } ) {
                      $clone->set_matrix( $matrix );
                  }
          );

Comments: Cloning is currently experimental, use with caution.
          It works on the assumption that the output of get_foo
          called on the invocant is to be provided as argument
          to set_foo on the clone - such as 
          $clone->set_name( $self->get_name ). Sometimes this 
          doesn't work, for example where this symmetry doesn't
          exist, or where the return value of get_foo isn't valid
          input for set_foo. If such a copy fails, a warning is 
          emitted. To make sure all relevant attributes are copied
          into the clone, additional code references can be 
          provided, as in the example above. Typically, this is
          done by overrides of this method in child classes.

SERIALIZERS

to_nexus()

Serializes invocant to nexus string.

Type    : Stringifier
Title   : to_nexus
Usage   : my $string = $tree->to_nexus;
Function: Turns the invocant tree object 
          into a nexus string
Returns : SCALAR
Args    : Any arguments that can be passed to Bio::Phylo::Forest::to_nexus

to_newick()

Serializes invocant to newick string.

Type    : Stringifier
Title   : to_newick
Usage   : my $string = $tree->to_newick;
Function: Turns the invocant tree object 
          into a newick string
Returns : SCALAR
Args    : NONE

to_xml()

Serializes invocant to xml.

Type    : Serializer
Title   : to_xml
Usage   : my $xml = $obj->to_xml;
Function: Turns the invocant object into an XML string.
Returns : SCALAR
Args    : NONE

to_svg()

Serializes invocant to SVG.

Type    : Serializer
Title   : to_svg
Usage   : my $svg = $obj->to_svg;
Function: Turns the invocant object into an SVG string.
Returns : SCALAR
Args    : Same args as the Bio::Phylo::Treedrawer constructor
Notes   : This will only work if you have the SVG module
          from CPAN installed on your system.

to_dom()

Type    : Serializer
Title   : to_dom
Usage   : $tree->to_dom($dom)
Function: Generates a DOM subtree from the invocant
          and its contained objects
Returns : an Element object
Args    : DOM factory object

CITATION

If you use Bio::Phylo in published research, please cite it:

Rutger A Vos, Jason Caravas, Klaas Hartmann, Mark A Jensen and Chase Miller, 2011. Bio::Phylo - phyloinformatic analysis using Perl. BMC Bioinformatics 12:63. http://dx.doi.org/10.1186/1471-2105-12-63

To install Bio::Phylo, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Bio::Phylo

CPAN shell

perl -MCPAN -e shell
install Bio::Phylo

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)