private static IEnumerable <TSource> Equal <TSource>(IIndex <int, TSource> source,
BinaryExpression binaryExpression)
{
if (source is Index <int, TSource> )
{
Index <int, TSource> index = (Index <int, TSource>)source;
int max = index.Max();
ConstantExpression constantExpression = null;
if (binaryExpression.Right.NodeType == ExpressionType.Constant)
{
constantExpression = (ConstantExpression)binaryExpression.Right;
}
if (source.Contains((int)constantExpression.Value))
{
var item = source[(int)constantExpression.Value];
yield return(item);
}
}
else if (source is EqualIndex <int, TSource> )
{
EqualIndex <int, TSource> index = (EqualIndex <int, TSource>)source;
ConstantExpression constantExpression = null;
if (binaryExpression.Right.NodeType == ExpressionType.Constant)
{
constantExpression = (ConstantExpression)binaryExpression.Right;
}
if (source.Contains((int)constantExpression.Value))
{
var item = source[(int)constantExpression.Value];
yield return(item);
}
}
}
/// <summary>Destructively modifies the input and returns it as a convenience.</summary>
public virtual Pair <UnaryGrammar, BinaryGrammar> Apply(Pair <UnaryGrammar, BinaryGrammar> bgug)
{
Alpha = trainOptions.ruleSmoothingAlpha;
ICounter <string> symWeights = new ClassicCounter <string>();
ICounter <string> symCounts = new ClassicCounter <string>();
//Tally unary rules
foreach (UnaryRule rule in bgug.First())
{
if (!tagIndex.Contains(rule.parent))
{
UpdateCounters(rule, symWeights, symCounts);
}
}
//Tally binary rules
foreach (BinaryRule rule_1 in bgug.Second())
{
UpdateCounters(rule_1, symWeights, symCounts);
}
//Compute smoothed rule scores, unary
foreach (UnaryRule rule_2 in bgug.First())
{
if (!tagIndex.Contains(rule_2.parent))
{
rule_2.score = SmoothRuleWeight(rule_2, symWeights, symCounts);
}
}
//Compute smoothed rule scores, binary
foreach (BinaryRule rule_3 in bgug.Second())
{
rule_3.score = SmoothRuleWeight(rule_3, symWeights, symCounts);
}
return(bgug);
}
public virtual void TestToArray()
{
string[] strs = new string[2];
strs = Sharpen.Collections.ToArray(index.ObjectsList(), strs);
NUnit.Framework.Assert.AreEqual(2, strs.Length);
NUnit.Framework.Assert.IsTrue(index.Contains(strs[0]));
NUnit.Framework.Assert.IsTrue(index.Contains(strs[1]));
}
public void IndexIsEmptyAfterClear()
{
_items.Clear();
Assert.IsFalse(_itemsById.Contains(1));
Assert.IsFalse(_itemsById.Contains(2));
Assert.IsFalse(_itemsByName.Contains("one"));
Assert.IsFalse(_itemsByName.Contains("two"));
}
/// <summary>Adds dependencies to list depList.</summary>
/// <remarks>
/// Adds dependencies to list depList. These are in terms of the original
/// tag set not the reduced (projected) tag set.
/// </remarks>
protected internal static MLEDependencyGrammar.EndHead TreeToDependencyHelper(Tree tree, IList <IntDependency> depList, int loc, IIndex <string> wordIndex, IIndex <string> tagIndex)
{
// try {
// PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out,"GB18030"),true);
// tree.pennPrint(pw);
// }
// catch (UnsupportedEncodingException e) {}
if (tree.IsLeaf() || tree.IsPreTerminal())
{
MLEDependencyGrammar.EndHead tempEndHead = new MLEDependencyGrammar.EndHead();
tempEndHead.head = loc;
tempEndHead.end = loc + 1;
return(tempEndHead);
}
Tree[] kids = tree.Children();
if (kids.Length == 1)
{
return(TreeToDependencyHelper(kids[0], depList, loc, wordIndex, tagIndex));
}
MLEDependencyGrammar.EndHead tempEndHead_1 = TreeToDependencyHelper(kids[0], depList, loc, wordIndex, tagIndex);
int lHead = tempEndHead_1.head;
int split = tempEndHead_1.end;
tempEndHead_1 = TreeToDependencyHelper(kids[1], depList, tempEndHead_1.end, wordIndex, tagIndex);
int end = tempEndHead_1.end;
int rHead = tempEndHead_1.head;
string hTag = ((IHasTag)tree.Label()).Tag();
string lTag = ((IHasTag)kids[0].Label()).Tag();
string rTag = ((IHasTag)kids[1].Label()).Tag();
string hWord = ((IHasWord)tree.Label()).Word();
string lWord = ((IHasWord)kids[0].Label()).Word();
string rWord = ((IHasWord)kids[1].Label()).Word();
bool leftHeaded = hWord.Equals(lWord);
string aTag = (leftHeaded ? rTag : lTag);
string aWord = (leftHeaded ? rWord : lWord);
int hT = tagIndex.IndexOf(hTag);
int aT = tagIndex.IndexOf(aTag);
int hW = (wordIndex.Contains(hWord) ? wordIndex.IndexOf(hWord) : wordIndex.IndexOf(LexiconConstants.UnknownWord));
int aW = (wordIndex.Contains(aWord) ? wordIndex.IndexOf(aWord) : wordIndex.IndexOf(LexiconConstants.UnknownWord));
int head = (leftHeaded ? lHead : rHead);
int arg = (leftHeaded ? rHead : lHead);
IntDependency dependency = new IntDependency(hW, hT, aW, aT, leftHeaded, (leftHeaded ? split - head - 1 : head - split));
depList.Add(dependency);
IntDependency stopL = new IntDependency(aW, aT, IntTaggedWord.StopWordInt, IntTaggedWord.StopTagInt, false, (leftHeaded ? arg - split : arg - loc));
depList.Add(stopL);
IntDependency stopR = new IntDependency(aW, aT, IntTaggedWord.StopWordInt, IntTaggedWord.StopTagInt, true, (leftHeaded ? end - arg - 1 : split - arg - 1));
depList.Add(stopR);
//System.out.println("Adding: "+dependency+" at "+tree.label());
tempEndHead_1.head = head;
return(tempEndHead_1);
}
public OutsideRuleFilter(BinaryGrammar bg, IIndex <string> stateIndex, IIndex <string> tagIndex)
{
this.tagIndex = tagIndex;
int numStates = stateIndex.Size();
numTags = tagIndex.Size();
Allocate(numStates);
for (int state = 0; state < numStates; state++)
{
string stateStr = stateIndex.Get(state);
IList <string> left = new List <string>();
IList <string> right = new List <string>();
if (!bg.IsSynthetic(state))
{
RegisterRule(left, right, state);
continue;
}
bool foundSemi = false;
bool foundDots = false;
IList <string> array = left;
StringBuilder sb = new StringBuilder();
for (int c = 0; c < stateStr.Length; c++)
{
if (stateStr[c] == ':')
{
foundSemi = true;
continue;
}
if (!foundSemi)
{
continue;
}
if (stateStr[c] == ' ')
{
if (sb.Length > 0)
{
string str = sb.ToString();
if (!tagIndex.Contains(str))
{
str = null;
}
array.Add(str);
sb = new StringBuilder();
}
continue;
}
if (!foundDots && stateStr[c] == '.')
{
c += 3;
foundDots = true;
array = right;
continue;
}
sb.Append(stateStr[c]);
}
RegisterRule(left, right, state);
}
}
// naClass.init(naWord, ttags);
private int Add(AmbiguityClass a)
{
if (classes.Contains(a))
{
return(classes.IndexOf(a));
}
classes.Add(a);
return(classes.IndexOf(a));
}
/// <summary>Checks whether a word is in the lexicon.</summary>
/// <remarks>
/// Checks whether a word is in the lexicon. This version works even while
/// compiling lexicon with current counters (rather than using the compiled
/// rulesWithWord array).
/// TODO: The previous version would insert rules into the
/// wordNumberer. Is that the desired behavior? Why not test in
/// some way that doesn't affect the index? For example, start by
/// testing wordIndex.contains(word).
/// </remarks>
/// <param name="word">The word as a String</param>
/// <returns>Whether the word is in the lexicon</returns>
public virtual bool IsKnown(string word)
{
if (!wordIndex.Contains(word))
{
return(false);
}
IntTaggedWord iW = new IntTaggedWord(wordIndex.IndexOf(word), nullTag);
return(seenCounter.GetCount(iW) > 0.0);
}
public void Add(string key, Stream data)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
CheckDisposed();
if (_index.Contains(key))
{
throw new DuplicateException($"An entry with the same key ({key}) already exists.");
}
var indexData = _storage.Append(data);
_index.Add(key, indexData);
}
public bool Contains(string key)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(nameof(key));
}
CheckDisposed();
return(_index.Contains(key));
}
public virtual void TestUnmodifiableViewEtc()
{
IList <string> list = new List <string>();
list.Add("A");
list.Add("B");
list.Add("A");
list.Add("C");
HashIndex <string> index4 = new HashIndex <string>(list);
HashIndex <string> index5 = new HashIndex <string>();
Sharpen.Collections.AddAll(index5, list);
NUnit.Framework.Assert.AreEqual("Equality failure", index4, index5);
index5.AddToIndex("D");
index5.AddToIndex("E");
index5.IndexOf("F");
Sharpen.Collections.AddAll(index5, list);
NUnit.Framework.Assert.AreEqual(5, index5.Count);
NUnit.Framework.Assert.AreEqual(3, index4.Count);
NUnit.Framework.Assert.IsTrue(index4.Contains("A"));
NUnit.Framework.Assert.AreEqual(0, index4.IndexOf("A"));
NUnit.Framework.Assert.AreEqual(1, index4.IndexOf("B"));
NUnit.Framework.Assert.AreEqual(2, index4.IndexOf("C"));
NUnit.Framework.Assert.AreEqual("A", index4.Get(0));
IIndex <string> index4u = index4.UnmodifiableView();
NUnit.Framework.Assert.AreEqual(3, index4u.Size());
NUnit.Framework.Assert.IsTrue(index4u.Contains("A"));
NUnit.Framework.Assert.AreEqual(0, index4u.IndexOf("A"));
NUnit.Framework.Assert.AreEqual(1, index4u.IndexOf("B"));
NUnit.Framework.Assert.AreEqual(2, index4u.IndexOf("C"));
NUnit.Framework.Assert.AreEqual("A", index4u.Get(0));
NUnit.Framework.Assert.AreEqual(-1, index4u.AddToIndex("D"));
bool okay = false;
try
{
index4u.Unlock();
}
catch (NotSupportedException)
{
okay = true;
}
finally
{
NUnit.Framework.Assert.IsTrue(okay);
}
}
public bool Contains(string key)
{
return(ReadLock(() => _index.Contains(key), $"Timeout {_timeout} expired to read index by key {key}"));
}
public override bool Contains(object o)
{
return(backingIndex.Contains(o) || spilloverIndex.Contains(o));
}
