public void DataContractAndDataContractJsonSerializersVectorTest()
{
for (var vectorType = 0; vectorType < 4; vectorType++)
{
Vector v;
if (vectorType == 0)
{
v = Vector.FromArray(3.5, 4.3);
}
else
{
var sparsity = Sparsity.Sparse;
if (vectorType == 1)
{
sparsity = Sparsity.Sparse;
}
else if (vectorType == 2)
{
sparsity = Sparsity.ApproximateWithTolerance(0.1);
}
else if (vectorType == 3)
{
sparsity = Sparsity.Piecewise;
}
v = Vector.Constant(3, 1.4, sparsity);
v[1] = 2.5;
}
var v2 = CloneDataContract(v);
Assert.Equal(0, v.MaxDiff(v2), 1e-10);
}
}
/// <summary>
/// Tests EP and BP gate exit ops for Bernoulli random variable for correctness given message parameters and a shift.
/// </summary>
/// <param name="gate1ProbTrue">Probability of being true for the variable when the selector is true.</param>
/// <param name="gate2ProbTrue">Probability of being true for the variable when the selector is false.</param>
/// <param name="selectorProbTrue">Probability of being true for the selector variable.</param>
/// <param name="shift">The value of the shift.</param>
private void DoBernoulliExitTest(double gate1ProbTrue, double gate2ProbTrue, double selectorProbTrue, double shift)
{
const double ExitTwoProbTrue = 0.3; // ExitTwo op depends on the incoming message from outside the gate
var cases = new[] { Bernoulli.FromLogOdds(Math.Log(selectorProbTrue) - shift), Bernoulli.FromLogOdds(Math.Log(1 - selectorProbTrue) - shift) };
var values = new[] { new Bernoulli(gate1ProbTrue), new Bernoulli(gate2ProbTrue) };
var exitTwo = new Bernoulli(ExitTwoProbTrue);
Bernoulli value1, value2;
double expectedProbTrueFromExit = (selectorProbTrue * gate1ProbTrue) + ((1 - selectorProbTrue) * gate2ProbTrue);
value1 = GateExitOp <bool> .ExitAverageConditional(new Bernoulli(), cases, values, new Bernoulli());
value2 = BeliefPropagationGateExitOp.ExitAverageConditional(cases, values, new Bernoulli());
Assert.Equal(expectedProbTrueFromExit, value1.GetProbTrue(), 1e-4);
Assert.Equal(expectedProbTrueFromExit, value2.GetProbTrue(), 1e-4);
double gate1Scale = (ExitTwoProbTrue * gate1ProbTrue) + ((1 - ExitTwoProbTrue) * (1 - gate1ProbTrue));
double gate2Scale = (ExitTwoProbTrue * gate2ProbTrue) + ((1 - ExitTwoProbTrue) * (1 - gate2ProbTrue));
double expectedProbTrueFromExitTwo =
(selectorProbTrue * gate1ProbTrue / gate1Scale) + ((1 - selectorProbTrue) * gate2ProbTrue / gate2Scale);
double expectedProbFalseFromExitTwo =
(selectorProbTrue * (1 - gate1ProbTrue) / gate1Scale) + ((1 - selectorProbTrue) * (1 - gate2ProbTrue) / gate2Scale);
expectedProbTrueFromExitTwo /= expectedProbTrueFromExitTwo + expectedProbFalseFromExitTwo;
value1 = GateExitTwoOp.ExitTwoAverageConditional <Bernoulli>(exitTwo, cases[0], cases[1], values, new Bernoulli());
value2 = BeliefPropagationGateExitTwoOp.ExitTwoAverageConditional(exitTwo, cases[0], cases[1], values, new Bernoulli());
Assert.Equal(expectedProbTrueFromExitTwo, value1.GetProbTrue(), 1e-4);
Assert.Equal(expectedProbTrueFromExitTwo, value2.GetProbTrue(), 1e-4);
}
public void SparseDirichletProduct()
{
double commonPseudoCount = 1.0;
double nonCommonPseudoCount1 = 10.0;
double nonCommonPseudoCount2 = 30.0;
Dirichlet d1 = new Dirichlet(
SparseVector.FromSparseValues(100, commonPseudoCount, new List <SparseElement>
{
new SparseElement(20, nonCommonPseudoCount1),
new SparseElement(55, nonCommonPseudoCount1)
}));
Dirichlet d2 = new Dirichlet(
SparseVector.FromSparseValues(100, commonPseudoCount, new List <SparseElement>
{
new SparseElement(25, nonCommonPseudoCount2),
new SparseElement(55, nonCommonPseudoCount2)
}));
Dirichlet d = d1 * d2;
Assert.Equal(Sparsity.Sparse, d.Sparsity);
SparseVector sv = (SparseVector)(d.PseudoCount);
Assert.Equal(3, sv.SparseValues.Count);
}
/// <summary>
/// A helper function for evidence messages when the output of the factor is not observed.
/// </summary>
/// <param name="str">The message to <c>str</c>.</param>.
private static void TestEvidence(StringDistribution str)
{
Assert.Equal(0, StringFormatOp_RequireEveryPlaceholder_NoArgumentNames.LogEvidenceRatio(str));
Assert.Equal(0, StringFormatOp_RequireEveryPlaceholder.LogEvidenceRatio(str));
Assert.Equal(0, StringFormatOp_AllowMissingPlaceholders_NoArgumentNames.LogEvidenceRatio(str));
Assert.Equal(0, StringFormatOp_AllowMissingPlaceholders.LogEvidenceRatio(str));
}
public void RandRestartThreadsTest()
{
double sum1 = RandRestartThreadsTest_Helper();
double sum2 = RandRestartThreadsTest_Helper();
Assert.Equal(sum1, sum2, 1e-10);
}
public void SparseDiscreteRatio()
{
double commonValue = 1.0;
double nonCommonValue1 = 10.0;
double nonCommonValue2 = 30.0;
Discrete d1 = new Discrete(
SparseVector.FromSparseValues(100, commonValue, new List <SparseElement>
{
new SparseElement(20, nonCommonValue1),
new SparseElement(55, nonCommonValue1)
}));
Discrete d2 = new Discrete(
SparseVector.FromSparseValues(100, commonValue, new List <SparseElement>
{
new SparseElement(25, nonCommonValue2),
new SparseElement(55, nonCommonValue2)
}));
Discrete d = d1 / d2;
Assert.Equal(Sparsity.Sparse, d.Sparsity);
SparseVector sv = (SparseVector)(d.GetProbs());
Assert.Equal(3, sv.SparseValues.Count);
}
public void ImpossibleBranchTest3()
{
Variable <string> str1 = Variable.StringLower().Named("str1");
Variable <string> str2 = Variable.StringLower().Named("str2");
Variable <string> text = Variable.New <string>().Named("text");
Variable <int> selector = Variable.DiscreteUniform(2).Named("selector");
using (Variable.Case(selector, 0))
{
text.SetTo(str1 + Variable.Constant(" ") + str2);
}
using (Variable.Case(selector, 1))
{
text.SetTo(str1);
}
text.ObservedValue = "abc";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Discrete>(selector);
var str1Posterior = engine.Infer <StringDistribution>(str1);
var str2Posterior = engine.Infer <StringDistribution>(str2);
Assert.True(selectorPosterior.IsPointMass && selectorPosterior.Point == 1);
Assert.True(str1Posterior.IsPointMass && str1Posterior.Point == "abc");
Assert.Equal(StringDistribution.Lower(), str2Posterior);
}
public void Copy()
{
StringTransducer copy = StringTransducer.Copy();
StringInferenceTestUtilities.TestTransducerValue(copy, "important", "important", 1.0);
StringInferenceTestUtilities.TestTransducerValue(copy, "important", "i", 0.0);
StringInferenceTestUtilities.TestTransducerValue(copy, "important", "imp", 0.0);
StringInferenceTestUtilities.TestTransducerValue(copy, "important", "t", 0.0);
StringInferenceTestUtilities.TestTransducerValue(copy, "important", "mpo", 0.0);
StringInferenceTestUtilities.TestTransducerValue(copy, string.Empty, string.Empty, 1.0);
StringInferenceTestUtilities.TestTransducerValue(copy, "important", string.Empty, 0.0);
StringInferenceTestUtilities.TestTransducerValue(copy, string.Empty, "important", 0.0);
//// Test that projection on Copy() doesn't change the automaton
StringAutomaton automaton = StringAutomaton.ConstantOn(2.0, "a", "ab", "ac");
automaton = automaton.Sum(StringAutomaton.ConstantOn(1.0, "a"));
automaton = automaton.Sum(StringAutomaton.Constant(2.0));
automaton = automaton.Product(StringAutomaton.Constant(3.0));
StringAutomaton automatonClone = copy.ProjectSource(automaton);
Assert.Equal(automaton, automatonClone);
}
public void GatedModelUncertainOutputTest()
{
Variable <bool> selector = Variable.Bernoulli(0.5);
Variable <string> concat = Variable.New <string>();
using (Variable.If(selector))
{
Variable <string> arg1 = Variable.Random(StringDistribution.OneOf("ab", "abc"));
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d"));
concat.SetTo(arg1 + arg2);
}
using (Variable.IfNot(selector))
{
Variable <string> arg1 = "ab";
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d", "e"));
concat.SetTo(arg1 + arg2);
}
Variable.ConstrainEqualRandom(concat, StringDistribution.OneOf("abcd", "abd"));
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(9.0 / 17.0, selectorPosterior.GetProbTrue());
}
public void GatedModelObservedOutputTest2()
{
Variable <bool> selector = Variable.Bernoulli(0.5);
Variable <string> concat = Variable.New <string>();
using (Variable.If(selector))
{
Variable <string> arg1 = Variable.StringLower();
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d"));
concat.SetTo(arg1 + arg2);
}
using (Variable.IfNot(selector))
{
Variable <string> arg1 = "ab";
Variable <string> arg2 = Variable.Random(StringDistribution.OneOf("cd", "d", "e"));
concat.SetTo(arg1 + arg2);
}
concat.ObservedValue = "abcd";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(0.0, selectorPosterior.GetProbTrue());
}
public void InferArgumentsFromConcatenationTest2()
{
var str1 = Variable.StringUpper(minLength: 0);
var str2 = Variable.StringLower(minLength: 0);
var str3 = Variable.StringUpper(minLength: 0);
var s = str1 + str2 + str3;
s.ObservedValue = "ABC";
var engine = new InferenceEngine();
var posteriorOverStr1 = engine.Infer <StringDistribution>(str1);
StringInferenceTestUtilities.TestIfIncludes(posteriorOverStr1, string.Empty, "A", "AB", "ABC");
StringInferenceTestUtilities.TestIfExcludes(posteriorOverStr1, "B", "BC", "C");
var posteriorOverStr2 = engine.Infer <StringDistribution>(str2);
Assert.True(posteriorOverStr2.IsPointMass);
Assert.Equal(string.Empty, posteriorOverStr2.Point);
var posteriorOverStr3 = engine.Infer <StringDistribution>(str3);
StringInferenceTestUtilities.TestIfIncludes(posteriorOverStr3, "ABC", "BC", "C", string.Empty);
StringInferenceTestUtilities.TestIfExcludes(posteriorOverStr3, "A", "AB", "B");
}
public void Transpose()
{
StringTransducer transducer = StringTransducer.Consume(StringAutomaton.Constant(3.0));
StringTransducer transpose1 = StringTransducer.Transpose(transducer);
StringTransducer transpose2 = transducer.Clone();
transpose2.TransposeInPlace();
var pairs = new[]
{
new[] { "a", string.Empty },
new[] { string.Empty, string.Empty },
new[] { "a", "bc" },
new[] { "a", "a" }
};
foreach (string[] valuePair in pairs)
{
double referenceValue1 = transducer.GetValue(valuePair[0], valuePair[1]);
Assert.Equal(referenceValue1, transpose1.GetValue(valuePair[1], valuePair[0]));
Assert.Equal(referenceValue1, transpose2.GetValue(valuePair[1], valuePair[0]));
double referenceValue2 = transducer.GetValue(valuePair[1], valuePair[0]);
Assert.Equal(referenceValue2, transpose1.GetValue(valuePair[0], valuePair[1]));
Assert.Equal(referenceValue2, transpose2.GetValue(valuePair[0], valuePair[1]));
}
}
public void WordMiddleLimitedLength()
{
const double Eps = 1e-6;
var wordMiddleLimitedLength1 = WordStrings.WordMiddle(3, 5);
StringInferenceTestUtilities.TestIfIncludes(wordMiddleLimitedLength1, " h w ", ". ab.", "...");
StringInferenceTestUtilities.TestIfExcludes(
wordMiddleLimitedLength1,
"hello",
" w",
"hi ",
"1 2",
".",
"..",
" hello world ",
string.Empty);
Assert.Equal(wordMiddleLimitedLength1.GetLogProb(" h w "), wordMiddleLimitedLength1.GetLogProb(" h "), Eps);
var wordMiddleLimitedLength2 = WordStrings.WordMiddle(1, 5);
StringInferenceTestUtilities.TestIfIncludes(wordMiddleLimitedLength2, " ", " h w ", ". ab.", "...");
StringInferenceTestUtilities.TestIfExcludes(wordMiddleLimitedLength2, "hello", " w", "hi ", "1 2", " hello world ", string.Empty);
Assert.Equal(wordMiddleLimitedLength2.GetLogProb("."), wordMiddleLimitedLength2.GetLogProb(" h "), Eps);
var wordMiddleLimitedLength3 = WordStrings.WordMiddle(1, 2);
StringInferenceTestUtilities.TestIfIncludes(wordMiddleLimitedLength3, " ", " .");
StringInferenceTestUtilities.TestIfExcludes(wordMiddleLimitedLength3, "hw", " w", "h ", "12", " hello world ", string.Empty);
Assert.Equal(wordMiddleLimitedLength3.GetLogProb("."), wordMiddleLimitedLength3.GetLogProb(".."), Eps);
}
/// <summary>
/// A helper function for evidence messages when the output of the factor is observed.
/// </summary>
/// <param name="str">The observed value of <c>str</c>.</param>
/// <param name="format">The message from <c>format</c>.</param>
/// <param name="args">The message from <c>args</c>.</param>
/// <param name="expectedLogEvidence">
/// The expected log-evidence if the format string is required to contain placeholders for all arguments.
/// </param>
/// <param name="expectedLogEvidenceWithMissingPlaceholders">
/// The expected log-evidence if the format string may not contain placeholders for some arguments.
/// </param>
private static void TestEvidence(
string str,
StringDistribution format,
StringDistribution[] args,
double expectedLogEvidence,
double expectedLogEvidenceWithMissingPlaceholders)
{
const double LogEvidenceEps = 1e-6;
string[] argNames = GetDefaultArgumentNames(args.Length);
Assert.Equal(
expectedLogEvidence,
StringFormatOp_RequireEveryPlaceholder_NoArgumentNames.LogEvidenceRatio(str, format, args),
LogEvidenceEps);
Assert.Equal(
expectedLogEvidence,
StringFormatOp_RequireEveryPlaceholder.LogEvidenceRatio(str, format, args, argNames),
LogEvidenceEps);
Assert.Equal(
expectedLogEvidenceWithMissingPlaceholders,
StringFormatOp_AllowMissingPlaceholders_NoArgumentNames.LogEvidenceRatio(str, format, args),
LogEvidenceEps);
Assert.Equal(
expectedLogEvidenceWithMissingPlaceholders,
StringFormatOp_AllowMissingPlaceholders.LogEvidenceRatio(str, format, args, argNames),
LogEvidenceEps);
}
public void SimpleGatedModelTest4()
{
const double SelectorProbabilityTrue = 0.3;
const string PreferredOption = "a";
Variable <string> str = Variable.StringUniform().Named("str");
Variable <bool> selector = Variable.Bernoulli(SelectorProbabilityTrue).Named("selector");
using (Variable.If(selector))
{
Variable.ConstrainEqual(str, PreferredOption);
}
using (Variable.IfNot(selector))
{
Variable.ConstrainEqualRandom(str, StringDistribution.Any());
}
str.ObservedValue = PreferredOption;
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(1.0, selectorPosterior.GetProbTrue(), 1e-6);
}
public void ImpossibleBranchTest1()
{
Variable <string> str = Variable.New <string>().Named("str");
Variable <bool> selector = Variable.Bernoulli(0.5).Named("selector");
using (Variable.If(selector))
{
var str1 = Variable.StringUniform();
var str2 = Variable.StringUniform();
str.SetTo(str1 + " " + str2);
}
using (Variable.IfNot(selector))
{
var str1 = Variable.StringUniform();
var str2 = Variable.StringUniform();
str.SetTo(str1 + "-" + str2);
}
str.ObservedValue = "ab-c";
var engine = new InferenceEngine();
var selectorPosterior = engine.Infer <Bernoulli>(selector);
Assert.Equal(1.0, selectorPosterior.GetProbFalse());
}
public void ComputeNormalizerWithManyNonTrivialLoops2()
{
StringAutomaton automaton = StringAutomaton.Zero();
automaton.AddStates(6);
automaton.States[0].AddEpsilonTransition(Weight.FromValue(0.2), automaton.States[1]);
automaton.States[0].AddEpsilonTransition(Weight.FromValue(0.5), automaton.States[3]);
automaton.States[0].EndWeight = Weight.FromValue(0.3);
automaton.States[1].AddEpsilonTransition(Weight.FromValue(0.8), automaton.States[0]);
automaton.States[1].AddEpsilonTransition(Weight.FromValue(0.1), automaton.States[2]);
automaton.States[1].EndWeight = Weight.FromValue(0.1);
automaton.States[2].EndWeight = Weight.FromValue(1.0);
automaton.States[3].AddEpsilonTransition(Weight.FromValue(0.2), automaton.States[4]);
automaton.States[3].AddEpsilonTransition(Weight.FromValue(0.1), automaton.States[5]);
automaton.States[3].EndWeight = Weight.FromValue(0.7);
automaton.States[4].AddEpsilonTransition(Weight.FromValue(0.5), automaton.States[2]);
automaton.States[4].AddEpsilonTransition(Weight.FromValue(0.5), automaton.States[6]);
automaton.States[4].EndWeight = Weight.FromValue(0.0);
automaton.States[5].AddEpsilonTransition(Weight.FromValue(0.1), automaton.States[3]);
automaton.States[5].AddEpsilonTransition(Weight.FromValue(0.9), automaton.States[6]);
automaton.States[5].EndWeight = Weight.Zero;
automaton.States[6].EndWeight = Weight.One;
AssertStochastic(automaton);
Assert.Equal(0.0, automaton.GetLogNormalizer(), 1e-6);
Assert.Equal(0.0, GetLogNormalizerByGetValue(automaton), 1e-6);
Assert.Equal(0.0, GetLogNormalizerByGetValueWithTransducers(automaton), 1e-6);
}
public void StringFormatTest2()
{
var templates = Variable.Observed(new string[] { "My name is {0}.", "I'm {0}." });
templates.Name = nameof(templates);
var a = Variable.Random(StringDistribution.OneOf("John", "Tom"));
a.Name = nameof(a);
var templateNumber = Variable.DiscreteUniform(templates.Range);
templateNumber.Name = nameof(templateNumber);
var b = Variable.New <string>().Named("b");
using (Variable.Switch(templateNumber))
{
b.SetTo(Variable.StringFormat(templates[templateNumber], a));
}
var engine = new InferenceEngine();
engine.Compiler.GivePriorityTo(typeof(ReplicateOp_NoDivide));
engine.Compiler.RecommendedQuality = QualityBand.Experimental;
Test("a", engine.Infer <IDistribution <string> >(a), "John", "Tom");
Test("b", engine.Infer <IDistribution <string> >(b), "My name is John.", "My name is Tom.", "I'm John.", "I'm Tom.");
b.ObservedValue = "My name is John.";
var tempNum = engine.Infer <Discrete>(templateNumber);
Assert.Equal(new Discrete(1.0, 0.0), tempNum);
Test("a", engine.Infer <IDistribution <string> >(a), "John");
}
public void SampleGeometric()
{
Rand.Restart(96);
const double StoppingProbability = 0.7;
// The length of sequences sampled from this distribution must follow a geometric distribution
StringAutomaton automaton = StringAutomaton.Zero();
automaton.Start = automaton.AddState();
automaton.Start.SetEndWeight(Weight.FromValue(StoppingProbability));
automaton.Start.AddTransition('a', Weight.FromValue(1 - StoppingProbability), automaton.Start);
StringDistribution dist = StringDistribution.FromWeightFunction(automaton);
var acc = new MeanVarianceAccumulator();
const int SampleCount = 30000;
for (int i = 0; i < SampleCount; ++i)
{
string sample = dist.Sample();
acc.Add(sample.Length);
}
const double ExpectedMean = (1.0 - StoppingProbability) / StoppingProbability;
const double ExpectedVariance = (1.0 - StoppingProbability) / (StoppingProbability * StoppingProbability);
Assert.Equal(ExpectedMean, acc.Mean, 1e-2);
Assert.Equal(ExpectedVariance, acc.Variance, 1e-2);
}
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 void RepeatCorrectness()
{
var sourceDict = new Dictionary <string, double>()
{
["a"] = 0.5,
["aa"] = 0.5
};
var wf = StringDictionaryWeightFunction.FromDistinctValues(sourceDict);
var repeatedWf = wf.Repeat(0, 3);
var expectedResultDict = new Dictionary <string, double>()
{
[string.Empty] = 1.0,
["a"] = 0.5,
["aa"] = 0.75, // aa, a+a
["aaa"] = 0.625, // aa+a, a+aa, a+a+a
["aaaa"] = 0.625, // aa+aa, aa+a+a, a+aa+a, a+a+aa
["aaaaa"] = 0.375, // aa+aa+a, aa+a+aa, a+aa+aa
["aaaaaa"] = 0.125 // aa+aa+aa
};
Assert.Equal(expectedResultDict.Count, repeatedWf.Dictionary.Count);
foreach (var kvp in expectedResultDict)
{
Assert.True(repeatedWf.Dictionary.TryGetValue(kvp.Key, out Weight weight));
Assert.Equal(kvp.Value, weight.Value, MMath.Ulp1);
}
}
public void AssertEqualTo(MyClass that)
{
Assert.Equal(0, this.bernoulli.MaxDiff(that.bernoulli));
Assert.Equal(0, this.beta.MaxDiff(that.beta));
Assert.Equal(0, this.binomial.MaxDiff(that.binomial));
Assert.Equal(0, this.conjugateDirichlet.MaxDiff(that.conjugateDirichlet));
Assert.Equal(0, this.dirichlet.MaxDiff(that.dirichlet));
Assert.Equal(0, this.discrete.MaxDiff(that.discrete));
Assert.Equal(0, this.gamma.MaxDiff(that.gamma));
Assert.Equal(0, this.gammaPower.MaxDiff(that.gammaPower));
Assert.Equal(0, this.gaussian.MaxDiff(that.gaussian));
Assert.Equal(0, this.nonconjugateGaussian.MaxDiff(that.nonconjugateGaussian));
Assert.Equal(0, this.pointMass.MaxDiff(that.pointMass));
Assert.Equal(0, this.sparseBernoulliList.MaxDiff(that.sparseBernoulliList));
Assert.Equal(0, this.sparseBetaList.MaxDiff(that.sparseBetaList));
Assert.Equal(0, this.sparseGammaList.MaxDiff(that.sparseGammaList));
Assert.Equal(0, this.truncatedGamma.MaxDiff(that.truncatedGamma));
Assert.Equal(0, this.truncatedGaussian.MaxDiff(that.truncatedGaussian));
Assert.Equal(0, this.wrappedGaussian.MaxDiff(that.wrappedGaussian));
Assert.Equal(0, this.sparseGaussianList.MaxDiff(that.sparseGaussianList));
Assert.Equal(0, this.unnormalizedDiscrete.MaxDiff(that.unnormalizedDiscrete));
Assert.Equal(0, this.vectorGaussian.MaxDiff(that.vectorGaussian));
Assert.Equal(0, this.wishart.MaxDiff(that.wishart));
Assert.Equal(0, this.pareto.MaxDiff(that.pareto));
Assert.Equal(0, this.poisson.MaxDiff(that.poisson));
Assert.Equal(0, ga.MaxDiff(that.ga));
Assert.Equal(0, vga.MaxDiff(that.vga));
Assert.Equal(0, ga2D.MaxDiff(that.ga2D));
Assert.Equal(0, vga2D.MaxDiff(that.vga2D));
Assert.Equal(0, gaJ.MaxDiff(that.gaJ));
Assert.Equal(0, vgaJ.MaxDiff(that.vgaJ));
Assert.Equal(0, this.sparseGp.MaxDiff(that.sparseGp));
Assert.True(this.quantileEstimator.ValueEquals(that.quantileEstimator));
}
public void OneOfTest()
{
var abc = StringDistribution.OneOf("a", "b", "c");
var s = abc.ToString();
Console.WriteLine("a or b or c:" + s);
Assert.Equal("[a|b|c]", s);
}
public void PointMassDetectionLoopInDeadEnd()
{
StringAutomaton f = StringAutomaton.Zero();
f.Start.AddTransition('a', Weight.FromValue(0.5)).AddSelfTransition('a', Weight.FromValue(0.5)).AddTransition('b', Weight.One);
f.Start.AddTransition('b', Weight.FromValue(0.5)).EndWeight = Weight.One;
Assert.Equal("b", f.TryComputePoint());
}
public void PointMassDetectionWithDeadLoop()
{
StringAutomaton f = StringAutomaton.Zero();
f.Start.AddTransition('a', Weight.FromValue(0.5)).AddTransition('b', Weight.Zero, f.Start);
f.Start.AddTransitionsForSequence("abc").EndWeight = Weight.One;
Assert.Equal("abc", f.TryComputePoint());
}
public void PointMassDetectionWithEpsilonLoop()
{
StringAutomaton f = StringAutomaton.Zero();
AddEpsilonLoop(f.Start, 5, 0.5);
f.Start.AddTransitionsForSequence("abc").EndWeight = Weight.One;
Assert.Equal("abc", f.TryComputePoint());
}
public void Repeat2()
{
var baseDist = StringDistribution.OneOf("a", "b");
var dist1 = StringDistribution.Repeat(baseDist, minTimes: 1, maxTimes: 3);
var dist2 = StringDistribution.Repeat(DiscreteChar.OneOf('a', 'b'), minTimes: 1, maxTimes: 3);
Assert.Equal(dist2, dist1);
}
/// <summary>
/// Tests whether the logarithm of the value of a given automaton on given strings equals to a specified value.
/// </summary>
/// <param name="automaton">The automaton.</param>
/// <param name="trueLogValue">The expected logarithm of the function value.</param>
/// <param name="strings">The strings to test.</param>
public static void TestValue(ListAutomaton <string, StringDistribution> automaton, double trueValue, params List <string>[] strings)
{
foreach (var str in strings)
{
double logValue = automaton.GetLogValue(str);
Assert.Equal(Math.Log(trueValue), logValue, LogValueEps);
}
}
public void NormalCdfRatioTest()
{
double r0 = MMath.Sqrt2PI / 2;
Assert.Equal(r0, MMath.NormalCdfRatio(0));
Assert.Equal(r0, MMath.NormalCdfRatio(6.6243372842224754E-170));
Assert.Equal(r0, MMath.NormalCdfRatio(-6.6243372842224754E-170));
}
public void WordMiddle()
{
var wordMiddle = WordStrings.WordMiddle();
StringInferenceTestUtilities.TestIfIncludes(wordMiddle, " hello world ", ". abc.", ". abc. def gh. ", " ", "..");
StringInferenceTestUtilities.TestIfExcludes(wordMiddle, "hello", " world", "hi ", "1 2", string.Empty);
Assert.Equal(wordMiddle.GetLogProb(" "), wordMiddle.GetLogProb(" world "));
}