Beispiel #1
1
  private static void replace(Tree code, String data, Tree replacement) {
    System.out.println("Trying to replace" + data + " with " + replacement + " in " + code);
    if (code.getData().equals(data)) {
      System.out.println("Replacing " + data + " with " + replacement);
      code.removeChildren(false);
      for (Tree t : replacement.getChildren()) {
        code.addChild(new Tree(t), false);
      }
      code.setData(replacement.getData());
    } else if (code.getData().equals(FUN)) {
      // Shadowing
      Vector<Tree> fn = code.getChildren();
      Vector<Tree> args = fn.get(0).getChildren();

      for (Tree t : args) {
        if (t.getData().equals(data)) {
          return;
        }
      }

      // If we made it here, the replacement term is not in the args
      replace(fn.get(1), data, replacement);
    } else {
      for (Tree t : code.getChildren()) {
        replace(t, data, replacement);
      }
    }
  }
Beispiel #2
0
 /**
  * Get Last Root Child Forest -------------------------- Returns the children of the last root as
  * a forest. Let v be the last root. This method returns F(v).
  */
 public Forest getLastRootChildForest() {
   Tree lastRoot = getLastRoot();
   if (lastRoot == null) {
     return null;
   }
   List<Tree> children = lastRoot.getChildren();
   if (children.isEmpty()) {
     return null;
   }
   return new Forest(lastRoot.getChildren());
 }
Beispiel #3
0
 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);
 }
Beispiel #4
0
 private static <L> void traversalHelper(Tree<L> tree, List<Tree<L>> traversal, boolean preOrder) {
   if (preOrder) traversal.add(tree);
   for (Tree<L> child : tree.getChildren()) {
     traversalHelper(child, traversal, preOrder);
   }
   if (!preOrder) traversal.add(tree);
 }
Beispiel #5
0
 /**
  * Recursively transforms each node of <code>tree</code> parameter according to the passed in
  * <code>LabelFactory</code>. None of the structure of the <code>Tree</code> is altered only the
  * information stored in the Label at each node.
  *
  * @param <S> Original Tree label type
  * @param <T> Output tree label type
  * @param tree
  * @param labelFactory
  * @return Tree with transformed labels according to <code>labelFactory</code>
  */
 public static <S, T> Tree<T> transformTreeLabels(Tree<S> tree, LabelFactory<S, T> labelFactory) {
   T newLabel = labelFactory.newLabel(tree);
   List<Tree<T>> newChildren = new ArrayList<Tree<T>>();
   for (Tree<S> node : tree.getChildren()) {
     Tree<T> newNode = transformTreeLabels(node, labelFactory);
     newChildren.add(newNode);
   }
   return new Tree<T>(newLabel, newChildren);
 }
Beispiel #6
0
 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(" "));
   }
 }
Beispiel #7
0
 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);
   }
 }
Beispiel #8
0
 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));
 }
Beispiel #9
0
 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);
 }
Beispiel #10
0
 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;
 }
Beispiel #11
0
 private static <L> void renderFlat(Tree<L> tree, StringBuilder sb) {
   if (tree.isLeaf()) {
     sb.append(tree.getLabel().toString());
     return;
   }
   sb.append('(');
   sb.append(tree.getLabel().toString());
   sb.append(' ');
   sb.append(tree.getChildren().get(0).getLabel().toString());
   sb.append(')');
 }
Beispiel #12
0
 static <T> Stream<T> levelOrder(Tree<T> tree) {
   Stream<T> result = Stream.empty();
   final java.util.Queue<Tree<T>> queue = new java.util.LinkedList<>();
   queue.add(tree);
   while (!queue.isEmpty()) {
     final Tree<T> next = queue.remove();
     result = result.prepend(next.getValue());
     queue.addAll(next.getChildren().toJavaList());
   }
   return result.reverse();
 }
Beispiel #13
0
 public Tree<String> transformTree(Tree<String> tree) {
   String transformedLabel = transformLabel(tree);
   if (tree.isLeaf()) {
     return new Tree<String>(transformedLabel);
   }
   List<Tree<String>> transformedChildren = new ArrayList<Tree<String>>();
   for (Tree<String> child : tree.getChildren()) {
     transformedChildren.add(transformTree(child));
   }
   return new Tree<String>(transformedLabel, transformedChildren);
 }
Beispiel #14
0
 static <T> Stream<T> inOrder(Tree<T> tree) {
   if (tree.isLeaf()) {
     return Stream.of(tree.getValue());
   } else {
     final List<Node<T>> children = tree.getChildren();
     return children
         .tail()
         .foldLeft(Stream.<T>empty(), (acc, child) -> acc.appendAll(inOrder(child)))
         .prepend(tree.getValue())
         .prependAll(inOrder(children.head()));
   }
 }
