public object Clone()
{
Parse clonedParse = (Parse)base.MemberwiseClone();
clonedParse.mParts = new List <Parse>(mParts);
if (mDerivation != null)
{
clonedParse.InitializeDerivationBuffer();
clonedParse.AppendDerivationBuffer(mDerivation.ToString());
}
return(clonedParse);
}
// Methods ------------------------------
/// <summary>
/// Returns a parse for the specified parse of tokens.
/// </summary>
/// <param name="flatParse">
/// A flat parse containing only tokens and a root node, p.
/// </param>
/// <param name="parseCount">
/// the number of parses required
/// </param>
/// <returns>
/// A full parse of the specified tokens or the flat chunks of the tokens if a full parse could not be found.
/// </returns>
public virtual Parse[] FullParse(Parse flatParse, int parseCount)
{
if (CreateDerivationString)
{
flatParse.InitializeDerivationBuffer();
}
var oldDerivationsHeap = new Util.SortedSet <Parse>();
var parses = new Util.SortedSet <Parse>();
int derivationLength = 0;
int maxDerivationLength = 2 * flatParse.ChildCount + 3;
oldDerivationsHeap.Add(flatParse);
Parse guessParse = null;
double bestComplete = -100000; //approximating -infinity/0 in ln domain
var buildProbabilities = new double[this.buildModel.OutcomeCount];
var checkProbabilities = new double[this.checkModel.OutcomeCount];
while (parses.Count < m && derivationLength < maxDerivationLength)
{
var newDerivationsHeap = new Util.TreeSet <Parse>();
if (oldDerivationsHeap.Count > 0)
{
int derivationsProcessed = 0;
foreach (Parse currentParse in oldDerivationsHeap)
{
derivationsProcessed++;
if (derivationsProcessed >= k)
{
break;
}
// for each derivation
//Parse currentParse = (Parse) pi.Current;
if (currentParse.Probability < bestComplete) //this parse and the ones which follow will never win, stop advancing.
{
break;
}
if (guessParse == null && derivationLength == 2)
{
guessParse = currentParse;
}
Parse[] newDerivations = null;
if (0 == derivationLength)
{
newDerivations = AdvanceTags(currentParse);
}
else if (1 == derivationLength)
{
if (newDerivationsHeap.Count < k)
{
newDerivations = AdvanceChunks(currentParse, bestComplete);
}
else
{
newDerivations = AdvanceChunks(currentParse, newDerivationsHeap.Last().Probability);
}
}
else
{ // derivationLength > 1
newDerivations = AdvanceParses(currentParse, q, buildProbabilities, checkProbabilities);
}
if (newDerivations != null)
{
for (int currentDerivation = 0, derivationCount = newDerivations.Length; currentDerivation < derivationCount; currentDerivation++)
{
if (newDerivations[currentDerivation].IsComplete)
{
AdvanceTop(newDerivations[currentDerivation], buildProbabilities, checkProbabilities);
if (newDerivations[currentDerivation].Probability > bestComplete)
{
bestComplete = newDerivations[currentDerivation].Probability;
}
parses.Add(newDerivations[currentDerivation]);
}
else
{
newDerivationsHeap.Add(newDerivations[currentDerivation]);
}
}
//RN added sort
newDerivationsHeap.Sort();
}
else
{
//Console.Error.WriteLine("Couldn't advance parse " + derivationLength + " stage " + derivationsProcessed + "!\n");
}
}
derivationLength++;
oldDerivationsHeap = newDerivationsHeap;
}
else
{
break;
}
}
//RN added sort
parses.Sort();
if (parses.Count == 0)
{
//Console.Error.WriteLine("Couldn't find parse for: " + flatParse);
//oFullParse = (Parse) mOldDerivationsHeap.First();
return(new Parse[] { guessParse });
}
else if (parseCount == 1)
{
//RN added parent adjustment
Parse topParse = parses.First();
topParse.UpdateChildParents();
return(new Parse[] { topParse });
}
else
{
var topParses = new List <Parse>(parseCount);
while (!parses.IsEmpty() && topParses.Count < parseCount)
{
Parse topParse = parses.First();
//RN added parent adjustment
topParse.UpdateChildParents();
topParses.Add(topParse);
parses.Remove(topParse);
}
return(topParses.ToArray());
}
}
// Methods ------------------------------
/// <summary>
/// Returns a parse for the specified parse of tokens.
/// </summary>
/// <param name="flatParse">
/// A flat parse containing only tokens and a root node, p.
/// </param>
/// <param name="parseCount">
/// the number of parses required
/// </param>
/// <returns>
/// A full parse of the specified tokens or the flat chunks of the tokens if a full parse could not be found.
/// </returns>
public virtual Parse[] FullParse(Parse flatParse, int parseCount)
{
if (CreateDerivationString)
{
flatParse.InitializeDerivationBuffer();
}
var oldDerivationsHeap = new Util.SortedSet<Parse>();
var parses = new Util.SortedSet<Parse>();
int derivationLength = 0;
int maxDerivationLength = 2 * flatParse.ChildCount + 3;
oldDerivationsHeap.Add(flatParse);
Parse guessParse = null;
double bestComplete = - 100000; //approximating -infinity/0 in ln domain
var buildProbabilities = new double[this.buildModel.OutcomeCount];
var checkProbabilities = new double[this.checkModel.OutcomeCount];
while (parses.Count < m && derivationLength < maxDerivationLength)
{
var newDerivationsHeap = new Util.TreeSet<Parse>();
if (oldDerivationsHeap.Count > 0)
{
int derivationsProcessed = 0;
foreach (Parse currentParse in oldDerivationsHeap)
{
derivationsProcessed++;
if (derivationsProcessed >= k)
{
break;
}
// for each derivation
//Parse currentParse = (Parse) pi.Current;
if (currentParse.Probability < bestComplete) //this parse and the ones which follow will never win, stop advancing.
{
break;
}
if (guessParse == null && derivationLength == 2)
{
guessParse = currentParse;
}
Parse[] newDerivations = null;
if (0 == derivationLength)
{
newDerivations = AdvanceTags(currentParse);
}
else if (derivationLength == 1)
{
if (newDerivationsHeap.Count < k)
{
newDerivations = AdvanceChunks(currentParse, bestComplete);
}
else
{
newDerivations = AdvanceChunks(currentParse, newDerivationsHeap.Last().Probability);
}
}
else
{ // derivationLength > 1
newDerivations = AdvanceParses(currentParse, q, buildProbabilities, checkProbabilities);
}
if (newDerivations != null)
{
for (int currentDerivation = 0, derivationCount = newDerivations.Length; currentDerivation < derivationCount; currentDerivation++)
{
if (newDerivations[currentDerivation].IsComplete)
{
AdvanceTop(newDerivations[currentDerivation], buildProbabilities, checkProbabilities);
if (newDerivations[currentDerivation].Probability > bestComplete)
{
bestComplete = newDerivations[currentDerivation].Probability;
}
parses.Add(newDerivations[currentDerivation]);
}
else
{
newDerivationsHeap.Add(newDerivations[currentDerivation]);
}
}
//RN added sort
newDerivationsHeap.Sort();
}
else
{
//Console.Error.WriteLine("Couldn't advance parse " + derivationLength + " stage " + derivationsProcessed + "!\n");
}
}
derivationLength++;
oldDerivationsHeap = newDerivationsHeap;
}
else
{
break;
}
}
//RN added sort
parses.Sort();
if (parses.Count == 0)
{
//Console.Error.WriteLine("Couldn't find parse for: " + flatParse);
//oFullParse = (Parse) mOldDerivationsHeap.First();
return new Parse[] {guessParse};
}
else if (parseCount == 1)
{
//RN added parent adjustment
Parse topParse = parses.First();
topParse.UpdateChildParents();
return new Parse[] {topParse};
}
else
{
var topParses = new List<Parse>(parseCount);
while(!parses.IsEmpty() && topParses.Count < parseCount)
{
Parse topParse = parses.First();
//RN added parent adjustment
topParse.UpdateChildParents();
topParses.Add(topParse);
parses.Remove(topParse);
}
return topParses.ToArray();
}
}
/// <summary>
/// Returns a parse for the specified parse of tokens.
/// </summary>
/// <param name="flatParse">
/// A flat parse containing only tokens and a root node, p.
/// </param>
/// <param name="parseCount">
/// the number of parses required
/// </param>
/// <returns>
/// A full parse of the specified tokens or the flat chunks of the tokens if a full parse could not be found.
/// </returns>
public virtual Parse[] FullParse(Parse flatParse, int parseCount)
{
if (CreateDerivationString)
{
flatParse.InitializeDerivationBuffer();
}
mOldDerivationsHeap.Clear();
mNewDerivationsHeap.Clear();
mParses.Clear();
int derivationLength = 0;
int maxDerivationLength = 2 * flatParse.ChildCount + 3;
mOldDerivationsHeap.Add(flatParse);
Parse guessParse = null;
double bestComplete = -100000; //approximating -infinity/0 in ln domain
while (mParses.Count < M && derivationLength < maxDerivationLength)
{
mNewDerivationsHeap = new Util.TreeSet <Parse>();
if (mOldDerivationsHeap.Count > 0)
{
int derivationsProcessed = 0;
foreach (Parse currentParse in mOldDerivationsHeap)
//for (System.Collections.IEnumerator pi = mOldDerivationsHeap.GetEnumerator(); pi.MoveNext() && derivationsProcessed < K; derivationsProcessed++)
{
derivationsProcessed++;
if (derivationsProcessed >= K)
{
break;
}
// for each derivation
//Parse currentParse = (Parse) pi.Current;
if (currentParse.Probability < bestComplete) //this parse and the ones which follow will never win, stop advancing.
{
break;
}
if (guessParse == null && derivationLength == 2)
{
guessParse = currentParse;
}
//System.Console.Out.Write(derivationLength + " " + derivationsProcessed + " "+currentParse.Probability);
//System.Console.Out.Write(currentParse.Show());
//System.Console.Out.WriteLine();
Parse[] newDerivations = null;
if (0 == derivationLength)
{
newDerivations = AdvanceTags(currentParse);
}
else if (1 == derivationLength)
{
if (mNewDerivationsHeap.Count < K)
{
newDerivations = AdvanceChunks(currentParse, bestComplete);
}
else
{
newDerivations = AdvanceChunks(currentParse, ((Parse)mNewDerivationsHeap.Last()).Probability);
}
}
else
{ // derivationLength > 1
newDerivations = AdvanceParses(currentParse, Q);
}
if (newDerivations != null)
{
for (int currentDerivation = 0, derivationCount = newDerivations.Length; currentDerivation < derivationCount; currentDerivation++)
{
if (newDerivations[currentDerivation].IsComplete)
{
AdvanceTop(newDerivations[currentDerivation]);
if (newDerivations[currentDerivation].Probability > bestComplete)
{
bestComplete = newDerivations[currentDerivation].Probability;
}
mParses.Add(newDerivations[currentDerivation]);
}
else
{
mNewDerivationsHeap.Add(newDerivations[currentDerivation]);
}
}
//RN added sort
mNewDerivationsHeap.Sort();
}
else
{
//Console.Error.WriteLine("Couldn't advance parse " + derivationLength + " stage " + derivationsProcessed + "!\n");
}
}
derivationLength++;
mOldDerivationsHeap = mNewDerivationsHeap;
}
else
{
break;
}
}
//RN added sort
mParses.Sort();
if (mParses.Count == 0)
{
//Console.Error.WriteLine("Couldn't find parse for: " + flatParse);
//oFullParse = (Parse) mOldDerivationsHeap.First();
return(new Parse[] { guessParse });
}
else if (parseCount == 1)
{
//RN added parent adjustment
Parse topParse = mParses.First();
topParse.UpdateChildParents();
return(new Parse[] { topParse });
}
else
{
var topParses = new List <Parse>(parseCount);
while (!mParses.IsEmpty() && topParses.Count < parseCount)
{
Parse topParse = mParses.First();
//RN added parent adjustment
topParse.UpdateChildParents();
topParses.Add(topParse);
mParses.Remove(topParse);
}
return(topParses.ToArray());
}
}
/// <summary>
/// Returns a parse for the specified parse of tokens.
/// </summary>
/// <param name="flatParse">
/// A flat parse containing only tokens and a root node, p.
/// </param>
/// <param name="parseCount">
/// the number of parses required
/// </param>
/// <returns>
/// A full parse of the specified tokens or the flat chunks of the tokens if a full parse could not be found.
/// </returns>
public virtual Parse[] FullParse(Parse flatParse, int parseCount)
{
if (mCreateDerivationString)
{
flatParse.InitializeDerivationBuffer();
}
mOldDerivationsHeap.Clear();
mNewDerivationsHeap.Clear();
mParses.Clear();
int derivationLength = 0;
int maxDerivationLength = 2 * flatParse.ChildCount + 3;
mOldDerivationsHeap.Add(flatParse);
Parse guessParse = null;
double bestComplete = - 100000; //approximating -infinity/0 in ln domain
while (mParses.Count < M && derivationLength < maxDerivationLength)
{
mNewDerivationsHeap = new Util.TreeSet<Parse>();
if (mOldDerivationsHeap.Count > 0)
{
int derivationsProcessed = 0;
foreach (Parse currentParse in mOldDerivationsHeap)
//for (System.Collections.IEnumerator pi = mOldDerivationsHeap.GetEnumerator(); pi.MoveNext() && derivationsProcessed < K; derivationsProcessed++)
{
derivationsProcessed++;
if (derivationsProcessed >= K)
{
break;
}
// for each derivation
//Parse currentParse = (Parse) pi.Current;
if (currentParse.Probability < bestComplete) //this parse and the ones which follow will never win, stop advancing.
{
break;
}
if (guessParse == null && derivationLength == 2)
{
guessParse = currentParse;
}
//System.Console.Out.Write(derivationLength + " " + derivationsProcessed + " "+currentParse.Probability);
//System.Console.Out.Write(currentParse.Show());
//System.Console.Out.WriteLine();
Parse[] newDerivations = null;
if (0 == derivationLength)
{
newDerivations = AdvanceTags(currentParse);
}
else if (1 == derivationLength)
{
if (mNewDerivationsHeap.Count < K)
{
//System.Console.Error.WriteLine("advancing ts " + derivationsProcessed + " " + mNewDerivationsHeap.Count + " < " + K);
newDerivations = AdvanceChunks(currentParse, bestComplete);
}
else
{
//System.Console.Error.WriteLine("advancing ts " + derivationsProcessed + " prob=" + ((Parse) mNewDerivationsHeap.Last()).Probability);
newDerivations = AdvanceChunks(currentParse,((Parse) mNewDerivationsHeap.Last()).Probability);
}
}
else
{ // derivationLength > 1
newDerivations = AdvanceParses(currentParse, Q);
}
if (newDerivations != null)
{
for (int currentDerivation = 0, derivationCount = newDerivations.Length; currentDerivation < derivationCount; currentDerivation++)
{
//System.out.println("currentDerivation="+currentDerivation+" of "+newDerivations.length);
if (newDerivations[currentDerivation].IsComplete)
{
AdvanceTop(newDerivations[currentDerivation]);
if (newDerivations[currentDerivation].Probability > bestComplete)
{
bestComplete = newDerivations[currentDerivation].Probability;
}
mParses.Add(newDerivations[currentDerivation]);
}
else
{
mNewDerivationsHeap.Add(newDerivations[currentDerivation]);
}
}
//RN added sort
mNewDerivationsHeap.Sort();
}
else
{
System.Console.Error.WriteLine("Couldn't advance parse " + derivationLength + " stage " + derivationsProcessed + "!\n");
}
}
derivationLength++;
mOldDerivationsHeap = mNewDerivationsHeap;
}
else
{
break;
}
}
//RN added sort
mParses.Sort();
if (mParses.Count == 0)
{
System.Console.Error.WriteLine("Couldn't find parse for: " + flatParse);
//oFullParse = (Parse) mOldDerivationsHeap.First();
return new Parse[] {guessParse};
}
else if (parseCount == 1)
{
//RN added parent adjustment
Parse topParse = mParses.First();
topParse.UpdateChildParents();
return new Parse[] {topParse};
}
else
{
List<Parse> topParses = new List<Parse>(parseCount);
while(!mParses.IsEmpty() && topParses.Count < parseCount)
{
Parse topParse = mParses.First();
//RN added parent adjustment
topParse.UpdateChildParents();
topParses.Add(topParse);
mParses.Remove(topParse);
}
return topParses.ToArray();
}
}