public void ConstructorTest9()
{
var original = new LognormalDistribution(location: 0.42, shape: 1.1);
var log = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.ProbabilityDensityFunction(i);
double actual = log.ProbabilityDensityFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-8);
}
testLognormal(log);
}
public void ConstructorTest3()
{
var original = new InverseGaussianDistribution(mean: 0.42, shape: 1.2);
var invGaussian = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = invGaussian.DistributionFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 0.1);
}
testInvGaussian(invGaussian);
}
public void ConstructorTest17()
{
var original = new VonMisesDistribution(mean: 0.42, concentration: 1.2);
var vonMises = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.ProbabilityDensityFunction(i);
double actual = vonMises.ProbabilityDensityFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-6);
}
testVonMises(vonMises, 1);
}
public void ConstructorTest2()
{
var original = new NormalDistribution(mean: 4, stdDev: 4.2);
var normal = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = normal.DistributionFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-6);
}
testNormal(normal, 1);
}
public void ConstructorTest6()
{
var original = new LaplaceDistribution(location: 4, scale: 2);
var laplace = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.ProbabilityDensityFunction(i);
double actual = laplace.ProbabilityDensityFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-6);
}
testLaplace(laplace);
}
public void ConstructorTest15()
{
var original = new NakagamiDistribution(shape: 2.4, spread: 4.2);
var nakagami = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = nakagami.DistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-2));
Assert.IsFalse(double.IsNaN(expected));
Assert.IsFalse(double.IsNaN(actual));
}
testNakagami(nakagami);
}
public void ConstructorTest13()
{
var original = new GompertzDistribution(eta: 4.2, b: 1.1);
var gompertz = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = gompertz.DistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-7));
Assert.IsFalse(double.IsNaN(expected));
Assert.IsFalse(double.IsNaN(actual));
}
testGompertz(gompertz);
}
public void ConstructorTest11()
{
var original = new ChiSquareDistribution(degreesOfFreedom: 7);
var chisq = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = chisq.DistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-5));
Assert.IsFalse(Double.IsNaN(actual));
Assert.IsFalse(Double.IsNaN(expected));
}
testChiSquare(chisq);
}
public void ConstructorTest7()
{
var original = new LaplaceDistribution(location: 4, scale: 2);
var laplace = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = laplace.DistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-5));
Assert.IsFalse(Double.IsNaN(expected));
Assert.IsFalse(Double.IsNaN(actual));
}
testLaplace(laplace);
}
public void ConstructorTest10()
{
var original = new ChiSquareDistribution(degreesOfFreedom: 7);
var chisq = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.ProbabilityDensityFunction(i);
double actual = chisq.ProbabilityDensityFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-8);
Assert.IsFalse(Double.IsNaN(actual));
Assert.IsFalse(Double.IsNaN(expected));
}
testChiSquare(chisq);
}
/// <summary>
/// Creates a OxyPlot's graph for the Cumulative Distribution Function.
/// </summary>
///
public PlotModel CreateCDF()
{
try
{
double[] y;
try { y = supportPoints.Apply((x) => instance.DistributionFunction(x)); }
catch
{
var general = GeneralContinuousDistribution
.FromDensityFunction(instance.Support, instance.ProbabilityFunction);
y = supportPoints.Apply((x) => general.DistributionFunction(x));
}
return(createBaseModel(range, "CDF", supportPoints, y, instance is UnivariateDiscreteDistribution));
}
catch
{
return(null);
}
}
public void ConstructorTest8()
{
var original = new LognormalDistribution(location: 0.42, shape: 1.1);
var log = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = log.DistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-2));
Assert.IsFalse(Double.IsNaN(expected));
Assert.IsFalse(Double.IsNaN(actual));
}
testLognormal(log);
}
public void ConstructorTest12()
{
var original = new GompertzDistribution(eta: 4.2, b: 1.1);
var gompertz = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +7; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = gompertz.DistributionFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-3);
Assert.IsFalse(double.IsNaN(expected));
Assert.IsFalse(double.IsNaN(actual));
}
testGompertz(gompertz);
}
/// <summary>
/// Creates a OxyPlot's graph for the Inverse Probability Density Function.
/// </summary>
///
public PlotModel CreateIPDF()
{
try
{
double[] y;
try { y = probabilities.Apply(instance.QuantileDensityFunction); }
catch
{
var general = GeneralContinuousDistribution
.FromDistributionFunction(instance.Support, instance.DistributionFunction);
y = probabilities.Apply(general.QuantileDensityFunction);
}
return(createBaseModel(unit, "IPDF", probabilities, y, false));
}
catch
{
return(null);
}
}
public void ConstructorTest14()
{
var original = new NakagamiDistribution(shape: 2.4, spread: 4.2);
var nakagami = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.ProbabilityDensityFunction(i);
double actual = nakagami.ProbabilityDensityFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-3);
Assert.IsFalse(double.IsNaN(expected));
Assert.IsFalse(double.IsNaN(actual));
}
testNakagami(nakagami);
}
public void InverseDistributionFunctionTest()
{
double[] expected =
{
Double.NegativeInfinity, -4.38252, -2.53481, -1.20248,
-0.0640578, 1.0, 2.06406, 3.20248,4.53481, 6.38252,
Double.PositiveInfinity
};
NormalDistribution original = new NormalDistribution(1.0, 4.2);
var target = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (int i = 0; i < expected.Length; i++)
{
double x = i / 10.0;
double actual = target.InverseDistributionFunction(x);
Assert.AreEqual(expected[i], actual, 1e-5);
Assert.IsFalse(Double.IsNaN(actual));
}
}
/// <summary>
/// Creates a OxyPlot's graph for the Cumulative Hazard Function.
/// </summary>
///
public PlotModel CreateCHF()
{
double[] y;
try { y = supportPoints.Apply(instance.CumulativeHazardFunction); }
catch
{
try
{
var general = GeneralContinuousDistribution
.FromDensityFunction(instance.Support, instance.ProbabilityFunction);
y = supportPoints.Apply(general.CumulativeHazardFunction);
}
catch
{
var general = GeneralContinuousDistribution
.FromDistributionFunction(instance.Support, instance.DistributionFunction);
y = supportPoints.Apply(general.CumulativeHazardFunction);
}
}
return(createBaseModel(range, "CHF", supportPoints, y, instance is UnivariateDiscreteDistribution));
}
public void MeasuresTest_KaplanMeier()
{
double[] values =
{
0.0000000000000000, 0.0351683340828711, 0.0267358118285064,
0.0000000000000000, 0.0103643094219679, 0.9000000000000000,
0.0000000000000000, 0.0000000000000000, 0.0000000000000000,
0.000762266794052363, 0.000000000000000
};
double[] times =
{
11, 1, 9, 8, 7, 3, 6, 5, 4, 2, 10
};
var target = new EmpiricalHazardDistribution(times, values, SurvivalEstimator.KaplanMeier);
var general = new GeneralContinuousDistribution(target);
//Assert.AreEqual(general.Mean, target.Mean);
//Assert.AreEqual(general.Variance, target.Variance);
Assert.AreEqual(general.Median, target.Median);
for (int i = -10; i < 10; i++)
{
double x = i;
double expected = general.CumulativeHazardFunction(x);
double actual = target.CumulativeHazardFunction(x);
Assert.AreEqual(expected, actual, 1e-4);
}
for (int i = -10; i < 10; i++)
{
double x = i;
double expected = general.HazardFunction(x);
double actual = target.HazardFunction(x);
Assert.AreEqual(expected, actual, 1e-5);
}
}
private static void testGompertz(GeneralContinuousDistribution gompertz)
{
double median = gompertz.Median; // 0.13886469671401389
double cdf = gompertz.DistributionFunction(x: 0.27); // 0.76599768199799145
double pdf = gompertz.ProbabilityDensityFunction(x: 0.27); // 1.4549484164912097
double lpdf = gompertz.LogProbabilityDensityFunction(x: 0.27); // 0.37497044741163688
double ccdf = gompertz.ComplementaryDistributionFunction(x: 0.27); // 0.23400231800200855
double icdf = gompertz.InverseDistributionFunction(p: cdf); // 0.26999999999766749
double hf = gompertz.HazardFunction(x: 0.27); // 6.2176666834502088
double chf = gompertz.CumulativeHazardFunction(x: 0.27); // 1.4524242576820101
Assert.AreEqual(0.13886469671401389, median, 1e-6);
Assert.AreEqual(1.4524242576820101, chf, 1e-5);
Assert.AreEqual(0.76599768199799145, cdf, 1e-5);
Assert.AreEqual(1.4549484164912097, pdf, 1e-6);
Assert.AreEqual(0.37497044741163688, lpdf, 1e-6);
Assert.AreEqual(6.2176666834502088, hf, 1e-4);
Assert.AreEqual(0.23400231800200855, ccdf, 1e-5);
Assert.AreEqual(0.26999999999766749, icdf, 1e-5);
}
public void UsageTest()
{
// Let's suppose we have a formula that defines a probability distribution
// but we dont know much else about it. We don't know the form of its cumulative
// distribution function, for example. We would then like to know more about
// it, such as the underlying distribution's moments, characteristics, and
// properties.
// Let's suppose the formula we have is this one:
double mu = 5;
double sigma = 4.2;
Func <double, double> df = x => 1.0 / (sigma * Math.Sqrt(2 * Math.PI))
* Math.Exp(-Math.Pow(x - mu, 2) / (2 * sigma * sigma));
// And for the moment, let's also pretend we don't know it is actually the
// p.d.f. of a Gaussian distribution with mean 5 and std. deviation of 4.2.
// So, let's create a distribution based _solely_ on the formula we have:
var distribution = GeneralContinuousDistribution.FromDensityFunction(df);
// Now, we can check everything that we can know about it:
double mean = distribution.Mean; // 5
double median = distribution.Median; // 5
double var = distribution.Variance; // 17.64
double mode = distribution.Mode; // 5
double cdf = distribution.DistributionFunction(x: 1.4); // 0.19568296915377595
double pdf = distribution.ProbabilityDensityFunction(x: 1.4); // 0.065784567984404935
double lpdf = distribution.LogProbabilityDensityFunction(x: 1.4); // -2.7213699972695058
double ccdf = distribution.ComplementaryDistributionFunction(x: 1.4); // 0.80431703084622408
double icdf = distribution.InverseDistributionFunction(p: cdf); // 1.3999999997024655
double hf = distribution.HazardFunction(x: 1.4); // 0.081789351041333558
double chf = distribution.CumulativeHazardFunction(x: 1.4); // 0.21776177055276186
Assert.AreEqual(5.0000000000000071, mean, 1e-10);
Assert.AreEqual(4.9999999999999991, median, 1e-5);
Assert.AreEqual(4.9999999992474002, mode, 1e-7);
Assert.AreEqual(17.639999999999958, var, 1e-10);
Assert.AreEqual(0.21776177055276186, chf, 1e-10);
Assert.AreEqual(0.19568296915377595, cdf, 1e-10);
Assert.AreEqual(0.065784567984404935, pdf, 1e-10);
Assert.AreEqual(-2.7213699972695058, lpdf, 1e-10);
Assert.AreEqual(0.081789351041333558, hf, 1e-10);
Assert.AreEqual(0.80431703084622408, ccdf, 1e-10);
Assert.AreEqual(1.3999999997024655, icdf, 1e-7);
var range1 = distribution.GetRange(0.95);
var range2 = distribution.GetRange(0.99);
var range3 = distribution.GetRange(0.01);
Assert.AreEqual(-1.9083852331957445, range1.Min);
Assert.AreEqual(11.908385199564195, range1.Max);
Assert.AreEqual(-4.7706612258820975, range2.Min);
Assert.AreEqual(14.770661223067844, range2.Max);
Assert.AreEqual(-4.7706612258820993, range3.Min);
Assert.AreEqual(14.770661223067844, range3.Max);
}
