public void TestThreeIndependentCoinFlips()
{
p_xy = new [, ] {
{ 1 / 9f, 1 / 9f, 1 / 9f },
{ 1 / 9f, 1 / 9f, 1 / 9f },
{ 1 / 9f, 1 / 9f, 1 / 9f }
};
p_x = ProbabilityDistribution.MarginalX(p_xy);
p_y = ProbabilityDistribution.MarginalY(p_xy);
Assert.True(ProbabilityDistribution.IsValid(p_x));
Assert.True(ProbabilityDistribution.IsValid(p_y));
Assert.True(ProbabilityDistribution.IsValid(p_xy));
Assert.Equal(1.58f, ProbabilityDistribution.Entropy(p_x, 2), 2);
Assert.Equal(1.58f, ProbabilityDistribution.Entropy(p_y, 2), 2);
Assert.Equal(1f, ProbabilityDistribution.Entropy(p_x, p_x.Length), 2);
Assert.Equal(1f, ProbabilityDistribution.Entropy(p_y, p_y.Length), 2);
Assert.Equal(1.1f, ProbabilityDistribution.Entropy(p_x), 2);
Assert.Equal(1.1f, ProbabilityDistribution.Entropy(p_y), 2);
Assert.Equal(3.17f, ProbabilityDistribution.JointEntropy(p_xy, 2), 2);
Assert.Equal(1f, ProbabilityDistribution.JointEntropy(p_xy, p_xy.Length), 2);
Assert.Equal(2.2f, ProbabilityDistribution.JointEntropy(p_xy), 2);
Assert.Equal(1.58f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x, 2), 2);
Assert.Equal(0.5f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x, p_xy.Length), 2);
Assert.Equal(1f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x, p_x.Length), 2);
Assert.Equal(1.1f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x), 2);
Assert.Equal(1.58f, ProbabilityDistribution.ConditionalEntropyXY(p_xy, p_y, 2), 2);
Assert.Equal(1.1f, ProbabilityDistribution.ConditionalEntropyXY(p_xy, p_y), 2);
Assert.Equal(0f, ProbabilityDistribution.MutualInformation(p_x, p_y, p_xy, 2), 2);
Assert.Equal(0f, ProbabilityDistribution.MutualInformation(p_x, p_y, p_xy), 2);
Assert.Equal(0f, ProbabilityDistribution.MutualInformation(p_x, p_y, p_xy, p_xy.Length), 2);
Assert.Equal(0f, ProbabilityDistribution.MutualInformation(p_x, p_y, p_xy, p_x.Length), 2);
}
public void TestCompareWithProbability()
{
var fc = new TallyAlphabet <int>(new[] { "a", "b", "c" }, 3, y => y);
fc.Add("a", 2);
fc.Add("a", 1);
fc.Add("a", 0);
fc.Add("b", 2);
fc.Add("b", 1);
fc.Add("b", 0);
fc.Add("c", 2);
fc.Add("c", 1);
fc.Add("c", 0);
Assert.Equal(1 / 3f, fc.ProbabilityX("a"), 2);
Assert.Equal(1 / 3f, fc.ProbabilityX("b"), 2);
Assert.Equal(1 / 3f, fc.ProbabilityX("c"), 2);
Assert.Equal(1 / 3f, fc.ProbabilityY(0));
Assert.Equal(1 / 3f, fc.ProbabilityY(1));
Assert.Equal(1 / 9f, fc.ProbabilityXY("a", 0));
Assert.Equal(1 / 3f, fc.ProbabilityYGivenX(0, "a"), 2);
Assert.Equal(1 / 3f, fc.ProbabilityYGivenX(1, "a"), 2);
Assert.Equal(1 / 3f, fc.ProbabilityYGivenX(0, "b"), 2);
Assert.Equal(1 / 3f, fc.ProbabilityYGivenX(1, "b"), 2);
Assert.Equal(1f, fc.EntropyYGivenX(3), 1);
Assert.Equal(9, fc.probabilityXY.Length);
Assert.Equal(new [] { 1 / 3f, 1 / 3f, 1 / 3f }, fc.probabilityX);
Assert.Equal(new [] { 1 / 3f, 1 / 3f, 1 / 3f }, fc.probabilityY);
Assert.Equal(new [, ] {
{ 1 / 9f, 1 / 9f, 1 / 9f },
{ 1 / 9f, 1 / 9f, 1 / 9f },
{ 1 / 9f, 1 / 9f, 1 / 9f },
}, fc.probabilityXY);
Assert.Equal(1 / 2f, ProbabilityDistribution.ConditionalEntropyYX(fc.probabilityXY, fc.probabilityX, fc.probabilityXY.Length));
Assert.Equal(1f, ProbabilityDistribution.ConditionalEntropyYX(fc.probabilityXY, fc.probabilityX, fc.probabilityX.Length));
Assert.Equal(1f, fc.EntropyXGivenY(3), 1);
Assert.Equal(1 / 2f, ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY, fc.probabilityY, fc.probabilityXY.Length));
Assert.Equal(1f, ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY, fc.probabilityY, fc.probabilityY.Length));
Assert.Equal(2f, fc.EntropyXY(3), 1);
Assert.Equal(2f, ProbabilityDistribution.JointEntropy(fc.probabilityXY, fc.probabilityX.Length), 1);
Assert.Equal(1f, ProbabilityDistribution.JointEntropy(fc.probabilityXY, fc.probabilityXY.Length), 1);
Assert.Equal(3.2f, ProbabilityDistribution.JointEntropy(fc.probabilityXY, 2), 1);
Assert.Equal(1f, fc.EntropyX(3), 2);
Assert.Equal(1f, ProbabilityDistribution.Entropy(fc.probabilityX, fc.probabilityX.Length), 2);
Assert.Equal(0.5f, ProbabilityDistribution.Entropy(fc.probabilityX, fc.probabilityXY.Length), 2);
Assert.Equal(1f, fc.EntropyY(3), 1);
Assert.Equal(1f, ProbabilityDistribution.Entropy(fc.probabilityY, fc.probabilityY.Length), 2);
Assert.Equal(0.5f, ProbabilityDistribution.Entropy(fc.probabilityY, fc.probabilityXY.Length), 2);
// H(X|Y) = H(X,Y) - H(Y)
// This should always be true.
Assert.Equal(0f, fc.EntropyXGivenY() - fc.EntropyXY() + fc.EntropyY(), 1);
Assert.Equal(0f, ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY, fc.probabilityY)
- ProbabilityDistribution.JointEntropy(fc.probabilityXY)
+ ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY, fc.probabilityY), 1);
Assert.Equal(0f, fc.MutualInformationXY(3), 2);
}
public void TestArrayTallyAlphabet2()
{
var fc = new ArrayTallyAlphabet <int>(new[] { "a", "b", "c" }, 3, y => y);
fc.Add(new [] { "a", "b" }, new [] { 2, 1 });
fc.Add(new [] { "a", "b" }, new [] { 1, 1 });
fc.Add(new [] { "a", "b" }, new [] { 0, 1 });
fc.Add(new [] { "b", "b" }, new [] { 2, 1 });
fc.Add(new [] { "b", "b" }, new [] { 1, 1 });
fc.Add(new [] { "b", "b" }, new [] { 0, 1 });
fc.Add(new [] { "c", "b" }, new [] { 2, 1 });
fc.Add(new [] { "c", "b" }, new [] { 1, 1 });
fc.Add(new [] { "c", "b" }, new [] { 0, 1 });
Assert.Equal(9, fc.probabilityXY[0, 0].Length);
Assert.Equal(new [] { 1 / 3f, 1 / 3f, 1 / 3f }, fc.probabilityX[0]);
Assert.Equal(new [, ] {
{ 1 / 9f, 1 / 9f, 1 / 9f },
{ 1 / 9f, 1 / 9f, 1 / 9f },
{ 1 / 9f, 1 / 9f, 1 / 9f },
}, fc.probabilityXY[0, 0]);
Assert.Equal(new [, ] {
{ 0f, 0f, 0f },
{ 1 / 3f, 1 / 3f, 1 / 3f },
{ 0f, 0f, 0f },
}, fc.probabilityXY[1, 0]);
Assert.Equal(new [, ] {
{ 0f, 0f, 0f },
{ 0f, 1f, 0f },
{ 0f, 0f, 0f },
}, fc.probabilityXY[1, 1]);
Assert.Equal(new [] { 1 / 3f, 1 / 3f, 1 / 3f }, ProbabilityDistribution.MarginalY(fc.probabilityXY[0, 0]));
Assert.Equal(new [] { 1 / 3f, 1 / 3f, 1 / 3f }, ProbabilityDistribution.MarginalY(fc.probabilityXY[1, 0]));
Assert.Equal(new [] { 0f, 1f, 0f }, ProbabilityDistribution.MarginalX(fc.probabilityXY[1, 0]));
Assert.Equal(new [] { 0f, 1f, 0f }, fc.probabilityX[1]);
Assert.Equal(new [] { 1 / 3f, 1 / 3f, 1 / 3f }, fc.probabilityY[0]);
Assert.Equal(new [] { 0f, 1f, 0f }, fc.probabilityY[1]);
Assert.Equal(1 / 2f, ProbabilityDistribution.ConditionalEntropyYX(fc.probabilityXY[0, 0], fc.probabilityX[0], fc.probabilityXY[0, 0].Length));
Assert.Equal(1f, ProbabilityDistribution.ConditionalEntropyYX(fc.probabilityXY[0, 0], fc.probabilityX[0], fc.probabilityX[0].Length));
Assert.Equal(1 / 2f, ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY[0, 0], fc.probabilityY[0], fc.probabilityXY[0, 0].Length));
Assert.Equal(1f, ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY[0, 0], fc.probabilityY[0], fc.probabilityY[0].Length));
Assert.Equal(2f, ProbabilityDistribution.JointEntropy(fc.probabilityXY[0, 0], fc.probabilityX[0].Length), 1);
Assert.Equal(1f, ProbabilityDistribution.JointEntropy(fc.probabilityXY[0, 0], fc.probabilityXY[0, 0].Length), 1);
Assert.Equal(3.2f, ProbabilityDistribution.JointEntropy(fc.probabilityXY[0, 0], 2), 1);
Assert.Equal(1f, ProbabilityDistribution.Entropy(fc.probabilityX[0], fc.probabilityX[0].Length), 2);
Assert.Equal(0.5f, ProbabilityDistribution.Entropy(fc.probabilityX[0], fc.probabilityXY[0, 0].Length), 2);
Assert.Equal(1f, ProbabilityDistribution.Entropy(fc.probabilityY[0], fc.probabilityY[0].Length), 2);
Assert.Equal(0.5f, ProbabilityDistribution.Entropy(fc.probabilityY[0], fc.probabilityXY[0, 0].Length), 2);
// H(X|Y) = H(X,Y) - H(Y)
// This should always be true.
Assert.Equal(0f, ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY[0, 0], fc.probabilityY[0])
- ProbabilityDistribution.JointEntropy(fc.probabilityXY[0, 0])
+ ProbabilityDistribution.ConditionalEntropyXY(fc.probabilityXY[0, 0], fc.probabilityY[0]), 1);
}
public void TestExample2()
{
p_xy = new [, ] {
{ 1 / 4f, 1 / 4f, 0f },
{ 1 / 2f, 0f, 0f },
{ 0f, 0f, 0f }
};
p_x = ProbabilityDistribution.MarginalX(p_xy);
p_y = ProbabilityDistribution.MarginalY(p_xy);
// Assert.Equal(2f, ProbabilityDistribution.Entropy(p_x, 2));
// Assert.Equal(7/4f, ProbabilityDistribution.Entropy(p_y, 2));
Assert.Equal(3 / 2f, ProbabilityDistribution.JointEntropy(p_xy, 2));
Assert.Equal(0.47f, ProbabilityDistribution.JointEntropy(p_xy, p_xy.Length), 2);
Assert.Equal(1.04f, ProbabilityDistribution.JointEntropy(p_xy), 2);
Assert.Equal(1 / 2f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x, 2));
Assert.Equal(0.16f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x, p_xy.Length), 2);
Assert.Equal(0.32f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x, p_x.Length), 2);
Assert.Equal(0.35f, ProbabilityDistribution.ConditionalEntropyYX(p_xy, p_x), 2);
Assert.Equal(0.69f, ProbabilityDistribution.ConditionalEntropyXY(p_xy, p_y, 2), 2);
Assert.Equal(0.22f, ProbabilityDistribution.ConditionalEntropyXY(p_xy, p_y, p_xy.Length), 2);
Assert.Equal(0.43f, ProbabilityDistribution.ConditionalEntropyXY(p_xy, p_y, p_y.Length), 2);
Assert.Equal(0.48f, ProbabilityDistribution.ConditionalEntropyXY(p_xy, p_y), 2);
// Assert.Equal(3/8f, ProbabilityDistribution.MutualInformation(p_x, p_y, p_xy, 2));
}
