public void MessageOpsTest()
{
const double Eps = 1e-6;
StringDistribution str1 = StringOfLengthOp.StrAverageConditional(DiscreteChar.Letter(), 10);
Assert.Equal(StringDistribution.Repeat(DiscreteChar.Letter(), 10, 10), str1);
StringDistribution str2 = StringOfLengthOp.StrAverageConditional(
DiscreteChar.PointMass('a'), Discrete.UniformInRange(5, 2, 4));
Assert.Equal(StringDistribution.OneOf("aa", "aaa", "aaaa"), str2);
StringDistribution str3 = StringOfLengthOp.StrAverageConditional(
DiscreteChar.OneOf('a', 'b'), new Discrete(0.1, 0.0, 0.6, 0.3));
StringInferenceTestUtilities.TestProbability(str3, 0.1, string.Empty);
StringInferenceTestUtilities.TestProbability(str3, 0.6 / 4, "aa", "ab", "ba", "bb");
StringInferenceTestUtilities.TestProbability(str3, 0.3 / 8, "aaa", "bbb", "abb", "bab");
Discrete length1 = StringOfLengthOp.LengthAverageConditional(
StringDistribution.OneOf("aa", "bbb"), DiscreteChar.PointMass('a'), Discrete.Uniform(10));
Assert.Equal(Discrete.PointMass(2, 10), length1);
Discrete length2 = StringOfLengthOp.LengthAverageConditional(
StringDistribution.OneOf("aab", "ab", "b", "bc"), DiscreteChar.OneOf('a', 'b'), Discrete.Uniform(10));
Assert.Equal(4.0 / 7.0, length2[1], Eps);
Assert.Equal(2.0 / 7.0, length2[2], Eps);
Assert.Equal(1.0 / 7.0, length2[3], Eps);
}
public static DiscreteChar CharacterAverageConditional(string str)
{
Argument.CheckIfNotNull(str, "str");
if (str.Length == 1)
{
return(DiscreteChar.PointMass(str[0]));
}
throw new AllZeroException("The length of the given string is not 1.");
}
public void GetOutgoingTransitionsForDeterminization3()
{
var builder = new StringAutomaton.Builder();
builder.Start.AddTransition(DiscreteChar.UniformInRange('a', 'b'), Weight.FromValue(2));
builder.Start.AddTransition(DiscreteChar.UniformInRanges('b', 'd'), Weight.FromValue(3));
builder.Start.AddTransition(DiscreteChar.UniformInRanges('e', 'g'), Weight.FromValue(4));
builder.Start.AddTransition(DiscreteChar.UniformInRanges(char.MinValue, 'a'), Weight.FromValue(5));
var wrapper = new StringAutomatonWrapper(builder);
var outgoingTransitions =
wrapper.GetOutgoingTransitionsForDeterminization(new Dictionary <int, Weight> {
{ 0, Weight.FromValue(6) }
});
var expectedOutgoingTransitions = new[]
{
new ValueTuple <DiscreteChar, Weight, IEnumerable <KeyValuePair <int, Weight> > >(
DiscreteChar.UniformInRange(char.MinValue, (char)('a' - 1)),
Weight.FromValue(30.0 * 97.0 / 98.0),
new Dictionary <int, Weight> {
{ 4, Weight.FromValue(1) }
}),
new ValueTuple <DiscreteChar, Weight, IEnumerable <KeyValuePair <int, Weight> > >(
DiscreteChar.PointMass('a'),
Weight.FromValue((30.0 / 98.0) + 6.0),
new Dictionary <int, Weight> {
{ 1, Weight.FromValue(6.0 / ((30.0 / 98.0) + 6.0)) }, { 4, Weight.FromValue((30.0 / 98.0) / ((30.0 / 98.0) + 6.0)) }
}),
new ValueTuple <DiscreteChar, Weight, IEnumerable <KeyValuePair <int, Weight> > >(
DiscreteChar.PointMass('b'),
Weight.FromValue(12.0),
new Dictionary <int, Weight> {
{ 1, Weight.FromValue(0.5) }, { 2, Weight.FromValue(0.5) }
}),
new ValueTuple <DiscreteChar, Weight, IEnumerable <KeyValuePair <int, Weight> > >(
DiscreteChar.UniformInRange('c', 'd'),
Weight.FromValue(12.0),
new Dictionary <int, Weight> {
{ 2, Weight.FromValue(1.0) }
}),
new ValueTuple <DiscreteChar, Weight, IEnumerable <KeyValuePair <int, Weight> > >(
DiscreteChar.UniformInRange('e', 'g'),
Weight.FromValue(24.0),
new Dictionary <int, Weight> {
{ 3, Weight.FromValue(1.0) }
}),
};
AssertCollectionsEqual(expectedOutgoingTransitions, outgoingTransitions, TransitionInfoEqualityComparer.Instance);
}
public void ComplementWorks()
{
TestComplement(DiscreteChar.PointMass('\0'));
TestComplement(DiscreteChar.PointMass('a'));
TestComplement(DiscreteChar.PointMass(char.MaxValue));
var a = DiscreteChar.PointMass('a');
var b = DiscreteChar.PointMass('b');
var ab = default(DiscreteChar);
ab.SetToSum(1, a, 2, b);
// 2 subsequent ranges
Assert.Equal(2, ab.Ranges.Count);
TestComplement(ab);
void TestComplement(DiscreteChar dist)
{
var uniformDist = dist.Clone();
uniformDist.SetToPartialUniform();
var complement = dist.Complement();
// complement should always be partial uniform
Assert.True(complement.IsPartialUniform());
// overlap is zero
Assert.True(double.IsNegativeInfinity(dist.GetLogAverageOf(complement)));
Assert.True(double.IsNegativeInfinity(uniformDist.GetLogAverageOf(complement)));
// union is covers the whole range
var sum = default(DiscreteChar);
sum.SetToSum(1, dist, 1, complement);
sum.SetToPartialUniform();
Assert.True(sum.IsUniform());
// Doing complement again will cover the same set of characters
var complement2 = complement.Complement();
Assert.Equal(uniformDist, complement2);
}
}
public void MessageOperatorsTest()
{
var str1 = StringFromArrayOp.StrAverageConditional(new[] { DiscreteChar.PointMass('a'), DiscreteChar.OneOf('b', 'c'), DiscreteChar.OneOf('d', 'e') });
Assert.Equal(StringDistribution.OneOf("abd", "abe", "acd", "ace"), str1, Eps);
var str2 = StringFromArrayOp.StrAverageConditional(new DiscreteChar[0]);
Assert.Equal(StringDistribution.Empty(), str2, Eps);
var chars1 = StringFromArrayOp.CharactersAverageConditional(
StringDistribution.OneOf("ab", "cd"),
new[] { DiscreteChar.PointMass('a'), DiscreteChar.Uniform() },
new DiscreteChar[2]);
Assert.Equal(DiscreteChar.OneOf('a', 'c'), chars1[0], Eps);
Assert.Equal(DiscreteChar.PointMass('b'), chars1[1], Eps);
var chars2 = StringFromArrayOp.CharactersAverageConditional(
StringDistribution.OneOf("ab", "ac"),
new[] { DiscreteChar.Uniform(), DiscreteChar.Uniform() },
new DiscreteChar[2]);
Assert.Equal(DiscreteChar.PointMass('a'), chars2[0], Eps);
Assert.Equal(DiscreteChar.OneOf('b', 'c'), chars2[1], Eps);
var chars3 = StringFromArrayOp.CharactersAverageConditional(
StringDistribution.OneOf("ab", "ac", "bc"),
new[] { DiscreteChar.Uniform(), DiscreteChar.Uniform() },
new DiscreteChar[2]);
Assert.Equal(2.0 / 3.0, chars3[0]['a'], Eps);
Assert.Equal(1.0 / 3.0, chars3[0]['b'], Eps);
Assert.Equal(1.0 / 3.0, chars3[1]['b'], Eps);
Assert.Equal(2.0 / 3.0, chars3[1]['c'], Eps);
var chars4 = StringFromArrayOp.CharactersAverageConditional(
StringDistribution.OneOf("ab", "cde"),
new[] { DiscreteChar.Uniform(), DiscreteChar.Uniform() },
new DiscreteChar[2]);
Assert.Equal(DiscreteChar.PointMass('a'), chars4[0], Eps);
Assert.Equal(DiscreteChar.PointMass('b'), chars4[1], Eps);
var chars5 = StringFromArrayOp.CharactersAverageConditional(
StringDistribution.OneOf("ab", "cb", "ae", "ax"),
new[] { DiscreteChar.PointMass('a'), DiscreteChar.PointMass('b') },
new DiscreteChar[2]);
Assert.Equal(DiscreteChar.OneOf('a', 'c'), chars5[0], Eps);
Assert.Equal(DiscreteChar.OneOf('b', 'e', 'x'), chars5[1], Eps);
var chars6 = StringFromArrayOp.CharactersAverageConditional(
StringDistribution.OneOf("abcd", "accd", "acce"),
new[] { DiscreteChar.Uniform(), DiscreteChar.Uniform(), DiscreteChar.Uniform(), DiscreteChar.PointMass('d') },
new DiscreteChar[4]);
Assert.Equal(DiscreteChar.PointMass('a'), chars6[0], Eps);
Assert.Equal(DiscreteChar.OneOf('b', 'c'), chars6[1], Eps);
Assert.Equal(DiscreteChar.PointMass('c'), chars6[2], Eps);
Assert.Equal(2.0 / 3.0, chars6[3]['d'], Eps);
Assert.Equal(1.0 / 3.0, chars6[3]['e'], Eps);
}