public void NormalCdf2Test4()
{
for (int j = 8; j <= 17; j++)
{
double r = -1 + System.Math.Pow(10, -j);
double expected = System.Math.Log(NormalCdfZero(r));
for (int i = 5; i < 100; i++)
{
double x = -System.Math.Pow(10, -i);
double y = -x;
double actual = MMath.NormalCdfLn(x, y, r);
//double actual = Math.Log(NormalCdfConFrac3(x, y, r));
double error;
if (actual == expected)
{
error = 0;
}
else
{
error = System.Math.Abs(actual - expected);
}
//Console.WriteLine($"NormalCdfLn({x},{y},{r}) = {actual}, error = {error}");
Assert.True(error < 1e-9);
}
}
}
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 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 NormalCdfIntegralTest()
{
Assert.True(0 <= NormalCdfIntegral(190187183095334850882507750944849586799124505055478568794871547478488387682304.0, -190187183095334850882507750944849586799124505055478568794871547478488387682304.0, -1, 0.817880416082724044547388352452631856079457366800004151664125953519049673808376291470533145141236089924006896061006277409614237094627499958581030715374379576478204968748786874650796450332240045653919846557755590765736997127532958984375e-78).Mantissa);
Assert.True(0 <= NormalCdfIntegral(213393529.2046706974506378173828125, -213393529.2046706974506378173828125, -1, 0.72893668811495072384656764856902984306419313043079455383121967315673828125e-9).Mantissa);
Assert.True(0 < NormalCdfIntegral(-0.421468532207607216033551367218024097383022308349609375, 0.42146843802130329326161017888807691633701324462890625, -0.99999999999999989, 0.62292398855983019004972723654291189010479001808562316000461578369140625e-8).Mantissa);
// Checking all cases takes a long time.
const int limit = 2_000_000;
int count = 0;
Parallel.ForEach(OperatorTests.Doubles(), x =>
{
if (count > limit)
{
return;
}
foreach (var y in OperatorTests.Doubles())
{
if (count > limit)
{
break;
}
foreach (var r in OperatorTests.Doubles().Where(d => d >= -1 && d <= 1))
{
if (count > limit)
{
break;
}
MMath.NormalCdfIntegral(x, y, r);
Interlocked.Add(ref count, 1);
}
}
});
}
public void ZeroDetection()
{
StringDistribution dist1 = StringDistribution.OneOf(1.0, StringDistribution.Zero(), 0.0, StringDistribution.Any());
Assert.True(dist1.IsZero());
StringInferenceTestUtilities.TestProbability(dist1, 0.0, string.Empty, "a", "bc");
StringDistribution dist2 = StringDistribution.Capitalized(2, 4).Product(StringDistribution.Any(minLength: 5, maxLength: 7));
Assert.True(dist2.IsZero());
StringInferenceTestUtilities.TestProbability(dist2, 0.0, string.Empty, "Abc", "Abcdef");
StringDistribution dist3 = StringDistribution.Digits(minLength: 3, maxLength: 3).Product(StringDistribution.String("12a"));
Assert.True(dist3.IsZero());
StringInferenceTestUtilities.TestProbability(dist3, 0.0, string.Empty, "12a", "1", "2", "666");
StringDistribution dist4 = StringDistribution.Any(minLength: 1, maxLength: 2).Product(StringDistribution.Any(minLength: 2, maxLength: 3).Product(StringDistribution.Any(minLength: 3, maxLength: 4)));
Assert.True(dist4.IsZero());
StringInferenceTestUtilities.TestProbability(dist4, 0.0, string.Empty, "a", "ab", "abc", "abcd");
StringDistribution dist5 = StringDistribution.Any().Append(StringDistribution.Zero());
Assert.True(dist5.IsZero());
StringInferenceTestUtilities.TestProbability(dist5, 0.0, string.Empty, "a", "bc");
StringDistribution dist6 = StringDistribution.Zero().Append(StringDistribution.OneOf("abc", "def"));
Assert.True(dist6.IsZero());
StringInferenceTestUtilities.TestProbability(dist6, 0.0, string.Empty, "a", "bc");
}
public void NormalCdf2Test()
{
double x = 1.2, y = 1.3;
double xy1 = System.Math.Max(0.0, MMath.NormalCdf(x) + MMath.NormalCdf(y) - 1);
Assert.True(0 < MMath.NormalCdf(6.8419544775976187E-08, -5.2647906596206016E-08, -1, 3.1873689658872377E-10).Mantissa);
// In sage:
// integral(1/(2*pi*sqrt(1-t*t))*exp(-(x*x+y*y-2*t*x*y)/(2*(1-t*t))),t,-1,r).n(digits=200);
double[,] normalcdf2_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdf2.csv"));
CheckFunctionValues("NormalCdf2", new MathFcn3(MMath.NormalCdf), normalcdf2_pairs);
// using wolfram alpha: (for cases where r=-1 returns zero)
// log(integrate(1/(2*pi*sqrt(1-t*t))*exp(-(2*0.1*0.1 - 2*t*0.1*0.1)/(2*(1-t*t))),t,-1,-0.9999))
// log(integrate(1/(2*pi*sqrt(1-t*t))*exp(-(2*1.5*1.5 + 2*t*1.5*1.5)/(2*(1-t*t))),t,-1,-0.5))
double[,] normalcdfln2_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdfLn2.csv"));
CheckFunctionValues("NormalCdfLn2", new MathFcn3(MMath.NormalCdfLn), normalcdfln2_pairs);
double[,] normalcdfRatioLn2_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdfRatioLn2.csv"));
CheckFunctionValues("NormalCdfRatioLn2", new MathFcn4(NormalCdfRatioLn), normalcdfRatioLn2_pairs);
// The true values are computed using
// x * MMath.NormalCdf(x, y, r) + System.Math.Exp(Gaussian.GetLogProb(x, 0, 1) + MMath.NormalCdfLn(ymrx)) + r * System.Math.Exp(Gaussian.GetLogProb(y, 0, 1) + MMath.NormalCdfLn(xmry))
// where
// ymrx = (y - r * x) / sqrt(1-r*r)
// xmry = (x - r * y) / sqrt(1-r*r)
double[,] normalcdfIntegral_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdfIntegral.csv"));
CheckFunctionValues("NormalCdfIntegral", new MathFcn3(MMath.NormalCdfIntegral), normalcdfIntegral_pairs);
double[,] normalcdfIntegralRatio_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdfIntegralRatio.csv"));
CheckFunctionValues("NormalCdfIntegralRatio", new MathFcn3(MMath.NormalCdfIntegralRatio), normalcdfIntegralRatio_pairs);
}
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 Repeat1()
{
var dist = StringDistribution.Repeat(StringDistribution.OneOf("ab", "cd"), minTimes: 1, maxTimes: 3);
Assert.True(dist.IsProper());
StringInferenceTestUtilities.TestProbability(dist, StringInferenceTestUtilities.StringUniformProbability(1, 3, 2), "ab", "cd", "abab", "abcd", "cdabcd", "cdcdcd");
}
public void LengthBounds()
{
var lengthDist1 = StringDistribution.Any(minLength: 1, maxLength: 3);
Assert.True(lengthDist1.IsProper());
StringInferenceTestUtilities.TestProbability(lengthDist1, StringInferenceTestUtilities.StringUniformProbability(1, 3, 65536), "a", "aa", "aaa");
StringInferenceTestUtilities.TestProbability(lengthDist1, 0.0, string.Empty, "aaaa");
var lengthDist2 = StringDistribution.Repeat(DiscreteChar.OneOf('a', 'b'), minTimes: 1, maxTimes: 3);
Assert.True(lengthDist2.IsProper());
StringInferenceTestUtilities.TestProbability(lengthDist2, StringInferenceTestUtilities.StringUniformProbability(1, 3, 2), "a", "ab", "aba");
StringInferenceTestUtilities.TestProbability(lengthDist2, 0.0, string.Empty, "aaaa", "abab", "cc");
var lengthDist3 = StringDistribution.Repeat(DiscreteChar.OneOf('a', 'b'), minTimes: 2, maxTimes: 2);
Assert.True(lengthDist3.IsProper());
StringInferenceTestUtilities.TestProbability(lengthDist3, StringInferenceTestUtilities.StringUniformProbability(2, 2, 2), "aa", "ab", "ba", "bb");
StringInferenceTestUtilities.TestProbability(lengthDist3, 0.0, string.Empty, "a", "abab", "cc");
var minLengthDist = StringDistribution.Any(minLength: 2);
Assert.False(minLengthDist.IsProper());
StringInferenceTestUtilities.TestProbability(minLengthDist, 1.0, "aa", "123", "@*(@*&(@)");
StringInferenceTestUtilities.TestProbability(minLengthDist, 0.0, string.Empty, "a", "!");
var maxLengthDist = StringDistribution.ZeroOrMore(DiscreteChar.Digit(), maxTimes: 3);
Assert.True(maxLengthDist.IsProper());
StringInferenceTestUtilities.TestProbability(maxLengthDist, StringInferenceTestUtilities.StringUniformProbability(0, 3, 10), string.Empty, "1", "32", "432");
StringInferenceTestUtilities.TestProbability(maxLengthDist, 0.0, "abc", "1234");
}
public void DataContractSerializerMatrixTest()
{
for (int matrixType = 0; matrixType < 2; matrixType++)
{
MemoryStream stream = new MemoryStream();
//FileStream stream = new FileStream("temp.txt", FileMode.Create);
Matrix m;
if (matrixType == 0)
{
m = new Matrix(new double[, ] {
{ 2, 3, 4 }, { 5, 6, 7 }
});
}
else
{
m = new PositiveDefiniteMatrix(new double[, ] {
{ 2, 1 }, { 1, 2 }
});
}
var m2 = CloneDataContract(m);
Assert.True(m.MaxDiff(m2) < 1e-10);
stream.Close();
}
}
public void ZeroDetectionWithEpsilonLoop1()
{
StringAutomaton f = StringAutomaton.Zero();
AddEpsilonLoop(f.Start, 5, 0);
Assert.False(f.IsCanonicZero());
Assert.True(f.IsZero());
}
public void CaseInvariant()
{
var caseInvariantDist = StringDistribution.CaseInvariant("0aBC");
Assert.True(caseInvariantDist.IsProper());
StringInferenceTestUtilities.TestProbability(caseInvariantDist, 1.0 / 8.0, "0aBC", "0abc", "0Abc");
StringInferenceTestUtilities.TestProbability(caseInvariantDist, 0.0, "0aB", string.Empty);
}
public void PointMassToUniform()
{
var dist = StringDistribution.String("1337");
Assert.False(dist.IsUniform());
dist.SetToUniform();
Assert.True(dist.IsUniform());
}
public void ZeroDetectionWithDeadSelfLoop()
{
StringAutomaton f = StringAutomaton.Zero();
f.Start.AddSelfTransition('x', Weight.Zero);
f.Start.AddTransition('y', Weight.Zero).EndWeight = Weight.One;
Assert.True(f.IsZero());
}
public void Empty()
{
var empty = StringDistribution.Empty();
StringInferenceTestUtilities.TestProbability(empty, 1.0, string.Empty);
StringInferenceTestUtilities.TestProbability(empty, 0.0, "something");
Assert.True(empty.IsPointMass);
Assert.Equal(string.Empty, empty.Point);
}
public void ZeroDetectionWithEpsilonLoop2()
{
StringAutomaton f = StringAutomaton.Zero();
AddEpsilonLoop(f.Start, 5, 2.0);
f.Start.AddTransition('a', Weight.One);
Assert.False(f.IsCanonicZero());
Assert.True(f.IsZero());
}
public void PointMassDetection()
{
StringDistribution s1 = StringDistribution.OneOf("hello", "world", "people");
StringDistribution s2 = StringDistribution.OneOf("greetings", "people", "animals");
StringDistribution point1 = s1.Product(s2);
Assert.True(point1.IsPointMass);
Assert.Equal("people", point1.Point);
StringDistribution point2 = StringDistribution.OneOf(new Dictionary <string, double> {
{ "a", 3.0 }, { "b", 0.0 }
});
Assert.True(point2.IsPointMass);
Assert.Equal("a", point2.Point);
StringDistribution point3 = StringDistribution.CaseInvariant("123");
Assert.True(point3.IsPointMass);
Assert.Equal("123", point3.Point);
StringDistribution point4 = StringDistribution.Char('Z');
Assert.True(point4.IsPointMass);
Assert.Equal("Z", point4.Point);
StringDistribution point5 = StringDistribution.OneOf(1.0, StringDistribution.String("!"), 0.0, StringDistribution.Any());
Assert.True(point5.IsPointMass);
Assert.Equal("!", point5.Point);
StringDistribution point6 = StringDistribution.Repeat('@', minTimes: 3, maxTimes: 3);
Assert.True(point6.IsPointMass);
Assert.Equal("@@@", point6.Point);
StringDistribution point7 = StringDistribution.String("hello").Append(StringDistribution.String(" world"));
Assert.True(point7.IsPointMass);
Assert.Equal("hello world", point7.Point);
string point = string.Empty;
StringAutomaton point8Automaton = StringAutomaton.Empty();
for (int i = 0; i < 22; ++i)
{
const string PointElement = "a";
point8Automaton.AppendInPlace(StringAutomaton.ConstantOn(1.0, PointElement, PointElement));
point += PointElement;
}
StringDistribution point8 = StringDistribution.FromWeightFunction(point8Automaton);
Assert.True(point8.IsPointMass);
Assert.Equal(point, point8.Point);
}
private static void CheckFunctionValues(string name, Delegate fcn, double[,] pairs, double assertTolerance)
{
Vector x = Vector.Zero(pairs.GetLength(1) - 1);
object[] args = new object[x.Count];
for (int i = 0; i < pairs.GetLength(0); i++)
{
for (int k = 0; k < x.Count; k++)
{
x[k] = pairs[i, k];
args[k] = x[k];
}
bool showTiming = false;
if (showTiming)
{
Stopwatch watch = Stopwatch.StartNew();
int repetitionCount = 100000;
for (int repetition = 0; repetition < repetitionCount; repetition++)
{
Util.DynamicInvoke(fcn, args);
}
watch.Stop();
Trace.WriteLine($" ({watch.ElapsedTicks} ticks for {repetitionCount} calls)");
}
double fx = pairs[i, x.Count];
double result = (double)Util.DynamicInvoke(fcn, args);
if (!double.IsNaN(result) && System.Math.Sign(result) != System.Math.Sign(fx) && fx != 0 && result != 0)
{
string strMsg = $"{name}({x:g17})\t has wrong sign (result = {result:g17})";
Trace.WriteLine(strMsg);
Assert.True(false, strMsg);
}
double err = MMath.AbsDiff(result, fx, 1e14 * double.Epsilon);
if (Double.IsInfinity(fx))
{
err = (result == fx) ? 0 : Double.PositiveInfinity;
}
if (Double.IsNaN(fx))
{
err = Double.IsNaN(result) ? 0 : Double.NaN;
}
if (!IsErrorSignificant(TOLERANCE, err))
{
Trace.WriteLine($"{name}({x:g17})\t ok");
}
else
{
string strMsg = $"{name}({x:g17})\t wrong by {err.ToString("g2")} (result = {result:g17})";
Trace.WriteLine(strMsg);
if (IsErrorSignificant(assertTolerance, err) || double.IsNaN(err))
{
Assert.True(false, strMsg);
}
}
}
}
/// <summary>
/// Tests if a transducer projects each of given strings to a zero function.
/// </summary>
/// <param name="transducer">The transducer.</param>
/// <param name="strings">The strings to test.</param>
public static void TestIfTransducerRejects(StringTransducer transducer, params string[] strings)
{
foreach (string str in strings)
{
var res = transducer.ProjectSource(StringAutomaton.ConstantOn(1.0, str));
Assert.True(res.IsZero());
var res2 = transducer.ProjectSource(str);
Assert.True(res2.IsZero());
}
}
public void NormalCdfTest()
{
/* In python mpmath:
* from mpmath import *
* mp.dps = 500
* mp.pretty = True
* ncdf(-12.2)
*/
// In wolfram alpha: (not always accurate)
// http://www.wolframalpha.com/input/?i=erfc%2813%2Fsqrt%282%29%29%2F2
// In xcas: (not always accurate)
// Digits := 30
// phi(x) := evalf(erfc(-x/sqrt(2))/2);
double[,] normcdf_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdf.csv"));
CheckFunctionValues("NormalCdf", new MathFcn(MMath.NormalCdf), normcdf_pairs);
Assert.Equal(0.5, MMath.NormalCdf(0));
Assert.True(MMath.NormalCdf(7.9) <= 1);
Assert.True(MMath.NormalCdf(-40) >= 0);
Assert.True(MMath.NormalCdf(-80) >= 0);
double[,] erfc_pairs = new double[normcdf_pairs.GetLength(0), normcdf_pairs.GetLength(1)];
for (int i = 0; i < normcdf_pairs.GetLength(0); i++)
{
double input = normcdf_pairs[i, 0];
double output = normcdf_pairs[i, 1];
erfc_pairs[i, 0] = -input / MMath.Sqrt2;
erfc_pairs[i, 1] = 2 * output;
}
CheckFunctionValues("Erfc", new MathFcn(MMath.Erfc), erfc_pairs);
double[,] normcdfinv_pairs = new double[normcdf_pairs.GetLength(0), 2];
for (int i = 0; i < normcdfinv_pairs.GetLength(0); i++)
{
double input = normcdf_pairs[i, 0];
double output = normcdf_pairs[i, 1];
if (!(Double.IsPositiveInfinity(input) || Double.IsNegativeInfinity(input)) && (input <= -10 || input >= 6))
{
normcdfinv_pairs[i, 0] = 0.5;
normcdfinv_pairs[i, 1] = 0;
}
else
{
normcdfinv_pairs[i, 0] = output;
normcdfinv_pairs[i, 1] = input;
}
}
CheckFunctionValues("NormalCdfInv", new MathFcn(MMath.NormalCdfInv), normcdfinv_pairs);
double[,] normcdfln_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdfLn.csv"));
CheckFunctionValues("NormalCdfLn", new MathFcn(MMath.NormalCdfLn), normcdfln_pairs);
double[,] normcdflogit_pairs = ReadPairs(Path.Combine(TestUtils.DataFolderPath, "SpecialFunctionsValues", "NormalCdfLogit.csv"));
CheckFunctionValues("NormalCdfLogit", new MathFcn(MMath.NormalCdfLogit), normcdflogit_pairs);
}
public void DigammaInvTest()
{
for (int i = 0; i < 1000; i++)
{
double y = -3 + i * 0.01;
double x = MMath.DigammaInv(y);
double y2 = MMath.Digamma(x);
double error = MMath.AbsDiff(y, y2, 1e-8);
Assert.True(error < 1e-8);
}
}
public void LogisticGaussianTest2()
{
for (int i = 4; i < 100; i++)
{
double v = System.Math.Pow(10, i);
double f = MMath.LogisticGaussian(1, v);
double err = System.Math.Abs(f - 0.5);
//Console.WriteLine("{0}: {1} {2}", i, f, err);
Assert.True(err < 2e-2 / i);
}
}
/// <summary>
/// Tests whether the support of a given distribution includes or excludes given values.
/// </summary>
/// <param name="distribution">The distribution.</param>
/// <param name="values">The values to test.</param>
/// <param name="testInclusion">Specifies whether the inclusion test must be performed instead of the exclusion test.</param>
private static void TestInclusionExclusion <T>(IDistribution <T> distribution, T[] values, bool testInclusion)
{
Console.WriteLine("Testing distribution: " + distribution.ToString());
foreach (var val in values)
{
var excluded = double.IsNegativeInfinity(distribution.GetLogProb(val));
var msg = val + (excluded ? " was not in " : " was in ");
Assert.True(excluded != testInclusion, msg + " " + distribution.ToString());
Console.WriteLine(msg + "distribution");
}
}
public void AsAutomatonCompression()
{
var normalizedAutomaton = StringDictionaryWeightFunction.FromValues(NormalizedComplexDistributionTable).AsAutomaton();
Assert.True(normalizedAutomaton.IsDeterministic());
Assert.True(normalizedAutomaton.States.Count <= 23);
var nonNormalizedAutomaton = StringDictionaryWeightFunction.FromValues(NonNormalizedComplexDistributionTable).AsAutomaton();
Assert.True(nonNormalizedAutomaton.IsDeterministic());
Assert.True(nonNormalizedAutomaton.States.Count <= 31);
}
public void WeightedAverageTest()
{
Assert.Equal(Environment.Is64BitProcess ? 3.86361619394904E-311 : 3.86361619394162E-311, MMath.WeightedAverage(0.82912896852490248, 2.5484859206000203E-311, 3.50752234977395E-313, 31.087830618727477));
Assert.Equal(MMath.WeightedAverage(0.1, double.MinValue, 0.01, double.MinValue), double.MinValue);
Assert.Equal(MMath.WeightedAverage(0.1, -double.Epsilon, double.MaxValue, -double.Epsilon), -double.Epsilon);
Assert.Equal(MMath.WeightedAverage(1e-100, 2e-250, 1e-100, 4e-250), MMath.Average(2e-250, 4e-250));
Assert.Equal(MMath.WeightedAverage(1e100, 2e250, 1e100, 4e250), MMath.Average(2e250, 4e250));
Assert.Equal(MMath.WeightedAverage(0, 0, 0.1, -double.Epsilon), -double.Epsilon);
Assert.Equal(MMath.WeightedAverage(0.1, -double.Epsilon, 0, double.NegativeInfinity), -double.Epsilon);
Assert.False(double.IsNaN(MMath.WeightedAverage(1.7976931348623157E+308, double.NegativeInfinity, 4.94065645841247E-324, double.NegativeInfinity)));
Assert.False(double.IsNaN(MMath.WeightedAverage(0.01, double.NegativeInfinity, double.MaxValue, double.MaxValue)));
Assert.False(double.IsNaN(MMath.WeightedAverage(0.01, double.NegativeInfinity, double.Epsilon, double.NegativeInfinity)));
Assert.Equal(double.MaxValue, MMath.WeightedAverage(double.MaxValue, double.MaxValue, double.MaxValue, double.MaxValue));
const int limit = 2_000_000;
int count = 0;
Parallel.ForEach(OperatorTests.DoublesAtLeastZero(), wa =>
{
Parallel.ForEach(OperatorTests.DoublesAtLeastZero(), wb =>
{
if (count > limit)
{
return;
}
Trace.WriteLine($"wa = {wa}, wb = {wb}");
foreach (var a in OperatorTests.Doubles())
{
if (count > limit)
{
break;
}
foreach (var b in OperatorTests.Doubles())
{
if (count > limit)
{
break;
}
if (double.IsNaN(a + b))
{
continue;
}
double midpoint = MMath.WeightedAverage(wa, a, wb, b);
Assert.True(midpoint >= System.Math.Min(a, b), $"Failed assertion: MMath.WeightedAverage({wa:r}, {a:r}, {wb:r}, {b:r}) {midpoint} >= {System.Math.Min(a, b)}");
Assert.True(midpoint <= System.Math.Max(a, b), $"Failed assertion: MMath.WeightedAverage({wa:r}, {a:r}, {wb:r}, {b:r}) {midpoint} <= {System.Math.Max(a, b)}");
if (wa == wb)
{
Assert.Equal(MMath.Average(a, b), midpoint);
}
Interlocked.Add(ref count, 1);
}
}
});
});
}
public void NormalizeWithInfiniteEpsilon1()
{
StringAutomaton automaton = StringAutomaton.Zero();
automaton.Start.AddTransition('a', Weight.One).AddSelfTransition(null, Weight.FromValue(3)).EndWeight = Weight.One;
// The automaton takes an infinite value on "a", and yet the normalization must work
Assert.True(automaton.TryNormalizeValues());
StringInferenceTestUtilities.TestValue(automaton, 1, "a");
StringInferenceTestUtilities.TestValue(automaton, 0, "b");
}
public void WeightedAverageTest()
{
Assert.Equal(MMath.WeightedAverage(0.1, double.MinValue, 0.01, double.MinValue), double.MinValue);
Assert.Equal(MMath.WeightedAverage(0.1, -double.Epsilon, double.MaxValue, -double.Epsilon), -double.Epsilon);
Assert.Equal(MMath.WeightedAverage(1e-100, 2e-250, 1e-100, 4e-250), MMath.Average(2e-250, 4e-250));
Assert.Equal(MMath.WeightedAverage(1e100, 2e250, 1e100, 4e250), MMath.Average(2e250, 4e250));
Assert.Equal(MMath.WeightedAverage(0, 0, 0.1, -double.Epsilon), -double.Epsilon);
Assert.Equal(MMath.WeightedAverage(0.1, -double.Epsilon, 0, double.NegativeInfinity), -double.Epsilon);
Assert.False(double.IsNaN(MMath.WeightedAverage(1.7976931348623157E+308, double.NegativeInfinity, 4.94065645841247E-324, double.NegativeInfinity)));
Assert.False(double.IsNaN(MMath.WeightedAverage(0.01, double.NegativeInfinity, double.MaxValue, double.MaxValue)));
Assert.False(double.IsNaN(MMath.WeightedAverage(0.01, double.NegativeInfinity, double.Epsilon, double.NegativeInfinity)));
Assert.Equal(double.MaxValue, MMath.WeightedAverage(double.MaxValue, double.MaxValue, double.MaxValue, double.MaxValue));
const int limit = 2_000_000;
int count = 0;
Parallel.ForEach(OperatorTests.DoublesAtLeastZero(), wa =>
{
Parallel.ForEach(OperatorTests.DoublesAtLeastZero(), wb =>
{
if (count > limit)
{
return;
}
Trace.WriteLine($"wa = {wa}, wb = {wb}");
foreach (var a in OperatorTests.Doubles())
{
if (count > limit)
{
break;
}
foreach (var b in OperatorTests.Doubles())
{
if (count > limit)
{
break;
}
if (double.IsNaN(a + b))
{
continue;
}
double midpoint = MMath.WeightedAverage(wa, a, wb, b);
Assert.True(midpoint >= System.Math.Min(a, b), $"Failed assertion: {midpoint} >= {System.Math.Min(a, b)}, wa={wa:r}, a={a:r}, wb={wb:r}, b={b:r}");
Assert.True(midpoint <= System.Math.Max(a, b), $"Failed assertion: {midpoint} <= {System.Math.Max(a, b)}, wa={wa:r}, a={a:r}, wb={wb:r}, b={b:r}");
if (wa == wb)
{
Assert.Equal(MMath.Average(a, b), midpoint);
}
Interlocked.Add(ref count, 1);
}
}
});
});
}
public void NormalizeWithInfiniteEpsilon2()
{
StringAutomaton automaton = StringAutomaton.Zero();
automaton.Start.AddTransition('a', Weight.One).AddSelfTransition(null, Weight.FromValue(2)).EndWeight = Weight.One;
automaton.Start.AddTransition('b', Weight.One).AddSelfTransition(null, Weight.FromValue(1)).EndWeight = Weight.One;
// "a" branch infinitely dominates over the "b" branch
Assert.True(automaton.TryNormalizeValues());
StringInferenceTestUtilities.TestValue(automaton, 1, "a");
Assert.True(automaton.GetValue("b") < 1e-50);
}
/// <summary>
/// Tests whether the product of given distributions is equal to another distribution on a specified strings.
/// </summary>
/// <param name="argument1">The first argument of the product.</param>
/// <param name="argument2">The second argument of the product.</param>
/// <param name="trueProduct">The true product.</param>
/// <param name="stringsToCheckOn">The strings to test.</param>
public static void TestProduct(
StringDistribution argument1, StringDistribution argument2, StringDistribution trueProduct, params string[] stringsToCheckOn)
{
var product = new StringDistribution();
double productLogNormalizer = product.SetToProductAndReturnLogNormalizer(argument1, argument2);
double logAverageOf = argument1.GetLogAverageOf(argument2);
Assert.Equal(productLogNormalizer, logAverageOf);
Assert.Equal(logAverageOf, Clone(argument1).GetLogAverageOf(argument2));
if (trueProduct.IsZero())
{
Assert.True(product.IsZero());
Assert.True(double.IsNegativeInfinity(productLogNormalizer));
}
else if (trueProduct.IsPointMass)
{
Assert.True(product.IsPointMass);
Assert.Equal(product.Point, trueProduct.Point);
}
else if (trueProduct.IsUniform())
{
Assert.True(product.IsUniform());
}
else
{
Assert.False(product.IsZero());
Assert.False(product.IsPointMass);
Assert.False(product.IsUniform());
Assert.Equal(trueProduct.IsProper(), product.IsProper());
foreach (var str in stringsToCheckOn)
{
double logProb1 = argument1.GetLogProb(str);
double logProb2 = argument2.GetLogProb(str);
double logProbProduct = trueProduct.GetLogProb(str);
if (double.IsNegativeInfinity(logProb1) || double.IsNegativeInfinity(logProb2))
{
Assert.True(double.IsNegativeInfinity(logProbProduct));
}
else if (double.IsNegativeInfinity(logProbProduct))
{
Assert.True(double.IsNegativeInfinity(logProb1) || double.IsNegativeInfinity(logProb2));
}
else
{
Assert.Equal(logProb1 + logProb2, logProbProduct + productLogNormalizer, LogValueEps);
}
}
}
}
public void Uniform()
{
var unif1 = StringDistribution.Any();
var unif2 = StringDistribution.Uniform();
Assert.True(unif1.IsUniform());
Assert.True(unif2.IsUniform());
Assert.False(unif1.IsProper());
Assert.False(unif2.IsProper());
StringInferenceTestUtilities.TestProbability(unif1, 1.0, "hello", string.Empty);
StringInferenceTestUtilities.TestProbability(unif2, 1.0, "hello", string.Empty);
}