public void UpdateValue_KeyNotInDictionary_UpdateIntialValue() { const int key = 1; _target.UpdateValue(key, l => { l.Add("wow"); return(l); }, new List <string>()); Assert.That(_target[key], Has.Count.EqualTo(1)); Assert.That(_target[key][0], Is.EqualTo("wow")); }
public void Increment(TSample sample, int count) { if (count == 0) return; _sampleCounts.UpdateValue(sample, () => 0, c => c + count); SampleOutcomeCount += count; }
public void UpdateValue_Arguments() { IDictionary <string, int> s = null; Assert.Throws <ArgumentNullException>(() => s.UpdateValue("key", v => v)); s = new Dictionary <string, int> (); Assert.Throws <ArgumentNullException>(() => s.UpdateValue("key", null)); }
/// <summary> /// Notifies this analysis that the specified morphological rule was unapplied. /// </summary> /// <param name="mrule">The morphological rule.</param> /// <param name="realizational"> </param> internal void MorphologicalRuleUnapplied(IMorphologicalRule mrule, bool realizational) { CheckFrozen(); _mrulesUnapplied.UpdateValue(mrule, () => 0, count => count + 1); if (!realizational) { _mrules.Push(mrule); } }
public void Collect(TraversalState traversalState) { if (traversalState.CurrentInstance.IsModule()) { return; } _result.UpdateValue(traversalState.CurrentInstance.ModuleName, count => ++ count, 0); }
public void Collect(Instance instance) { if (instance.IsModule()) { return; } _result.UpdateValue(instance.ModuleName, i => instance.Net.Count <= i.Net.Count ? i : instance, instance); }
/// <summary> /// Notifies this word that the specified morphological rule was unapplied. Null /// indicates that an unknown compounding rule was unapplied. This is used when /// generating a compound word, because the compounding rule is usually not known just /// the non-head allomorph. /// </summary> internal void MorphologicalRuleUnapplied(IMorphologicalRule mrule) { CheckFrozen(); if (mrule != null) { _mrulesUnapplied.UpdateValue(mrule, () => 0, count => count + 1); } if (!(mrule is RealizationalAffixProcessRule)) { _mruleApps.Add(mrule); _mruleAppIndex++; } }
private void WriteNgramCountsFile(string lmPrefix, int ngramSize) { int wordCount = 0; var ngrams = new Dictionary <Ngram <string>, int>(); var vocab = new HashSet <string>(); foreach (TextSegment segment in _parallelCorpus.TargetSegments .Where((s, i) => !_tuneCorpusIndices.Contains(i) && !s.IsEmpty)) { var words = new List <string> { "<s>" }; foreach (string word in segment.Segment.Preprocess(_targetPreprocessor)) { if (vocab.Contains(word)) { words.Add(word); } else { vocab.Add(word); words.Add("<unk>"); } } words.Add("</s>"); if (words.Count == 2) { continue; } wordCount += words.Count; for (int n = 1; n <= ngramSize; n++) { for (int i = 0; i <= words.Count - n; i++) { var ngram = new Ngram <string>(Enumerable.Range(i, n).Select(j => words[j])); ngrams.UpdateValue(ngram, () => 0, c => c + 1); } } } using (var writer = new StreamWriter(lmPrefix)) { foreach (KeyValuePair <Ngram <string>, int> kvp in ngrams.OrderBy(kvp => kvp.Key.Length) .ThenBy(kvp => string.Join(" ", kvp.Key))) { writer.Write("{0} {1} {2}\n", string.Join(" ", kvp.Key), kvp.Key.Length == 1 ? wordCount : ngrams[kvp.Key.TakeAllExceptLast()], kvp.Value); } } }
/// <summary> /// Notifies this word synthesis that the specified morphological rule has applied. /// </summary> internal void MorphologicalRuleApplied(IMorphologicalRule mrule) { CheckFrozen(); if (IsMorphologicalRuleApplicable(mrule)) { _mruleAppIndex--; } // indicate that the current non-head was applied if this is a compounding rule if (mrule is CompoundingRule) { _nonHeadAppIndex--; } _mrulesApplied.UpdateValue(mrule, () => 0, count => count + 1); }
public void UpdateValue() { #region UpdateValue var words = new[] { "Count", "the", "the", "repeated", "words", }; var wordCounts = new Dictionary <string, int> (); foreach (var word in words) { int c; wordCounts.TryGetValue(word, out c); Assert.AreEqual(c + 1, wordCounts.UpdateValue(word, v => v + 1)); } Assert.AreEqual(4, wordCounts.Count); Assert.AreEqual(1, wordCounts ["Count"]); Assert.AreEqual(2, wordCounts ["the"]); Assert.AreEqual(1, wordCounts ["repeated"]); Assert.AreEqual(1, wordCounts ["words"]); #endregion }
/// <summary> /// Notifies this word synthesis that the specified morphological rule has applied. /// </summary> internal void MorphologicalRuleApplied(IMorphologicalRule mrule) { CheckFrozen(); _mrulesApplied.UpdateValue(mrule, () => 0, count => count + 1); }
public void UpdateValue_Arguments() { IDictionary<string, int> s = null; Assert.Throws<ArgumentNullException>(() => s.UpdateValue ("key", v => v)); s = new Dictionary<string, int> (); Assert.Throws<ArgumentNullException>(() => s.UpdateValue ("key", null)); }
public void UpdateValue() { #region UpdateValue var words = new[]{ "Count", "the", "the", "repeated", "words", }; var wordCounts = new Dictionary<string, int> (); foreach (var word in words) { int c; wordCounts.TryGetValue (word, out c); Assert.AreEqual (c + 1, wordCounts.UpdateValue (word, v => v + 1)); } Assert.AreEqual (4, wordCounts.Count); Assert.AreEqual (1, wordCounts ["Count"]); Assert.AreEqual (2, wordCounts ["the"]); Assert.AreEqual (1, wordCounts ["repeated"]); Assert.AreEqual (1, wordCounts ["words"]); #endregion }