Beispiel #15
0
  Tree parse(String code) throws CompilationException {
    if (code == null || code.isEmpty()) return null;

    // Base Case
    if (code.charAt(0) != '(') return new Tree(code);

    // Recursive Case
    ArrayList<String> chunks = findChunks(code);
    List<Tree> kids = new LinkedList<Tree>();
    for (String chunk : chunks) {
      kids.add(parse(chunk));
    }

    if (!kids.isEmpty() && isReserved(kids.get(0).getData())) {
      // Now we need to make special Trees based on what kind of special thing
      // this is
      Tree first = kids.get(0);
      if (first.getChildren() != null && first.getChildren().size() > 0) return new Tree(kids);

      kids.remove(0);
      String word = first.getData();
      if (word.equals(FUN)) {
        // (FUN (arg1 arg2 [...]) body) ; note that args are optional
        if (kids.size() <= 1) throw new CompilationException(code);
        if (kids.get(1).getChildren() == null) throw new CompilationException(code);

        return new Tree(FUN, kids);
      } else if (word.equals(IF)) {
        // (if cond then else)
        if (kids.size() != 3) throw new CompilationException(code);
        return new Tree(IF, kids);
      } else {
        return new Tree(word, kids);
      }
    } else {
      return new Tree(kids);
    }
  }
Beispiel #16
0
 public Tree<E> transformTree(Tree<E> tree) {
   E label = tree.getLabel();
   List<Tree<E>> children = tree.getChildren();
   while (children.size() == 1
       && !children.get(0).isLeaf()
       && label.equals(children.get(0).getLabel())) {
     children = children.get(0).getChildren();
   }
   List<Tree<E>> transformedChildren = new ArrayList<Tree<E>>();
   for (Tree<E> child : children) {
     transformedChildren.add(transformTree(child));
   }
   return new Tree<E>(label, transformedChildren);
 }
Beispiel #17
0
  /**
   * Get Forest Minus Last Root -------------------------- Let F be the forest and v is the lass
   * root. This method returns F - v. Note that this is different than F - T(v). The children of v
   * are promoted to be roots.
   */
  public Forest getForestMinusLastRoot() {
    List<Tree> newRoots = new ArrayList<Tree>();

    // Add all the previous roots
    newRoots.addAll(roots.subList(0, roots.size() - 1));

    // Add the last roots children
    Tree lastRoot = getLastRoot();
    newRoots.addAll(lastRoot.getChildren());

    if (newRoots.isEmpty()) {
      return null;
    }
    return new Forest(newRoots);
  }
Beispiel #18
0
 @SuppressWarnings("unchecked")
 static <T, U> Tree<U> apply(
     Node<T> node, Function<? super T, ? extends Iterable<? extends U>> mapper) {
   final Tree<U> mapped = Tree.ofAll(mapper.apply(node.getValue()));
   if (mapped.isEmpty()) {
     return Tree.empty();
   } else {
     final List<Node<U>> children =
         (List<Node<U>>)
             (Object)
                 node.getChildren()
                     .map(child -> FlatMap.apply(child, mapper))
                     .filter(Tree::isDefined);
     return Tree.of(mapped.getValue(), children.prependAll(mapped.getChildren()));
   }
 }
Beispiel #19
0
  /**
   * Get All Suffix Subforests ------------------------- What is a suffix subforest you may ask? Is
   * all the right most nodes in a forest, plus all the suffix subforests of each root. Its useful
   * for the recursive definition of distance with equivalence between two queries. If there are n
   * nodes in a forest, there are exactly n suffix subforests.
   */
  public List<Forest> getAllSuffixSubforests() {
    List<Forest> subforests = new ArrayList<Forest>();

    for (int i = 0; i < roots.size(); i++) {
      List<Tree> suffixRoots = roots.subList(i, roots.size());
      subforests.add(new Forest(suffixRoots));
    }

    for (Tree root : roots) {
      List<Tree> children = root.getChildren();
      if (!children.isEmpty()) {
        Forest childForest = new Forest(children);
        subforests.addAll(childForest.getAllSuffixSubforests());
      }
    }
    return subforests;
  }
Beispiel #20
0
 public Tree<String> transformTree(Tree<String> tree) {
   String label = tree.getLabel();
   if (label.equals("-NONE-")) {
     return null;
   }
   if (tree.isLeaf()) {
     return new Tree<String>(label);
   }
   List<Tree<String>> children = tree.getChildren();
   List<Tree<String>> transformedChildren = new ArrayList<Tree<String>>();
   for (Tree<String> child : children) {
     Tree<String> transformedChild = transformTree(child);
     if (transformedChild != null) transformedChildren.add(transformedChild);
   }
   if (transformedChildren.size() == 0) return null;
   return new Tree<String>(label, transformedChildren);
 }
Beispiel #21
0
 public Tree<String> transformTree(Tree<String> tree) {
   String label = tree.getLabel();
   Matcher matcher = punctuationPattern.matcher(label);
   if (matcher.matches()) {
     return null;
   }
   if (tree.isLeaf()) {
     return new Tree<String>(label);
   }
   List<Tree<String>> children = tree.getChildren();
   List<Tree<String>> transformedChildren = new ArrayList<Tree<String>>();
   for (Tree<String> child : children) {
     Tree<String> transformedChild = transformTree(child);
     if (transformedChild != null) transformedChildren.add(transformedChild);
   }
   if (transformedChildren.size() == 0) return null;
   return new Tree<String>(label, transformedChildren);
 }
