public override bool Equals(object obj) { if (this == obj) { return(true); } if (obj == null) { return(false); } if (GetType() != obj.GetType()) { return(false); } TwoPlanarConfig that = (TwoPlanarConfig)obj; if (ActiveStack.Count != that.ActiveStack.Count) { return(false); } if (InactiveStack.Count != that.InactiveStack.Count) { return(false); } if (input.Count != that.Input.Count) { return(false); } if (dependencyGraph.NEdges() != that.DependencyGraph.NEdges()) { return(false); } for (int i = 0; i < ActiveStack.Count; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: if (ActiveStack.get(i).Index != that.ActiveStack.get(i).Index) { return(false); } } for (int i = 0; i < InactiveStack.Count; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: if (InactiveStack.get(i).Index != that.InactiveStack.get(i).Index) { return(false); } } for (int i = 0; i < input.Count; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: if (input.get(i).Index != that.Input.get(i).Index) { return(false); } } return(dependencyGraph.Edges.Equals(that.DependencyGraph.Edges)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.parser.history.action.GuideUserAction getDeterministicAction(org.maltparser.parser.history.GuideUserHistory history, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override GuideUserAction getDeterministicAction(GuideUserHistory history, ParserConfiguration config) { TwoPlanarConfig theConfig = (TwoPlanarConfig)config; if (theConfig.getRootHandling() != TwoPlanarConfig.NORMAL && theConfig.ActiveStack.Peek().Root) { return(updateActionContainers(history, SHIFT, null)); } return(null); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void apply(org.maltparser.parser.history.action.GuideUserAction currentAction, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override void apply(GuideUserAction currentAction, ParserConfiguration config) { TwoPlanarConfig planarConfig = (TwoPlanarConfig)config; Stack <DependencyNode> activeStack = planarConfig.ActiveStack; Stack <DependencyNode> inactiveStack = planarConfig.InactiveStack; Stack <DependencyNode> input = planarConfig.Input; currentAction.getAction(actionContainers); Edge e = null; int actionCode = transActionContainer.ActionCode; switch (actionCode) { case LEFTARC: e = planarConfig.DependencyStructure.AddDependencyEdge(input.Peek().Index, activeStack.Peek().Index); addEdgeLabels(e); break; case RIGHTARC: e = planarConfig.DependencyStructure.AddDependencyEdge(activeStack.Peek().Index, input.Peek().Index); addEdgeLabels(e); break; case SWITCH: planarConfig.switchStacks(); if (planarConfig.reduceAfterSwitch()) { planarConfig.ActiveStack.Pop(); } break; case REDUCE: activeStack.Pop(); break; case REDUCEBOTH: activeStack.Pop(); inactiveStack.Pop(); break; default: //SHIFT DependencyNode n = input.Pop(); activeStack.Push(n); inactiveStack.Push(n); break; } planarConfig.LastAction = actionCode; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private org.maltparser.core.syntaxgraph.edge.Edge getFirstPendingLinkOnAnyPlane(TwoPlanarConfig config, org.maltparser.core.syntaxgraph.DependencyStructure gold) throws org.maltparser.core.exception.MaltChainedException private Edge getFirstPendingLinkOnAnyPlane(TwoPlanarConfig config, IDependencyStructure gold) { Edge e1 = getFirstPendingLinkOnActivePlane(config, gold); Edge e2 = getFirstPendingLinkOnInactivePlane(config, gold); int left1 = Math.Min(e1.Source.Index, e1.Target.Index); int left2 = Math.Min(e2.Source.Index, e2.Target.Index); if (left1 > left2) { return(e1); } else { return(e2); } }
/// <summary> /// Gets the shortest pending link between (to or from) the input node and a node to the left of rightmostLimit, such that the link /// can be established on the given plane. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private org.maltparser.core.syntaxgraph.edge.Edge getFirstPendingLinkOnPlane(TwoPlanarConfig config, org.maltparser.core.syntaxgraph.DependencyStructure gold, int plane, int rightmostLimit) throws org.maltparser.core.exception.MaltChainedException private Edge getFirstPendingLinkOnPlane(TwoPlanarConfig config, IDependencyStructure gold, int plane, int rightmostLimit) { TwoPlanarConfig planarConfig = (TwoPlanarConfig)config; //DependencyStructure dg = planarConfig.getDependencyGraph(); -> no need, if rightmostLimit is well chosen, due to algorithm invariants int inputPeekIndex = planarConfig.Input.Peek().Index; Edge current = null; int maxIndex; if (planarConfig.getRootHandling() == TwoPlanarConfig.NORMAL) { maxIndex = -1; //count links from dummy root } else { maxIndex = 0; //do not count links from dummy root } if (gold.GetTokenNode(inputPeekIndex).hasLeftDependent() && gold.GetTokenNode(inputPeekIndex).LeftmostDependent.Index < rightmostLimit) { SortedSet <DependencyNode> dependents = gold.GetTokenNode(inputPeekIndex).LeftDependents; for (IEnumerator <DependencyNode> iterator = dependents.GetEnumerator(); iterator.MoveNext();) { DependencyNode dependent = (DependencyNode)iterator.Current; if (dependent.Index > maxIndex && dependent.Index < rightmostLimit && getLinkDecision(dependent.HeadEdge, config) == plane) { maxIndex = dependent.Index; current = dependent.HeadEdge; } } } //at this point, current is the first left-pointing link, but we have to check right-pointing link as well //System.out.println("in" + inputPeekIndex + " rl" + rightmostLimit); if (gold.GetTokenNode(inputPeekIndex).Head.Index < rightmostLimit) { //System.out.println(":"); if (gold.GetTokenNode(inputPeekIndex).Head.Index > maxIndex && getLinkDecision(gold.GetTokenNode(inputPeekIndex).HeadEdge, config) == plane) { //System.out.println("::"); current = gold.GetTokenNode(inputPeekIndex).HeadEdge; } } return(current); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void update(TwoPlanarConfig config) throws org.maltparser.core.exception.MaltChainedException private void update(TwoPlanarConfig config) { if (subFunction == TwoPlanarSubFunction.ACTIVESTACK) { address.Address = config.getActiveStackNode(index); } else if (subFunction == TwoPlanarSubFunction.INACTIVESTACK) { address.Address = config.getInactiveStackNode(index); } else if (subFunction == TwoPlanarSubFunction.INPUT) { address.Address = config.getInputNode(index); } else { address.Address = null; } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void initialize(org.maltparser.parser.ParserConfiguration parserConfiguration) throws org.maltparser.core.exception.MaltChainedException public virtual void initialize(ParserConfiguration parserConfiguration) { if (parserConfiguration != null) { TwoPlanarConfig planarConfig = (TwoPlanarConfig)parserConfiguration; activeStack = planarConfig.activeStack; Stack <DependencyNode> sourceActiveStack = planarConfig.ActiveStack; Stack <DependencyNode> sourceInactiveStack = planarConfig.InactiveStack; Stack <DependencyNode> sourceInput = planarConfig.Input; DependencyGraph = planarConfig.DependencyGraph; for (int i = 0, n = sourceActiveStack.Count; i < n; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: ActiveStack.Push(dependencyGraph.GetDependencyNode(sourceActiveStack.get(i).Index)); } for (int i = 0, n = sourceInactiveStack.Count; i < n; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: InactiveStack.Push(dependencyGraph.GetDependencyNode(sourceInactiveStack.get(i).Index)); } for (int i = 0, n = sourceInput.Count; i < n; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: input.Push(dependencyGraph.GetDependencyNode(sourceInput.get(i).Index)); } } else { ActiveStack.Push(dependencyGraph.DependencyRoot); InactiveStack.Push(dependencyGraph.DependencyRoot); for (int i = dependencyGraph.HighestTokenIndex; i > 0; i--) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode node = dependencyGraph.getDependencyNode(i); DependencyNode node = dependencyGraph.GetDependencyNode(i); if (node != null) { input.Push(node); } } } }
/// <summary> /// Decides in which plane link e should be created. /// </summary> private int getLinkDecision(Edge e, TwoPlanarConfig config) { int constraint = getPlaneConstraint(e); if (constraint == ANY_PLANE) { //choose active plane if (config.StackActivityState == TwoPlanarConfig.FIRST_STACK) { return(FIRST_PLANE); } else { return(SECOND_PLANE); } } else { return(constraint); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public boolean permissible(org.maltparser.parser.history.action.GuideUserAction currentAction, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override bool permissible(GuideUserAction currentAction, ParserConfiguration config) { currentAction.getAction(actionContainers); int trans = transActionContainer.ActionCode; TwoPlanarConfig planarConfig = (TwoPlanarConfig)config; DependencyNode activeStackPeek = planarConfig.ActiveStack.Peek(); DependencyNode inactiveStackPeek = planarConfig.InactiveStack.Peek(); DependencyNode inputPeek = planarConfig.Input.Peek(); IDependencyStructure dg = planarConfig.DependencyGraph; //int rootHandling = planarConfig.getRootHandling(); bool singleHeadConstraint = planarConfig.requiresSingleHead(); bool noCoveredRootsConstraint = planarConfig.requiresNoCoveredRoots(); bool acyclicityConstraint = planarConfig.requiresAcyclicity(); //boolean connectednessConstraintOnReduce = planarConfig.requiresConnectednessCheckOnReduce(); //boolean connectednessConstraintOnShift = planarConfig.requiresConnectednessCheckOnShift(); if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled) { return(false); } //if ((trans == LEFTARC || trans == REDUCE) && stackPeek.isRoot()) { // return false; //} if (trans == LEFTARC) { //avoid making root child of something if (activeStackPeek.Root) { return(false); } //enforce single-head constraint if present if (activeStackPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (activeStackPeek.hasHead() && dg.GetTokenNode(activeStackPeek.Index).Head.Index == inputPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && activeStackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == RIGHTARC) { //enforce single-head constraint if present if (inputPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (inputPeek.hasHead() && dg.GetTokenNode(inputPeek.Index).Head.Index == activeStackPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && activeStackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == REDUCE) { //do not reduce the dummy root if (activeStackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if (!activeStackPeek.hasHead() && noCoveredRootsConstraint) { return(false); } //TODO does this line still make sense? (from Nivre arc-eager) //if ( !stackPeek.hasHead() && rootHandling == PlanarConfig.STRICT ) // return false; //enforce connectedness constraint if present /* * if ( connectednessConstraintOnReduce ) * { * boolean path1 = ( stackPeek.findComponent().getIndex() == inputPeek.findComponent().getIndex() ); * boolean path2; * if ( planarConfig.getStack().size() < 2 ) path2=false; * else * { * DependencyNode stackPrev = planarConfig.getStack().get(planarConfig.getStack().size()-2); * path2 = stackPrev.findComponent().getIndex() == stackPeek.findComponent().getIndex(); * } * return path1 || path2; * } */ } if (trans == SHIFT) { /* * if ( connectednessConstraintOnShift && planarConfig.getInput().size() == 1 ) //last word * { * boolean path = ( planarConfig.getDependencyGraph().getTokenNode(1).findComponent().getIndex() == inputPeek.findComponent().getIndex() ); //require connection to 1st * return path; * } */ } if (trans == REDUCEBOTH) { //do not reduce the dummy root if (activeStackPeek.Root || inactiveStackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if ((!activeStackPeek.hasHead() || inactiveStackPeek.hasHead()) && noCoveredRootsConstraint) { return(false); } //TODO remove this: //not using this transition at the moment, so return(false); } if (trans == SWITCH) { if (planarConfig.reduceAfterSwitch()) { if (inactiveStackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if (!inactiveStackPeek.hasHead() && noCoveredRootsConstraint) { return(false); } } else { if (planarConfig.LastAction == SWITCH) { return(false); } } } return(true); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.parser.history.action.GuideUserAction predict(org.maltparser.core.syntaxgraph.DependencyStructure gold, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override GuideUserAction predict(IDependencyStructure gold, ParserConfiguration config) { TwoPlanarConfig planarConfig = (TwoPlanarConfig)config; IDependencyStructure dg = planarConfig.DependencyGraph; DependencyNode activeStackPeek = planarConfig.ActiveStack.Peek(); DependencyNode inactiveStackPeek = planarConfig.InactiveStack.Peek(); int activeStackPeekIndex = activeStackPeek.Index; int inactiveStackPeekIndex = inactiveStackPeek.Index; int inputPeekIndex = planarConfig.Input.Peek().Index; //System.out.println("Initting crossings"); if (crossingsGraph == null) { initCrossingsGraph(gold); } //System.out.println("Crossings initted"); if (!activeStackPeek.Root && gold.GetTokenNode(activeStackPeekIndex).Head.Index == inputPeekIndex && !checkIfArcExists(dg, inputPeekIndex, activeStackPeekIndex)) { if (planarConfig.StackActivityState == TwoPlanarConfig.FIRST_STACK) { propagatePlaneConstraint(gold.GetTokenNode(activeStackPeekIndex).HeadEdge, FIRST_PLANE); } else { propagatePlaneConstraint(gold.GetTokenNode(activeStackPeekIndex).HeadEdge, SECOND_PLANE); } //System.out.println("From " + inputPeekIndex + " to " + activeStackPeekIndex); return(updateActionContainers(TwoPlanar.LEFTARC, gold.GetTokenNode(activeStackPeekIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index == activeStackPeekIndex && !checkIfArcExists(dg, activeStackPeekIndex, inputPeekIndex)) { if (planarConfig.StackActivityState == TwoPlanarConfig.FIRST_STACK) { propagatePlaneConstraint(gold.GetTokenNode(inputPeekIndex).HeadEdge, FIRST_PLANE); } else { propagatePlaneConstraint(gold.GetTokenNode(inputPeekIndex).HeadEdge, SECOND_PLANE); } //System.out.println("From " + activeStackPeekIndex + " to " + inputPeekIndex); return(updateActionContainers(TwoPlanar.RIGHTARC, gold.GetTokenNode(inputPeekIndex).HeadEdge.LabelSet)); } else if (!inactiveStackPeek.Root && gold.GetTokenNode(inactiveStackPeekIndex).Head.Index == inputPeekIndex && !checkIfArcExists(dg, inputPeekIndex, inactiveStackPeekIndex)) { //need to create link, but on the other plane!! //TODO is this if branch really necessary? i.e. will this happen? (later branches already switch) //System.out.println("Switch one"); return(updateActionContainers(TwoPlanar.SWITCH, null)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index == inactiveStackPeekIndex && !checkIfArcExists(dg, inactiveStackPeekIndex, inputPeekIndex)) { //need to create link, but on the other plane!! //TODO is this if branch really necessary? i.e. will this happen? (later branches already switch) //System.out.println("Switch two"); return(updateActionContainers(TwoPlanar.SWITCH, null)); } else if (getFirstPendingLinkOnActivePlane(planarConfig, gold) != null) { //System.out.println("Reduce one"); return(updateActionContainers(TwoPlanar.REDUCE, null)); } else if (getFirstPendingLinkOnInactivePlane(planarConfig, gold) != null) { //System.out.println("Switch for reducing"); return(updateActionContainers(TwoPlanar.SWITCH, null)); } //TODO: double reduce somehow? (check if reduced node is not covered by links of the other plane, or something like that). else { //System.out.println("Shift"); return(updateActionContainers(TwoPlanar.SHIFT, null)); } }
/// <summary> /// Gets the shortest pending link between (to or from) the input node and a node to the left of the top of the inactive stack, /// such that the link can be established on the inactive plane. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private org.maltparser.core.syntaxgraph.edge.Edge getFirstPendingLinkOnInactivePlane(TwoPlanarConfig config, org.maltparser.core.syntaxgraph.DependencyStructure gold) throws org.maltparser.core.exception.MaltChainedException private Edge getFirstPendingLinkOnInactivePlane(TwoPlanarConfig config, IDependencyStructure gold) { return(getFirstPendingLinkOnPlane(config, gold, config.StackActivityState == TwoPlanarConfig.FIRST_STACK ? SECOND_PLANE : FIRST_PLANE, config.InactiveStack.Peek().Index)); }