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); }