Uses of Interface
pal.tree.Node

Packages that use Node
pal.eval Classes for evaluating evolutionary hypothesis (chi-square and likelihood criteria) and estimating model parameters. 
pal.gui GUI components for some special objects (e.g., trees). 
pal.tree Classes for providing the data structure of trees, for constructing and modifying trees, and for parameterizing trees (e.g., clock constraint). 
pal.treesearch   
pal.xml Utility classes for converting PAL objects to and from XML documents. 
 

Uses of Node in pal.eval
 

Methods in pal.eval that return Node
protected  Node SimpleLikelihoodCalculator.getNextBranch(Node branch, Node center)
          get next branch around a center node (center may be root, but root is never returned)
 

Methods in pal.eval with parameters of type Node
protected  Node SimpleLikelihoodCalculator.getNextBranch(Node branch, Node center)
          get next branch around a center node (center may be root, but root is never returned)
protected  double[][] SimpleLikelihoodCalculator.getPartial(Node branch)
          get partial likelihood of a branch
protected  void SimpleLikelihoodCalculator.partialsExternal(Node branch)
          compute partials for external branch
protected  void SimpleLikelihoodCalculator.partialsInternal(Node center)
          compute partials for branch around center node (it is assumed that multiplied partials are available in the neighbor branch)
protected  void SimpleLikelihoodCalculator.productPartials(Node center)
          multiply partials into the neighbour of branch
 

Uses of Node in pal.gui
 

Classes in pal.gui that implement Node
 class PositionedNode
          A tree node that has a scalar position for the purposes of drawing the tree.
 

Methods in pal.gui that return Node
 Node PositionedNode.getPeer()
           
 

Methods in pal.gui with parameters of type Node
protected static double TreePainter.getMaxLeafTime(Node node)
           
protected  LabelDisplayer TreePainter.getNodeDisplay(Node n, LabelDisplayer defaultDisplay)
           
protected  java.lang.String TreePainter.getNodeName(Node node)
           
 

Constructors in pal.gui with parameters of type Node
PositionedNode(Node node)
           
PositionedNode(Node node, Node highlightNode)
          Builds a tree based on node, but highlights highlightNode
 

Uses of Node in pal.tree
 

Subinterfaces of Node in pal.tree
 interface AttributeNode
          interface for a node (includes branch) in a binary/non-binary rooted/unrooted tree.
 

Classes in pal.tree that implement Node
 class SimpleNode
          data structure for a node (includes branch) in a binary/non-binary rooted/unrooted tree
 

Methods in pal.tree that return Node
static Node NodeFactory.createNode()
          create a node
static Node NodeFactory.createNode(Identifier id)
          create a node, with a specified identifier
static Node NodeFactory.createNode(Identifier id, double height)
          create a node, with a specified identifier
static Node NodeFactory.createNode(Node node)
          constructor used to clone a node and all children
static Node NodeFactory.createNode(Node[] children)
           
static Node NodeFactory.createNode(Node[] children, double height)
          Create a node with the specified children, and the specified branch height
static Node NodeFactory.createNodeBranchLength(double branchLength, Identifier id)
          create a node, with a specified identifier
static Node NodeFactory.createNodeBranchLength(double branchLength, Node[] children)
          Create a node with the specified children, and the specified branch length
static Node NodeUtils.findByIdentifier(Node node, Identifier identifier)
          Returns the first node in this tree that has the required identifier.
static Node[] NodeUtils.findByIdentifier(Node node, Identifier[] identifiers)
          Returns the first nodes in this tree that has the required identifiers.
static Node NodeUtils.findByIdentifier(Node node, java.lang.String identifierName)
          Returns the first node in this tree that has the required identifier.
static Node[] NodeUtils.findByIdentifier(Node node, java.lang.String[] identifierNames)
          Returns the first nodes in this tree that has the required identifiers.
 Node Tree.TreeBase.findNode(int num)
          return node with number num (as displayed in ASCII tree)
 Node SimpleTree.findNode(int num)
          return node with number num (as displayed in ASCII tree)
 Node TreeRestricter.generateNode()
           
 Node[] TreeManipulator.getAllRootedBy(java.lang.String[] outgroupNames)
           
 Node TreeManipulator.getAsInputRooting()
          A method for recovering the input (construction) tree (with the EXPANSION/MIMIC/REDUCED differences)
 Node SimpleNode.getChild(int n)
          get child node
 Node Node.getChild(int n)
          get child node
