/** * Returns {@code true} if the dependency label of this node equals to the specific label. * @param label the dependency label to be compared. * @return {@code true} if the dependency label of this node equals to the specific label. */ public boolean isLabel(String label) { return d_head.label != null && d_head.isLabel(label); }
public boolean containsDependent(String label) { for (DEPArc node : l_dependents) { if (node.isLabel(label)) return true; } return false; }
public boolean isLabel(Pattern regex) { return d_head.label != null && d_head.isLabel(regex); }
public void removeFirstDependentByLabel(String label) { for (DEPArc arc : l_dependents) { if (arc.isLabel(label)) { l_dependents.remove(arc); break; } } }
public List<DEPArc> getXHeads(String label) { List<DEPArc> list = new ArrayList<DEPArc>(); for (DEPArc arc : x_heads) { if (arc.isLabel(label)) list.add(arc); } return list; }
public void removeDependentsByLabels(Pattern regex) { List<DEPArc> remove = new ArrayList<DEPArc>(); for (DEPArc arc : l_dependents) { if (arc.isLabel(regex)) remove.add(arc); } l_dependents.removeAll(remove); }
@Deprecated private void stripUnnecessaries(DEPNode node) { List<DEPArc> remove = new ArrayList<DEPArc>(); for (DEPArc arc : node.getDependents()) { if (arc.isLabel(DEPLibEn.DEP_PUNCT) || arc.isLabel(DEPLibEn.DEP_COMPLM) || arc.isLabel(DEPLibEn.DEP_MARK)) remove.add(arc); } node.removeDependents(remove); }
public DEPNode getFirstDependentByLabel(String label) { for (DEPArc arc : l_dependents) { if (arc.isLabel(label)) return arc.getNode(); } return null; }
public List<DEPNode> getDependentsByLabels(Pattern regex) { List<DEPNode> list = new ArrayList<DEPNode>(); for (DEPArc arc : l_dependents) { if (arc.isLabel(regex)) list.add(arc.getNode()); } return list; }
public List<DEPNode> getDependentsByLabels(String... labels) { List<DEPNode> list = new ArrayList<DEPNode>(); for (DEPArc arc : l_dependents) { for (String label : labels) { if (arc.isLabel(label)) list.add(arc.getNode()); } } return list; }
/** * If both the specific node and label match, returns 1. * If only the specific node matches, returns 2. * Otherwise, returns 0. * @param node the node to be compared. * @param label the label to be compared. * @return If both the specific node and label match, returns 1. * If only the specific node matches, returns 2. * Otherwise, returns 0. */ public int compareTo(DEPNode node, String label) { if (isNode(node)) return isLabel(label) ? 1 : 2; return 0; }
if (arc.isLabel(DEPLibEn.DEP_NN) || dep.isPos(CTLibEn.POS_PRPS))
private void removeDependents(DEPNode root, DEPNode verb) { List<DEPArc> remove = new ArrayList<DEPArc>(); for (DEPArc arc : verb.getDependents()) { if (arc.isLabel(P_REMOVE)) { arc.getNode().setHead(root); remove.add(arc); } } verb.removeDependents(remove); }
public void getDescendentsAux(DEPNode node, List<DEPNode> desc, Pattern regex) { for (DEPArc arc : node.getDependents()) { if (arc.isLabel(regex)) { getDescendentsAux(arc.getNode(), desc, regex); desc.add(arc.getNode()); } } }
@Override public void countAccuracy(int[] counts) { int i, pTotal = 0, rTotal = 0, correct = 0; StringIntPair[] gHeads; List<SRLArc> sHeads; for (i=1; i<t_size; i++) { sHeads = d_tree.get(i).getSHeads(); gHeads = g_heads[i]; pTotal += sHeads.size(); rTotal += gHeads.length; for (StringIntPair p : gHeads) for (DEPArc arc : sHeads) if (arc.getNode().id == p.i && arc.isLabel(p.s)) correct++; } counts[0] += correct; counts[1] += pTotal; counts[2] += rTotal; }
/** {@link LGAsk#generateAskFromQuestion(DEPTree, String)}. */ private void relocateAuxiliary(DEPTree tree, DEPNode verb) { List<DEPNode> auxes = new ArrayList<DEPNode>(); DEPNode sbj = null; for (DEPArc arc : verb.getDependents()) { if (arc.isLabel(DEPLibEn.P_AUX)) auxes.add(arc.getNode()); else if (arc.isLabel(DEPLibEn.P_SBJ)) sbj = arc.getNode(); } if (sbj != null) { if (!auxes.isEmpty() && auxes.get(0).id < sbj.id) { relocateAuxiliaryAux(tree, verb, auxes, sbj); } else if (verb.isLemma(ENAux.BE) && verb.id < sbj.id) { tree.remove(verb); tree.add(sbj.getLastNode().id, verb); setBeVerbForm(verb, sbj); } } }
static public boolean containsNegation(SRLTree tree) { DEPNode pred = tree.getPredicate(); for (DEPArc arc : pred.getDependents()) { if (arc.isLabel(DEPLibEn.DEP_NEG)) return true; } for (SRLArc arc : tree.getArguments()) { if (arc.isLabel(SRLLib.ARGM_NEG)) return true; } return false; } }
private DEPNode getNodeFromSyntacticInfo(DEPNode head, ArgInfo rArg, String delim) { Pair<String,String> p = rArg.popNextSyntacticInfo(); String label = p.o1, lemma = p.o2; DEPNode dep; for (DEPArc arc : head.getDependents()) { dep = arc.getNode(); if (dep.isLemma(lemma) && (arc.isLabel(label) || (label.equals(DEPLibEn.DEP_PREP) && dep.isPos(CTLibEn.POS_IN)))) { if (!rArg.hasSyntacticInfo()) return dep; else return getNodeFromSyntacticInfo(dep, rArg, delim); } } return null; }
/** Called by {@link DEPLibEn#postLabel(DEPTree)}. */ static private void labelReferentOfRelativeClause(DEPNode verb, List<DEPArc> argList) { DEPNode top = getTopVerbChain(verb); DEPNode head = top.getHead(); if (top.isLabel(DEPLibEn.DEP_RCMOD) && !head.containsSHead(verb)) { for (DEPArc arc : argList) { if (arc.isLabel(SRLLib.P_ARG_REF) && isReferentArgument(arc.getNode())) { head.addSHead(verb, SRLLib.getBaseLabel(arc.getLabel())); return; } } } }