//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 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: 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));
}
}
//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: 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: private void deattachCoveredRootsForDeprojectivization(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException
private void deattachCoveredRootsForDeprojectivization(IDependencyStructure pdg)
{
foreach (int index in pdg.TokenIndices)
{
if (pdg.GetDependencyNode(index).HeadEdge.hasLabel(deprelSymbolTable))
{
if (pdg.GetDependencyNode(index).HeadEdge.hasLabel(ppcoveredRootSymbolTable) && ppcoveredRootSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(ppcoveredRootSymbolTable)).Equals("#true#"))
{
pdg.MoveDependencyEdge(pdg.DependencyRoot.Index, pdg.GetDependencyNode(index).Index);
}
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private org.maltparser.core.syntaxgraph.node.DependencyNode getShortestNonProjectiveNode(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException
private DependencyNode getShortestNonProjectiveNode(IDependencyStructure pdg)
{
DependencyNode shortestNonProjectiveNode = null;
foreach (int index in pdg.DependencyIndices)
{
if (!pdg.GetDependencyNode(index).Projective&& (shortestNonProjectiveNode == null || nodeRelationLength[index] < nodeRelationLength[shortestNonProjectiveNode.Index]))
{
// || (nodeRelationLength.get(index) == nodeRelationLength.get(shortestNonProjectiveNode.getIndex())))) {
shortestNonProjectiveNode = pdg.GetDependencyNode(index);
}
}
return(shortestNonProjectiveNode);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private org.maltparser.core.syntaxgraph.node.DependencyNode getDeepestNonProjectiveNode(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException
private DependencyNode getDeepestNonProjectiveNode(IDependencyStructure pdg)
{
DependencyNode deepestNonProjectiveNode = null;
foreach (int index in pdg.DependencyIndices)
{
if (!pdg.GetDependencyNode(index).Projective&& (deepestNonProjectiveNode == null || pdg.GetDependencyNode(index).DependencyNodeDepth > pdg.GetDependencyNode(deepestNonProjectiveNode.Index).DependencyNodeDepth))
{
deepestNonProjectiveNode = pdg.GetDependencyNode(index);
}
}
return(deepestNonProjectiveNode);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private boolean necessarySwap(org.maltparser.core.syntaxgraph.DependencyStructure gold, org.maltparser.core.syntaxgraph.DependencyStructure parse, org.maltparser.core.syntaxgraph.node.DependencyNode node, java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> input) throws org.maltparser.core.exception.MaltChainedException
private bool necessarySwap(IDependencyStructure gold, IDependencyStructure parse, DependencyNode node, Stack <DependencyNode> input)
{
DependencyNode left = node;
int index = input.Count - 1;
if (index < 0)
{
return(true);
}
DependencyNode right = input.Peek();
int rc = -1;
while (projectiveInterval(parse, left, right))
{
if (rc == right.Index)
{
return(false);
}
if (gold.GetDependencyNode(node.Index).Head.Index == right.Index)
{
return(!leftComplete(gold, node));
}
if (gold.GetDependencyNode(right.Index).Head.Index == node.Index)
{
if (gold.GetDependencyNode(right.Index).hasRightDependent())
{
rc = gold.GetDependencyNode(right.Index).RightmostProperDescendantIndex;
}
else
{
return(false);
}
}
if (index > 0)
{
left = right;
//JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing:
right = input.get(--index);
}
else
{
break;
}
}
return(true);
}
/// <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 deprojectivize(org.maltparser.core.syntaxgraph.DependencyStructure pdg, int markingStrategy) throws org.maltparser.core.exception.MaltChainedException
public void deprojectivize(IDependencyStructure pdg, int markingStrategy)
{
SymbolTable deprelSymbolTable = pdg.SymbolTables.getSymbolTable("DEPREL");
SymbolTable ppliftedSymbolTable = pdg.SymbolTables.getSymbolTable("PPLIFTED");
SymbolTable pppathSymbolTable = pdg.SymbolTables.getSymbolTable("PPPATH");
bool[] nodeLifted = new bool[pdg.NDependencyNode()];
Arrays.fill(nodeLifted, false);
bool[] nodePath = new bool[pdg.NDependencyNode()];
Arrays.fill(nodePath, false);
string[] synacticHeadDeprel = new string[pdg.NDependencyNode()];
Arrays.fill(synacticHeadDeprel, null);
foreach (int index in pdg.TokenIndices)
{
Edge e = pdg.GetDependencyNode(index).HeadEdge;
if (e.hasLabel(deprelSymbolTable))
{
if (e.hasLabel(pppathSymbolTable) && pppathSymbolTable.getSymbolCodeToString(e.getLabelCode(pppathSymbolTable)).Equals("#true#"))
{
nodePath[pdg.GetDependencyNode(index).Index] = true;
}
if (e.hasLabel(ppliftedSymbolTable) && !ppliftedSymbolTable.getSymbolCodeToString(e.getLabelCode(ppliftedSymbolTable)).Equals("#false#"))
{
nodeLifted[index] = true;
if (!ppliftedSymbolTable.getSymbolCodeToString(e.getLabelCode(ppliftedSymbolTable)).Equals("#true#"))
{
synacticHeadDeprel[index] = ppliftedSymbolTable.getSymbolCodeToString(e.getLabelCode(ppliftedSymbolTable));
}
}
}
}
deattachCoveredRootsForDeprojectivization(pdg, deprelSymbolTable);
if (markingStrategy == HEAD && needsDeprojectivizeWithHead(pdg, nodeLifted, nodePath, synacticHeadDeprel, deprelSymbolTable))
{
deprojectivizeWithHead(pdg, pdg.DependencyRoot, nodeLifted, nodePath, synacticHeadDeprel, deprelSymbolTable);
}
else if (markingStrategy == PATH)
{
deprojectivizeWithPath(pdg, pdg.DependencyRoot, nodeLifted, nodePath);
}
else if (markingStrategy == HEADPATH)
{
deprojectivizeWithHeadAndPath(pdg, pdg.DependencyRoot, nodeLifted, nodePath, synacticHeadDeprel, deprelSymbolTable);
}
}
/// <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: public void initialize(org.maltparser.parser.ParserConfiguration parserConfiguration) throws org.maltparser.core.exception.MaltChainedException
public virtual void initialize(ParserConfiguration parserConfiguration)
{
if (parserConfiguration != null)
{
CovingtonConfig covingtonConfig = (CovingtonConfig)parserConfiguration;
List <DependencyNode> sourceInput = covingtonConfig.Input;
DependencyGraph = covingtonConfig.DependencyGraph;
for (int i = 0, n = sourceInput.Count; i < n; i++)
{
input.Add(dependencyGraph.GetDependencyNode(sourceInput[i].Index));
}
left = covingtonConfig.Left;
right = covingtonConfig.Right;
rightstop = covingtonConfig.Rightstop;
leftstop = covingtonConfig.Leftstop;
}
else
{
for (int i = 0, n = dependencyGraph.HighestTokenIndex; i <= n; i++)
{
DependencyNode node = dependencyGraph.GetDependencyNode(i);
if (node != null)
{
input.Add(node);
}
}
if (allowRoot == true)
{
leftstop = 0;
}
else
{
leftstop = 1;
}
rightstop = dependencyGraph.HighestTokenIndex;
left = leftstop;
right = left + 1;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void deprojectivize(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException
public virtual void deprojectivize(IDependencyStructure pdg)
{
initDeprojeciviztion(pdg);
foreach (int index in pdg.TokenIndices)
{
if (pdg.GetDependencyNode(index).HeadEdge.hasLabel(deprelSymbolTable))
{
if (pdg.GetDependencyNode(index).HeadEdge.hasLabel(pppathSymbolTable) && pppathSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(pppathSymbolTable)).Equals("#true#"))
{
Path = pdg.GetDependencyNode(index);
}
if (pdg.GetDependencyNode(index).HeadEdge.hasLabel(ppliftedSymbolTable) && !ppliftedSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(ppliftedSymbolTable)).Equals("#false#"))
{
nodeLifted[index] = true;
if (!ppliftedSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(ppliftedSymbolTable)).Equals("#true#"))
{
synacticHeadDeprel[index] = ppliftedSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(ppliftedSymbolTable));
}
}
}
}
deattachCoveredRootsForDeprojectivization(pdg);
if (markingStrategy == PseudoProjectiveEncoding.HEAD && needsDeprojectivizeWithHead(pdg))
{
deprojectivizeWithHead(pdg, pdg.DependencyRoot);
}
else if (markingStrategy == PseudoProjectiveEncoding.PATH)
{
deprojectivizeWithPath(pdg, pdg.DependencyRoot);
}
else if (markingStrategy == PseudoProjectiveEncoding.HEADPATH)
{
deprojectivizeWithHeadAndPath(pdg, pdg.DependencyRoot);
}
}
// Check whether there is at least one node in the specified dependency structure that can be lifted.
// If this is not the case, there is no need to call deprojectivizeWithHead.
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private boolean needsDeprojectivizeWithHead(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException
private bool needsDeprojectivizeWithHead(IDependencyStructure pdg)
{
foreach (int index in pdg.DependencyIndices)
{
if (nodeLifted[index])
{
DependencyNode node = pdg.GetDependencyNode(index);
if (breadthFirstSearchSortedByDistanceForHead(pdg, node.Head, node, synacticHeadDeprel[index]) != null)
{
return(true);
}
}
}
return(false);
}
protected internal virtual void CopyDynamicInput(IDependencyStructure source, IDependencyStructure target)
{
foreach (int index in source.TokenIndices)
{
DependencyNode sNode = source.GetDependencyNode(index);
DependencyNode tNode = target.GetDependencyNode(index);
foreach (SymbolTable table in sNode.LabelTypes)
{
if (!tNode.hasLabel(table))
{
tNode.addLabel(table, sNode.getLabelSymbol(table));
}
}
}
}
//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 (task.Equals("projectivity"))
{
if (cachedSource == null)
{
cachedSource = (IDependencyStructure)flowChartinstance.getFlowChartRegistry(typeof(IDependencyStructure), sourceName);
}
try
{
writer.append("graph # ");
writer.append(Convert.ToString(graphCounter));
writer.append('\n');
foreach (int index in cachedSource.TokenIndices)
{
DependencyNode node = cachedSource.GetDependencyNode(index);
writer.append(Convert.ToString(node.Index));
writer.append('\t');
writer.append(Convert.ToString(node.Head.Index));
writer.append('\t');
writer.append('#');
writer.append('\t');
if (node.Projective)
{
writer.append("@P");
}
else
{
writer.append("@N");
}
writer.append('\n');
}
writer.append('\n');
}
catch (IOException e)
{
throw new MaltChainedException("", e);
}
graphCounter++;
}
return(signal);
}
/// <summary>
/// Copies the edges of the source dependency structure to the target dependency structure
/// </summary>
/// <param name="source"> a source dependency structure </param>
/// <param name="target"> a target dependency structure </param>
/// <exception cref="MaltChainedException"> </exception>
protected internal virtual void CopyEdges(IDependencyStructure source, IDependencyStructure target)
{
foreach (int index in source.TokenIndices)
{
DependencyNode sNode = source.GetDependencyNode(index);
if (sNode.hasHead())
{
Edge s = sNode.HeadEdge;
Edge t = target.AddDependencyEdge(s.Source.Index, s.Target.Index);
foreach (SymbolTable table in s.LabelTypes)
{
t.addLabel(table, s.getLabelSymbol(table));
}
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private boolean leftComplete(org.maltparser.core.syntaxgraph.DependencyStructure gold, org.maltparser.core.syntaxgraph.node.DependencyNode right) throws org.maltparser.core.exception.MaltChainedException
private bool leftComplete(IDependencyStructure gold, DependencyNode right)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode goldNode = gold.getDependencyNode(right.getIndex());
DependencyNode goldNode = gold.GetDependencyNode(right.Index);
if (!goldNode.hasLeftDependent())
{
return(true);
}
else if (!right.hasLeftDependent())
{
return(false);
}
else if (goldNode.LeftmostDependent.Index == right.LeftmostDependent.Index)
{
return(true);
}
return(false);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private boolean projectiveInterval(org.maltparser.core.syntaxgraph.DependencyStructure parse, org.maltparser.core.syntaxgraph.node.DependencyNode left, org.maltparser.core.syntaxgraph.node.DependencyNode right) throws org.maltparser.core.exception.MaltChainedException
private bool projectiveInterval(IDependencyStructure parse, DependencyNode left, DependencyNode right)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int l = swapArray.get(left.getIndex());
int l = swapArray[left.Index];
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int r = swapArray.get(right.getIndex());
int r = swapArray[right.Index];
DependencyNode node = null;
if (l > r)
{
return(false);
}
else
{
for (int i = l + 1; i < r; i++)
{
for (int j = 0; j < swapArray.Count; j++)
{
if (swapArray[j] == i)
{
node = parse.GetDependencyNode(j);
break;
}
}
while (node.hasHead())
{
node = node.Head;
}
if (!(node == left || node == right))
{
return(false);
}
}
return(true);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void projectivize(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException
public virtual void projectivize(IDependencyStructure pdg)
{
id++;
if (!pdg.Tree)
{
configLogger.info("\n[Warning: Sentence '" + id + "' cannot projectivize, because the dependency graph is not a tree]\n");
return;
}
DependencyNode deepestNonProjectiveNode;
initProjectivization(pdg);
if (rootAttachment == CoveredRootAttachment.IGNORE)
{
if (markingStrategy != PseudoProjectiveEncoding.NONE)
{
while (!pdg.Projective)
{
if (liftingOrder == LiftingOrder.DEEPEST)
{
deepestNonProjectiveNode = getDeepestNonProjectiveNode(pdg);
}
else
{
deepestNonProjectiveNode = getShortestNonProjectiveNode(pdg);
}
if (!attachCoveredRoots(pdg, deepestNonProjectiveNode))
{
nodeLifted[deepestNonProjectiveNode.Index] = true;
setHeadDeprel(deepestNonProjectiveNode, deepestNonProjectiveNode.Head);
Path = deepestNonProjectiveNode.Head;
pdg.MoveDependencyEdge(pdg.GetDependencyNode(deepestNonProjectiveNode.Head.Head.Index).Index, deepestNonProjectiveNode.Index);
}
}
deattachCoveredRootsForProjectivization(pdg);
}
}
else
{
if (rootAttachment != CoveredRootAttachment.NONE)
{
foreach (int index in pdg.TokenIndices)
{
attachCoveredRoots(pdg, pdg.GetTokenNode(index));
}
}
if (markingStrategy != PseudoProjectiveEncoding.NONE)
{
while (!pdg.Projective)
{
if (liftingOrder == LiftingOrder.DEEPEST)
{
deepestNonProjectiveNode = getDeepestNonProjectiveNode(pdg);
}
else
{
deepestNonProjectiveNode = getShortestNonProjectiveNode(pdg);
}
nodeLifted[deepestNonProjectiveNode.Index] = true;
setHeadDeprel(deepestNonProjectiveNode, deepestNonProjectiveNode.Head);
Path = deepestNonProjectiveNode.Head;
pdg.MoveDependencyEdge(pdg.GetDependencyNode(deepestNonProjectiveNode.Head.Head.Index).Index, deepestNonProjectiveNode.Index);
}
}
}
// collectTraceStatistics(pdg);
assignPseudoProjectiveDeprels(pdg);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void assignPseudoProjectiveDeprelsForMerge(org.maltparser.core.syntaxgraph.DependencyStructure pdg) throws org.maltparser.core.exception.MaltChainedException
private void assignPseudoProjectiveDeprelsForMerge(IDependencyStructure pdg)
{
List <string> originalDeprel = new List <string>();
string newLabel;
originalDeprel.Add(null);
foreach (int index in pdg.TokenIndices)
{
originalDeprel.Add(deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)));
}
foreach (int index in pdg.TokenIndices)
{
newLabel = null;
if (!isCoveredRoot(pdg.GetDependencyNode(index)))
{
if (markingStrategy == PseudoProjectiveEncoding.HEAD)
{
if (nodeLifted[index])
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "|"
+ originalDeprel[headDeprel[index].Index];
// } else {
// newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.getDependencyNode(index).getHeadEdge().getLabelCode(deprelSymbolTable));
}
}
else if (markingStrategy == PseudoProjectiveEncoding.PATH)
{
if (nodeLifted[index] && nodePath[index])
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "|%";
}
else if (nodeLifted[index] && !nodePath[index])
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "|";
}
else if (!nodeLifted[index] && nodePath[index])
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "%";
}
}
else if (markingStrategy == PseudoProjectiveEncoding.HEADPATH)
{
if (nodeLifted[index] && nodePath[index])
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "|"
+ originalDeprel[headDeprel[index].Index] + "%";
}
else if (nodeLifted[index] && !nodePath[index])
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "|"
+ originalDeprel[headDeprel[index].Index];
}
else if (!nodeLifted[index] && nodePath[index])
{
newLabel = originalDeprel[pdg.GetDependencyNode(index).Index] + "%";
}
}
else if (markingStrategy == PseudoProjectiveEncoding.TRACE)
{
if (nodeLifted[index])
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "|";
}
}
}
else if (!(rootAttachment == CoveredRootAttachment.NONE || rootAttachment == CoveredRootAttachment.IGNORE))
{
newLabel = deprelSymbolTable.getSymbolCodeToString(pdg.GetDependencyNode(index).HeadEdge.getLabelCode(deprelSymbolTable)) + "|null";
}
if (!ReferenceEquals(newLabel, null))
{
setLabel(pdg.GetDependencyNode(index), newLabel);
}
}
}