static Node RootedTreeUtils.getClade(Node root, Node clade)
           
 Node TreeManipulator.getDefaultRoot()
           
 Node ParameterizedTree.ParameterizedTreeBase.getExternalNode(int i)
          returns the ith external node in the tree.
 Node Tree.getExternalNode(int i)
           
 Node Tree.TreeBase.getExternalNode(int i)
          Returns the ith external node.
 Node SimpleTree.getExternalNode(int i)
          Returns the ith external node.
static Node[] NodeUtils.getExternalNodes(Node root)
          Obtains all external nodes from tree defined by root and returns as an array
static Node NodeUtils.getFirstCommonAncestor(Node[] nodes)
          For a set of nodes in the tree returns the common ancestor closest to all nodes (most recent common ancestor)
static Node NodeUtils.getFirstCommonAncestor(Node nodeOne, Node nodeTwo)
          For two nodes in the tree returns the common ancestor closest to both nodes (most recent common ancestor)
 Node ParameterizedTree.ParameterizedTreeBase.getInternalNode(int i)
          returns the ith internal node in the tree.
 Node Tree.getInternalNode(int i)
           
 Node Tree.TreeBase.getInternalNode(int i)
          Returns the ith internal node.
 Node SimpleTree.getInternalNode(int i)
          Returns the ith internal node.
static Node[] NodeUtils.getInternalNodes(Node root, boolean includeRoot)
          Obtains all internal nodes from tree defined by root and returns as an array
 Node TreeManipulator.getMidPointRooted()
           
static Node TreeUtils.getNodeByName(Node root, java.lang.String name)
           
static Node TreeUtils.getNodeByName(Tree tree, java.lang.String name)
           
 Node TreeManipulator.PALNodeWrapper.getPALPeer()
           
 Node SimpleNode.getParent()
          Returns the parent node of this node.
 Node Node.getParent()
          Returns the parent node of this node.
static Node TreeUtils.getRandomNode(Tree tree)
          Returns a uniformly distributed random node from the tree, including both internal and external nodes.
 Node ParameterizedTree.ParameterizedTreeBase.getRoot()
          Returns the root node of this tree.
 Node Tree.getRoot()
           
 Node Tree.TreeBase.getRoot()
          Returns the root node of this tree.
 Node SimpleTree.getRoot()
          Returns the root node of this tree.
 Node TreeManipulator.getRootedAbove(Node base)
           
 Node TreeManipulator.getRootedBy(java.lang.String[] outgroupNames)
           
 Node TreeManipulator.getRootedBy(java.lang.String[] outgroupNames, double ingroupBranchLength)
           
static Node RootedTreeUtils.getSubtree(Node root, Node node)
           
 Node TreeManipulator.getUnrooted()
          return unrooted node
static Node NodeUtils.postorderSuccessor(Node node)
          determine postorder successor of a node
static Node NodeUtils.preorderSuccessor(Node node)
          determine preorder successor of this node
 Node SimpleNode.removeChild(int n)
          remove child
 Node Node.removeChild(int n)
          remove child
 

Methods in pal.tree with parameters of type Node
 void SimpleNode.addChild(Node n)
          add new child node
 void Node.addChild(Node c)
          add new child node
 TreeManipulator TreeManipulator.BranchAccess.attachSubTree(Node subTree, int constructionMode)
          Create a new TreeManipulator object that has sub grafted on (half way across this branch)
static int RootedTreeUtils.cladeCount(Node subtree, java.util.Vector trees)
           
static int RootedTreeUtils.collectTaxa(Node root, java.util.Hashtable table)
          Collects all of the names of the taxa in the tree into a hashtable.
 pal.tree.TreeRestricter.RNode TreeRestricter.construct(Node peer, java.lang.String[] names, boolean inclusion, boolean isRoot)
           
