public void NormalFitCovariances()
{
NormalDistribution N = new NormalDistribution(-1.0, 2.0);
// Create a bivariate sample to hold our fitted best mu and sigma values
// so we can determine their covariance as well as their means and variances
BivariateSample parameters = new BivariateSample();
MultivariateSample covariances = new MultivariateSample(3);
// A bunch of times, create a normal sample
for (int i = 0; i < 128; i++)
{
// We use small samples so the variation in mu and sigma will be more substantial.
Sample s = TestUtilities.CreateSample(N, 8, i);
// Fit each sample to a normal distribution
NormalFitResult fit = NormalDistribution.FitToSample(s);
// and record the mu and sigma values from the fit into our bivariate sample
parameters.Add(fit.Mean.Value, fit.StandardDeviation.Value);
// also record the claimed covariances among these parameters
covariances.Add(fit.Parameters.CovarianceMatrix[0, 0], fit.Parameters.CovarianceMatrix[1, 1], fit.Parameters.CovarianceMatrix[0, 1]);
}
// the mean fit values should agree with the population distribution
Assert.IsTrue(parameters.X.PopulationMean.ConfidenceInterval(0.95).ClosedContains(N.Mean));
Assert.IsTrue(parameters.Y.PopulationMean.ConfidenceInterval(0.95).ClosedContains(N.StandardDeviation));
// but also the covariances of those fit values should agree with the claimed covariances
Assert.IsTrue(parameters.X.PopulationVariance.ConfidenceInterval(0.95).ClosedContains(covariances.Column(0).Mean));
Assert.IsTrue(parameters.Y.PopulationVariance.ConfidenceInterval(0.95).ClosedContains(covariances.Column(1).Mean));
Assert.IsTrue(parameters.PopulationCovariance.ConfidenceInterval(0.95).ClosedContains(covariances.Column(2).Mean));
}
public void ShapiroFranciaNullDistribution()
{
Random rng = new Random(57721);
foreach (int n in TestUtilities.GenerateIntegerValues(16, 128, 4))
{
Sample vSample = new Sample();
ContinuousDistribution vDistribution = null;
NormalDistribution zDistribution = new NormalDistribution(-2.0, 3.0);
for (int i = 0; i < 256; i++)
{
Sample zSample = TestUtilities.CreateSample(zDistribution, n, i);
TestResult sf = zSample.ShapiroFranciaTest();
vSample.Add(sf.Statistic);
vDistribution = sf.Distribution;
}
TestResult ks = vSample.KolmogorovSmirnovTest(vDistribution);
Assert.IsTrue(ks.Probability > 0.01);
// The returned SF null distribution is approximate, so we can't
// make arbitrarily stringent P demands for arbitrarily large samples.
}
}
public void DistributionRandomDeviates()
{
// Check that random deviates generated match distribution
foreach (ContinuousDistribution distribution in distributions)
{
Console.WriteLine(distribution.GetType().Name);
Sample s = TestUtilities.CreateSample(distribution, 128);
TestResult r = s.KolmogorovSmirnovTest(distribution);
Assert.IsTrue(r.Probability > 0.01);
}
}
public void DistributionRandomDeviates()
{
foreach (ContinuousDistribution distribution in distributions)
{
Console.WriteLine(distribution.GetType().Name);
Sample s = TestUtilities.CreateSample(distribution, 128);
TestResult r = s.KolmogorovSmirnovTest(distribution);
Console.WriteLine(r.LeftProbability);
Assert.IsTrue(r.LeftProbability < 0.95);
}
}
// We see a reliabile failure of KS or Kuiper tests for Beta distribution with small parameters, e.g. Beta(0.01,0.01).
// This appears to occur whether we use inverse CDF or x/(x+y) to generate beta deviates.
// Perhaps it indicates a problem with P computation for beta in this region?
private static List <ContinuousDistribution> CreateDistributions()
{
List <ContinuousDistribution> distributions = new List <ContinuousDistribution>(new ContinuousDistribution[] {
new NoncentralChiSquaredDistribution(2, 3.0),
new CauchyDistribution(1.0, 2.0),
new UniformDistribution(Interval.FromEndpoints(-2.0, 1.0)), new UniformDistribution(Interval.FromEndpoints(7.0, 9.0)),
new NormalDistribution(3.0, 2.0),
new ExponentialDistribution(2.0),
new ChiSquaredDistribution(3),
new StudentDistribution(5),
new LognormalDistribution(0.2, 0.4),
new WeibullDistribution(2.0, 3.0),
new LogisticDistribution(-4.0, 5.0),
new FisherDistribution(4.0, 7.0),
new KuiperDistribution(),
new KolmogorovDistribution(),
new TriangularDistribution(1.0, 2.0, 4.0),
new BetaDistribution(0.5, 0.5), new BetaDistribution(0.5, 2.0), new BetaDistribution(2.0, 2.0),
new ParetoDistribution(1.0, 3.0),
new WaldDistribution(3.0, 1.0),
new PearsonRDistribution(7),
new GammaDistribution(0.8), new GammaDistribution(3.0, 5.0), new GammaDistribution(96.2),
new GumbelDistribution(1.2, 2.3),
new LaplaceDistribution(4.5, 6.0),
new ChiDistribution(1), new ChiDistribution(4),
new RayleighDistribution(3.0),
new FrechetDistribution(2.9, 4.0),
new NoncentralChiSquaredDistribution(2, 1.5),
new TestDistribution()
});
// Add some distributions that come from tests.
Sample small = TestUtilities.CreateSample(distributions[0], 7);
Sample large = TestUtilities.CreateSample(distributions[1], 127);
distributions.Add(small.KolmogorovSmirnovTest(distributions[2]).Statistic.Distribution);
distributions.Add(large.KolmogorovSmirnovTest(distributions[3]).Statistic.Distribution);
//distributions.Add(small.KuiperTest(distributions[4]).Distribution);
//distributions.Add(large.KuiperTest(distributions[5]).Distribution);
//distributions.Add(Sample.MannWhitneyTest(small, large).Distribution);
BivariateSample two = new BivariateSample();
two.Add(new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }, new double[] { 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 });
//distributions.Add(two.SpearmanRhoTest().Distribution);
//distributions.Add(two.KendallTauTest().Distribution);
return(distributions);
}
public void TwoSampleKolmogorovNullDistributionTest()
{
ContinuousDistribution population = new ExponentialDistribution();
int[] sizes = new int[] { 23, 30, 175 };
foreach (int na in sizes)
{
foreach (int nb in sizes)
{
Console.WriteLine("{0} {1}", na, nb);
Sample d = new Sample();
ContinuousDistribution nullDistribution = null;
for (int i = 0; i < 128; i++)
{
Sample a = TestUtilities.CreateSample(population, na, 31415 + na + i);
Sample b = TestUtilities.CreateSample(population, nb, 27182 + nb + i);
TestResult r = Sample.KolmogorovSmirnovTest(a, b);
d.Add(r.Statistic);
nullDistribution = r.Distribution;
}
// Only do full KS test if the number of bins is larger than the sample size, otherwise we are going to fail
// because the KS test detects the granularity of the distribution
TestResult mr = d.KolmogorovSmirnovTest(nullDistribution);
Console.WriteLine(mr.LeftProbability);
if (AdvancedIntegerMath.LCM(na, nb) > d.Count)
{
Assert.IsTrue(mr.LeftProbability < 0.99);
}
// But always test that mean and standard deviation are as expected
Console.WriteLine("{0} {1}", nullDistribution.Mean, d.PopulationMean.ConfidenceInterval(0.99));
Assert.IsTrue(d.PopulationMean.ConfidenceInterval(0.99).ClosedContains(nullDistribution.Mean));
Console.WriteLine("{0} {1}", nullDistribution.StandardDeviation, d.PopulationStandardDeviation.ConfidenceInterval(0.99));
Assert.IsTrue(d.PopulationStandardDeviation.ConfidenceInterval(0.99).ClosedContains(nullDistribution.StandardDeviation));
Console.WriteLine("{0} {1}", nullDistribution.CentralMoment(3), d.PopulationCentralMoment(3).ConfidenceInterval(0.99));
//Assert.IsTrue(d.PopulationMomentAboutMean(3).ConfidenceInterval(0.99).ClosedContains(nullDistribution.MomentAboutMean(3)));
//Console.WriteLine("m {0} {1}", nullDistribution.Mean, d.PopulationMean);
}
}
}
public void KuiperNullDistributionTest()
{
// The distribution is irrelevent; pick one at random
Distribution sampleDistribution = new NormalDistribution();
// Loop over various sample sizes
foreach (int n in TestUtilities.GenerateIntegerValues(2, 128, 16))
{
// Create a sample to hold the KS statistics
Sample testStatistics = new Sample();
// and a variable to hold the claimed null distribution, which should be the same for each test
Distribution nullDistribution = null;
// Create a bunch of samples, each with n+1 data points
// We pick n+1 instead of n just to have different sample size values than in the KS test case
for (int i = 0; i < 256; i++)
{
// Just use n+i as a seed in order to get different points each time
Sample sample = TestUtilities.CreateSample(sampleDistribution, n + 1, 512 * n + i + 2);
// Do a Kuiper test of the sample against the distribution each time
TestResult r1 = sample.KuiperTest(sampleDistribution);
// Record the test statistic value and the claimed null distribution
testStatistics.Add(r1.Statistic);
nullDistribution = r1.Distribution;
}
// Do a KS test of our sample of Kuiper statistics against the claimed null distribution
// We could use a Kuiper test here instead, which would be way cool and meta, but we picked KS instead for variety
TestResult r2 = testStatistics.KolmogorovSmirnovTest(nullDistribution);
Console.WriteLine("{0} {1} {2}", n, r2.Statistic, r2.LeftProbability);
Assert.IsTrue(r2.RightProbability > 0.01);
// Test moment matches, too
Console.WriteLine(" {0} {1}", testStatistics.PopulationMean, nullDistribution.Mean);
Console.WriteLine(" {0} {1}", testStatistics.PopulationVariance, nullDistribution.Variance);
Assert.IsTrue(testStatistics.PopulationMean.ConfidenceInterval(0.99).ClosedContains(nullDistribution.Mean));
Assert.IsTrue(testStatistics.PopulationVariance.ConfidenceInterval(0.99).ClosedContains(nullDistribution.Variance));
}
}
public void KolmogorovNullDistributionTest()
{
// The distribution is irrelevent; pick one at random
ContinuousDistribution sampleDistribution = new LognormalDistribution();
// Loop over various sample sizes
foreach (int n in TestUtilities.GenerateIntegerValues(4, 128, 8))
{
// Create a sample to hold the KS statistics
Sample testStatistics = new Sample();
// and a variable to hold the claimed null distribution, which should be the same for each test
ContinuousDistribution nullDistribution = null;
// Create a bunch of samples, each with n data points
for (int i = 0; i < 128; i++)
{
// Just use n+i as a seed in order to get different points each time
Sample sample = TestUtilities.CreateSample(sampleDistribution, n, 512 * n + i + 1);
// Do a KS test of the sample against the distribution each time
TestResult r1 = sample.KolmogorovSmirnovTest(sampleDistribution);
// Record the test statistic value and the claimed null distribution
testStatistics.Add(r1.Statistic);
nullDistribution = r1.Distribution;
}
// Do a Kuiper test of our sample of KS statistics against the claimed null distribution
// We could use a KS test here instead, which would be way cool and meta, but we picked Kuiper instead for variety
TestResult r2 = testStatistics.KuiperTest(nullDistribution);
Assert.IsTrue(r2.Probability > 0.01);
// Test moment matches, too
Assert.IsTrue(testStatistics.PopulationMean.ConfidenceInterval(0.99).ClosedContains(nullDistribution.Mean));
Assert.IsTrue(testStatistics.PopulationStandardDeviation.ConfidenceInterval(0.99).ClosedContains(nullDistribution.StandardDeviation));
}
}
