public virtual void TestPointwiseMutualInformation()
{
ICounter <string> x = new ClassicCounter <string>();
x.IncrementCount("0", 0.8);
x.IncrementCount("1", 0.2);
ICounter <int> y = new ClassicCounter <int>();
y.IncrementCount(0, 0.25);
y.IncrementCount(1, 0.75);
ICounter <Pair <string, int> > joint;
joint = new ClassicCounter <Pair <string, int> >();
joint.IncrementCount(new Pair <string, int>("0", 0), 0.1);
joint.IncrementCount(new Pair <string, int>("0", 1), 0.7);
joint.IncrementCount(new Pair <string, int>("1", 0), 0.15);
joint.IncrementCount(new Pair <string, int>("1", 1), 0.05);
// Check that correct PMI values are calculated, using tables from
// http://en.wikipedia.org/wiki/Pointwise_mutual_information
double pmi;
Pair <string, int> pair;
pair = new Pair <string, int>("0", 0);
pmi = Counters.PointwiseMutualInformation(x, y, joint, pair);
NUnit.Framework.Assert.AreEqual(-1, pmi, 10e-5);
pair = new Pair <string, int>("0", 1);
pmi = Counters.PointwiseMutualInformation(x, y, joint, pair);
NUnit.Framework.Assert.AreEqual(0.222392421, pmi, 10e-5);
pair = new Pair <string, int>("1", 0);
pmi = Counters.PointwiseMutualInformation(x, y, joint, pair);
NUnit.Framework.Assert.AreEqual(1.584962501, pmi, 10e-5);
pair = new Pair <string, int>("1", 1);
pmi = Counters.PointwiseMutualInformation(x, y, joint, pair);
NUnit.Framework.Assert.AreEqual(-1.584962501, pmi, 10e-5);
}
/// <summary>for testing purposes only</summary>
public static void Main(string[] args)
{
object[] a1 = new object[] { "a", "b" };
object[] a2 = new object[] { "a", "b" };
System.Console.Out.WriteLine(Arrays.Equals(a1, a2));
GeneralizedCounter <string> gc = new GeneralizedCounter <string>(3);
gc.IncrementCount(Arrays.AsList(new string[] { "a", "j", "x" }), 3.0);
gc.IncrementCount(Arrays.AsList(new string[] { "a", "l", "x" }), 3.0);
gc.IncrementCount(Arrays.AsList(new string[] { "b", "k", "y" }), 3.0);
gc.IncrementCount(Arrays.AsList(new string[] { "b", "k", "z" }), 3.0);
System.Console.Out.WriteLine("incremented counts.");
System.Console.Out.WriteLine(gc.DumpKeys());
System.Console.Out.WriteLine("string representation of generalized counter:");
System.Console.Out.WriteLine(gc.ToString());
gc.PrintKeySet();
System.Console.Out.WriteLine("entry set:\n" + gc.EntrySet());
ArrayPrintDouble(gc.GetCounts(Arrays.AsList(new string[] { "a", "j", "x" })));
ArrayPrintDouble(gc.GetCounts(Arrays.AsList(new string[] { "a", "j", "z" })));
ArrayPrintDouble(gc.GetCounts(Arrays.AsList(new string[] { "b", "k", "w" })));
ArrayPrintDouble(gc.GetCounts(Arrays.AsList(new string[] { "b", "k", "z" })));
GeneralizedCounter <string> gc1 = gc.Conditionalize(Arrays.AsList(new string[] { "a" }));
gc1.IncrementCount(Arrays.AsList(new string[] { "j", "x" }));
gc1.IncrementCount2D("j", "z");
GeneralizedCounter <string> gc2 = gc1.Conditionalize(Arrays.AsList(new string[] { "j" }));
gc2.IncrementCount1D("x");
System.Console.Out.WriteLine("Pretty-printing gc after incrementing gc1:");
gc.PrettyPrint();
System.Console.Out.WriteLine("Total: " + gc.TotalCount());
gc1.PrintKeySet();
System.Console.Out.WriteLine("another entry set:\n" + gc1.EntrySet());
ClassicCounter <IList <string> > c = gc.CounterView();
System.Console.Out.WriteLine("string representation of counter view:");
System.Console.Out.WriteLine(c.ToString());
double d1 = c.GetCount(Arrays.AsList(new string[] { "a", "j", "x" }));
double d2 = c.GetCount(Arrays.AsList(new string[] { "a", "j", "w" }));
System.Console.Out.WriteLine(d1 + " " + d2);
ClassicCounter <IList <string> > c1 = gc1.CounterView();
System.Console.Out.WriteLine("Count of {j,x} -- should be 3.0\t" + c1.GetCount(Arrays.AsList(new string[] { "j", "x" })));
System.Console.Out.WriteLine(c.KeySet() + " size " + c.KeySet().Count);
System.Console.Out.WriteLine(c1.KeySet() + " size " + c1.KeySet().Count);
System.Console.Out.WriteLine(c1.Equals(c));
System.Console.Out.WriteLine(c.Equals(c1));
System.Console.Out.WriteLine(c.Equals(c));
System.Console.Out.WriteLine("### testing equality of regular Counter...");
ClassicCounter <string> z1 = new ClassicCounter <string>();
ClassicCounter <string> z2 = new ClassicCounter <string>();
z1.IncrementCount("a1");
z1.IncrementCount("a2");
z2.IncrementCount("b");
System.Console.Out.WriteLine(z1.Equals(z2));
System.Console.Out.WriteLine(z1.ToString());
System.Console.Out.WriteLine(z1.KeySet().ToString());
}
public virtual void TestL2Norm()
{
ClassicCounter <string> c = new ClassicCounter <string>();
c.IncrementCount("a", 3);
c.IncrementCount("b", 4);
NUnit.Framework.Assert.AreEqual(5.0, Counters.L2Norm(c), Tolerance);
c.IncrementCount("c", 6);
c.IncrementCount("d", 4);
c.IncrementCount("e", 2);
NUnit.Framework.Assert.AreEqual(9.0, Counters.L2Norm(c), Tolerance);
}
public virtual void TestL2Normalize()
{
ClassicCounter <string> c = new ClassicCounter <string>();
c.IncrementCount("a", 4.0);
c.IncrementCount("b", 2.0);
c.IncrementCount("c", 1.0);
c.IncrementCount("d", 2.0);
ICounter <string> d = Counters.L2Normalize(c);
NUnit.Framework.Assert.AreEqual(d.GetCount("a"), 0.8, Tolerance);
NUnit.Framework.Assert.AreEqual(d.GetCount("b"), 0.4, Tolerance);
NUnit.Framework.Assert.AreEqual(d.GetCount("c"), 0.2, Tolerance);
NUnit.Framework.Assert.AreEqual(d.GetCount("d"), 0.4, Tolerance);
}
public virtual void TestLogNormalize()
{
ClassicCounter <string> c = new ClassicCounter <string>();
c.IncrementCount("a", Math.Log(4.0));
c.IncrementCount("b", Math.Log(2.0));
c.IncrementCount("c", Math.Log(1.0));
c.IncrementCount("d", Math.Log(1.0));
Counters.LogNormalizeInPlace(c);
NUnit.Framework.Assert.AreEqual(c.GetCount("a"), -0.693, Tolerance);
NUnit.Framework.Assert.AreEqual(c.GetCount("b"), -1.386, Tolerance);
NUnit.Framework.Assert.AreEqual(c.GetCount("c"), -2.079, Tolerance);
NUnit.Framework.Assert.AreEqual(c.GetCount("d"), -2.079, Tolerance);
NUnit.Framework.Assert.AreEqual(Counters.LogSum(c), 0.0, Tolerance);
}
public virtual void IncrementCount(K1 o1, K2 o2, double count)
{
ClassicCounter <K2> c = GetCounter(o1);
c.IncrementCount(o2, count);
total += count;
}
public DirichletProcess(IProbabilityDistribution <E> baseMeasure, double alpha)
{
this.baseMeasure = baseMeasure;
this.alpha = alpha;
this.sampled = new ClassicCounter <E>();
sampled.IncrementCount(null, alpha);
}
/// <summary>
/// Returns the counters with keys as the first key and count as the
/// total count of the inner counter for that key
/// </summary>
/// <returns>counter of type K1</returns>
public virtual ICounter <K1> SumInnerCounter()
{
ICounter <K1> summed = new ClassicCounter <K1>();
foreach (K1 key in this.FirstKeySet())
{
summed.IncrementCount(key, this.GetCounter(key).TotalCount());
}
return(summed);
}
public virtual E DrawSample(Random random)
{
E drawn = Counters.Sample(sampled);
if (drawn == null)
{
drawn = baseMeasure.DrawSample(random);
}
sampled.IncrementCount(drawn);
return(drawn);
}
/* Helper to simpleGoodTuringSmoothedCounter() */
private static ICounter <int> CollectCountCounts <E>(ICounter <E> counts)
{
ICounter <int> cc = new ClassicCounter <int>();
// counts of counts
foreach (KeyValuePair <E, double> entry in counts.EntrySet())
{
//E item = entry.getKey();
int count = (int)Math.Round(entry.Value);
cc.IncrementCount(count);
}
return(cc);
}
internal virtual Pair <ClassicCounter <OUT>, ClassicCounter <OUT> > EvalPrecision(ICollection <In> guesses, ICollection <In> golds)
{
ICollection <In> internalGuesses = null;
ICollection <In> internalGolds = null;
if (bagEval)
{
internalGuesses = new List <In>(guesses.Count);
internalGolds = new List <In>(golds.Count);
}
else
{
internalGuesses = Generics.NewHashSet(guesses.Count);
internalGolds = Generics.NewHashSet(golds.Count);
}
Sharpen.Collections.AddAll(internalGuesses, guesses);
Sharpen.Collections.AddAll(internalGolds, golds);
ClassicCounter <OUT> thisGuessed = new ClassicCounter <OUT>();
ClassicCounter <OUT> thisCorrect = new ClassicCounter <OUT>();
foreach (IN o in internalGuesses)
{
OUT equivalenceClass = eq.EquivalenceClass(o);
thisGuessed.IncrementCount(equivalenceClass);
if (checker.Contained(o, internalGolds))
{
thisCorrect.IncrementCount(equivalenceClass);
RemoveItem(o, internalGolds, checker);
}
else
{
if (verbose)
{
System.Console.Out.WriteLine("Eval missed " + o);
}
}
}
return(Generics.NewPair(thisGuessed, thisCorrect));
}
public virtual void TestClassicCounterHistoricalMain()
{
c.SetCount("p", 0);
c.SetCount("q", 2);
ClassicCounter <string> small_c = new ClassicCounter <string>(c);
ICounter <string> c7 = c.GetFactory().Create();
c7.AddAll(c);
NUnit.Framework.Assert.AreEqual(c.TotalCount(), 2.0);
c.IncrementCount("p");
NUnit.Framework.Assert.AreEqual(c.TotalCount(), 3.0);
c.IncrementCount("p", 2.0);
NUnit.Framework.Assert.AreEqual(Counters.Min(c), 2.0);
NUnit.Framework.Assert.AreEqual(Counters.Argmin(c), "q");
// Now p is p=3.0, q=2.0
c.SetCount("w", -5.0);
c.SetCount("x", -4.5);
IList <string> biggestKeys = new List <string>(c.KeySet());
NUnit.Framework.Assert.AreEqual(biggestKeys.Count, 4);
biggestKeys.Sort(Counters.ToComparator(c, false, true));
NUnit.Framework.Assert.AreEqual("w", biggestKeys[0]);
NUnit.Framework.Assert.AreEqual("x", biggestKeys[1]);
NUnit.Framework.Assert.AreEqual("p", biggestKeys[2]);
NUnit.Framework.Assert.AreEqual("q", biggestKeys[3]);
NUnit.Framework.Assert.AreEqual(Counters.Min(c), -5.0, Tolerance);
NUnit.Framework.Assert.AreEqual(Counters.Argmin(c), "w");
NUnit.Framework.Assert.AreEqual(Counters.Max(c), 3.0, Tolerance);
NUnit.Framework.Assert.AreEqual(Counters.Argmax(c), "p");
if (integral)
{
NUnit.Framework.Assert.AreEqual(Counters.Mean(c), -1.0);
}
else
{
NUnit.Framework.Assert.AreEqual(Counters.Mean(c), -1.125, Tolerance);
}
if (!integral)
{
// only do this for floating point counters. Too much bother to rewrite
c.SetCount("x", -2.5);
ClassicCounter <string> c2 = new ClassicCounter <string>(c);
NUnit.Framework.Assert.AreEqual(3.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(2.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(-5.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(-2.5, c2.GetCount("x"));
ICounter <string> c3 = c.GetFactory().Create();
foreach (string str in c2.KeySet())
{
c3.IncrementCount(str);
}
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("p"));
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("q"));
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("w"));
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("x"));
Counters.AddInPlace(c2, c3, 10.0);
NUnit.Framework.Assert.AreEqual(13.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(12.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(5.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(7.5, c2.GetCount("x"));
c3.AddAll(c);
NUnit.Framework.Assert.AreEqual(4.0, c3.GetCount("p"));
NUnit.Framework.Assert.AreEqual(3.0, c3.GetCount("q"));
NUnit.Framework.Assert.AreEqual(-4.0, c3.GetCount("w"));
NUnit.Framework.Assert.AreEqual(-1.5, c3.GetCount("x"));
Counters.SubtractInPlace(c3, c);
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("p"));
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("q"));
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("w"));
NUnit.Framework.Assert.AreEqual(1.0, c3.GetCount("x"));
foreach (string str_1 in c.KeySet())
{
c3.IncrementCount(str_1);
}
NUnit.Framework.Assert.AreEqual(2.0, c3.GetCount("p"));
NUnit.Framework.Assert.AreEqual(2.0, c3.GetCount("q"));
NUnit.Framework.Assert.AreEqual(2.0, c3.GetCount("w"));
NUnit.Framework.Assert.AreEqual(2.0, c3.GetCount("x"));
Counters.DivideInPlace(c2, c3);
NUnit.Framework.Assert.AreEqual(6.5, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(6.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(2.5, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(3.75, c2.GetCount("x"));
Counters.DivideInPlace(c2, 0.5);
NUnit.Framework.Assert.AreEqual(13.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(12.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(5.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(7.5, c2.GetCount("x"));
Counters.MultiplyInPlace(c2, 2.0);
NUnit.Framework.Assert.AreEqual(26.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(24.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(10.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(15.0, c2.GetCount("x"));
Counters.DivideInPlace(c2, 2.0);
NUnit.Framework.Assert.AreEqual(13.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(12.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(5.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(7.5, c2.GetCount("x"));
foreach (string str_2 in c2.KeySet())
{
c2.IncrementCount(str_2);
}
NUnit.Framework.Assert.AreEqual(14.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(13.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(6.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(8.5, c2.GetCount("x"));
foreach (string str_3 in c.KeySet())
{
c2.IncrementCount(str_3);
}
NUnit.Framework.Assert.AreEqual(15.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(14.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(7.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(9.5, c2.GetCount("x"));
c2.AddAll(small_c);
NUnit.Framework.Assert.AreEqual(15.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(16.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(7.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(9.5, c2.GetCount("x"));
NUnit.Framework.Assert.AreEqual(new HashSet <string>(Arrays.AsList("p", "q")), Counters.KeysAbove(c2, 14));
NUnit.Framework.Assert.AreEqual(new HashSet <string>(Arrays.AsList("q")), Counters.KeysAt(c2, 16));
NUnit.Framework.Assert.AreEqual(new HashSet <string>(Arrays.AsList("x", "w")), Counters.KeysBelow(c2, 9.5));
Counters.AddInPlace(c2, small_c, -6);
NUnit.Framework.Assert.AreEqual(15.0, c2.GetCount("p"));
NUnit.Framework.Assert.AreEqual(4.0, c2.GetCount("q"));
NUnit.Framework.Assert.AreEqual(7.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(9.5, c2.GetCount("x"));
Counters.SubtractInPlace(c2, small_c);
Counters.SubtractInPlace(c2, small_c);
Counters.RetainNonZeros(c2);
NUnit.Framework.Assert.AreEqual(15.0, c2.GetCount("p"));
NUnit.Framework.Assert.IsFalse(c2.ContainsKey("q"));
NUnit.Framework.Assert.AreEqual(7.0, c2.GetCount("w"));
NUnit.Framework.Assert.AreEqual(9.5, c2.GetCount("x"));
}
// serialize to Stream
if (c is ISerializable)
{
try
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream @out = new ObjectOutputStream(new BufferedOutputStream(baos));
@out.WriteObject(c);
@out.Close();
// reconstitute
byte[] bytes = baos.ToByteArray();
ObjectInputStream @in = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(bytes)));
c = IOUtils.ReadObjectFromObjectStream(@in);
@in.Close();
if (!this.integral)
{
NUnit.Framework.Assert.AreEqual(-2.5, c.TotalCount());
NUnit.Framework.Assert.AreEqual(-5.0, Counters.Min(c));
NUnit.Framework.Assert.AreEqual("w", Counters.Argmin(c));
}
c.Clear();
if (!this.integral)
{
NUnit.Framework.Assert.AreEqual(0.0, c.TotalCount());
}
}
catch (IOException ioe)
{
Fail("IOException: " + ioe);
}
catch (TypeLoadException cce)
{
Fail("ClassNotFoundException: " + cce);
}
}
}
/// <summary>For internal testing purposes only.</summary>
public static void Main(string[] args)
{
ICounter <string> c2 = new ClassicCounter <string>();
c2.IncrementCount("p", 13);
c2.SetCount("q", 12);
c2.SetCount("w", 5);
c2.IncrementCount("x", 7.5);
// System.out.println(getDistribution(c2).getCount("w") + " should be 0.13333");
ClassicCounter <string> c = new ClassicCounter <string>();
double p = 1000;
string Unk = "!*UNKNOWN*!";
ICollection <string> s = Generics.NewHashSet();
s.Add(Unk);
// fill counter with roughly Zipfian distribution
// "1" : 1000
// "2" : 500
// "3" : 333
// ...
// "UNK" : 45
// ...
// "666" : 2
// "667" : 1
// ...
// "1000" : 1
for (int rank = 1; rank < 2000; rank++)
{
string i = rank.ToString();
c.SetCount(i, Math.Round(p / rank));
s.Add(i);
}
for (int rank_1 = 2000; rank_1 <= 4000; rank_1++)
{
string i = rank_1.ToString();
s.Add(i);
}
Distribution <string> n = GetDistribution(c);
Distribution <string> prior = GetUniformDistribution(s);
Distribution <string> dir1 = DistributionWithDirichletPrior(c, prior, 4000);
Distribution <string> dir2 = DynamicCounterWithDirichletPrior(c, prior, 4000);
Distribution <string> add1;
Distribution <string> gt;
if (true)
{
add1 = LaplaceSmoothedDistribution(c, 4000);
gt = GoodTuringSmoothedCounter(c, 4000);
}
else
{
c.SetCount(Unk, 45);
add1 = LaplaceWithExplicitUnknown(c, 0.5, Unk);
gt = GoodTuringWithExplicitUnknown(c, Unk);
}
Distribution <string> sgt = SimpleGoodTuring(c, 4000);
System.Console.Out.Printf("%10s %10s %10s %10s %10s %10s %10s%n", "Freq", "Norm", "Add1", "Dir1", "Dir2", "GT", "SGT");
System.Console.Out.Printf("%10s %10s %10s %10s %10s %10s %10s%n", "----------", "----------", "----------", "----------", "----------", "----------", "----------");
for (int i_1 = 1; i_1 < 5; i_1++)
{
System.Console.Out.Printf("%10d ", Math.Round(p / i_1));
string @in = i_1.ToString();
System.Console.Out.Printf("%10.8f ", n.ProbabilityOf(@in.ToString()));
System.Console.Out.Printf("%10.8f ", add1.ProbabilityOf(@in));
System.Console.Out.Printf("%10.8f ", dir1.ProbabilityOf(@in));
System.Console.Out.Printf("%10.8f ", dir2.ProbabilityOf(@in));
System.Console.Out.Printf("%10.8f ", gt.ProbabilityOf(@in));
System.Console.Out.Printf("%10.8f ", sgt.ProbabilityOf(@in));
System.Console.Out.WriteLine();
}
System.Console.Out.Printf("%10s %10s %10s %10s %10s %10s %10s%n", "----------", "----------", "----------", "----------", "----------", "----------", "----------");
System.Console.Out.Printf("%10d ", 1);
string last = 1500.ToString();
System.Console.Out.Printf("%10.8f ", n.ProbabilityOf(last));
System.Console.Out.Printf("%10.8f ", add1.ProbabilityOf(last));
System.Console.Out.Printf("%10.8f ", dir1.ProbabilityOf(last));
System.Console.Out.Printf("%10.8f ", dir2.ProbabilityOf(last));
System.Console.Out.Printf("%10.8f ", gt.ProbabilityOf(last));
System.Console.Out.Printf("%10.8f ", sgt.ProbabilityOf(last));
System.Console.Out.WriteLine();
System.Console.Out.Printf("%10s %10s %10s %10s %10s %10s %10s%n", "----------", "----------", "----------", "----------", "----------", "----------", "----------");
System.Console.Out.Printf("%10s ", "UNK");
System.Console.Out.Printf("%10.8f ", n.ProbabilityOf(Unk));
System.Console.Out.Printf("%10.8f ", add1.ProbabilityOf(Unk));
System.Console.Out.Printf("%10.8f ", dir1.ProbabilityOf(Unk));
System.Console.Out.Printf("%10.8f ", dir2.ProbabilityOf(Unk));
System.Console.Out.Printf("%10.8f ", gt.ProbabilityOf(Unk));
System.Console.Out.Printf("%10.8f ", sgt.ProbabilityOf(Unk));
System.Console.Out.WriteLine();
System.Console.Out.Printf("%10s %10s %10s %10s %10s %10s %10s%n", "----------", "----------", "----------", "----------", "----------", "----------", "----------");
System.Console.Out.Printf("%10s ", "RESERVE");
System.Console.Out.Printf("%10.8f ", n.GetReservedMass());
System.Console.Out.Printf("%10.8f ", add1.GetReservedMass());
System.Console.Out.Printf("%10.8f ", dir1.GetReservedMass());
System.Console.Out.Printf("%10.8f ", dir2.GetReservedMass());
System.Console.Out.Printf("%10.8f ", gt.GetReservedMass());
System.Console.Out.Printf("%10.8f ", sgt.GetReservedMass());
System.Console.Out.WriteLine();
System.Console.Out.Printf("%10s %10s %10s %10s %10s %10s %10s%n", "----------", "----------", "----------", "----------", "----------", "----------", "----------");
System.Console.Out.Printf("%10s ", "Total");
System.Console.Out.Printf("%10.8f ", n.TotalCount());
System.Console.Out.Printf("%10.8f ", add1.TotalCount());
System.Console.Out.Printf("%10.8f ", dir1.TotalCount());
System.Console.Out.Printf("%10.8f ", dir2.TotalCount());
System.Console.Out.Printf("%10.8f ", gt.TotalCount());
System.Console.Out.Printf("%10.8f ", sgt.TotalCount());
System.Console.Out.WriteLine();
}