static boolean RootedTreeUtils.containsClade(Node root, Node clade)
           
static boolean RootedTreeUtils.containsNovelTaxa(Node root, java.util.Hashtable taxa)
           
static boolean RootedTreeUtils.containsSubtree(Node root, Node node)
           
static void NodeUtils.convertNegativeBranchLengthsToZeroLength(Node node)
          If the given node or the sub tree defined by that node have negative branch lengths, they'll have zeron branch lengths after a call to this function!
static Node NodeFactory.createNode(Node node)
          constructor used to clone a node and all children
static Node NodeFactory.createNode(Node[] children)
           
static Node NodeFactory.createNode(Node[] children, double height)
          Create a node with the specified children, and the specified branch height
static Node NodeFactory.createNodeBranchLength(double branchLength, Node[] children)
          Create a node with the specified children, and the specified branch length
static boolean RootedTreeUtils.equal(Node node1, Node node2)
           
static void NodeUtils.exchangeInfo(Node node1, Node node2)
          Exchange field info between two nodes.
static Node NodeUtils.findByIdentifier(Node node, Identifier identifier)
          Returns the first node in this tree that has the required identifier.
static Node[] NodeUtils.findByIdentifier(Node node, Identifier[] identifiers)
          Returns the first nodes in this tree that has the required identifiers.
static Node NodeUtils.findByIdentifier(Node node, java.lang.String identifierName)
          Returns the first node in this tree that has the required identifier.
static Node[] NodeUtils.findByIdentifier(Node node, java.lang.String[] identifierNames)
          Returns the first nodes in this tree that has the required identifiers.
static double NodeUtils.findLargestChild(Node node)
          Finds the largest child (in terms of node height).
 java.lang.Object ParameterizedTree.ParameterizedTreeBase.getAttribute(Node node, java.lang.String name)
           
 java.lang.Object Tree.getAttribute(Node node, java.lang.String name)
           
 java.lang.Object Tree.TreeBase.getAttribute(Node node, java.lang.String name)
           
 java.lang.Object SimpleTree.getAttribute(Node node, java.lang.String name)
           
static void CladeSystem.getClade(IdGroup idGroup, Node internalNode, boolean[] clade)
          get clade for internal node
static Node RootedTreeUtils.getClade(Node root, Node clade)
           
static double NodeUtils.getDistanceToRoot(Node node)
          determine distance to root
static Node[] NodeUtils.getExternalNodes(Node root)
          Obtains all external nodes from tree defined by root and returns as an array
static void NodeUtils.getExternalNodes(Node root, java.util.Vector store)
          Appends all external nodes from tree defined by root to Vector store
static Node NodeUtils.getFirstCommonAncestor(Node[] nodes)
          For a set of nodes in the tree returns the common ancestor closest to all nodes (most recent common ancestor)
static Node NodeUtils.getFirstCommonAncestor(Node nodeOne, Node nodeTwo)
          For two nodes in the tree returns the common ancestor closest to both nodes (most recent common ancestor)
static int NodeUtils.getInternalNodeCount(Node root)
           
static Node[] NodeUtils.getInternalNodes(Node root, boolean includeRoot)
          Obtains all internal nodes from tree defined by root and returns as an array
static void NodeUtils.getInternalNodes(Node root, java.util.Vector store)
          Appends all internal nodes from tree defined by root to Vector store
static int NodeUtils.getLeafCount(Node node)
          Return the number of terminal leaves below this node or 1 if this is a terminal leaf.
static double NodeUtils.getMaximumPathLengthLengthToLeaf(Node root)
           
static int NodeUtils.getMaxNodeDepth(Node root)
           
static double RootedTreeUtils.getMeanCladeHeight(Node clade, java.util.Vector trees)
           
static double RootedTreeUtils.getMeanSubtreeHeight(Node subtree, java.util.Vector trees)
           
static double NodeUtils.getMinimumPathLengthLengthToLeaf(Node root)
           
static Node TreeUtils.getNodeByName(Node root, java.lang.String name)
           