Beispiel #22
0
 /** Display a node, implementing Penn Treebank style layout */
 private static <L> void renderTree(
     Tree<L> tree,
     int indent,
     boolean parentLabelNull,
     boolean firstSibling,
     boolean leftSiblingPreTerminal,
     boolean topLevel,
     StringBuilder sb) {
   // the condition for staying on the same line in Penn Treebank
   boolean suppressIndent =
       (parentLabelNull
           || (firstSibling && tree.isPreTerminal())
           || (leftSiblingPreTerminal
               && tree.isPreTerminal()
               && (tree.getLabel() == null || !tree.getLabel().toString().startsWith("CC"))));
   if (suppressIndent) {
     sb.append(' ');
   } else {
     if (!topLevel) {
       sb.append('\n');
     }
     for (int i = 0; i < indent; i++) {
       sb.append("  ");
     }
   }
   if (tree.isLeaf() || tree.isPreTerminal()) {
     renderFlat(tree, sb);
     return;
   }
   sb.append('(');
   sb.append(tree.getLabel());
   renderChildren(
       tree.getChildren(),
       indent + 1,
       tree.getLabel() == null || tree.getLabel().toString() == null,
       sb);
   sb.append(')');
 }
Beispiel #23
0
  private boolean step(Tree code) {
    if (code.getData().equals(FUN)) return false;

    if (code.getData().equals("")
        && code.getChildren().size() >= 1
        && code.getChild(0).getData().equals(FUN)) {
      // This is an APPLY -- make sure it works.
      Tree fn = code.getChild(0);
      Vector<Tree> fnargs = fn.getChildren();
      Tree body = fnargs.get(1);
      fnargs = fnargs.get(0).getChildren();

      Vector<Tree> inargs = code.getChildren();
      inargs.remove(0);
      for (Tree t : inargs) {
        if (step(t)) return true;
      }

      if (fnargs.size() != inargs.size()) {
        return false;
      }

      for (int i = 0; i < fnargs.size(); i++) {
        replace(body, fnargs.get(i).getData(), inargs.get(i));
      }

      code.removeChildren(false);
      for (Tree t : body.getChildren()) {
        code.addChild(t, false);
      }
      code.setData(body.getData());

      return true;
    } else if (code.getData().equals(IF)) {
      // IF
      Vector<Tree> ifargs = code.getChildren();
      if (step(ifargs.get(0))) return true;

      if (ifargs.get(0).getData().equals("0")) { // "0" is our only false value
        System.out.println("FALSE IF");
        code.removeChildren(false);

        for (Tree kkid : ifargs.get(2).getChildren()) {
          code.addChild(kkid, false);
        }

        code.setData(ifargs.get(2).getData());
      } else {
        System.out.println("TRUE IF: " + ifargs.get(0));
        code.removeChildren(false);

        for (Tree kkid : ifargs.get(1).getChildren()) {
          code.addChild(kkid, false);
        }

        code.setData(ifargs.get(1).getData());
      }
      return true;
    }

    for (Tree kid : code.getChildren()) {
      if (step(kid)) {
        System.out.println("stepped " + kid);
        return true;
      }
    }

    if (code.getData().equals("<")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      if (left < right) {
        code.setData("1");
      } else {
        code.setData("0");
      }

      return true;
    } else if (code.getData().equals(">")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      if (left > right) {
        code.setData("1");
      } else {
        code.setData("0");
      }

      return true;
    } else if (code.getData().equals("=")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      if (left.equals(right)) {
        code.setData("1");
      } else {
        code.setData("0");
      }

      return true;
    } else if (code.getData().equals("+")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      code.setData("" + (left + right));

      return true;
    } else if (code.getData().equals("-")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      code.setData("" + (left - right));

      return true;
    } else if (code.getData().equals("*")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      code.setData("" + (left * right));

      return true;
    } else if (code.getData().equals("/")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      code.setData("" + (left / right));

      return true;
    } else if (code.getData().equals("^")) {
      Vector<Tree> ltargs = code.getChildren();
      Double left = Double.parseDouble(ltargs.get(0).getData());
      Double right = Double.parseDouble(ltargs.get(1).getData());

      code.removeChildren(false);
      code.setData("" + Math.pow(left, right));

      return true;
    }

    System.out.println("Couldn't step: " + code.getData());
    return false;
  }
Beispiel #24
0
 static <T> Stream<T> postOrder(Tree<T> tree) {
   return tree.getChildren()
       .foldLeft(Stream.<T>empty(), (acc, child) -> acc.appendAll(postOrder(child)))
       .append(tree.getValue());
 }
Beispiel #25
0
 static <T> Stream<T> preOrder(Tree<T> tree) {
   return tree.getChildren()
       .foldLeft(Stream.of(tree.getValue()), (acc, child) -> acc.appendAll(preOrder(child)));
 }