public void MaritzJarrettConfidenceIntervalWeighedTest1()
{
var random = new Random(42);
var distribution = new BetaDistribution(2, 10);
double[] data = distribution.Random(random).Next(10);
var sample1 = new Sample(data);
var sample2 = new Sample(data, new ConstantSequence(1).GenerateArray(data.Length));
var sample3 = new Sample(
data.Concat(new[] { 10.0, 10.0, 10.0 }).ToArray(),
new ConstantSequence(1).GenerateArray(data.Length).Concat(new[] { 0.0, 0.0, 0.0 }).ToArray()
);
var estimator = HarrellDavisQuantileEstimator.Instance;
var probability = Probability.Half;
var level = ConfidenceLevel.L90;
var ci1 = estimator.GetQuantileConfidenceIntervalEstimator(sample1, probability).GetConfidenceInterval(level);
var ci2 = estimator.GetQuantileConfidenceIntervalEstimator(sample2, probability).GetConfidenceInterval(level);
var ci3 = estimator.GetQuantileConfidenceIntervalEstimator(sample3, probability).GetConfidenceInterval(level);
Output.WriteLine("CI1: " + ci1.ToString("N9"));
Output.WriteLine("CI2: " + ci2.ToString("N9"));
Output.WriteLine("CI3: " + ci3.ToString("N9"));
var comparer = new AbsoluteEqualityComparer(1e-9);
Assert.True(ci1.Equals(ci2, comparer));
Assert.True(ci1.Equals(ci3, comparer));
}
public void MaritzJarrettConfidenceIntervalWeighedTest2()
{
var sample = new Sample(new[] { 1.0, 2.0, 2.5, 4.0, 5.0 }, new[] { 0.1, 0.4, 0.3, 0.5, 0.244 });
var interval = HarrellDavisQuantileEstimator.Instance
.GetQuantileConfidenceIntervalEstimator(sample, 0.5)
.GetConfidenceInterval(ConfidenceLevel.L95);
var comparer = new AbsoluteEqualityComparer(1e-6);
Assert.Equal(-0.983888521830027, interval.Lower, comparer);
Assert.Equal(7.26422828233614, interval.Upper, comparer);
}
public void MixtureExponentialTest1()
{
var exp = new ExponentialDistribution();
var mixture = new MixtureDistribution(exp, new ShiftedDistribution(exp, 10));
var comparer = new AbsoluteEqualityComparer(1e-4);
for (double p = 0; p < 1.0; p += 0.01)
{
double q = mixture.Quantile(p);
output.WriteLine($"{p.ToStringInvariant("N2")}: {q.ToStringInvariant()}");
Assert.Equal(p, mixture.Cdf(q), comparer);
}
}
public void Cdf(string testDataKey)
{
var testData = TestDataCdfMap[testDataKey];
var distribution = new NormalDistribution(testData.Mean, testData.StdDev);
var comparer = new AbsoluteEqualityComparer(1e-5);
var x = testData.X;
var expectedCdf = testData.Expected;
for (int i = 0; i < x.Length; i++)
{
double actualCdf = distribution.Cdf(x[i]);
Assert.Equal(expectedCdf[i], actualCdf, comparer);
}
}
protected void CheckSimple([NotNull] TestData testData, [NotNull] double[] actual, string kind)
{
var comparer = new AbsoluteEqualityComparer(1e-2);
DumpArray("Source ", testData.Source);
for (int i = 0; i < testData.Probabilities.Length; i++)
{
Output.WriteLine($"----- {kind} -----");
Output.WriteLine("Probability : " + testData.Probabilities[i]);
Output.WriteLine("Expected : " + testData.Expected[i]);
Output.WriteLine("Actual : " + actual[i]);
Assert.Equal(testData.Expected[i], actual[i], comparer);
}
}
public void BetaCompleteLogValue()
{
var comparer = new AbsoluteEqualityComparer(0.0000001);
for (int a = 1; a <= 20; a++)
{
for (int b = 1; b <= 20; b++)
{
double actual = BetaFunction.CompleteLogValue(a, b);
double expected = Math.Log(Factorial(a - 1) * Factorial(b - 1) / Factorial(a + b - 1));
Assert.Equal(expected, actual, comparer);
}
}
}
protected void Check([NotNull] IQuantileEstimator estimator, [NotNull] TestData testData)
{
var comparer = new AbsoluteEqualityComparer(1e-2);
DumpArray("Source ", testData.Source);
var actual = estimator.GetQuantiles(testData.Source, testData.Quantiles);
for (int i = 0; i < testData.Quantiles.Length; i++)
{
output.WriteLine("-----");
output.WriteLine("Quantile : " + testData.Quantiles[i]);
output.WriteLine("Expected : " + testData.Expected[i]);
output.WriteLine("Actual : " + actual[i]);
Assert.Equal(testData.Expected[i], actual[i], comparer);
}
}
public void GammaFunctionLogValue()
{
var comparer = new AbsoluteEqualityComparer(0.0001);
for (int i = 0; i < knownX.Length; i++)
{
double expected = Math.Log(knownY[i]);
double actual = GammaFunction.LogValue(knownX[i]);
output.WriteLine($"X = {knownX[i]}");
output.WriteLine($"Expected = {expected}");
output.WriteLine($"Actual = {actual}");
output.WriteLine("");
Assert.Equal(expected, actual, comparer);
}
}
public void HyndmanFanPartitioningHeapsQuantileEstimatorTest()
{
double[] fullSource = { 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66 };
var probabilities = Enumerable.Range(0, 101).Select(x => (Probability)(x / 100.0)).ToArray();
var types = new[]
{
HyndmanFanType.Type1, HyndmanFanType.Type2, HyndmanFanType.Type3, HyndmanFanType.Type4, HyndmanFanType.Type5,
HyndmanFanType.Type6, HyndmanFanType.Type7, HyndmanFanType.Type8, HyndmanFanType.Type9,
};
var comparer = new AbsoluteEqualityComparer(1e-2);
var shuffler = new Shuffler(new Random(42));
for (int n = 1; n <= fullSource.Length; n++)
{
double[] source = fullSource.Take(n).ToArray();
var sample = new Sample(source);
foreach (var type in types)
{
for (int i = 0; i < probabilities.Length; i++)
{
var probability = probabilities[i];
var hyEstimator = new HyndmanFanQuantileEstimator(type);
double expectedValue = hyEstimator.GetQuantile(sample, probability);
var phEstimator = new PartitioningHeapsMovingQuantileEstimator(n, probability, type);
shuffler.Shuffle(source);
foreach (double value in source)
{
phEstimator.Add(value);
}
double actualValue = phEstimator.GetQuantile();
if (!comparer.Equals(expectedValue, actualValue))
{
Output.WriteLine($"n = {n}, type = {type}, p = {probability}: E = {expectedValue}, A = {actualValue}");
}
Assert.Equal(expectedValue, actualValue, comparer);
}
}
}
}
/// <summary>
/// Base method for Cdf and Pdf tests
/// </summary>
private void Beta(double a, double b, [NotNull] double[] expected, Func <BetaDistribution, double, double> getValue)
{
var distribution = new BetaDistribution(a, b);
var comparer = new AbsoluteEqualityComparer(1e-2);
int n = expected.Length - 1;
double maxDelta = 0;
for (int i = 0; i < expected.Length; i++)
{
double x = i * 1.0 / n;
double actual = getValue(distribution, x);
output.WriteLine($"x = {x}");
output.WriteLine($"Actual = {actual}");
output.WriteLine($"Expected = {expected[i]}");
maxDelta = Math.Max(maxDelta, Math.Abs(actual - expected[i]));
Assert.Equal(expected[i], actual, comparer);
}
output.WriteLine("-----");
output.WriteLine($"MaxDelta = {maxDelta}");
}