static double[] NodeUtils.getPathLengthInfo(Node root)
          Calculates max/min lengths of paths from root to leaf, taking into account branch lengths
 Node TreeManipulator.getRootedAbove(Node base)
           
static void SplitUtils.getSplit(IdGroup idGroup, Node internalNode, boolean[] split)
          get split for branch associated with internal node
static Node RootedTreeUtils.getSubtree(Node root, Node node)
           
 Tree TreeManipulator.getTreeRootedAbove(Node n)
           
static int NodeUtils.getUnrootedBranchCount(Node center)
          returns number of branches centered around an internal node in an unrooted tree
static void NodeUtils.heights2Lengths(Node node)
          determines branch lengths of this and all descendent nodes from heights
static void NodeUtils.heights2Lengths(Node node, boolean respectMinimum)
          determines branch lengths of this and all descendent nodes from heights
protected  void SimpleNode.init(Node n)
           
protected  void SimpleNode.init(Node n, boolean keepId)
          Initialized node instance variables based on given Node.
protected  void SimpleNode.init(Node n, boolean keepId, LabelMapping lm)
          Initialized node instance variables based on given Node.
 void SimpleNode.insertChild(Node n, int pos)
          add new child node (insertion at a specific position)
 void Node.insertChild(Node c, int pos)
          add new child node (insertion at a specific position)
static void RootedTreeInterface.Utils.instruct(Node palRoot, RootedTreeInterface treeInterface)
          Build a tree display based on a normal pal node.
static void UnrootedTreeInterface.Utils.instruct(Node root, UnrootedTreeInterface treeInterface)
          Build a tree display based on a normal pal node.
static boolean NodeUtils.isAncestor(Node possibleAncestor, Node node)
          For two nodes in the tree true if the first node is the ancestor of the second
static void NodeUtils.joinChilds(Node node, int n1, int n2)
          join two childs, introducing a new node/branch in the tree that replaces the first child
static void NodeUtils.lengths2Heights(Node root)
          Converts lengths to heights, *without* assuming contemporaneous tips.
static void NodeUtils.lengths2HeightsKeepTips(Node node, boolean useMax)
          Converts lengths to heights, but maintains tip heights.
static void NodeUtils.localHeights2Lengths(Node node, boolean respectMinimum)
          determines branch lengths of this node and its immediate descendent nodes from heights.
static Node NodeUtils.postorderSuccessor(Node node)
          determine postorder successor of a node
static Node NodeUtils.preorderSuccessor(Node node)
          determine preorder successor of this node
static void NodeUtils.printNH(java.io.PrintWriter out, Node node, boolean printLengths, boolean printInternalLabels)
          prints node in New Hamshire format.
static int NodeUtils.printNH(java.io.PrintWriter out, Node node, boolean printLengths, boolean printInternalLabels, int column, boolean breakLines)
           
static void NodeUtils.removeBranch(Node node)
          remove internal branch (collapse node with its parent)
static void NodeUtils.removeChild(Node parent, Node child)
          remove child
 void Tree.TreeBase.reroot(Node node)
          make provided node the root node
 void SimpleTree.reroot(Node node)
          make provided node the root node
static void TreeUtils.reroot(Tree tree, Node node)
           
static void NodeUtils.restoreBranch(Node node)
          restore internal branch
static boolean RootedTreeUtils.sameTaxa(Node node1, Node node2)
           
 void ParameterizedTree.ParameterizedTreeBase.setAttribute(Node node, java.lang.String name, java.lang.Object value)
           
 void Tree.setAttribute(Node node, java.lang.String name, java.lang.Object value)
          Sets an named attribute for a given node.
 void Tree.TreeBase.setAttribute(Node node, java.lang.String name, java.lang.Object value)
          Sets an named attribute for a given node.
 void SimpleTree.setAttribute(Node node, java.lang.String name, java.lang.Object value)
          Sets an named attribute for a given node.
 void SimpleNode.setChild(int n, Node node)
          set child node
 void Node.setChild(int n, Node node)
          set child node
 void SimpleNode.setParent(Node node)
          Set the parent node of this node.
 void Node.setParent(Node node)
          Set the parent node of this node.
 void ParameterizedTree.ParameterizedTreeBase.setRoot(Node root)
           
 void Tree.setRoot(Node root)
          This method constructs a tree from the given root node.
 void Tree.TreeBase.setRoot(Node theRoot)
          Called by subclasses that can't give root at time of construction (of this class)
 void SimpleTree.setRoot(Node r)
          Set a new node as root node.
