/** Unit tests */ public static void main(String[] args) { final Tree targetTree = tree( 1, tree( 2, tree(3, tree(4), tree(3, tree(4), tree(5))), tree(5, tree(6, tree(7), tree(8, tree(9), tree())), tree(10, tree(11), tree()))), tree(12)); System.out.println(" Test Pattern"); checkPattern(targetTree, tree(), Optional.of(targetTree)); checkPattern(targetTree, tree(9), Optional.of(tree(9))); checkPattern(targetTree, tree(12), Optional.of(tree(12))); checkPattern(targetTree, tree(13), Optional.empty()); checkPattern(targetTree, tree(1), Optional.of(targetTree)); checkPattern(targetTree, tree(2, tree(3), tree(5)), Optional.of(targetTree.left())); checkPattern( targetTree, tree(3, tree(4), tree(5)), Optional.of(targetTree.left().left().right())); checkPattern( targetTree, tree(6, tree(), tree(8)), Optional.of(targetTree.left().right().left())); checkPattern(targetTree, tree(6, tree(), tree(7)), Optional.empty()); checkPattern( targetTree, tree(5, tree(6, tree(7), tree(8, tree(9), tree())), tree(10, tree(11), tree())), Optional.of(targetTree.left().right())); }
public Forest(List<Tree> roots) { this.roots = roots; size = 0; for (Tree root : roots) { size += root.size(); } }
private static <T> void writeTreeBranch( Tree<T> tree, Writer writer, List<Boolean> lines, boolean lastBranch) throws IOException { for (boolean line : lines) { if (line) { writer.write(" | "); } else { writer.write(" "); } } if (lastBranch) { writer.write(" '-- "); } else { writer.write(" |-- "); } writer.write(String.valueOf(tree.getNodeData())); writer.write("\n"); Iterator<Tree<T>> branchIt = tree.iterator(); while (branchIt.hasNext()) { Tree<T> branch = branchIt.next(); List<Boolean> newLines = new ArrayList<Boolean>(); newLines.addAll(lines); newLines.add(!lastBranch); writeTreeBranch(branch, writer, newLines, !branchIt.hasNext()); } }
/*.................................................................................................................*/ public String getStringForTree(int ic) { if (treesBlock == null) return ""; Tree tree = treesBlock.getTree(ic); if (tree == null) return ""; if (tree.hasPolytomies(tree.getRoot())) return "Yes"; else return "No"; }
private static <L> Tree<L> deepCopy(Tree<L> tree) { List<Tree<L>> childrenCopies = new ArrayList<Tree<L>>(); for (Tree<L> child : tree.getChildren()) { childrenCopies.add(deepCopy(child)); } return new Tree<L>(tree.getLabel(), childrenCopies); }
public static void main(String[] args) throws java.lang.Exception { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); Tree tree = new Tree(); int n = Integer.parseInt(br.readLine()); int nn = n - 1; TreeNode[] treeNodes = new TreeNode[n]; int i = 0; while (n-- > 0) { String[] strs = br.readLine().split(" "); int r = Integer.parseInt(strs[1]); int n1 = Integer.parseInt(strs[0]); treeNodes[i] = new TreeNode(n1, r); i = i + 1; } boolean[] x = new boolean[nn + 1]; while (nn-- > 0) { String[] strs = br.readLine().split(" "); int s = Integer.parseInt(strs[0]); int t = Integer.parseInt(strs[1]); if (!x[s]) { tree.insert(treeNodes[s]); x[s] = true; } if (!x[t]) { tree.insert(treeNodes[t]); x[t] = true; } } tree.levelOrder(tree.root); }
/** * Returns the index of <code>daughter</code> in <code>parent</code> by ==. Returns -1 if <code> * daughter</code> not found. */ public static int objectEqualityIndexOf(Tree parent, Tree daughter) { for (int i = 0; i < parent.children().length; i++) { if (daughter == parent.children()[i]) { return i; } } return -1; }
/** * returns the syntactic category of the tree as a list of the syntactic categories of the mother * and the daughters */ public static List<String> localTreeAsCatList(Tree t) { List<String> l = new ArrayList<String>(t.children().length + 1); l.add(t.label().value()); for (int i = 0; i < t.children().length; i++) { l.add(t.children()[i].label().value()); } return l; }
/* * Trim BST - Given min and max trim the tree so that all nodes has values between min and max */ public Tree trimTree(Tree node, int min, int max) { if (node == null) return null; node.left = trimTree(node.left, min, max); node.right = trimTree(node.right, min, max); if (node.value < min) return node.right; else if (node.value > max) return node.left; else return node; }
/*..........................................ContinuousHistory................*/ private void fillDistribution(Tree tree, int node, ContinuousAdjustable dist) { if (tree.nodeIsTerminal(node)) { int t = tree.taxonNumberOfNode(node); for (int i = 0; i < getNumItems(); i++) dist.setState(t, i, getState(node, i)); } else for (int d = tree.firstDaughterOfNode(node); tree.nodeExists(d); d = tree.nextSisterOfNode(d)) fillDistribution(tree, d, dist); }
private static <L> void appendPreTerminalYield(Tree<L> tree, List<L> yield) { if (tree.isPreTerminal()) { yield.add(tree.getLabel()); return; } for (Tree<L> child : tree.getChildren()) { appendPreTerminalYield(child, yield); } }
/** * Search the tree for the first instance of `pattern`, giving preference to the left child. * * <p>`pattern` is a tree, representing a pattern of nodes. `NilNode`s should be considered * wildcards. * * <p>Example patterns ---------------- `Tree()` Matches any tree. * * <p>`Tree(3)` Matches any tree where the root node has a value of `3`. * * <p>`Tree(3, Tree(2), Tree())` Matches any tree where the root node has a value of `3`, and a * left sub-tree with a root value of `2`, and any (or no) right sub-tree. */ static Optional<Tree> find(Tree target, Tree pattern) { if (pattern.isEmpty()) return Optional.of(target); if (target.isEmpty()) return Optional.empty(); if (prefixMatches(target, pattern)) return Optional.of(target); Optional<Tree> leftMatch = find(target.left(), pattern); if (leftMatch.isPresent()) return leftMatch; return find(target.right(), pattern); }
/** * output the top level labels for each tree * * @param trees the trees to predict * @return the prediction labels for each tree */ public List<Integer> predict(List<Tree> trees) { List<Integer> ret = new ArrayList<>(); for (Tree t : trees) { forwardPropagateTree(t); ret.add(SimpleBlas.iamax(t.prediction())); } return ret; }
private static String toLispString(Tree<?> tree) { final String value = String.valueOf(tree.getValue()); if (tree.isLeaf()) { return value; } else { return String.format( "(%s %s)", value, tree.getChildren().map(Node::toLispString).mkString(" ")); } }
/*..........................................ContinuousHistory................*/ public void calcMinMaxStates(Tree tree, int node) { for (int i = 0; i < getNumItems(); i++) { double s = getState(node, i); maxState = MesquiteDouble.maximum(maxState, s); minState = MesquiteDouble.minimum(minState, s); } for (int d = tree.firstDaughterOfNode(node); tree.nodeExists(d); d = tree.nextSisterOfNode(d)) calcMinMaxStates(tree, d); }
private static <L> List<Tree<L>> spliceNodesHelper(Tree<L> tree, Filter<L> filter) { List<Tree<L>> splicedChildren = new ArrayList<Tree<L>>(); for (Tree<L> child : tree.getChildren()) { List<Tree<L>> splicedChildList = spliceNodesHelper(child, filter); splicedChildren.addAll(splicedChildList); } if (filter.accept(tree.getLabel())) return splicedChildren; return Collections.singletonList(new Tree<L>(tree.getLabel(), splicedChildren)); }
/** * output the prediction probabilities for each tree * * @param trees the trees to predict * @return the prediction probabilities for each tree */ public List<FloatMatrix> output(List<Tree> trees) { List<FloatMatrix> ret = new ArrayList<>(); for (Tree t : trees) { forwardPropagateTree(t); ret.add(t.prediction()); } return ret; }
private List<Tree> helper(List<Tree> treeList, int start) { List<Tree> newTreeList = new ArrayList<Tree>(treeList.size()); for (Tree tree : treeList) { int end = start + tree.yield().size(); newTreeList.add(prune(tree, start)); start = end; } return newTreeList; }
private int setWordsHelper(List<L> words, int wordNum) { if (isLeaf()) { label = words.get(wordNum); return wordNum + 1; } else { for (Tree<L> child : getChildren()) wordNum = child.setWordsHelper(words, wordNum); return wordNum; } }
private boolean LexicalAnalyzer(ArrayList<Word> words, int index, String newWord) { String[] sent = toSentence(words); /// lexical analyzer List<CoreLabel> rawWords = Sentence.toCoreLabelList(sent); Tree parse = lp.apply(rawWords); // PrintStream outa = new PrintStream(new FileOutputStream("output1.txt")); // System.setOut(outa); // System.out.println("KKKKKKK"); // parse.pennPrint(); String oldTree = parse.toString(); // String oldTree=baos.toString(); // System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out))); // System.out.println(oldTree); words.get(index).setNewValue(newWord); sent = toSentence(words); rawWords = Sentence.toCoreLabelList(sent); parse = lp.apply(rawWords); // PrintStream outb = new PrintStream(new FileOutputStream("output2.txt")); // System.setOut(outb); // parse.pennPrint(); String newTree = parse.toString(); oldTree = oldTree.replaceAll(words.get(index).getOrigValue() + "[)]", newWord + ")"); // System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out))); System.out.println(oldTree + "\n" + newTree); // System.out.println(oldTree.equals(newTree)); if (oldTree.equals(newTree)) { if (index == 0) { String str = words.get(index).getNewValue(); String cap = str.substring(0, 1).toUpperCase() + str.substring(1); words.get(index).setNewValue(cap); } return true; } else { words.get(index).setNewValue(null); return false; } /* catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); return false; } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); return false; }*/ // return true; }
/** * Returns a new object indicating the states at the tips (used whether or not History is * reconstruction) */ public CharacterDistribution getStatesAtTips(Tree tree) { if (observedStates != null) return (CharacterDistribution) observedStates.getAdjustableClone(); else { ContinuousAdjustable d = new ContinuousAdjustable(tree.getTaxa(), tree.getTaxa().getNumTaxa()); d.setItemsAs(this); fillDistribution(tree, tree.getRoot(), d); return d; } }
private static <L> Tree<L> pruneNodesHelper(Tree<L> tree, Filter<L> filter) { if (filter.accept(tree.getLabel())) return null; List<Tree<L>> prunedChildren = new ArrayList<Tree<L>>(); for (Tree<L> child : tree.getChildren()) { Tree<L> prunedChild = pruneNodesHelper(child, filter); if (prunedChild != null) prunedChildren.add(prunedChild); } if (prunedChildren.isEmpty() && !tree.isLeaf()) return null; return new Tree<L>(tree.getLabel(), prunedChildren); }
private static void preTerminals(Tree t, List<Tree> l) { if (t.isPreTerminal()) { l.add(t); } else { Tree[] kids = t.children(); for (int j = 0, n = kids.length; j < n; j++) { preTerminals(kids[j], l); } } }
@Override public String toString() { String str = "forest: {\n"; for (Tree t : roots) { str += t.toString(1); str += "-----\n"; } str += "}"; return str; }
public Tree add(Tree node, int value) { if (node == null) { node = new Tree(value); return node; } else { if (value < node.value) node.left = add(node.left, value); else node.right = add(node.right, value); } return node; }
private static <L> int toConstituentCollectionHelper( Tree<L> tree, int start, List<Constituent<L>> constituents) { if (tree.isLeaf() || tree.isPreTerminal()) return 1; int span = 0; for (Tree<L> child : tree.getChildren()) { span += toConstituentCollectionHelper(child, start + span, constituents); } constituents.add(new Constituent<L>(tree.getLabel(), start, start + span)); return span; }
public static <A> void printTree(Tree<A> tree, PrintStream ps) { ps.printf("(%s (", tree.value()); for (Tree<A> t : tree.children()) { printTree(t, ps); ps.print(","); } ps.print("))"); }
public static String transformLabel(Tree<String> tree) { String transformedLabel = tree.getLabel(); int cutIndex = transformedLabel.indexOf('-'); int cutIndex2 = transformedLabel.indexOf('='); if (cutIndex2 > 0 && (cutIndex2 < cutIndex || cutIndex == -1)) cutIndex = cutIndex2; if (cutIndex > 0 && !tree.isLeaf()) { transformedLabel = transformedLabel.substring(0, cutIndex); } return transformedLabel; }
private static void leafLabels(Tree t, List<Label> l) { if (t.isLeaf()) { l.add(t.label()); } else { Tree[] kids = t.children(); for (int j = 0, n = kids.length; j < n; j++) { leafLabels(kids[j], l); } } }
/** Method declaration */ private void initGUI() { Panel pQuery = new Panel(); Panel pCommand = new Panel(); pResult = new Panel(); pQuery.setLayout(new BorderLayout()); pCommand.setLayout(new BorderLayout()); pResult.setLayout(new BorderLayout()); Font fFont = new Font("Dialog", Font.PLAIN, 12); txtCommand = new TextArea(5, 40); txtCommand.addKeyListener(this); txtResult = new TextArea(20, 40); txtCommand.setFont(fFont); txtResult.setFont(new Font("Courier", Font.PLAIN, 12)); butExecute = new Button("Execute"); butClear = new Button("Clear"); butExecute.addActionListener(this); butClear.addActionListener(this); pCommand.add("East", butExecute); pCommand.add("West", butClear); pCommand.add("Center", txtCommand); gResult = new Grid(); setLayout(new BorderLayout()); pResult.add("Center", gResult); pQuery.add("North", pCommand); pQuery.add("Center", pResult); fMain.add("Center", pQuery); tTree = new Tree(); // (ulrivo): screen with less than 640 width Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); if (d.width >= 640) { tTree.setMinimumSize(new Dimension(200, 100)); } else { tTree.setMinimumSize(new Dimension(80, 100)); } gResult.setMinimumSize(new Dimension(200, 300)); fMain.add("West", tTree); doLayout(); fMain.pack(); }