//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private org.maltparser.core.syntaxgraph.node.DependencyNode breadthFirstSearchSortedByDistanceForHeadAndPath(org.maltparser.core.syntaxgraph.DependencyStructure dg, org.maltparser.core.syntaxgraph.node.DependencyNode start, org.maltparser.core.syntaxgraph.node.DependencyNode avoid, String syntacticHeadDeprelCode) throws org.maltparser.core.exception.MaltChainedException private DependencyNode breadthFirstSearchSortedByDistanceForHeadAndPath(IDependencyStructure dg, DependencyNode start, DependencyNode avoid, string syntacticHeadDeprelCode) { DependencyNode dependent; List <DependencyNode> nodes = new List <DependencyNode>(), newNodes = null, secondChance = new List <DependencyNode>(); nodes.AddRange(findAllDependentsVectorSortedByDistanceToPProjNode(dg, start, avoid, true)); while (nodes.Count > 0) { dependent = nodes.RemoveAt(0); if (((newNodes = findAllDependentsVectorSortedByDistanceToPProjNode(dg, dependent, avoid, true)).Count) == 0 && deprelSymbolTable.getSymbolCodeToString(dependent.HeadEdge.getLabelCode(deprelSymbolTable)).Equals(syntacticHeadDeprelCode)) { return(dependent); } nodes.AddRange(newNodes); if (deprelSymbolTable.getSymbolCodeToString(dependent.HeadEdge.getLabelCode(deprelSymbolTable)).Equals(syntacticHeadDeprelCode) && newNodes.Count != 0) { secondChance.Add(dependent); } } if (secondChance.Count > 0) { return(secondChance[0]); } return(null); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void initProjectivization(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException private void initProjectivization(IDependencyStructure pdg) { nodeLifted.Clear(); nodeTrace.Clear(); headDeprel.Clear(); nodePath.Clear(); isCoveredRoot_Renamed.Clear(); nodeRelationLength.Clear(); foreach (int index in pdg.DependencyIndices) { nodeLifted.Add(false); nodeTrace.Add(new List <DependencyNode>()); headDeprel.Add(null); nodePath.Add(false); isCoveredRoot_Renamed.Add(false); if (ppliftedSymbolTable != null && index != 0) { pdg.GetDependencyNode(index).HeadEdge.LabelSet.put(ppliftedSymbolTable, ppliftedSymbolTable.getSymbolStringToCode("#false#")); } if (pppathSymbolTable != null && index != 0) { pdg.GetDependencyNode(index).HeadEdge.LabelSet.put(pppathSymbolTable, pppathSymbolTable.getSymbolStringToCode("#false#")); } if (ppcoveredRootSymbolTable != null && index != 0) { pdg.GetDependencyNode(index).HeadEdge.LabelSet.put(ppcoveredRootSymbolTable, ppcoveredRootSymbolTable.getSymbolStringToCode("#false#")); } } computeRelationLength(pdg); }
//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 configuration) throws org.maltparser.core.exception.MaltChainedException public override GuideUserAction predict(IDependencyStructure gold, ParserConfiguration configuration) { StackConfig config = (StackConfig)configuration; Stack <DependencyNode> stack = config.Stack; if (stack.Count < 2) { return(updateActionContainers(Projective.SHIFT, null)); } else { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: DependencyNode left = stack.get(stack.Count - 2); int leftIndex = left.Index; //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: int rightIndex = stack.get(stack.Count - 1).Index; if (!left.Root && gold.GetTokenNode(leftIndex).Head.Index == rightIndex) { return(updateActionContainers(Projective.LEFTARC, gold.GetTokenNode(leftIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(rightIndex).Head.Index == leftIndex && checkRightDependent(gold, config.DependencyGraph, rightIndex)) { return(updateActionContainers(Projective.RIGHTARC, gold.GetTokenNode(rightIndex).HeadEdge.LabelSet)); } else { return(updateActionContainers(Projective.SHIFT, null)); } // Solve the problem with non-projective input. } }
//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) { CovingtonConfig covingtonConfig = (CovingtonConfig)config; DependencyNode leftTarget = covingtonConfig.LeftTarget; DependencyNode rightTarget = covingtonConfig.RightTarget; IDependencyStructure dg = covingtonConfig.DependencyGraph; currentAction.getAction(actionContainers); int trans = transActionContainer.ActionCode; if (trans == SHIFT && covingtonConfig.AllowShift == false) { return(false); } if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled) { return(false); } if (trans == LEFTARC && leftTarget.Root) { return(false); } if (trans == LEFTARC && dg.HasLabeledDependency(leftTarget.Index)) { return(false); } if (trans == RIGHTARC && dg.HasLabeledDependency(rightTarget.Index)) { return(false); } return(true); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public int process(int signal) throws org.maltparser.core.exception.MaltChainedException public override int process(int signal) { if (taskName.Equals("process")) { if (cachedSourceGraph == null) { cachedSourceGraph = (IDependencyStructure)flowChartinstance.getFlowChartRegistry(typeof(IDependencyStructure), sourceName); } if (cachedTargetGraph == null) { cachedTargetGraph = (IDependencyStructure)flowChartinstance.getFlowChartRegistry(typeof(IDependencyStructure), targetName); } if (modeName.Equals("learn")) { singleMalt.OracleParse(cachedSourceGraph, cachedTargetGraph); } else if (modeName.Equals("parse")) { singleMalt.Parse(cachedSourceGraph); // if (cachedSourceGraph instanceof MappablePhraseStructureGraph) { // System.out.println("MappablePhraseStructureGraph"); // ((MappablePhraseStructureGraph)cachedSourceGraph).getMapping().connectUnattachedSpines((MappablePhraseStructureGraph)cachedSourceGraph); // } } } return(signal); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.core.syntaxgraph.DependencyStructure parse(org.maltparser.core.syntaxgraph.DependencyStructure goldDependencyGraph, org.maltparser.core.syntaxgraph.DependencyStructure parseDependencyGraph) throws org.maltparser.core.exception.MaltChainedException public override IDependencyStructure parse(IDependencyStructure goldDependencyGraph, IDependencyStructure parseDependencyGraph) { parserState.clear(); parserState.initialize(parseDependencyGraph); currentParserConfiguration = parserState.Configuration; TransitionSystem transitionSystem = parserState.TransitionSystem; while (!parserState.TerminalState) { GuideUserAction action = transitionSystem.getDeterministicAction(parserState.History, currentParserConfiguration); if (action == null) { action = oracleGuide.predict(goldDependencyGraph, currentParserConfiguration); try { classifierGuide.addInstance(featureModel, (GuideDecision)action); } catch (System.NullReferenceException e) { throw new MaltChainedException("The guide cannot be found. ", e); } } parserState.apply(action); } CopyEdges(currentParserConfiguration.DependencyGraph, parseDependencyGraph); parseDependencyGraph.LinkAllTreesToRoot(); oracleGuide.finalizeSentence(parseDependencyGraph); return(parseDependencyGraph); }
//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) { PlanarConfig planarConfig = (PlanarConfig)config; IDependencyStructure dg = planarConfig.DependencyGraph; DependencyNode stackPeek = planarConfig.Stack.Peek(); int stackPeekIndex = stackPeek.Index; int inputPeekIndex = planarConfig.Input.Peek().Index; if (!stackPeek.Root && gold.GetTokenNode(stackPeekIndex).Head.Index == inputPeekIndex && !checkIfArcExists(dg, inputPeekIndex, stackPeekIndex)) { return(updateActionContainers(Planar.LEFTARC, gold.GetTokenNode(stackPeekIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index == stackPeekIndex && !checkIfArcExists(dg, stackPeekIndex, inputPeekIndex)) { return(updateActionContainers(Planar.RIGHTARC, gold.GetTokenNode(inputPeekIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(inputPeekIndex).hasLeftDependent() && gold.GetTokenNode(inputPeekIndex).LeftmostDependent.Index < stackPeekIndex) { return(updateActionContainers(Planar.REDUCE, null)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index < stackPeekIndex && (!gold.GetTokenNode(inputPeekIndex).Head.Root || planarConfig.getRootHandling() == PlanarConfig.NORMAL)) { return(updateActionContainers(Planar.REDUCE, null)); } else { return(updateActionContainers(Planar.SHIFT, null)); } }
/// <summary> /// Same as parse(String[] tokens), but instead it returns an array of tokens with a head index and a dependency type at the end of string /// </summary> /// <param name="tokens"> an array of tokens to parse </param> /// <returns> an array of tokens with a head index and a dependency type at the end of string </returns> /// <exception cref="MaltChainedException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public String[] parseTokens(String[] tokens) throws org.maltparser.core.exception.MaltChainedException public virtual string[] parseTokens(string[] tokens) { IDependencyStructure outputGraph = parse(tokens); StringBuilder sb = new StringBuilder(); string[] outputTokens = new string[tokens.Length]; SymbolTable deprelTable = outputGraph.SymbolTables.getSymbolTable("DEPREL"); foreach (int?index in outputGraph.TokenIndices) { sb.Length = 0; if (index <= tokens.Length) { DependencyNode node = outputGraph.GetDependencyNode(index.Value); sb.Append(tokens[index - 1]); sb.Append('\t'); sb.Append(node.Head.Index); sb.Append('\t'); if (node.HeadEdge.hasLabel(deprelTable)) { sb.Append(node.HeadEdge.getLabelSymbol(deprelTable)); } else { sb.Append(outputGraph.GetDefaultRootEdgeLabelSymbol(deprelTable)); } outputTokens[index - 1] = sb.ToString(); } } return(outputTokens); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void copyPartialDependencyStructure(DependencyStructure sourceGraph, DependencyStructure targetGraph) throws org.maltparser.core.exception.MaltChainedException public virtual void copyPartialDependencyStructure(IDependencyStructure sourceGraph, IDependencyStructure targetGraph) { SymbolTable partHead = cachedSource.SymbolTables.getSymbolTable("PARTHEAD"); SymbolTable partDeprel = cachedSource.SymbolTables.getSymbolTable("PARTDEPREL"); if (partHead == null || partDeprel == null) { return; } SymbolTable deprel = cachedTarget.SymbolTables.getSymbolTable("DEPREL"); foreach (int index in sourceGraph.TokenIndices) { DependencyNode snode = sourceGraph.GetTokenNode(index); DependencyNode tnode = targetGraph.GetTokenNode(index); if (snode != null && tnode != null) { int spartheadindex = int.Parse(snode.getLabelSymbol(partHead)); string spartdeprel = snode.getLabelSymbol(partDeprel); if (spartheadindex > 0) { Edge.Edge tedge = targetGraph.AddDependencyEdge(spartheadindex, snode.Index); tedge.addLabel(deprel, spartdeprel); } } } }
private void initCrossingsGraph(IDependencyStructure dg) { crossingsGraph = new IdentityHashMap <Edge, IList <Edge> >(); SortedSet <Edge> edges = dg.Edges; //System.out.println(edges.size()); //System.out.println(dg.nEdges()); for (IEnumerator <Edge> iterator1 = edges.GetEnumerator(); iterator1.MoveNext();) { Edge edge1 = iterator1.Current; for (IEnumerator <Edge> iterator2 = edges.GetEnumerator(); iterator2.MoveNext();) { Edge edge2 = iterator2.Current; if (edge1.Source.Index < edge2.Source.Index && cross(edge1, edge2)) { //System.out.println("Crossing!"); IList <Edge> crossingEdge1 = crossingsGraph[edge1]; if (crossingEdge1 == null) { crossingEdge1 = new LinkedList <Edge>(); crossingsGraph[edge1] = crossingEdge1; } crossingEdge1.Add(edge2); IList <Edge> crossingEdge2 = crossingsGraph[edge2]; if (crossingEdge2 == null) { crossingEdge2 = new LinkedList <Edge>(); crossingsGraph[edge2] = crossingEdge2; } crossingEdge2.Add(edge1); } } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.core.syntaxgraph.DependencyStructure parse(org.maltparser.core.syntaxgraph.DependencyStructure parseDependencyGraph) throws org.maltparser.core.exception.MaltChainedException public override IDependencyStructure Parse(IDependencyStructure parseDependencyGraph) { parserState.clear(); parserState.initialize(parseDependencyGraph); currentParserConfiguration = parserState.Configuration; parseCount++; diagnostics.writeToDiaFile(parseCount + ""); while (!parserState.TerminalState) { GuideUserAction action = parserState.TransitionSystem.getDeterministicAction(parserState.History, currentParserConfiguration); if (action == null) { action = predict(); } else { diagnostics.writeToDiaFile(" *"); } diagnostics.writeToDiaFile(" " + parserState.TransitionSystem.getActionString(action)); parserState.apply(action); } CopyEdges(currentParserConfiguration.DependencyGraph, parseDependencyGraph); CopyDynamicInput(currentParserConfiguration.DependencyGraph, parseDependencyGraph); parseDependencyGraph.LinkAllTreesToRoot(); diagnostics.writeToDiaFile("\n"); return(parseDependencyGraph); }
//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) { StackConfig config = (StackConfig)parserConfiguration; Stack <DependencyNode> sourceStack = config.Stack; Stack <DependencyNode> sourceInput = config.Input; DependencyGraph = config.DependencyGraph; for (int i = 0, n = sourceStack.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: stack.Push(dependencyGraph.GetDependencyNode(sourceStack.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 { stack.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 && !node.hasHead()) { input.Push(node); } } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void process(Object[] arguments) throws org.maltparser.core.exception.MaltChainedException public virtual void process(object[] arguments) { if (mode == LEARN) { if (arguments.Length < 2 || !(arguments[0] is IDependencyStructure) || !(arguments[1] is IDependencyStructure)) { throw new MaltChainedException("The single malt learn task must be supplied with at least two dependency structures. "); } IDependencyStructure systemGraph = (IDependencyStructure)arguments[0]; IDependencyStructure goldGraph = (IDependencyStructure)arguments[1]; if (systemGraph.HasTokens() && Guide != null) { Guide.finalizeSentence(((Trainer)Algorithm).parse(goldGraph, systemGraph)); } } else if (mode == PARSE) { if (arguments.Length < 1 || !(arguments[0] is IDependencyStructure)) { throw new MaltChainedException("The single malt parse task must be supplied with at least one input terminal structure and one output dependency structure. "); } IDependencyStructure processGraph = (IDependencyStructure)arguments[0]; if (processGraph.HasTokens()) { parser.Parse(processGraph); // ((Parser)getAlgorithm()).parse(processGraph); } } }
private bool nodeComplete(IDependencyStructure gold, IDependencyStructure parseDependencyGraph, int nodeIndex) { if (gold.GetTokenNode(nodeIndex).hasLeftDependent()) { if (!parseDependencyGraph.GetTokenNode(nodeIndex).hasLeftDependent()) { return(false); } else if (gold.GetTokenNode(nodeIndex).LeftmostDependent.Index != parseDependencyGraph.GetTokenNode(nodeIndex).LeftmostDependent.Index) { return(false); } } if (gold.GetTokenNode(nodeIndex).hasRightDependent()) { if (!parseDependencyGraph.GetTokenNode(nodeIndex).hasRightDependent()) { return(false); } else if (gold.GetTokenNode(nodeIndex).RightmostDependent.Index != parseDependencyGraph.GetTokenNode(nodeIndex).RightmostDependent.Index) { return(false); } } return(true); }
// public void updateFeatureModel() throws MaltChainedException { // featureModel.update(); // } //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void finalizeSentence(org.maltparser.core.syntaxgraph.DependencyStructure dependencyGraph) throws org.maltparser.core.exception.MaltChainedException public virtual void finalizeSentence(IDependencyStructure dependencyGraph) { if (instanceModel != null) { instanceModel.finalizeSentence(dependencyGraph); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void finalizeSentence(org.maltparser.core.syntaxgraph.DependencyStructure dependencyGraph) throws org.maltparser.core.exception.MaltChainedException public virtual void finalizeSentence(IDependencyStructure dependencyGraph) { if (decisionModel != null) { decisionModel.finalizeSentence(dependencyGraph); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private boolean deprojectivizeWithHeadAndPath(org.maltparser.core.syntaxgraph.DependencyStructure pdg, org.maltparser.core.syntaxgraph.node.DependencyNode node) throws org.maltparser.core.exception.MaltChainedException private bool deprojectivizeWithHeadAndPath(IDependencyStructure pdg, DependencyNode node) { bool success = true, childSuccess = false; int i, childAttempts = 2; DependencyNode child, possibleSyntacticHead; if (node.hasHead() && node.HeadEdge.Labeled && nodeLifted[node.Index] && nodePath[node.Index]) { possibleSyntacticHead = breadthFirstSearchSortedByDistanceForHeadAndPath(pdg, node.Head, node, synacticHeadDeprel[node.Index]); if (possibleSyntacticHead != null) { pdg.MoveDependencyEdge(possibleSyntacticHead.Index, node.Index); nodeLifted[node.Index] = false; } else { success = false; } } if (node.hasHead() && node.HeadEdge.Labeled && nodeLifted[node.Index]) { possibleSyntacticHead = breadthFirstSearchSortedByDistanceForHeadAndPath(pdg, node.Head, node, synacticHeadDeprel[node.Index]); if (possibleSyntacticHead != null) { pdg.MoveDependencyEdge(possibleSyntacticHead.Index, node.Index); nodeLifted[node.Index] = false; } else { success = false; } } while (!childSuccess && childAttempts > 0) { childSuccess = true; List <DependencyNode> children = new List <DependencyNode>(); i = 0; while ((child = node.getLeftDependent(i)) != null) { children.Add(child); i++; } i = 0; while ((child = node.getRightDependent(i)) != null) { children.Add(child); i++; } for (i = 0; i < children.Count; i++) { child = children[i]; if (!deprojectivizeWithHeadAndPath(pdg, child)) { childSuccess = false; } } childAttempts--; } return(childSuccess && success); }
private bool nodeComplete(IDependencyStructure gold, IDependencyStructure parseDependencyGraph, int nodeIndex) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode goldNode = gold.getTokenNode(nodeIndex); DependencyNode goldNode = gold.GetTokenNode(nodeIndex); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode parseNode = parseDependencyGraph.getTokenNode(nodeIndex); DependencyNode parseNode = parseDependencyGraph.GetTokenNode(nodeIndex); if (goldNode.hasLeftDependent()) { if (!parseNode.hasLeftDependent()) { return(false); } else if (goldNode.LeftmostDependent.Index != parseNode.LeftmostDependent.Index) { return(false); } } if (goldNode.hasRightDependent()) { if (!parseNode.hasRightDependent()) { return(false); } else if (goldNode.RightmostDependent.Index != parseNode.RightmostDependent.Index) { return(false); } } return(true); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void parse(org.maltparser.core.syntaxgraph.DependencyStructure graph) throws org.maltparser.core.exception.MaltChainedException public void Parse(IDependencyStructure graph) { if (graph.HasTokens()) { LWDeterministicParser parser = new LWDeterministicParser(this, graph.SymbolTables); parser.parse(graph); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void parse(org.maltparser.core.syntaxgraph.DependencyStructure graph) throws org.maltparser.core.exception.MaltChainedException public virtual void Parse(IDependencyStructure graph) { if (graph.HasTokens()) { // ((Parser)getAlgorithm()).parse(graph); parser.Parse(graph); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void computeRelationLength(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException private void computeRelationLength(IDependencyStructure pdg) { nodeRelationLength.Add(0); foreach (int index in pdg.TokenIndices) { nodeRelationLength.Add(Math.Abs(pdg.GetDependencyNode(index).Index - pdg.GetDependencyNode(index).Head.Index)); } }
/// <summary> /// Creates a immutable dependency graph /// </summary> /// <param name="dataFormat"> a data format that describes the label types (or the columns in the input and output) </param> /// <param name="sourceGraph"> a dependency graph that implements the interface org.maltparser.core.syntaxgraph.DependencyStructure </param> /// <param name="defaultRootLabel"> the default root label </param> /// <exception cref="MaltChainedException"> </exception> public ConcurrentDependencyGraph(DataFormat.DataFormat dataFormat, IDependencyStructure sourceGraph, string defaultRootLabel) { DataFormat = dataFormat; nodes = new ConcurrentDependencyNode[sourceGraph.NDependencyNode()]; // Add nodes nodes[0] = new ConcurrentDependencyNode(this, 0, null); // ROOT foreach (int index in sourceGraph.TokenIndices) { DependencyNode gNode = sourceGraph.GetDependencyNode(index); string[] columns = new string[dataFormat.NumberOfColumns()]; for (int i = 0; i < dataFormat.NumberOfColumns(); i++) { ColumnDescription column = dataFormat.GetColumnDescription(i); if (!column.Internal) { if (column.Category == ColumnDescription.Input) { columns[i] = gNode.getLabelSymbol(sourceGraph.SymbolTables.getSymbolTable(column.Name)); } else if (column.Category == ColumnDescription.Head) { if (gNode.hasHead()) { columns[i] = Convert.ToString(gNode.HeadEdge.Source.Index); } else { columns[i] = Convert.ToString(-1); } } else if (column.Category == ColumnDescription.DependencyEdgeLabel) { SymbolTable sourceTable = sourceGraph.SymbolTables.getSymbolTable(column.Name); if (gNode.HeadEdge.hasLabel(sourceTable)) { columns[i] = gNode.HeadEdge.getLabelSymbol(sourceTable); } else { columns[i] = defaultRootLabel; } } else { columns[i] = "_"; } } } nodes[index] = new ConcurrentDependencyNode(this, index, columns); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void createSwapArray(org.maltparser.core.syntaxgraph.DependencyStructure goldDependencyGraph) throws org.maltparser.core.exception.MaltChainedException private void createSwapArray(IDependencyStructure goldDependencyGraph) { swapArray.Clear(); for (int i = 0; i <= goldDependencyGraph.HighestDependencyNodeIndex; i++) { swapArray.Add(new int?(i)); } createSwapArray(goldDependencyGraph.DependencyRoot, 0); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void deattachCoveredRootsForProjectivization(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException private void deattachCoveredRootsForProjectivization(IDependencyStructure pdg) { foreach (int index in pdg.TokenIndices) { if (isCoveredRoot(pdg.GetTokenNode(index))) { pdg.MoveDependencyEdge(pdg.DependencyRoot.Index, pdg.GetTokenNode(index).Index); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void assignPseudoProjectiveDeprels(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException private void assignPseudoProjectiveDeprels(IDependencyStructure pdg) { int newLabelCode; foreach (int index in pdg.TokenIndices) { if (!isCoveredRoot(pdg.GetDependencyNode(index))) { if (markingStrategy == PseudoProjectiveEncoding.HEAD || markingStrategy == PseudoProjectiveEncoding.PATH || markingStrategy == PseudoProjectiveEncoding.HEADPATH) { if (markingStrategy == PseudoProjectiveEncoding.PATH) { if (nodeLifted[index]) { newLabelCode = ppliftedSymbolTable.getSymbolStringToCode("#true#"); } else { newLabelCode = ppliftedSymbolTable.getSymbolStringToCode("#false#"); } pdg.GetDependencyNode(index).HeadEdge.addLabel(ppliftedSymbolTable, newLabelCode); } else { if (nodeLifted[index]) { newLabelCode = ppliftedSymbolTable.addSymbol(deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(headDeprel[index].Index).HeadEdge.getLabelCode(deprelSymbolTable))); } else { newLabelCode = ppliftedSymbolTable.getSymbolStringToCode("#false#"); } pdg.GetDependencyNode(index).HeadEdge.addLabel(ppliftedSymbolTable, newLabelCode); } } if (markingStrategy == PseudoProjectiveEncoding.PATH || markingStrategy == PseudoProjectiveEncoding.HEADPATH) { if (nodePath[index]) { newLabelCode = pppathSymbolTable.getSymbolStringToCode("#true#"); } else { newLabelCode = pppathSymbolTable.getSymbolStringToCode("#false#"); } pdg.GetDependencyNode(index).HeadEdge.addLabel(pppathSymbolTable, newLabelCode); } } else if (!(rootAttachment == CoveredRootAttachment.NONE || rootAttachment == CoveredRootAttachment.IGNORE)) { pdg.GetDependencyNode(index).HeadEdge.addLabel(ppcoveredRootSymbolTable, ppcoveredRootSymbolTable.getSymbolStringToCode("#true#")); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void finalizeSentence(org.maltparser.core.syntaxgraph.DependencyStructure dependencyGraph) throws org.maltparser.core.exception.MaltChainedException public virtual void finalizeSentence(IDependencyStructure dependencyGraph) { try { method.finalizeSentence(dependencyGraph); } catch (NullReferenceException e) { throw new GuideException("The learner cannot be found. ", e); } }
private void initDeprojeciviztion(IDependencyStructure pdg) { nodeLifted.Clear(); nodePath.Clear(); synacticHeadDeprel.Clear(); foreach (int index in pdg.DependencyIndices) { nodeLifted.Add(false); nodePath.Add(false); synacticHeadDeprel.Add(null); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private boolean attachCoveredRoots(org.maltparser.core.syntaxgraph.DependencyStructure pdg, org.maltparser.core.syntaxgraph.node.DependencyNode deepest) throws org.maltparser.core.exception.MaltChainedException private bool attachCoveredRoots(IDependencyStructure pdg, DependencyNode deepest) { int i; bool foundCoveredRoot = false; DependencyNode coveredRootHead; for (i = Math.Min(deepest.Index, deepest.Head.Index) + 1; i < Math.Max(deepest.Index, deepest.Head.Index); i++) { int leftMostIndex = pdg.GetDependencyNode(i).LeftmostProperDescendantIndex; if (leftMostIndex == -1) { leftMostIndex = i; } int rightMostIndex = pdg.GetDependencyNode(i).RightmostProperDescendantIndex; if (rightMostIndex == -1) { rightMostIndex = i; } if (!nodeLifted[i] && pdg.GetDependencyNode(i).Head.Root&& !deepest.Head.Root && Math.Min(deepest.Index, deepest.Head.Index) < leftMostIndex && rightMostIndex < Math.Max(deepest.Index, deepest.Head.Index)) { if (rootAttachment == CoveredRootAttachment.LEFT) { if (deepest.Head.Index < deepest.Index) { coveredRootHead = deepest.Head; } else { coveredRootHead = deepest; } } else if (rootAttachment == CoveredRootAttachment.RIGHT) { if (deepest.Index < deepest.Head.Index) { coveredRootHead = deepest.Head; } else { coveredRootHead = deepest; } } else { coveredRootHead = deepest.Head; } pdg.MoveDependencyEdge(coveredRootHead.Index, pdg.GetDependencyNode(i).Index); CoveredRoot = pdg.GetDependencyNode(i); foundCoveredRoot = true; } } return(foundCoveredRoot); }
//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 configuration) throws org.maltparser.core.exception.MaltChainedException public override GuideUserAction predict(IDependencyStructure gold, ParserConfiguration configuration) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final StackConfig config = (StackConfig)configuration; StackConfig config = (StackConfig)configuration; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> stack = config.getStack(); Stack <DependencyNode> stack = config.Stack; if (!swapArrayActive) { createSwapArray(gold); swapArrayActive = true; } if (stack.Count < 2) { return(updateActionContainers(NonProjective.SHIFT, null)); } else { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode left = stack.get(stack.size()-2); //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: DependencyNode left = stack.get(stack.Count - 2); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode right = stack.get(stack.size() - 1); //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: DependencyNode right = stack.get(stack.Count - 1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int leftIndex = left.getIndex(); int leftIndex = left.Index; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int rightIndex = right.getIndex(); int rightIndex = right.Index; if (swapArray[leftIndex] > swapArray[rightIndex] && necessarySwap(gold, config.DependencyGraph, right, config.Input)) { return(updateActionContainers(NonProjective.SWAP, null)); } else if (!left.Root && gold.GetTokenNode(leftIndex).Head.Index == rightIndex && nodeComplete(gold, config.DependencyGraph, leftIndex)) { return(updateActionContainers(NonProjective.LEFTARC, gold.GetTokenNode(leftIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(rightIndex).Head.Index == leftIndex && nodeComplete(gold, config.DependencyGraph, rightIndex)) { return(updateActionContainers(NonProjective.RIGHTARC, gold.GetTokenNode(rightIndex).HeadEdge.LabelSet)); } else { return(updateActionContainers(NonProjective.SHIFT, null)); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void createSwapArray(org.maltparser.core.syntaxgraph.DependencyStructure goldDependencyGraph) throws org.maltparser.core.exception.MaltChainedException private void createSwapArray(IDependencyStructure goldDependencyGraph) { swapArray.Clear(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int n = goldDependencyGraph.getHighestDependencyNodeIndex(); int n = goldDependencyGraph.HighestDependencyNodeIndex; for (int i = 0; i <= n; i++) { swapArray.Add(new int?(i)); } createSwapArray(goldDependencyGraph.DependencyRoot, 0); }