static int RootedTreeUtils.subtreeCount(Node subtree, java.util.Vector trees)
           
 

Constructors in pal.tree with parameters of type Node
SimpleNode(Node n)
          constructor used to clone a node and all children
SimpleNode(Node[] children)
           
SimpleNode(Node[] children, double branchLength)
          Constructor
SimpleNode(Node n, boolean keepIds)
           
SimpleNode(Node n, LabelMapping lm)
           
SimpleTree(Node r)
          constructor taking a root node
Tree.TreeBase(Node theRoot)
          constructor
Tree.TreeBase(Tree.TreeBase tree, Node newRoot)
          clone constructor
TreeManipulator.PALNodeWrapper(Node peer)
           
TreeManipulator.PALNodeWrapper(Node peer, TreeManipulator.PALNodeWrapper parent)
           
TreeManipulator(Node base)
          Units will be Units.UNKNOWN
TreeManipulator(Node base, int units)
          Construct a TreeManipulator based around a normal tree
TreeManipulator(Node base, int units, int constructionMode)
          Construct a TreeManipulator based around a normal tree
TreeRestricter(Node root, int units, java.lang.String[] names, boolean inclusion)
           
 

Uses of Node in pal.treesearch
 

Methods in pal.treesearch that return Node
 Node ConstrainedLeafNode.buildDescendentPALNodeBase()
           
 Node ConstrainedNode.buildDescendentPALNodeBase()
          Build node model base units (eg years)
 Node AbstractParentableConstrainedNode.buildDescendentPALNodeBase()
           
 Node ConstrainedLeafNode.buildDescendentPALNodeES(ConstraintModel.GroupManager groupManager)
           
 Node ConstrainedNode.buildDescendentPALNodeES(ConstraintModel.GroupManager groupConstraints)
          Build node with Expected Substitution Units
 Node AbstractParentableConstrainedNode.buildDescendentPALNodeES(ConstraintModel.GroupManager groupManager)
           
protected  Node AbstractParentableConstrainedNode.buildLeftDecendentPALNodeBase()
           
 Node UnrootedMLSearcher.buildPALNode()
           
 Node FreeLeafNode.buildPALNode(double branchLength, FreeBranch caller)
           
 Node GeneralLikelihoodSearcher.buildPALNodeBase()
           
 Node PivotNode.buildPALNodeBase()
           
 Node RootAccess.buildPALNodeBase()
           
 Node FreeBranch.buildPALNodeBase()
           
 Node FreeNode.buildPALNodeBase(double branchLength_, FreeBranch caller)
           
 Node PivotNode.buildPALNodeBase(double branchLength_, FreeBranch caller)
           
 Node FreeLeafNode.buildPALNodeBase(double branchLength, FreeBranch caller)
           
 Node FreeInternalNode.buildPALNodeBase(double branchLength, FreeBranch caller)
           
 Node FreeBranch.buildPALNodeBase(FreeNode caller)
           
 Node GeneralLikelihoodSearcher.buildPALNodeES()
           
 Node PivotNode.buildPALNodeES()
           
 Node RootAccess.buildPALNodeES()
           
 Node FreeBranch.buildPALNodeES()
           
 Node FreeNode.buildPALNodeES(double branchLength_, FreeBranch caller)
           
 Node PivotNode.buildPALNodeES(double branchLength_, FreeBranch caller)
           
 Node FreeLeafNode.buildPALNodeES(double branchLength, FreeBranch caller)
           
 Node FreeInternalNode.buildPALNodeES(double branchLength, FreeBranch caller)
           
 Node FreeBranch.buildPALNodeES(FreeNode caller)
           
protected  Node AbstractParentableConstrainedNode.buildRightDecendentPALNodeBase()
           
 

