public void SpearmanNullDistributionTest()
{
// Pick independent distributions for x and y, which needn't be normal and needn't be related.
ContinuousDistribution xDistrubtion = new UniformDistribution();
ContinuousDistribution yDistribution = new CauchyDistribution();
Random rng = new Random(1);
// Generate bivariate samples of various sizes
foreach (int n in TestUtilities.GenerateIntegerValues(4, 64, 8))
{
Sample testStatistics = new Sample();
ContinuousDistribution testDistribution = null;
for (int i = 0; i < 128; i++)
{
BivariateSample sample = new BivariateSample();
for (int j = 0; j < n; j++)
{
sample.Add(xDistrubtion.GetRandomValue(rng), yDistribution.GetRandomValue(rng));
}
TestResult result = sample.SpearmanRhoTest();
testStatistics.Add(result.Statistic);
testDistribution = result.Distribution;
}
TestResult r2 = testStatistics.KolmogorovSmirnovTest(testDistribution);
Assert.IsTrue(r2.Probability > 0.05);
Assert.IsTrue(testStatistics.PopulationMean.ConfidenceInterval(0.99).ClosedContains(testDistribution.Mean));
Assert.IsTrue(testStatistics.PopulationVariance.ConfidenceInterval(0.99).ClosedContains(testDistribution.Variance));
}
}
private static void AddRows(FrameTable table, IReadOnlyList <string> names, string sex, double meanHeight, double stddevHeight, double meanBmi, double stddevBmi, int flag, Random rng)
{
NormalDistribution gauss = new NormalDistribution();
UniformDistribution ages = new UniformDistribution(Interval.FromEndpoints(15.0, 75.0));
foreach (string name in names)
{
double zHeight = gauss.GetRandomValue(rng);
double height = meanHeight + stddevHeight * zHeight;
double zBmi = gauss.GetRandomValue(rng);
double bmi = meanBmi + stddevBmi * zBmi;
double weight = MoreMath.Sqr(height / 100.0) * bmi;
double t = -0.4 + 0.6 * zBmi + 0.8 * flag;
double p = 1.0 / (1.0 + Math.Exp(-t));
bool r = rng.NextDouble() < p;
int id = table.Rows.Count;
TimeSpan age = TimeSpan.FromDays(365.24 * ages.GetRandomValue(rng));
DateTime birthdate = (DateTime.Now - age).Date;
table.AddRow(id, name, sex, birthdate, height, weight, r);
}
}
public void MultivariateMoments()
{
// create a random sample
MultivariateSample M = new MultivariateSample(3);
ContinuousDistribution d0 = new NormalDistribution();
ContinuousDistribution d1 = new ExponentialDistribution();
ContinuousDistribution d2 = new UniformDistribution();
Random rng = new Random(1);
int n = 10;
for (int i = 0; i < n; i++)
{
M.Add(d0.GetRandomValue(rng), d1.GetRandomValue(rng), d2.GetRandomValue(rng));
}
// test that moments agree
for (int i = 0; i < 3; i++)
{
int[] p = new int[3];
p[i] = 1;
Assert.IsTrue(TestUtilities.IsNearlyEqual(M.Column(i).Mean, M.RawMoment(p)));
p[i] = 2;
Assert.IsTrue(TestUtilities.IsNearlyEqual(M.Column(i).Variance, M.CentralMoment(p)));
for (int j = 0; j < i; j++)
{
int[] q = new int[3];
q[i] = 1;
q[j] = 1;
Assert.IsTrue(TestUtilities.IsNearlyEqual(M.TwoColumns(i, j).Covariance, M.CentralMoment(q)));
}
}
}
public static double[] GenerateNoise(int k, string distr, double outlier)
{
double[] result = new double[k];
for (var i = 0; i < k; i++)
{
//the probability the point will be outlying
var variation = outliersProbability.GetRandomValue(rng);
//if a point will be outlying
if (variation < outlier)
{
result[i] = outliersDistribution.GetRandomValue(rng);
}
//if a point will be regular
else
{
//depending on the original error distribution we generate a value
switch (distr)
{
case "norm":
result[i] = EpsNormDistribution.GetRandomValue(rng);
break;
case "stud3":
result[i] = EpsStudDistribution.GetRandomValue(rng);
break;
}
}
}
return(result);
}
public static void Mutate(Chromosome chromosome, Random random)
{
NormalDistribution normal;
UniformDistribution uniform = new UniformDistribution(Interval.FromEndpoints(0, 1));
for (int i = 0; i < chromosome.Values.Count; i++)
{
if (uniform.GetRandomValue(random) <= MUTATION_PROBABILITY)
{
if (uniform.GetRandomValue(random) <= SELECTION_PROBABILITY)
normal = new NormalDistribution(MEAN, SIGMA_1);
else
normal = new NormalDistribution(MEAN, SIGMA_2);
chromosome.Values[i] += normal.GetRandomValue(random);
}
}
}
public void TestBivariateRegression()
{
// Do a bunch of linear regressions. r^2 should be distributed as expected.
double a0 = 1.0;
double b0 = 0.0;
Random rng = new Random(1001110000);
ContinuousDistribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-2.0, 4.0));
ContinuousDistribution eDistribution = new NormalDistribution();
List <double> r2Sample = new List <double>();
for (int i = 0; i < 500; i++)
{
BivariateSample xySample = new BivariateSample();
for (int k = 0; k < 10; k++)
{
double x = xDistribution.GetRandomValue(rng);
double y = a0 + b0 * x + eDistribution.GetRandomValue(rng);
xySample.Add(x, y);
}
LinearRegressionResult fit = xySample.LinearRegression();
double a = fit.Intercept.Value;
double b = fit.Slope.Value;
r2Sample.Add(fit.RSquared);
}
ContinuousDistribution r2Distribution = new BetaDistribution((2 - 1) / 2.0, (10 - 2) / 2.0);
TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution);
Assert.IsTrue(ks.Probability > 0.05);
}
public void MultivariateLinearRegressionAgreement2()
{
// A multivariate linear regression with just one x-column should be the same as a bivariate linear regression.
double intercept = 1.0;
double slope = -2.0;
ContinuousDistribution yErrDist = new NormalDistribution(0.0, 3.0);
UniformDistribution xDist = new UniformDistribution(Interval.FromEndpoints(-2.0, 3.0));
Random rng = new Random(1111111);
MultivariateSample multi = new MultivariateSample("x", "y");
for (int i = 0; i < 10; i++)
{
double x = xDist.GetRandomValue(rng);
double y = intercept + slope * x + yErrDist.GetRandomValue(rng);
multi.Add(x, y);
}
// Old multi linear regression code.
MultiLinearRegressionResult result1 = multi.LinearRegression(1);
// Simple linear regression code.
LinearRegressionResult result2 = multi.TwoColumns(0, 1).LinearRegression();
Assert.IsTrue(TestUtilities.IsNearlyEqual(result1.Parameters["Intercept"].Estimate, result2.Parameters["Intercept"].Estimate));
// New multi linear regression code.
MultiLinearRegressionResult result3 = multi.Column(1).ToList().MultiLinearRegression(multi.Column(0).ToList());
Assert.IsTrue(TestUtilities.IsNearlyEqual(result1.Parameters["Intercept"].Estimate, result3.Parameters["Intercept"].Estimate));
}
public void MultivariateLinearRegressionSimple()
{
// define model y = a + b0 * x0 + b1 * x1 + noise
double a = 1.0;
double b0 = -2.0;
double b1 = 3.0;
ContinuousDistribution x0distribution = new CauchyDistribution(10.0, 5.0);
ContinuousDistribution x1distribution = new UniformDistribution(Interval.FromEndpoints(-10.0, 20.0));
ContinuousDistribution noise = new NormalDistribution(0.0, 10.0);
// draw a sample from the model
Random rng = new Random(1);
MultivariateSample sample = new MultivariateSample("x0", "x1", "y");
FrameTable table = new FrameTable();
table.AddColumns <double>("x0", "x1", "y");
for (int i = 0; i < 100; i++)
{
double x0 = x0distribution.GetRandomValue(rng);
double x1 = x1distribution.GetRandomValue(rng);
double eps = noise.GetRandomValue(rng);
double y = a + b0 * x0 + b1 * x1 + eps;
sample.Add(x0, x1, y);
table.AddRow(x0, x1, y);
}
// do a linear regression fit on the model
ParameterCollection oldResult = sample.LinearRegression(2).Parameters;
MultiLinearRegressionResult newResult = table["y"].As <double>().MultiLinearRegression(
table["x0"].As <double>(), table["x1"].As <double>()
);
// the result should have the appropriate dimension
Assert.IsTrue(oldResult.Count == 3);
Assert.IsTrue(newResult.Parameters.Count == 3);
// The parameters should match the model
Assert.IsTrue(oldResult[0].Estimate.ConfidenceInterval(0.90).ClosedContains(b0));
Assert.IsTrue(oldResult[1].Estimate.ConfidenceInterval(0.90).ClosedContains(b1));
Assert.IsTrue(oldResult[2].Estimate.ConfidenceInterval(0.90).ClosedContains(a));
Assert.IsTrue(newResult.CoefficientOf(0).ConfidenceInterval(0.99).ClosedContains(b0));
Assert.IsTrue(newResult.CoefficientOf("x1").ConfidenceInterval(0.99).ClosedContains(b1));
Assert.IsTrue(newResult.Intercept.ConfidenceInterval(0.99).ClosedContains(a));
// The residuals should be compatible with the model predictions
for (int i = 0; i < table.Rows.Count; i++)
{
FrameRow row = table.Rows[i];
double x0 = (double)row["x0"];
double x1 = (double)row["x1"];
double yp = newResult.Predict(x0, x1).Value;
double y = (double)row["y"];
Assert.IsTrue(TestUtilities.IsNearlyEqual(newResult.Residuals[i], y - yp));
}
}
public Chromosome(Random random, int parameterSize)
{
this.values = new List <double>(parameterSize);
UniformDistribution uniform = new UniformDistribution(Interval.FromMidpointAndWidth(MIDPOINT_RANDOM, WIDTH_RANDOM));
for (int i = 0; i < parameterSize; i++)
{
this.values.Add(uniform.GetRandomValue(random));
}
}
public static void Mutate(Chromosome chromosome, Random random)
{
NormalDistribution normal;
UniformDistribution uniform = new UniformDistribution(Interval.FromEndpoints(0, 1));
for (int i = 0; i < chromosome.Values.Count; i++)
{
if (uniform.GetRandomValue(random) <= MUTATION_PROBABILITY)
{
if (uniform.GetRandomValue(random) <= SELECTION_PROBABILITY)
{
normal = new NormalDistribution(MEAN, SIGMA_1);
}
else
{
normal = new NormalDistribution(MEAN, SIGMA_2);
}
chromosome.Values[i] += normal.GetRandomValue(random);
}
}
}
private static Chromosome SelectParent(SortedSet<Chromosome> tournament, double sumFitness, Random random)
{
UniformDistribution uniform = new UniformDistribution(Interval.FromEndpoints(0, 1));
double randomNumber = uniform.GetRandomValue(random);
double sumLength = 0;
foreach (var chromosome in tournament)
{
sumLength += chromosome.Fitness / sumFitness;
if (randomNumber < sumLength)
return chromosome;
}
return tournament.Last();
}
public void TestMultivariateRegression()
{
double cz = 1.0;
double cx = 0.0;
double cy = 0.0;
Random rng = new Random(1001110000);
Distribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-4.0, 8.0));
Distribution yDistribution = new UniformDistribution(Interval.FromEndpoints(-8.0, 4.0));
Distribution eDistribution = new NormalDistribution();
Sample r2Sample = new Sample();
for (int i = 0; i < 500; i++)
{
MultivariateSample xyzSample = new MultivariateSample(3);
for (int k = 0; k < 12; k++)
{
double x = xDistribution.GetRandomValue(rng);
double y = yDistribution.GetRandomValue(rng);
double z = cx * x + cy * y + cz + eDistribution.GetRandomValue(rng);
xyzSample.Add(x, y, z);
}
FitResult fit = xyzSample.LinearRegression(2);
double fcx = fit.Parameters[0];
double fcy = fit.Parameters[1];
double fcz = fit.Parameters[2];
double ss2 = 0.0;
double ss1 = 0.0;
foreach (double[] xyz in xyzSample)
{
ss2 += MoreMath.Sqr(xyz[2] - (fcx * xyz[0] + fcy * xyz[1] + fcz));
ss1 += MoreMath.Sqr(xyz[2] - xyzSample.Column(2).Mean);
}
double r2 = 1.0 - ss2 / ss1;
r2Sample.Add(r2);
}
Console.WriteLine("{0} {1} {2} {3} {4}", r2Sample.Count, r2Sample.PopulationMean, r2Sample.StandardDeviation, r2Sample.Minimum, r2Sample.Maximum);
Distribution r2Distribution = new BetaDistribution((3 - 1) / 2.0, (12 - 3) / 2.0);
//Distribution r2Distribution = new BetaDistribution((10 - 2) / 2.0, (2 - 1) / 2.0);
Console.WriteLine("{0} {1}", r2Distribution.Mean, r2Distribution.StandardDeviation);
TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution);
Console.WriteLine(ks.RightProbability);
Console.WriteLine(ks.Probability);
}
public static Chromosome Cross(Tuple<Chromosome, Chromosome> pair, Random random)
{
IList<double> values;
UniformDistribution uniform = new UniformDistribution(Interval.FromEndpoints(0, 1));
DiscreteUniformDistribution discrete = new DiscreteUniformDistribution(0, 1);
double randomNumber = uniform.GetRandomValue(random);
if (randomNumber <= SELECTION_1_PROBABILITY) // whole arithmetic recombination
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => (x + y) / 2).ToList();
else if (randomNumber <= SELECTION_1_PROBABILITY + SELECTION_2_PROBABILITY) // discrete recombination
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => discrete.GetRandomValue(random) == 0 ? x : y).ToList();
else // simple arithmetic recombination
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => pair.Item1.Values.IndexOf(x) < pair.Item1.Values.Count / 2 ? x : (x + y) / 2).ToList();
return new Chromosome(values);
}
private static Chromosome SelectParent(SortedSet <Chromosome> tournament, double sumFitness, Random random)
{
UniformDistribution uniform = new UniformDistribution(Interval.FromEndpoints(0, 1));
double randomNumber = uniform.GetRandomValue(random);
double sumLength = 0;
foreach (var chromosome in tournament)
{
sumLength += chromosome.Fitness / sumFitness;
if (randomNumber < sumLength)
{
return(chromosome);
}
}
return(tournament.Last());
}
public void TestBivariateRegression()
{
double a0 = 1.0;
double b0 = 0.0;
Random rng = new Random(1001110000);
Distribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-2.0, 4.0));
Distribution eDistribution = new NormalDistribution();
Sample r2Sample = new Sample();
for (int i = 0; i < 500; i++)
{
BivariateSample xySample = new BivariateSample();
for (int k = 0; k < 10; k++)
{
double x = xDistribution.GetRandomValue(rng);
double y = a0 + b0 * x + eDistribution.GetRandomValue(rng);
xySample.Add(x, y);
}
FitResult fit = xySample.LinearRegression();
double a = fit.Parameters[0];
double b = fit.Parameters[1];
double ss2 = 0.0;
double ss1 = 0.0;
foreach (XY xy in xySample)
{
ss2 += MoreMath.Sqr(xy.Y - (a + b * xy.X));
ss1 += MoreMath.Sqr(xy.Y - xySample.Y.Mean);
}
double r2 = 1.0 - ss2 / ss1;
r2Sample.Add(r2);
}
Console.WriteLine("{0} {1} {2} {3} {4}", r2Sample.Count, r2Sample.PopulationMean, r2Sample.StandardDeviation, r2Sample.Minimum, r2Sample.Maximum);
Distribution r2Distribution = new BetaDistribution((2 - 1) / 2.0, (10 - 2) / 2.0);
//Distribution r2Distribution = new BetaDistribution((10 - 2) / 2.0, (2 - 1) / 2.0);
Console.WriteLine("{0} {1}", r2Distribution.Mean, r2Distribution.StandardDeviation);
TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution);
Console.WriteLine(ks.RightProbability);
Console.WriteLine(ks.Probability);
}
public void UniformOrderStatistics()
{
// Check that the order statistics of the uniform distribution are distributed as expected.
Random rng = new Random(1);
UniformDistribution u = new UniformDistribution();
Sample maxima = new Sample();
Sample minima = new Sample();
for (int i = 0; i < 100; i++)
{
double maximum = 0.0;
double minimum = 1.0;
for (int j = 0; j < 4; j++)
{
double value = u.GetRandomValue(rng);
if (value > maximum)
{
maximum = value;
}
if (value < minimum)
{
minimum = value;
}
}
maxima.Add(maximum);
minima.Add(minimum);
}
// maxima should be distributed according to Beta(n,1)
TestResult maxTest = maxima.KolmogorovSmirnovTest(new BetaDistribution(4, 1));
Assert.IsTrue(maxTest.Probability > 0.05);
// minima should be distributed according to Beta(1,n)
TestResult minTest = minima.KolmogorovSmirnovTest(new BetaDistribution(1, 4));
Assert.IsTrue(minTest.Probability > 0.05);
}
public static Chromosome Cross(Tuple <Chromosome, Chromosome> pair, Random random)
{
IList <double> values;
UniformDistribution uniform = new UniformDistribution(Interval.FromEndpoints(0, 1));
DiscreteUniformDistribution discrete = new DiscreteUniformDistribution(0, 1);
double randomNumber = uniform.GetRandomValue(random);
if (randomNumber <= SELECTION_1_PROBABILITY) // whole arithmetic recombination
{
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => (x + y) / 2).ToList();
}
else if (randomNumber <= SELECTION_1_PROBABILITY + SELECTION_2_PROBABILITY) // discrete recombination
{
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => discrete.GetRandomValue(random) == 0 ? x : y).ToList();
}
else // simple arithmetic recombination
{
values = pair.Item1.Values.Zip(pair.Item2.Values, (x, y) => pair.Item1.Values.IndexOf(x) < pair.Item1.Values.Count / 2 ? x : (x + y) / 2).ToList();
}
return(new Chromosome(values));
}
public void TestMultivariateRegression()
{
// Collect r^2 values from multivariate linear regressions.
double cz = 1.0;
double cx = 0.0;
double cy = 0.0;
Random rng = new Random(1001110000);
ContinuousDistribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-4.0, 8.0));
ContinuousDistribution yDistribution = new UniformDistribution(Interval.FromEndpoints(-8.0, 4.0));
ContinuousDistribution eDistribution = new NormalDistribution();
List <double> r2Sample = new List <double>();
for (int i = 0; i < 500; i++)
{
MultivariateSample xyzSample = new MultivariateSample(3);
for (int k = 0; k < 12; k++)
{
double x = xDistribution.GetRandomValue(rng);
double y = yDistribution.GetRandomValue(rng);
double z = cx * x + cy * y + cz + eDistribution.GetRandomValue(rng);
xyzSample.Add(x, y, z);
}
MultiLinearRegressionResult fit = xyzSample.LinearRegression(2);
double fcx = fit.Parameters.ValuesVector[0];
double fcy = fit.Parameters.ValuesVector[1];
double fcz = fit.Parameters.ValuesVector[2];
r2Sample.Add(fit.RSquared);
}
// r^2 values should be distributed as expected.
ContinuousDistribution r2Distribution = new BetaDistribution((3 - 1) / 2.0, (12 - 3) / 2.0);
TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution);
Assert.IsTrue(ks.Probability > 0.05);
}
public void UniformOrderStatistics()
{
// Check that the order statistics of the uniform distribution are distributed as expected.
Random rng = new Random(1);
UniformDistribution u = new UniformDistribution();
Sample maxima = new Sample();
Sample minima = new Sample();
for (int i = 0; i < 100; i++) {
double maximum = 0.0;
double minimum = 1.0;
for (int j = 0; j < 4; j++) {
double value = u.GetRandomValue(rng);
if (value > maximum) maximum = value;
if (value < minimum) minimum = value;
}
maxima.Add(maximum);
minima.Add(minimum);
}
// maxima should be distributed according to Beta(n,1)
TestResult maxTest = maxima.KolmogorovSmirnovTest(new BetaDistribution(4, 1));
Assert.IsTrue(maxTest.LeftProbability < 0.95);
// minima should be distributed according to Beta(1,n)
TestResult minTest = minima.KolmogorovSmirnovTest(new BetaDistribution(1, 4));
Assert.IsTrue(minTest.LeftProbability < 0.95);
}
public void MultivariateLinearRegression()
{
int outputIndex = 2;
double[] c = new double[] { -1.0, 2.0, -3.0, 4.0 };
Random rng = new Random(1001110000);
UniformDistribution pointDistribution = new UniformDistribution(Interval.FromEndpoints(-4.0, 4.0));
MultivariateSample sample = new MultivariateSample(c.Length);
for (int k = 0; k < 1000; k++) {
double[] row = new double[sample.Dimension];
double z = 0.0;
for (int i = 0; i < row.Length; i++) {
if (i == outputIndex) {
z += c[i];
} else {
row[i] = pointDistribution.GetRandomValue(rng);
z += row[i] * c[i];
}
}
double ez = Math.Exp(z);
double p = ez / (1.0 + ez);
row[outputIndex] = (rng.NextDouble() < p) ? 1.0 : 0.0;
sample.Add(row);
}
FitResult result = sample.LogisticLinearRegression(outputIndex);
for (int i = 0; i < result.Dimension; i++) {
Console.WriteLine(result.Parameter(i));
Assert.IsTrue(result.Parameter(i).ConfidenceInterval(0.99).ClosedContains(c[i]));
}
}
public void BivariateLogisticRegression()
{
double[] c = new double[] { -0.1, 1.0 };
Random rng = new Random(1);
UniformDistribution pointDistribution = new UniformDistribution(Interval.FromEndpoints(-4.0, 4.0));
BivariateSample sample1 = new BivariateSample();
MultivariateSample sample2 = new MultivariateSample(2);
for (int k = 0; k < 1000; k++) {
double x = pointDistribution.GetRandomValue(rng);
double z = c[0] * x + c[1];
double ez = Math.Exp(z);
double p = ez / (1.0 + ez);
double y = (rng.NextDouble() < p) ? 1.0 : 0.0;
sample1.Add(x, y);
sample2.Add(x, y);
}
Console.WriteLine(sample1.Covariance / sample1.X.Variance / sample1.Y.Mean / (1.0 - sample1.Y.Mean));
Console.WriteLine(sample1.Covariance / sample1.X.Variance / sample1.Y.Variance);
FitResult result1 = sample1.LinearLogisticRegression();
FitResult result2 = sample2.TwoColumns(0, 1).LinearLogisticRegression();
FitResult result3 = sample2.LogisticLinearRegression(1);
for (int i = 0; i < result1.Dimension; i++) {
Console.WriteLine("{0} {1} {2}", i, result1.Parameter(i), result3.Parameter(i) );
}
}
public void MultivariateMoments()
{
// create a random sample
MultivariateSample M = new MultivariateSample(3);
Distribution d0 = new NormalDistribution();
Distribution d1 = new ExponentialDistribution();
Distribution d2 = new UniformDistribution();
Random rng = new Random(1);
int n = 10;
for (int i = 0; i < n; i++) {
M.Add(d0.GetRandomValue(rng), d1.GetRandomValue(rng), d2.GetRandomValue(rng));
}
// test that moments agree
for (int i = 0; i < 3; i++) {
int[] p = new int[3];
p[i] = 1;
Assert.IsTrue(TestUtilities.IsNearlyEqual(M.Column(i).Mean, M.Moment(p)));
p[i] = 2;
Assert.IsTrue(TestUtilities.IsNearlyEqual(M.Column(i).Variance, M.MomentAboutMean(p)));
for (int j = 0; j < i; j++) {
int[] q = new int[3];
q[i] = 1;
q[j] = 1;
Assert.IsTrue(TestUtilities.IsNearlyEqual(M.TwoColumns(i, j).Covariance, M.MomentAboutMean(q)));
}
}
}
public void SpearmanNullDistributionTest()
{
// pick independent distributions for x and y, which needn't be normal and needn't be related
Distribution xDistrubtion = new UniformDistribution();
Distribution yDistribution = new CauchyDistribution();
Random rng = new Random(1);
// generate bivariate samples of various sizes
foreach (int n in TestUtilities.GenerateIntegerValues(4, 64, 8)) {
Sample testStatistics = new Sample();
Distribution testDistribution = null;
for (int i = 0; i < 128; i++) {
BivariateSample sample = new BivariateSample();
for (int j = 0; j < n; j++) {
sample.Add(xDistrubtion.GetRandomValue(rng), yDistribution.GetRandomValue(rng));
}
TestResult result = sample.SpearmanRhoTest();
testStatistics.Add(result.Statistic);
testDistribution = result.Distribution;
}
TestResult r2 = testStatistics.KuiperTest(testDistribution);
Console.WriteLine("n={0} P={1}", n, r2.LeftProbability);
Assert.IsTrue(r2.RightProbability > 0.05);
Assert.IsTrue(testStatistics.PopulationMean.ConfidenceInterval(0.99).ClosedContains(testDistribution.Mean));
Assert.IsTrue(testStatistics.PopulationVariance.ConfidenceInterval(0.99).ClosedContains(testDistribution.Variance));
}
}