public void CauchyDistributionConstructorTest1()
{
CauchyDistribution target = new CauchyDistribution();
Assert.AreEqual(0, target.Location);
Assert.AreEqual(1, target.Scale);
}
public void FitTest2()
{
double[] observations = { 0.25, 0.12, 0.72, 0.21, 0.62, 0.12, 0.62, 0.12 };
{
CauchyDistribution cauchy = new CauchyDistribution();
cauchy.Fit(observations);
Assert.AreEqual(0.18383597286086659, cauchy.Location, 1e-10);
Assert.AreEqual(-0.10530822112775458, cauchy.Scale, 1e-10);
Assert.IsFalse(Double.IsNaN(cauchy.Location));
Assert.IsFalse(Double.IsNaN(cauchy.Scale));
}
{
CauchyOptions options = new CauchyOptions()
{
EstimateLocation = true,
EstimateScale = false
};
CauchyDistribution cauchy = new CauchyDistribution(location: 0, scale: 4.2);
cauchy.Fit(observations, options);
Assert.AreEqual(0.34712181102025652, cauchy.Location, 1e-4);
Assert.AreEqual(4.2, cauchy.Scale, 1e-10);
Assert.IsFalse(Double.IsNaN(cauchy.Location));
Assert.IsFalse(Double.IsNaN(cauchy.Scale));
}
}
//End of ui.cs file Contents
//-------------------------------------------------------------------------
//Begin of Random.cs file contents
/// <summary>
/// Initializes the random-number generator with a specific seed.
/// </summary>
public void Initialize(uint seed)
{
RandomNumberGenerator = new MT19937Generator(seed);
betaDist = new BetaDistribution(RandomNumberGenerator);
betaPrimeDist = new BetaPrimeDistribution(RandomNumberGenerator);
cauchyDist = new CauchyDistribution(RandomNumberGenerator);
chiDist = new ChiDistribution(RandomNumberGenerator);
chiSquareDist = new ChiSquareDistribution(RandomNumberGenerator);
continuousUniformDist = new ContinuousUniformDistribution(RandomNumberGenerator);
erlangDist = new ErlangDistribution(RandomNumberGenerator);
exponentialDist = new ExponentialDistribution(RandomNumberGenerator);
fisherSnedecorDist = new FisherSnedecorDistribution(RandomNumberGenerator);
fisherTippettDist = new FisherTippettDistribution(RandomNumberGenerator);
gammaDist = new GammaDistribution(RandomNumberGenerator);
laplaceDist = new LaplaceDistribution(RandomNumberGenerator);
lognormalDist = new LognormalDistribution(RandomNumberGenerator);
normalDist = new NormalDistribution(RandomNumberGenerator);
paretoDist = new ParetoDistribution(RandomNumberGenerator);
powerDist = new PowerDistribution(RandomNumberGenerator);
rayleighDist = new RayleighDistribution(RandomNumberGenerator);
studentsTDist = new StudentsTDistribution(RandomNumberGenerator);
triangularDist = new TriangularDistribution(RandomNumberGenerator);
weibullDist = new WeibullDistribution(RandomNumberGenerator);
poissonDist = new PoissonDistribution(RandomNumberGenerator);
// generator.randomGenerator = new MT19937Generator(seed);
}
public void BivariatePolynomialRegressionSimple()
{
// Pick a simple polynomial
Polynomial p = Polynomial.FromCoefficients(3.0, -2.0, 1.0);
// Use it to generate a data set
Random rng = new Random(1);
ContinuousDistribution xDistribution = new CauchyDistribution(1.0, 2.0);
ContinuousDistribution errorDistribution = new NormalDistribution(0.0, 3.0);
List <double> xs = new List <double>(TestUtilities.CreateDataSample(rng, xDistribution, 10));
List <double> ys = new List <double>(xs.Select(x => p.Evaluate(x) + errorDistribution.GetRandomValue(rng)));
PolynomialRegressionResult fit = Bivariate.PolynomialRegression(ys, xs, p.Degree);
// Parameters should agree
Assert.IsTrue(fit.Parameters.Count == p.Degree + 1);
for (int k = 0; k <= p.Degree; k++)
{
Assert.IsTrue(fit.Coefficient(k).ConfidenceInterval(0.99).ClosedContains(p.Coefficient(k)));
}
// Residuals should agree
Assert.IsTrue(fit.Residuals.Count == xs.Count);
for (int i = 0; i < xs.Count; i++)
{
double z = ys[i] - fit.Predict(xs[i]).Value;
Assert.IsTrue(TestUtilities.IsNearlyEqual(z, fit.Residuals[i]));
}
// Intercept is same as coefficient of x^0
Assert.IsTrue(fit.Intercept == fit.Coefficient(0));
}
public void MultivariateLinearRegressionVariances()
{
// define model y = a + b0 * x0 + b1 * x1 + noise
double a = -3.0;
double b0 = 2.0;
double b1 = -1.0;
ContinuousDistribution x0distribution = new LaplaceDistribution();
ContinuousDistribution x1distribution = new CauchyDistribution();
ContinuousDistribution eDistribution = new NormalDistribution(0.0, 4.0);
FrameTable data = new FrameTable();
data.AddColumns <double>("a", "da", "b0", "db0", "b1", "db1", "ab1Cov", "p", "dp");
// draw a sample from the model
Random rng = new Random(4);
for (int j = 0; j < 64; j++)
{
List <double> x0s = new List <double>();
List <double> x1s = new List <double>();
List <double> ys = new List <double>();
for (int i = 0; i < 16; i++)
{
double x0 = x0distribution.GetRandomValue(rng);
double x1 = x1distribution.GetRandomValue(rng);
double e = eDistribution.GetRandomValue(rng);
double y = a + b0 * x0 + b1 * x1 + e;
x0s.Add(x0);
x1s.Add(x1);
ys.Add(y);
}
// do a linear regression fit on the model
MultiLinearRegressionResult result = ys.MultiLinearRegression(
new Dictionary <string, IReadOnlyList <double> > {
{ "x0", x0s }, { "x1", x1s }
}
);
UncertainValue pp = result.Predict(-5.0, 6.0);
data.AddRow(
result.Intercept.Value, result.Intercept.Uncertainty,
result.CoefficientOf("x0").Value, result.CoefficientOf("x0").Uncertainty,
result.CoefficientOf("x1").Value, result.CoefficientOf("x1").Uncertainty,
result.Parameters.CovarianceOf("Intercept", "x1"),
pp.Value, pp.Uncertainty
);
}
// The estimated parameters should agree with the model that generated the data.
// The variances of the estimates should agree with the claimed variances
Assert.IsTrue(data["a"].As <double>().PopulationStandardDeviation().ConfidenceInterval(0.99).ClosedContains(data["da"].As <double>().Mean()));
Assert.IsTrue(data["b0"].As <double>().PopulationStandardDeviation().ConfidenceInterval(0.99).ClosedContains(data["db0"].As <double>().Mean()));
Assert.IsTrue(data["b1"].As <double>().PopulationStandardDeviation().ConfidenceInterval(0.99).ClosedContains(data["db1"].As <double>().Mean()));
Assert.IsTrue(data["a"].As <double>().PopulationCovariance(data["b1"].As <double>()).ConfidenceInterval(0.99).ClosedContains(data["ab1Cov"].As <double>().Mean()));
Assert.IsTrue(data["p"].As <double>().PopulationStandardDeviation().ConfidenceInterval(0.99).ClosedContains(data["dp"].As <double>().Median()));
}
public void LinearLogisticRegressionSimple()
{
Polynomial m = Polynomial.FromCoefficients(-1.0, 2.0);
FrameTable table = new FrameTable();
table.AddColumn <double>("x");
table.AddColumn <string>("z");
Random rng = new Random(2);
ContinuousDistribution xDistribution = new CauchyDistribution(4.0, 2.0);
for (int i = 0; i < 24; i++)
{
double x = xDistribution.GetRandomValue(rng);
double y = m.Evaluate(x);
double p = 1.0 / (1.0 + Math.Exp(-y));
bool z = (rng.NextDouble() < p);
table.AddRow(x, z.ToString());
}
LinearLogisticRegressionResult fit = table["z"].As((string s) => Boolean.Parse(s)).LinearLogisticRegression(table["x"].As <double>());
Assert.IsTrue(fit.Intercept.ConfidenceInterval(0.99).ClosedContains(m.Coefficient(0)));
Assert.IsTrue(fit.Slope.ConfidenceInterval(0.99).ClosedContains(m.Coefficient(1)));
}
public void BivariateNonlinearFitSimple()
{
double t0 = 3.0;
double s0 = 1.0;
ContinuousDistribution xDistribution = new CauchyDistribution(0.0, 2.0);
ContinuousDistribution eDistribution = new NormalDistribution(0.0, 0.5);
Random rng = new Random(5);
List <double> x = TestUtilities.CreateDataSample(rng, xDistribution, 48).ToList();
List <double> y = x.Select(z => Math.Sin(2.0 * Math.PI * z / t0 + s0) + eDistribution.GetRandomValue(rng)).ToList();
Func <IReadOnlyDictionary <string, double>, double, double> fitFunction = (d, z) => {
double t = d["Period"];
double s = d["Phase"];
return(Math.Sin(2.0 * Math.PI * z / t + s));
};
Dictionary <string, double> start = new Dictionary <string, double>()
{
{ "Period", 2.5 }, { "Phase", 1.5 }
};
NonlinearRegressionResult result = y.NonlinearRegression(x, fitFunction, start);
Assert.IsTrue(result.Parameters["Period"].Estimate.ConfidenceInterval(0.99).ClosedContains(t0));
Assert.IsTrue(result.Parameters["Phase"].Estimate.ConfidenceInterval(0.99).ClosedContains(s0));
for (int i = 0; i < x.Count; i++)
{
double yp = result.Predict(x[i]);
Assert.IsTrue(TestUtilities.IsNearlyEqual(result.Residuals[i], y[i] - yp));
}
}
public void CauchyDistributionConstructorTest2()
{
double location = 0.42;
double scale = 1.57;
CauchyDistribution cauchy = new CauchyDistribution(location, scale);
double mean = cauchy.Mean; // NaN - Cauchy's mean is undefined.
double var = cauchy.Variance; // NaN - Cauchy's variance is undefined.
double median = cauchy.Median; // 0.42
double cdf = cauchy.DistributionFunction(x: 0.27); // 0.46968025841608563
double pdf = cauchy.ProbabilityDensityFunction(x: 0.27); // 0.2009112009763413
double lpdf = cauchy.LogProbabilityDensityFunction(x: 0.27); // -1.6048922547266871
double ccdf = cauchy.ComplementaryDistributionFunction(x: 0.27); // 0.53031974158391437
double icdf = cauchy.InverseDistributionFunction(p: 0.69358638272337991); // 1.5130304686978195
double hf = cauchy.HazardFunction(x: 0.27); // 0.3788491832800277
double chf = cauchy.CumulativeHazardFunction(x: 0.27); // 0.63427516833243092
string str = cauchy.ToString(System.Globalization.CultureInfo.InvariantCulture); // "Cauchy(x; x0 = 0.42, γ = 1.57)
Assert.IsTrue(Double.IsNaN(mean));
Assert.IsTrue(Double.IsNaN(var));
Assert.AreEqual(0.42, median);
Assert.AreEqual(0.63427516833243092, chf);
Assert.AreEqual(0.46968025841608563, cdf);
Assert.AreEqual(0.2009112009763413, pdf);
Assert.AreEqual(-1.6048922547266871, lpdf);
Assert.AreEqual(0.3788491832800277, hf);
Assert.AreEqual(0.53031974158391437, ccdf);
Assert.AreEqual(1.5130304686978195, icdf);
Assert.AreEqual("Cauchy(x; x0 = 0.42, γ = 1.57)", str);
}
public void FitTest2()
{
double[] observations = { 0.25, 0.12, 0.72, 0.21, 0.62, 0.12, 0.62, 0.12 };
{
CauchyDistribution cauchy = new CauchyDistribution();
cauchy.Fit(observations);
Assert.AreEqual(0.18784819147980944, cauchy.Location, 1e-6);
Assert.AreEqual(0.14168064551279669, cauchy.Scale, 1e-6);
Assert.IsFalse(Double.IsNaN(cauchy.Location));
Assert.IsFalse(Double.IsNaN(cauchy.Scale));
}
{
CauchyOptions options = new CauchyOptions()
{
EstimateLocation = true,
EstimateScale = false
};
CauchyDistribution cauchy = new CauchyDistribution(location: 0, scale: 4.2);
cauchy.Fit(observations, options);
Assert.AreEqual(0.34712181102025652, cauchy.Location, 1e-4);
Assert.AreEqual(4.2, cauchy.Scale, 1e-10);
Assert.IsFalse(Double.IsNaN(cauchy.Location));
Assert.IsFalse(Double.IsNaN(cauchy.Scale));
}
}
public void CauchyDistributionConstructorTest1()
{
CauchyDistribution target = new CauchyDistribution();
Assert.AreEqual(0, target.Location);
Assert.AreEqual(1, target.Scale);
}
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));
}
}
protected override void EndProcessing()
{
var dist = new CauchyDistribution(Location, Scale);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public void CauchyDistributionChiSquareTest(double center, double gamma)
{
var cauchyDistribution = new CauchyDistribution(gamma, center);
var test = ChiSquareTest.Test(cauchyDistribution);
Assert.IsTrue(test);
}
public void MedianTest()
{
double location = 2;
double scale = 4;
CauchyDistribution target = new CauchyDistribution(location, scale);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5), 1e-10);
}
public void MedianTest()
{
double location = 2;
double scale = 4;
CauchyDistribution target = new CauchyDistribution(location, scale);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5), 1e-10);
}
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 void CauchyFWHM()
{
// Check that FWHM really is the full-width at half-maximum.
CauchyDistribution D = new CauchyDistribution(1.0, 2.0);
double p = D.ProbabilityDensity(D.Median);
Assert.IsTrue(TestUtilities.IsNearlyEqual(D.ProbabilityDensity(D.Median - D.FullWithAtHalfMaximum / 2.0), p / 2.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(D.ProbabilityDensity(D.Median + D.FullWithAtHalfMaximum / 2.0), p / 2.0));
}
public void BivariateAssociationDiscreteNullDistribution()
{
Random rng = new Random(1);
// Pick very non-normal distributions for our non-parameteric tests
ContinuousDistribution xd = new FrechetDistribution(1.0);
ContinuousDistribution yd = new CauchyDistribution();
// Pick small sample sizes to get exact distributions
foreach (int n in TestUtilities.GenerateIntegerValues(4, 24, 4))
{
// Do a bunch of test runs, recording reported statistic for each.
List <int> spearmanStatistics = new List <int>();
List <int> kendallStatistics = new List <int>();
DiscreteDistribution spearmanDistribution = null;
DiscreteDistribution kendallDistribution = null;
for (int i = 0; i < 512; i++)
{
List <double> x = new List <double>();
List <double> y = new List <double>();
for (int j = 0; j < n; j++)
{
x.Add(xd.GetRandomValue(rng));
y.Add(yd.GetRandomValue(rng));
}
DiscreteTestStatistic spearman = Bivariate.SpearmanRhoTest(x, y).UnderlyingStatistic;
if (spearman != null)
{
spearmanStatistics.Add(spearman.Value);
spearmanDistribution = spearman.Distribution;
}
DiscreteTestStatistic kendall = Bivariate.KendallTauTest(x, y).UnderlyingStatistic;
if (kendall != null)
{
kendallStatistics.Add(kendall.Value);
kendallDistribution = kendall.Distribution;
}
}
// Test whether statistics are actually distributed as claimed
if (spearmanDistribution != null)
{
TestResult spearmanChiSquared = spearmanStatistics.ChiSquaredTest(spearmanDistribution);
Assert.IsTrue(spearmanChiSquared.Probability > 0.01);
}
if (kendallDistribution != null)
{
TestResult kendallChiSquared = kendallStatistics.ChiSquaredTest(kendallDistribution);
Assert.IsTrue(kendallChiSquared.Probability > 0.01);
}
}
}
public void CauchyDistributionConstructorTest2()
{
double location = 0.42;
double scale = 1.57;
CauchyDistribution cauchy = new CauchyDistribution(location, scale);
double mean = cauchy.Mean; // NaN - Cauchy's mean is undefined.
double var = cauchy.Variance; // NaN - Cauchy's variance is undefined.
double median = cauchy.Median; // 0.42
double mode = cauchy.Mode; // 0.42
double cdf = cauchy.DistributionFunction(x: 0.27); // 0.46968025841608563
double pdf = cauchy.ProbabilityDensityFunction(x: 0.27); // 0.2009112009763413
double lpdf = cauchy.LogProbabilityDensityFunction(x: 0.27); // -1.6048922547266871
double ccdf = cauchy.ComplementaryDistributionFunction(x: 0.27); // 0.53031974158391437
double icdf = cauchy.InverseDistributionFunction(p: 0.69358638272337991); // 1.5130304686978195
double hf = cauchy.HazardFunction(x: 0.27); // 0.3788491832800277
double chf = cauchy.CumulativeHazardFunction(x: 0.27); // 0.63427516833243092
string str = cauchy.ToString(System.Globalization.CultureInfo.InvariantCulture); // "Cauchy(x; x0 = 0.42, γ = 1.57)
Assert.IsTrue(Double.IsNaN(mean));
Assert.IsTrue(Double.IsNaN(var));
Assert.AreEqual(0.42, median);
Assert.AreEqual(0.42, mode, 1e-6);
Assert.AreEqual(0.63427516833243092, chf);
Assert.AreEqual(0.46968025841608563, cdf);
Assert.AreEqual(0.2009112009763413, pdf);
Assert.AreEqual(-1.6048922547266871, lpdf);
Assert.AreEqual(0.3788491832800277, hf);
Assert.AreEqual(0.53031974158391437, ccdf);
Assert.AreEqual(1.5130304686978195, icdf);
Assert.AreEqual("Cauchy(x; x0 = 0.42, γ = 1.57)", str);
var range1 = cauchy.GetRange(0.95);
var range2 = cauchy.GetRange(0.99);
var range3 = cauchy.GetRange(0.01);
Assert.AreEqual(-9.4925897567183526, range1.Min, 1e-10);
Assert.AreEqual(10.332589895085842, range1.Max, 1e-10);
Assert.AreEqual(-49.538210069999685, range2.Min, 1e-10);
Assert.AreEqual(50.378210075966564, range2.Max, 1e-10);
Assert.AreEqual(-49.538210069999892, range3.Min, 1e-10);
Assert.AreEqual(50.378210075966564, range3.Max, 1e-10);
Assert.AreEqual(Double.NegativeInfinity, cauchy.Support.Min);
Assert.AreEqual(Double.PositiveInfinity, cauchy.Support.Max);
Assert.AreEqual(cauchy.InverseDistributionFunction(0), cauchy.Support.Min);
Assert.AreEqual(cauchy.InverseDistributionFunction(1), cauchy.Support.Max);
}
public void FitTest()
{
CauchyDistribution target = new CauchyDistribution();
double[] observations = samples;
target.Fit(observations);
Assert.AreEqual(4.2, target.Location, 0.3);
Assert.AreEqual(0.21, target.Scale, 0.05);
}
public void CauchyDistributionConstructorTest()
{
double location = 2;
double scale = 4;
CauchyDistribution target = new CauchyDistribution(location, scale);
Assert.AreEqual(location, target.Location);
Assert.AreEqual(scale, target.Scale);
Assert.AreEqual(location, target.Median);
Assert.AreEqual(location, target.Mode);
Assert.IsTrue(Double.IsNaN(target.Mean));
Assert.IsTrue(Double.IsNaN(target.Variance));
Assert.AreEqual(Math.Log(scale) + Math.Log(4.0 * Math.PI), target.Entropy);
}
public void CauchyDistributionConstructorTest()
{
double location = 2;
double scale = 4;
CauchyDistribution target = new CauchyDistribution(location, scale);
Assert.AreEqual(location, target.Location);
Assert.AreEqual(scale, target.Scale);
Assert.AreEqual(location, target.Median);
Assert.AreEqual(location, target.Mode);
Assert.IsTrue(Double.IsNaN(target.Mean));
Assert.IsTrue(Double.IsNaN(target.Variance));
Assert.AreEqual(Math.Log(scale) + Math.Log(4.0 * Math.PI), target.Entropy);
}
public void BivariateNullAssociation()
{
Random rng = new Random(31415926);
// Create a data structure to hold the results of Pearson, Spearman, and Kendall tests.
FrameTable data = new FrameTable();
data.AddColumn <double>("r");
data.AddColumn <double>("ρ");
data.AddColumn <double>("τ");
// Create variables to hold the claimed distribution of each test statistic.
ContinuousDistribution PRD = null;
ContinuousDistribution SRD = null;
ContinuousDistribution KTD = null;
// Generate a large number of bivariate samples and conduct our three tests on each.
ContinuousDistribution xDistribution = new LognormalDistribution();
ContinuousDistribution yDistribution = new CauchyDistribution();
for (int j = 0; j < 100; j++)
{
List <double> x = new List <double>();
List <double> y = new List <double>();
for (int i = 0; i < 100; i++)
{
x.Add(xDistribution.GetRandomValue(rng));
y.Add(yDistribution.GetRandomValue(rng));
}
TestResult PR = Bivariate.PearsonRTest(x, y);
TestResult SR = Bivariate.SpearmanRhoTest(x, y);
TestResult KT = Bivariate.KendallTauTest(x, y);
PRD = PR.Statistic.Distribution;
SRD = SR.Statistic.Distribution;
KTD = KT.Statistic.Distribution;
data.AddRow(new Dictionary <string, object>()
{
{ "r", PR.Statistic.Value }, { "ρ", SR.Statistic.Value }, { "τ", KT.Statistic.Value }
});
}
Assert.IsTrue(data["r"].As <double>().KolmogorovSmirnovTest(PRD).Probability > 0.05);
Assert.IsTrue(data["ρ"].As <double>().KolmogorovSmirnovTest(SRD).Probability > 0.05);
Assert.IsTrue(data["τ"].As <double>().KolmogorovSmirnovTest(KTD).Probability > 0.05);
}
public void CauchyStudentAgreement()
{
StudentDistribution S = new StudentDistribution(1);
CauchyDistribution C = new CauchyDistribution();
// don't compare moments directly, because NaN != NaN
foreach (double P in probabilities)
{
double xS = S.InverseLeftProbability(P);
double xC = C.InverseLeftProbability(P);
Console.WriteLine("{0} {1} {2}", P, xS, xC);
Assert.IsTrue(TestUtilities.IsNearlyEqual(xS, xC));
Assert.IsTrue(TestUtilities.IsNearlyEqual(S.ProbabilityDensity(xS), C.ProbabilityDensity(xC)));
}
}
public void TestCauchy()
{
ProbabilityDistribution cauchy = new CauchyDistribution(location: 0.093, scale: 27.814);
var mc = new BondsSimulation();
var result = mc.Run(withProfile: new RunProfile()
{
SeedDistribution = DistributionPool.Instance.GetDistribution(Distribution.Normal, withPeakAt: 0.093, withScale: 27.814),
StepDistribution = DistributionPool.Instance.GetDistribution(Distribution.Normal, withPeakAt: 10.82, withScale: 17.16),
TrialLength = 30,
ContributionLength = 15,
InitialAmount = 10000,
ContributionAmount = 500,
WithdrawalAmount = 5000
});
string jsonResult = JsonConvert.SerializeObject(result);
}
public void DistributionFunctionTest()
{
double[] expected =
{
0.7729505, 0.7931890, 0.8105287, 0.8254671, 0.8384167, 0.8497145,
0.8596339, 0.8683966, 0.8761824, 0.8831381, 0.8893841, 0.8950196
};
CauchyDistribution target = new CauchyDistribution(location: -7.2, scale: 6.23);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.DistributionFunction(i);
Assert.AreEqual(expected[i], actual, 1e-7);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void ProbabilityDensityFunctionTest()
{
double[] expected =
{
0.03183099, 0.03314002, 0.03452385, 0.03598755, 0.03753654, 0.03917660,
0.04091387, 0.04275485, 0.04470644, 0.04677588, 0.04897075, 0.05129893
};
CauchyDistribution target = new CauchyDistribution(location: 4, scale: 2);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.ProbabilityDensityFunction(i / 10.0);
Assert.AreEqual(expected[i], actual, 1e-7);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void DistributionFunctionTest()
{
double[] expected =
{
0.7729505, 0.7931890, 0.8105287, 0.8254671, 0.8384167, 0.8497145,
0.8596339, 0.8683966, 0.8761824, 0.8831381, 0.8893841, 0.8950196
};
CauchyDistribution target = new CauchyDistribution(location: -7.2, scale: 6.23);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.DistributionFunction(i);
Assert.AreEqual(expected[i], actual, 1e-7);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void LogProbabilityDensityFunctionTest()
{
double[] expected =
{
-3.4572653, -3.2488640, -3.0165321, -2.7541678, -2.4530627, -2.1002413,
-1.6753581, -1.1447299, -0.4515827, 0.4647080, 1.1578552, 0.4647080
};
CauchyDistribution target = new CauchyDistribution(location: 1, scale: 0.1);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.LogProbabilityDensityFunction(i / 10.0);
Assert.AreEqual(expected[i], actual, 1e-7);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void DifferenceOfSeveralCauchysChiSquareTest(double center, double gamma, int count)
{
var distr1 = new CauchyDistribution(center, gamma);
var distr2 = new CauchyDistribution(center, gamma);
var diff = distr1 - distr2;
if (count > 2)
{
for (var i = 0; i < count - 2; i++)
{
var distr = new CauchyDistribution(center, gamma);
diff -= distr;
}
}
var test = ChiSquareTest.Test(diff);
Assert.IsTrue(test);
}
public void ProductOfSeveralCauchysChiSquareTest(double center, double gamma, int count)
{
var distr1 = new CauchyDistribution(center, gamma);
var distr2 = new CauchyDistribution(center, gamma);
var product = distr1 * distr2;
if (count > 2)
{
for (var i = 0; i < count - 2; i++)
{
var distr = new CauchyDistribution(center, gamma);
product *= distr;
}
}
var test = ChiSquareTest.Test(product);
Assert.IsTrue(test);
}
public void QuotientOfSeveralCauchysChiSquareTest(double center, double gamma, int count)
{
var distr1 = new CauchyDistribution(center, gamma);
var distr2 = new CauchyDistribution(center, gamma);
var quotient = distr1 / distr2;
if (count > 2)
{
for (var i = 0; i < count - 2; i++)
{
var distr = new CauchyDistribution(center, gamma);
quotient /= distr;
}
}
var test = ChiSquareTest.Test(quotient);
Assert.IsTrue(test);
}
public void SumOfSeveralCauchysChiSquareTest(double center, double gamma, int count)
{
var distr1 = new CauchyDistribution(center, gamma);
var distr2 = new CauchyDistribution(center, gamma);
var sum = distr1 + distr2;
if (count > 2)
{
for (var i = 0; i < count - 2; i++)
{
var distr = new CauchyDistribution(center, gamma);
sum += distr;
}
}
var test = ChiSquareTest.Test(sum);
Assert.IsTrue(test);
}
public void TestDistributionCauchy()
{
IDoubleDistribution dist = new CauchyDistribution(m_model, "CauchyDistribution", Guid.NewGuid(), 3.0, 3.0);
Assert.IsTrue(dist.GetValueWithCumulativeProbability(0.50) == 3.0);
dist.SetCDFInterval(0.5, 0.5);
Assert.IsTrue(dist.GetNext() == 3.0);
dist.SetCDFInterval(0.0, 1.0);
System.IO.StreamWriter tw = new System.IO.StreamWriter(Environment.GetEnvironmentVariable("TEMP") + "\\DistributionCauchy.csv");
Debug.WriteLine("Generating raw data.");
int DATASETSIZE = 1500000;
double[] rawData = new double[DATASETSIZE];
for (int x = 0; x < DATASETSIZE; x++)
{
rawData[x] = dist.GetNext();
//tw.WriteLine(rawData[x]);
}
Debug.WriteLine("Performing histogram analysis.");
Histogram1D_Double hist = new Histogram1D_Double(rawData, 0, 7.5, 100, "distribution");
hist.LabelProvider = new LabelProvider(((Histogram1D_Double)hist).DefaultLabelProvider);
hist.Recalculate();
Debug.WriteLine("Writing data dump file.");
int[] bins = (int[])hist.Bins;
for (int i = 0; i < bins.Length; i++)
{
//Debug.WriteLine(hist.GetLabel(new int[]{i}) + ", " + bins[i]);
tw.WriteLine(hist.GetLabel(new int[] { i }) + ", " + bins[i]);
}
tw.Flush();
tw.Close();
if (m_visuallyVerify)
{
System.Diagnostics.Process.Start("excel.exe", Environment.GetEnvironmentVariable("TEMP") + "\\DistributionCauchy.csv");
}
}
public void FitTest2()
{
double[] observations = { 0.25, 0.12, 0.72, 0.21, 0.62, 0.12, 0.62, 0.12 };
{
CauchyDistribution cauchy = new CauchyDistribution();
cauchy.Fit(observations);
Assert.AreEqual(0.18784819147980944, cauchy.Location, 1e-6);
Assert.AreEqual(0.14168064551279669, cauchy.Scale, 1e-6);
Assert.IsFalse(Double.IsNaN(cauchy.Location));
Assert.IsFalse(Double.IsNaN(cauchy.Scale));
}
{
CauchyOptions options = new CauchyOptions()
{
EstimateLocation = true,
EstimateScale = false
};
CauchyDistribution cauchy = new CauchyDistribution(location: 0, scale: 4.2);
cauchy.Fit(observations, options);
Assert.AreEqual(0.34712181102025652, cauchy.Location, 1e-4);
Assert.AreEqual(4.2, cauchy.Scale, 1e-10);
Assert.IsFalse(Double.IsNaN(cauchy.Location));
Assert.IsFalse(Double.IsNaN(cauchy.Scale));
}
}
public void FitTest2()
{
double[] observations = { 0.25, 0.12, 0.72, 0.21, 0.62, 0.12, 0.62, 0.12 };
{
CauchyDistribution cauchy = new CauchyDistribution();
cauchy.Fit(observations);
Assert.AreEqual(0.18383597286086659, cauchy.Location);
Assert.AreEqual(-0.10530822112775458, cauchy.Scale);
}
{
CauchyOptions options = new CauchyOptions()
{
EstimateLocation = true,
EstimateScale = false
};
CauchyDistribution cauchy = new CauchyDistribution(location: 0, scale: 4.2);
cauchy.Fit(observations, options);
Assert.AreEqual(0.34712181102025652, cauchy.Location);
Assert.AreEqual(4.2, cauchy.Scale);
}
}
public void LogProbabilityDensityFunctionTest()
{
double[] expected =
{
-3.4572653, -3.2488640, -3.0165321, -2.7541678, -2.4530627, -2.1002413,
-1.6753581, -1.1447299, -0.4515827, 0.4647080, 1.1578552, 0.4647080
};
CauchyDistribution target = new CauchyDistribution(location: 1, scale: 0.1);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.LogProbabilityDensityFunction(i / 10.0);
Assert.AreEqual(expected[i], actual, 1e-7);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void ProbabilityDensityFunctionTest()
{
double[] expected =
{
0.03183099, 0.03314002, 0.03452385, 0.03598755, 0.03753654, 0.03917660,
0.04091387, 0.04275485, 0.04470644, 0.04677588, 0.04897075, 0.05129893
};
CauchyDistribution target = new CauchyDistribution(location: 4, scale: 2);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.ProbabilityDensityFunction(i / 10.0);
Assert.AreEqual(expected[i], actual, 1e-7);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void CauchyDistributionConstructorTest2()
{
double location = 0.42;
double scale = 1.57;
CauchyDistribution cauchy = new CauchyDistribution(location, scale);
double mean = cauchy.Mean; // NaN - Cauchy's mean is undefined.
double var = cauchy.Variance; // NaN - Cauchy's variance is undefined.
double median = cauchy.Median; // 0.42
double cdf = cauchy.DistributionFunction(x: 0.27); // 0.46968025841608563
double pdf = cauchy.ProbabilityDensityFunction(x: 0.27); // 0.2009112009763413
double lpdf = cauchy.LogProbabilityDensityFunction(x: 0.27); // -1.6048922547266871
double ccdf = cauchy.ComplementaryDistributionFunction(x: 0.27); // 0.53031974158391437
double icdf = cauchy.InverseDistributionFunction(p: 0.69358638272337991); // 1.5130304686978195
double hf = cauchy.HazardFunction(x: 0.27); // 0.3788491832800277
double chf = cauchy.CumulativeHazardFunction(x: 0.27); // 0.63427516833243092
string str = cauchy.ToString(System.Globalization.CultureInfo.InvariantCulture); // "Cauchy(x; x0 = 0.42, γ = 1.57)
Assert.IsTrue(Double.IsNaN(mean));
Assert.IsTrue(Double.IsNaN(var));
Assert.AreEqual(0.42, median);
Assert.AreEqual(0.63427516833243092, chf);
Assert.AreEqual(0.46968025841608563, cdf);
Assert.AreEqual(0.2009112009763413, pdf);
Assert.AreEqual(-1.6048922547266871, lpdf);
Assert.AreEqual(0.3788491832800277, hf);
Assert.AreEqual(0.53031974158391437, ccdf);
Assert.AreEqual(1.5130304686978195, icdf);
Assert.AreEqual("Cauchy(x; x0 = 0.42, γ = 1.57)", str);
}
public void FitTest()
{
CauchyDistribution target = new CauchyDistribution();
double[] observations = samples;
target.Fit(observations);
Assert.AreEqual(4.2, target.Location, 0.3);
Assert.AreEqual(0.21, target.Scale, 0.05);
}
