/** * Returns an array of all leaves. * <p> * This uses {@link TreeNode#getLeaves()} on * the root of the tree. Be sure the tree is completely initialized, because * we need a root node and {@link TreeNode#isLeaf()} is used to distinguish * between leaves and inner nodes, and this only works on a properly initialized tree. * * @return treeNodes array of all leaves in this tree * @since 0.8.2 */ public TreeNode[] getLeaves() { return getRoot().getLeaves(); }
private static Set<TreePartition> getPartitions(Tree tree, Set<String> allTaxa){ Set<TreePartition> partitions = new HashSet<TreePartition>(); for (TreeNode current : tree.vertices()) { if (current.isInnerNode()) { // if (!current.equals(calculated.getRoot())) { TreeNode[] leafes = current.getLeaves(); if ((allTaxa.size() - leafes.length) > 1) partitions.add(new TreePartition(leafes, allTaxa)); // } } } return partitions; }
private List<String> labels(TreeNode n) { List<String> l = new ArrayList<String>(); for (TreeNode node : n.getLeaves()) { if (node.getLabel() != null && node.getLabel().length() > 0) { l.add(n.getLabel()); } } return l; }
public int compare(TreeNode o1, TreeNode o2) { String l1 = o1.getLabel(); String l2 = o2.getLabel(); if (l1 == null) { TreeNode[] leaves = o1.getLeaves(); l1 = leaves[leaves.length - 1].getLabel(); } if (l2 == null) { TreeNode[] leaves = o2.getLeaves(); l2 = leaves[leaves.length - 1].getLabel(); } return l1.compareTo(l2); }
private Map<TreeNode, Set<Object>> getNodeToLeafMap(Tree tree) { Map<TreeNode, Set<Object>> map = new HashMap<>(tree.getNumTaxa()); for (TreeNode node : tree.vertices()) { if (node.isInnerNode()) { Set<Object> leafSet = new HashSet<>(); for (TreeNode taxon : node.getLeaves()) { leafSet.add(nameToObject.get(taxon.getLabel())); } map.put(node, leafSet); } } return map; }
public PPCharacter(TreeNode character, Set<TreeNode> taxa) { TreeNode[] leafes = character.getLeaves(); edges = new HashSet<>(leafes.length); imaginaryEdges = new HashSet<>(taxa.size() - leafes.length); for (TreeNode taxon : leafes) { if (!nameToObject.containsKey(taxon.getLabel())) nameToObject.put(taxon.getLabel(), new Object()); edges.add(nameToObject.get(taxon.getLabel())); taxa.remove(taxon); } for (TreeNode taxon : taxa) { if (!nameToObject.containsKey(taxon.getLabel())) nameToObject.put(taxon.getLabel(), new Object()); imaginaryEdges.add(nameToObject.get(taxon.getLabel())); } }
for (TreeNode newchild : child.getLeaves()) { if (order.contains(newchild.getLabel())) { child = newchild;
final TreeNode[] leavesSubTree = nodeTree.getLeaves(); final TreeNode[] leavesSubCompareTree = nodeCompareTree.getLeaves(); String leaves = listLeaves(internalNodesTree.get(m).getLeaves()); System.out.print(leaves + "\t\t"); for (int n = 0; n < internalNodesCompareTree.size(); n++) { String leaves = listLeaves(internalNodesTree.get(k).getLeaves()); System.out.print(leaves + " "); for (int l = 0; l < internalNodesCompareTree.size(); l++) { } else { if (matrixDouble[a][b] == treeSet.getScore()) { if (computeBcn(internalNodesTree.get(a).getLeaves(), internalNodesCompareTree.get(b).getLeaves()) > computeBcn(treeSet.getNodeTree().getLeaves(), treeSet.getNodeCompareTree().getLeaves())) { treeSet.setNodeTree(internalNodesTree.get(a)); treeSet.setNodeCompareTree(internalNodesCompareTree.get(b)); } else { if (matrix[a][b].compareTo(treeSet.getScore2()) == 0) { if (computeBcn(internalNodesTree.get(a).getLeaves(), internalNodesCompareTree.get(b).getLeaves()) > computeBcn(treeSet.getNodeTree().getLeaves(), treeSet.getNodeCompareTree().getLeaves())) { treeSet.setNodeTree(internalNodesTree.get(a)); treeSet.setNodeCompareTree(internalNodesCompareTree.get(b)); } else { if (matrixDouble[b][a] == compareTreeSet.getScore()) { if (computeBcn(internalNodesTree.get(b).getLeaves(), internalNodesCompareTree.get(a).getLeaves()) > computeBcn(compareTreeSet.getNodeTree().getLeaves(), compareTreeSet.getNodeCompareTree().getLeaves())) { compareTreeSet.setNodeTree(internalNodesTree.get(b)); compareTreeSet.setNodeCompareTree(internalNodesCompareTree.get(a));
edgeWeight = edgeWeight * (root.getLeaves().length - node.getLeaves().length); } else if (weights == FlipCutWeights.Weights.EDGE_AND_ClADERATE) { edgeWeight = edgeWeight * (1 - (node.getLeaves().length / root.getLeaves().length)); } else if (weights == FlipCutWeights.Weights.ClADERATE) { edgeWeight = (1 - (node.getLeaves().length / root.getLeaves().length)); } else if (weights == FlipCutWeights.Weights.EDGE_AND_GLOBAL_ClADESIZE) { edgeWeight = edgeWeight * (taxaNumber - node.getLeaves().length); } else if (weights == FlipCutWeights.Weights.CLADESIZE) { edgeWeight = root.getLeaves().length - node.getLeaves().length; } else if (weights == FlipCutWeights.Weights.GLOBAL_CLADESIZE) { edgeWeight = taxaNumber - node.getLeaves().length; int leafesNumber = root.getLeaves().length; edgeWeight = (double) (leafesNumber - node.getLeaves().length) / leafesNumber; } else if (weights == FlipCutWeights.Weights.EDGE_AND_RELATIVE_CLADESIZE) { int leafesNumber = root.getLeaves().length; edgeWeight = edgeWeight * ((double) (leafesNumber - node.getLeaves().length) / leafesNumber);
for (TreeNode leaf : tree.getRoot().getLeaves()) { String label = leaf.getLabel(); if (label != null && label.length() > 0) {
for (TreeNode l : p.getLeaves()) { //TODO PROOF: fleisch thinks we need only the leaves of the siblings? String ll = l.getLabel(); if (ll != null && ll.length() > 0) {
for (TreeNode leaf : node.getLeaves()) { if (leaf.equalsNode(a)) posA = x; if (leaf.equalsNode(b)) posB = x;
private int searchInComp(TreeNode originNode, Tree tree) { // einstieg in den zweiten baum int retValue = 0; TreeNode found = null; TreeNode child = originNode.getLeaves()[0]; if (findLeaf(child, 0)) { found = (TreeNode) searchForNode(tree, child);
public Edge getDistanceEdge(TreeNode source, TreeNode target) { int intersection = 0; double s = 0; for (TreeNode treeNodeSource : source.getPartition() .getLeavesArray()) { for (TreeNode treeNodeTarget : target.getPartition() .getLeavesArray()) { if (treeNodeSource.getLabel().equals( treeNodeTarget.getLabel())) { // if (treeNodeSource.equals(treeNodeTarget)){ intersection++; } } } // //System.out.println("getDistance Methode likelihoods: intersection --> "+intersection); TreeNode getRootHelp = source; while (getRootHelp.getParent() != null) { getRootHelp = getRootHelp.getParent(); } int allLeaves = getRootHelp.getLeaves().length; s = BCNWithLikelihoods.computeValueWithDouble(allLeaves, source .getPartition().getSize(), target.getPartition().getSize(), intersection); return new Edge(source, target, s); }