public void Test_StructureDiffers_SameNodesCount()
{
int expectedNodesCount = 1 + 4 + 4 * 4;
TestTree tree1 = new TestTree(expectedNodesCount);
int idx = 0;
CreateTestTree(tree1, idx, ref idx, 0, 2, 4);
TestTree tree2 = new TestTree(expectedNodesCount);
idx = 0;
CreateTestTree(tree2, idx, ref idx, 0, 2, 4);
// Now move node 19 (last node in PP to be a child) of the root,
// and set node 20 as child of node 19.
Assert.AreEqual(2, tree2.GetDepth(19));
Assert.AreEqual(2, tree2.GetDepth(20));
tree2.SetDepth(19, (byte)1);
tree2.SetDepth(20, (byte)2);
CompareUFTrees <TestTree, TestTree> comp = new CompareUFTrees <TestTree, TestTree>();
bool result = comp.Compare(tree1, tree2, (t1, t2, n) => t1.Nodes[n].Value == t2.Nodes[n].Value);
Assert.IsFalse(result);
Assert.AreEqual(CompareUFTrees.ResultKind.StructureDiffers, comp.Result);
Assert.AreEqual(19, comp.DiffersAt);
}
public void Compare(ChanceTree ct0, ChanceTree ct1)
{
if (IsVerbose)
{
Output.WriteLine("Compare chance trees");
Output.WriteLine("0: '{0}'", ct0.Version.Description);
Output.WriteLine("1: '{0}'", ct1.Version.Description);
}
if (ct0.PlayersCount != ct1.PlayersCount)
{
throw new ApplicationException(String.Format("Player counts differ: {0} != {1}",
ct0.PlayersCount, ct1.PlayersCount));
}
CompareUFTrees <ChanceTree, ChanceTree> comp = new CompareUFTrees <ChanceTree, ChanceTree>();
_playersCount = ct0.PlayersCount;
_maxDepth = ct0.CalculateRoundsCount() * _playersCount;
LeavesCount = new int[2];
SumPotShareDiff = new double[_playersCount];
AveragePotShareDiff = new double[_playersCount];
SumProbabDiff = 0;
MaxProbabDiff = double.MinValue;
MaxPotShareDiff = new double[_playersCount].Fill(i => double.MinValue);
CompareTrees(ct0, ct1);
double leavesCount = (LeavesCount[0] + LeavesCount[1]) * 0.5;
AverageProbabDiff = SumProbabDiff / leavesCount;
AverageRelProbabDiff = SumRelProbabDiff / leavesCount;
for (int p = 0; p < _playersCount; ++p)
{
AveragePotShareDiff[p] = SumPotShareDiff[p] / leavesCount;
}
if (IsVerbose)
{
for (int p = 0; p < _playersCount; ++p)
{
Output.WriteLine("p {0}: leaves: {1:#,#}", p, LeavesCount[p]);
}
Output.WriteLine("Probab diff : max {0,-20} sum {1,-20} av {2,-20}", MaxProbabDiff, SumProbabDiff, AverageProbabDiff);
Output.WriteLine("Rel pr diff : max {0,-20} sum {1,-20} av {2,-20}", MaxRelProbabDiff, SumRelProbabDiff, AverageRelProbabDiff);
for (int p = 0; p < _playersCount; ++p)
{
Output.WriteLine("Pot share diff p {0}: max {1,-20} sum {2,-20} av {3,-20}", p,
MaxPotShareDiff[p], SumPotShareDiff[p], AveragePotShareDiff[p]);
}
}
// This prevents the chance trees from premature garbage collection.
string dummy = ct0.ToString() + ct1.ToString();
}
public void Test_Equal()
{
int expectedNodesCount = 1 + 4 + 4 * 4 + 4 * 4 * 4;
TestTree tree1 = new TestTree(expectedNodesCount);
TestTree tree2 = new TestTree(expectedNodesCount);
int idx = 0;
CreateTestTree(tree1, idx, ref idx, 0, 3, 4);
idx = 0;
CreateTestTree(tree2, idx, ref idx, 0, 3, 4);
CompareUFTrees <TestTree, TestTree> comp = new CompareUFTrees <TestTree, TestTree>();
bool result = comp.Compare(tree1, tree2, (t1, t2, n) => t1.Nodes[n].Value == t2.Nodes[n].Value);
Assert.IsTrue(result);
Assert.AreEqual(CompareUFTrees.ResultKind.Equal, comp.Result);
}
public void Test_StructureDiffers_DifferentNodesCount()
{
int expectedNodesCount = 1 + 4 + 4 * 4 + 4 * 4 * 4;
TestTree tree1 = new TestTree(expectedNodesCount);
int idx = 0;
CreateTestTree(tree1, idx, ref idx, 0, 3, 4);
expectedNodesCount = 1 + 4 + 4 * 4;
TestTree tree2 = new TestTree(expectedNodesCount);
idx = 0;
CreateTestTree(tree2, idx, ref idx, 0, 2, 4);
CompareUFTrees <TestTree, TestTree> comp = new CompareUFTrees <TestTree, TestTree>();
bool result = comp.Compare(tree1, tree2, (t1, t2, n) => t1.Nodes[n].Value == t2.Nodes[n].Value);
Assert.IsFalse(result);
Assert.AreEqual(CompareUFTrees.ResultKind.StructureDiffers, comp.Result);
Assert.AreEqual(-1, comp.DiffersAt);
}
public void Compare(StrategyTree st0, StrategyTree st1)
{
if (IsVerbose)
{
Output.WriteLine("Compare chance trees");
Output.WriteLine("0: '{0}'", st0.Version.Description);
Output.WriteLine("1: '{0}'", st1.Version.Description);
}
if (st0.PlayersCount != st1.PlayersCount)
{
ReportError(0, string.Format("player count: t0:{0} != t1:{1}", st0.PlayersCount, st1.PlayersCount));
}
int playersCount = st0.PlayersCount;
MaxProbabDiff = new double[playersCount].Fill(double.MinValue);
SumProbabDiff = new double[playersCount];
AverageProbabDiff = new double[playersCount];
PlayerNodesCount = new long[playersCount];
CompareUFTrees <StrategyTree, StrategyTree> comparer = new CompareUFTrees <StrategyTree, StrategyTree>();
comparer.Compare(st0, st1, CompareNodes);
if (comparer.Result != ICompareUFTreesDefs.ResultKind.Equal)
{
ReportError(comparer.DiffersAt, comparer.Result.ToString());
}
for (int p = 0; p < playersCount; ++p)
{
AverageProbabDiff[p] = SumProbabDiff[p] / PlayerNodesCount[p];
}
if (IsVerbose)
{
for (int p = 0; p < playersCount; ++p)
{
Output.WriteLine("Probab diff p {0}: max {1,-20} sum {2,-20} av {3,-20}",
p, MaxProbabDiff[p], SumProbabDiff[p], AverageProbabDiff[p]);
}
}
}