Methods in pal.treesearch with parameters of type Node
 UnrootedMLSearcher BranchAccess.attach(Node subTree, Alignment fullAlignment)
          Create a new Tree Searcher with a new sub tree attached
 UnrootedMLSearcher BranchAccess.attach(Node subTree, Alignment fullAlignment, SubstitutionModel model)
          Create a new Tree Searcher with a new sub tree attached
 ConstrainedNode GeneralConstructionTool.createConstrainedNode(Node peer, ParentableConstrainedNode parent, GeneralConstraintGroupManager.Store store, GeneralConstraintGroupManager groupManager)
          Create an appropriate constrained node given a peer, and it's parent node
 FreeNode GeneralConstructionTool.createFreeNode(Node peer, FreeBranch parent, GeneralConstraintGroupManager.Store store)
          Create an appropriate free node given a peer, and it's parent branch
 RootAccess GeneralConstructionTool.createRootAccess(Node baseTree, GeneralConstraintGroupManager.Store store)
           
 java.lang.String[] GeneralConstructionTool.getLeafLabelSet(Node peer)
          A horibly inefficient way of doing things.
 void GeneralConstructionTool.getLeafLabelSet(Node peer, java.util.ArrayList al)
           
 

Constructors in pal.treesearch with parameters of type Node
AbstractParentableConstrainedNode(Node peer, GeneralConstructionTool tool, GeneralConstraintGroupManager.Store store, GeneralConstraintGroupManager groupManager)
           
ConstrainedInternalNode(Node peer, ParentableConstrainedNode parentNode, GeneralConstructionTool tool, GeneralConstraintGroupManager.Store store, GeneralConstraintGroupManager groupManager)
           
ConstrainedLeafNode(ParentableConstrainedNode parentNode, Node peer, double height, GeneralConstructionTool tool, ConstraintModel.GroupManager parentGroup)
           
FreeBranch(Node n, FreeNode parent, GeneralConstructionTool tool, GeneralConstraintGroupManager.Store store)
          Continuing recurison constructor for a given tree
FreeBranch(Node n, GeneralConstructionTool tool, GeneralConstraintGroupManager.Store store)
          The starting constructor for building from a given tree
FreeInternalNode(Node i, FreeBranch parentFreeBranch, GeneralConstructionTool tool, GeneralConstraintGroupManager.Store store)
           
GeneralLikelihoodSearcher(Node baseTopology, Alignment baseAlignment, ConstraintModel constraintModel)
           
PivotNode(Node tree, FreeBranch parentConnection, GeneralConstructionTool tool, GeneralConstraintGroupManager constraintGroupManager, GeneralConstraintGroupManager.Store store)
          The subtree constructor with a connection to the rest of the tree
PivotNode(Node subTree, GeneralConstructionTool tool, GeneralConstraintGroupManager groupManager, GeneralConstraintGroupManager.Store store)
          The root constructor, only used when the whole tree is constrained
UnrootedMLSearcher(Node root)
          Create a searcher based on a given tree, that has no alignment , or model, specified (useful as backbone tree for attaching new nodes)
UnrootedMLSearcher(Node root, Alignment alignment, SubstitutionModel model)
           
UnrootedMLSearcher(Node root, Alignment alignment, SubstitutionModel model, LHCalculator.Factory calcFactory)
           
UnrootedMLSearcher(Node root, SubstitutionModel model)
          Create a searcher based on a given tree, that has no alignment specified (useful as backbone tree for attaching new nodes)
 

Uses of Node in pal.xml
 

Methods in pal.xml that return Node
static Node ElementParser.parseEdgeNodeElement(org.w3c.dom.Element e)
           
static Node ElementParser.parseNodeElement(org.w3c.dom.Element e)
           
 

Methods in pal.xml with parameters of type Node
static org.w3c.dom.Element ElementFactory.createEdgeNodeElement(Node node, org.w3c.dom.Document document)
           
static org.w3c.dom.Element ElementFactory.createNodeElement(Node node, org.w3c.dom.Document document)
           
static org.w3c.dom.Element ElementFactory.createNodeElement(Node node, org.w3c.dom.Document document, boolean includeEdges)