public virtual void IncrementCount(K1 o1, K2 o2, int count)
{
IntCounter <K2> c = GetCounter(o1);
c.IncrementCount(o2, count);
total += count;
}
public virtual void SubtractAll(K1 key, IntCounter <K2> c)
{
IntCounter <K2> myInner = GetCounter(key);
Counters.SubtractInPlace(myInner, c);
total -= c.TotalIntCount();
}
public virtual void AddAll(K1 key, IntCounter <K2> c)
{
IntCounter <K2> myInner = GetCounter(key);
Counters.AddInPlace(myInner, c);
total += c.TotalIntCount();
}
public virtual void SetCount(K1 o1, K2 o2, int count)
{
IntCounter <K2> c = GetCounter(o1);
int oldCount = GetCount(o1, o2);
total -= oldCount;
c.SetCount(o2, count);
total += count;
}
/// <summary>replace the counter for K1-index o by new counter c</summary>
public virtual IntCounter <K2> SetCounter(K1 o, IntCounter <K2> c)
{
IntCounter <K2> old = GetCounter(o);
total -= old.TotalIntCount();
map[o] = c;
total += c.TotalIntCount();
return(old);
}
public virtual IntCounter <K1> TotalCounts()
{
IntCounter <K1> tc = new IntCounter <K1>();
foreach (K1 k1 in map.Keys)
{
tc.SetCount(k1, map[k1].TotalCount());
}
return(tc);
}
public virtual int GetCount(K1 o1, K2 o2)
{
IntCounter <K2> c = GetCounter(o1);
if (c.TotalCount() == 0 && !c.KeySet().Contains(o2))
{
return(DefaultReturnValue());
}
return(c.GetIntCount(o2));
}
public virtual bool ContainsKey(K1 o1, K2 o2)
{
if (!map.Contains(o1))
{
return(false);
}
IntCounter <K2> c = map[o1];
return(c.ContainsKey(o2));
}
public virtual void AddAll(Edu.Stanford.Nlp.Stats.TwoDimensionalIntCounter <K1, K2> c)
{
foreach (K1 key in c.FirstKeySet())
{
IntCounter <K2> inner = c.GetCounter(key);
IntCounter <K2> myInner = GetCounter(key);
Counters.AddInPlace(myInner, inner);
total += inner.TotalIntCount();
}
}
// it's empty, get rid of it!
public virtual void Remove(K1 key)
{
IntCounter <K2> counter = map[key];
if (counter != null)
{
total -= counter.TotalIntCount();
}
Sharpen.Collections.Remove(map, key);
}
/// <returns>total number of entries (key pairs)</returns>
public virtual int Size()
{
int result = 0;
foreach (K1 o in FirstKeySet())
{
IntCounter <K2> c = map[o];
result += c.Size();
}
return(result);
}
/// <returns>the inner Counter associated with key o</returns>
public virtual IntCounter <K2> GetCounter(K1 o)
{
IntCounter <K2> c = map[o];
if (c == null)
{
c = new IntCounter <K2>(innerMF);
c.SetDefaultReturnValue(defaultValue);
map[o] = c;
}
return(c);
}
public virtual int Remove(K1 o1, K2 o2)
{
IntCounter <K2> c = GetCounter(o1);
int oldCount = GetCount(o1, o2);
total -= oldCount;
c.Remove(o2);
if (c.IsEmpty())
{
Sharpen.Collections.Remove(map, o1);
}
return(oldCount);
}
public virtual void RemoveZeroCounts()
{
ICollection <K1> firstKeySet = Generics.NewHashSet(FirstKeySet());
foreach (K1 k1 in firstKeySet)
{
IntCounter <K2> c = GetCounter(k1);
Counters.RetainNonZeros(c);
if (c.IsEmpty())
{
Sharpen.Collections.Remove(map, k1);
}
}
}
public virtual void SubtractAll(Edu.Stanford.Nlp.Stats.TwoDimensionalIntCounter <K1, K2> c, bool removeKeys)
{
foreach (K1 key in c.FirstKeySet())
{
IntCounter <K2> inner = c.GetCounter(key);
IntCounter <K2> myInner = GetCounter(key);
Counters.SubtractInPlace(myInner, inner);
if (removeKeys)
{
Counters.RetainNonZeros(myInner);
}
total -= inner.TotalIntCount();
}
}
/// <summary>
/// A simple String representation of this TwoDimensionalCounter, which has
/// the String representation of each key pair
/// on a separate line, followed by the count for that pair.
/// </summary>
/// <remarks>
/// A simple String representation of this TwoDimensionalCounter, which has
/// the String representation of each key pair
/// on a separate line, followed by the count for that pair.
/// The items are tab separated, so the result is a tab-separated value (TSV)
/// file. Iff none of the keys contain spaces, it will also be possible to
/// treat this as whitespace separated fields.
/// </remarks>
public override string ToString()
{
StringBuilder buff = new StringBuilder();
foreach (K1 key1 in map.Keys)
{
IntCounter <K2> c = GetCounter(key1);
foreach (K2 key2 in c.KeySet())
{
double score = c.GetCount(key2);
buff.Append(key1).Append("\t").Append(key2).Append("\t").Append(score).Append("\n");
}
}
return(buff.ToString());
}
public virtual IntCounter <Pair <K1, K2> > Flatten()
{
IntCounter <Pair <K1, K2> > result = new IntCounter <Pair <K1, K2> >();
result.SetDefaultReturnValue(defaultValue);
foreach (K1 key1 in FirstKeySet())
{
IntCounter <K2> inner = GetCounter(key1);
foreach (K2 key2 in inner.KeySet())
{
result.SetCount(new Pair <K1, K2>(key1, key2), inner.GetIntCount(key2));
}
}
return(result);
}
/// <summary>Produces a new ConditionalCounter.</summary>
/// <returns>a new ConditionalCounter, where order of indices is reversed</returns>
public static Edu.Stanford.Nlp.Stats.TwoDimensionalIntCounter <K2, K1> ReverseIndexOrder <K1, K2>(Edu.Stanford.Nlp.Stats.TwoDimensionalIntCounter <K1, K2> cc)
{
// the typing on the outerMF is violated a bit, but it'll work....
Edu.Stanford.Nlp.Stats.TwoDimensionalIntCounter <K2, K1> result = new Edu.Stanford.Nlp.Stats.TwoDimensionalIntCounter((MapFactory)cc.outerMF, (MapFactory)cc.innerMF);
foreach (K1 key1 in cc.FirstKeySet())
{
IntCounter <K2> c = cc.GetCounter(key1);
foreach (K2 key2 in c.KeySet())
{
int count = c.GetIntCount(key2);
result.SetCount(key2, key1, count);
}
}
return(result);
}
public virtual void Clean()
{
foreach (K1 key1 in Generics.NewHashSet(map.Keys))
{
IntCounter <K2> c = map[key1];
foreach (K2 key2 in Generics.NewHashSet(c.KeySet()))
{
if (c.GetIntCount(key2) == 0)
{
c.Remove(key2);
}
}
if (c.KeySet().IsEmpty())
{
Sharpen.Collections.Remove(map, key1);
}
}
}
public virtual void ClearCounts()
{
if (foundCorrect != null)
{
foundCorrect.Clear();
}
else
{
foundCorrect = new IntCounter <L>();
}
if (foundGuessed != null)
{
foundGuessed.Clear();
}
else
{
foundGuessed = new IntCounter <L>();
}
if (correctGuesses != null)
{
correctGuesses.Clear();
}
else
{
correctGuesses = new IntCounter <L>();
}
if (tpCount != null)
{
Arrays.Fill(tpCount, 0);
}
if (fnCount != null)
{
Arrays.Fill(fnCount, 0);
}
if (fpCount != null)
{
Arrays.Fill(fpCount, 0);
}
tokensCount = 0;
tokensCorrect = 0;
}
public _AbstractCollection_750(IntCounter <E> _enclosing)
{
this._enclosing = _enclosing;
}
public _IFactory_726(IntCounter <E> _enclosing)
{
this._enclosing = _enclosing;
this.serialVersionUID = 7470763055803428477L;
}
public _AbstractSet_436(IntCounter <E> _enclosing)
{
this._enclosing = _enclosing;
}
public _IFactory_726(IntCounter <E> _enclosing)
{
this._enclosing = _enclosing;
this.serialVersionUID = serialVersionUID;
}
public virtual int TotalCount(K1 k1)
{
IntCounter <K2> c = GetCounter(k1);
return(c.TotalIntCount());
}
