public void GammaFromExponential()
{
// test that x_1 + x_2 + ... + x_n ~ Gamma(n) when z ~ Exponential()
Random rng = new Random(1);
ExponentialDistribution eDistribution = new ExponentialDistribution();
// pick some low values of n so distribution is not simply normal
foreach (int n in new int[] { 2, 3, 4, 5 })
{
Sample gSample = new Sample();
for (int i = 0; i < 100; i++)
{
double sum = 0.0;
for (int j = 0; j < n; j++)
{
sum += eDistribution.GetRandomValue(rng);
}
gSample.Add(sum);
}
GammaDistribution gDistribution = new GammaDistribution(n);
TestResult result = gSample.KolmogorovSmirnovTest(gDistribution);
Assert.IsTrue(result.Probability > 0.05);
}
}
private static double[] plot(double[] dataset1, GammaDistribution a)
{
var hist = new Histogram();
hist.Compute(dataset1);
double x = hist.Range.Min;
double stepx = (hist.Range.Max - hist.Range.Min) / 100;
int size = 100;
var ax = new double[size];
var ay = new double[size];
for (int i = 0; i < size; i++)
{
double y = a.ProbabilityDensityFunction(x);
double ly = a.LogProbabilityDensityFunction(x);
Assert.AreEqual(y, Math.Exp(ly), 1e-10);
Assert.AreEqual(Math.Log(y), ly, 1e-10);
x = x + stepx;
ax[i] = x;
ay[i] = ly;
}
return(ay);
}
/*
* minValue: es el minimo de personas que llegan al andén
* maxValue: es el máximo de personas que llegan al andén
* lambda: es el deltaTiempo, intervalo de tiempo (en horas)
*
*/
public static int Gamma(int minValue, int maxValue, double lambda)
{
double r2, m, x, y, fx, k;
if ((minValue >= maxValue) || (minValue < 0) || (maxValue < 0))
{
throw new System.ArgumentException("Valores incorrectos");
}
k = 9.0;
GammaDistribution f = new GammaDistribution(k, lambda);
m = (1 / lambda) * (k - 1);
Random r = new Random();
do
{
x = r.NextDouble();
r2 = r.NextDouble();
y = m * r2;
fx = f.ProbabilityDensity(x);
} while (y < fx);
return(Convert.ToInt32(minValue + (maxValue - minValue) * x));
}
public void DistributionVarianceIntegral()
{
foreach (ContinuousDistribution distribution in distributions)
{
double v = distribution.Variance;
// Skip distributions with infinite variance
if (Double.IsNaN(v) || Double.IsInfinity(v))
{
continue;
}
// Skip beta distribution with enpoint singularities that cannot be numerically integrated
if (distribution is BetaDistribution b && ((b.Alpha < 1.0) || (b.Beta < 1.0)))
{
continue;
}
// Determine target precision, which must be reduced for some cases where an integral singularity means that cannot achieve full precision
double e = TestUtilities.TargetPrecision;
GammaDistribution gammaDistribution = distribution as GammaDistribution;
if ((gammaDistribution != null) && (gammaDistribution.Shape < 1.0))
{
e = Math.Sqrt(e);
}
Func <double, double> f = delegate(double x) {
double z = x - distribution.Mean;
return(distribution.ProbabilityDensity(x) * z * z);
};
double C2 = FunctionMath.Integrate(f, distribution.Support, new IntegrationSettings()
{
RelativePrecision = e, AbsolutePrecision = 0.0
}).Value;
Assert.IsTrue(TestUtilities.IsNearlyEqual(C2, distribution.Variance, e));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MultivariateTDistributionSettings"/> class
/// by measured value with degrees of freedom N-1.
/// </summary>
/// <param name="input">Matrix of measured values.</param>
/// <param name="degreesOfFreedom">Degrees of freedom.</param>
public MultivariateTDistributionSettings(double[,] input, double degreesOfFreedom)
: base(input)
{
DegreesOfFreedom = degreesOfFreedom;
baseGamma = new GammaDistribution(2.0, 0.5 * degreesOfFreedom);
baseChi = new ChiSquareDistribution((int)degreesOfFreedom);
}
public void GammaDistributionConstructorTest2()
{
var gamma = new GammaDistribution(theta: 4, k: 2);
double mean = gamma.Mean; // 8.0
double median = gamma.Median; // 6.7133878418421506
double var = gamma.Variance; // 32.0
double cdf = gamma.DistributionFunction(x: 0.27); // 0.002178158242390601
double pdf = gamma.ProbabilityDensityFunction(x: 0.27); // 0.015773530285395465
double lpdf = gamma.LogProbabilityDensityFunction(x: 0.27); // -4.1494220422235433
double ccdf = gamma.ComplementaryDistributionFunction(x: 0.27); // 0.99782184175760935
double icdf = gamma.InverseDistributionFunction(p: cdf); // 0.26999998689819171
double hf = gamma.HazardFunction(x: 0.27); // 0.015807962529274005
double chf = gamma.CumulativeHazardFunction(x: 0.27); // 0.0021805338793574793
string str = gamma.ToString(CultureInfo.InvariantCulture); // "Γ(x; k = 2, θ = 4)"
Assert.AreEqual(8.0, mean);
Assert.AreEqual(6.7133878418421506, median, 1e-6);
Assert.AreEqual(32.0, var);
Assert.AreEqual(0.0021805338793574793, chf);
Assert.AreEqual(0.002178158242390601, cdf);
Assert.AreEqual(0.015773530285395465, pdf);
Assert.AreEqual(-4.1494220422235433, lpdf);
Assert.AreEqual(0.015807962529274005, hf);
Assert.AreEqual(0.99782184175760935, ccdf);
Assert.AreEqual(0.26999998689819171, icdf, 1e-6);
Assert.AreEqual("Γ(x; k = 2, θ = 4)", str);
double p05 = gamma.DistributionFunction(median);
Assert.AreEqual(0.5, p05, 1e-6);
}
public void GammaDistributionConstructorTest2()
{
var gamma = new GammaDistribution(theta: 4, k: 2);
double mean = gamma.Mean; // 8.0
double median = gamma.Median; // 6.7133878418421506
double var = gamma.Variance; // 32.0
double cdf = gamma.DistributionFunction(x: 0.27); // 0.002178158242390601
double pdf = gamma.ProbabilityDensityFunction(x: 0.27); // 0.015773530285395465
double lpdf = gamma.LogProbabilityDensityFunction(x: 0.27); // -4.1494220422235433
double ccdf = gamma.ComplementaryDistributionFunction(x: 0.27); // 0.99782184175760935
double icdf = gamma.InverseDistributionFunction(p: cdf); // 0.26999998689819171
double hf = gamma.HazardFunction(x: 0.27); // 0.015807962529274005
double chf = gamma.CumulativeHazardFunction(x: 0.27); // 0.0021805338793574793
string str = gamma.ToString(CultureInfo.InvariantCulture); // "Γ(x; k = 2, θ = 4)"
Assert.AreEqual(8.0, mean);
Assert.AreEqual(6.7133878418421506, median, 1e-6);
Assert.AreEqual(32.0, var);
Assert.AreEqual(0.0021805338793574793, chf);
Assert.AreEqual(0.002178158242390601, cdf);
Assert.AreEqual(0.015773530285395465, pdf);
Assert.AreEqual(-4.1494220422235433, lpdf);
Assert.AreEqual(0.015807962529274005, hf);
Assert.AreEqual(0.99782184175760935, ccdf);
Assert.AreEqual(0.26999998689819171, icdf, 1e-6);
Assert.AreEqual("Γ(x; k = 2, θ = 4)", str);
double p05 = gamma.DistributionFunction(median);
Assert.AreEqual(0.5, p05, 1e-6);
}
/// <summary>
/// Initializes a new instance of the <see cref="MultivariateTDistributionSettings"/> class
/// by means vector, covariance matrix and degrees of freedom.
/// </summary>
/// <param name="means">Means vector.</param>
/// <param name="covarianceMatrix">Covariance matrix.</param>
/// <param name="degreesOfFreedom">Degrees of freedom.</param>
public MultivariateTDistributionSettings(double[] means, double[,] covarianceMatrix, double degreesOfFreedom)
: base(means, covarianceMatrix)
{
DegreesOfFreedom = degreesOfFreedom;
baseGamma = new GammaDistribution(2.0, 0.5 * degreesOfFreedom);
baseChi = new ChiSquareDistribution((int)degreesOfFreedom);
}
public void DistributionVarianceIntegral()
{
foreach (ContinuousDistribution distribution in distributions)
{
if (Double.IsNaN(distribution.Variance) || Double.IsInfinity(distribution.Variance))
{
continue;
}
double e = TestUtilities.TargetPrecision;
// since a Gamma distribution with \alpha < 1 has a power law singularity and numerical integration cannot achieve full precision with such a singularity,
// we reduce our precision requirement in this case
GammaDistribution gammaDistribution = distribution as GammaDistribution; if ((gammaDistribution != null) && (gammaDistribution.Shape < 1.0))
{
e = Math.Sqrt(e);
}
Console.WriteLine(distribution.GetType().Name);
Func <double, double> f = delegate(double x) {
double z = x - distribution.Mean;
return(distribution.ProbabilityDensity(x) * z * z);
};
double C2 = FunctionMath.Integrate(f, distribution.Support, new IntegrationSettings()
{
RelativePrecision = e, AbsolutePrecision = 0.0
}).Value;
Console.WriteLine(" {0} {1}", distribution.StandardDeviation, Math.Sqrt(C2));
Assert.IsTrue(TestUtilities.IsNearlyEqual(C2, distribution.Variance, e));
}
}
//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 TimeGammaGenerators()
{
double alpha = 1.0;
Random rng = new Random(1);
//IDeviateGenerator nRng = new AhrensDieterGammaGenerator(alpha);
IDeviateGenerator nRng = new MarsagliaTsangGammaGenerator(new PolarRejectionNormalDeviateGenerator(), alpha);
ContinuousDistribution d = new GammaDistribution(alpha);
//double sum = 0.0;
Sample sample = new Sample();
Stopwatch timer = Stopwatch.StartNew();
for (int i = 0; i < 1000000; i++)
{
//double x = nRng.GetNext(rng);
double x = d.InverseLeftProbability(rng.NextDouble());
//sum += x;
sample.Add(x);
}
timer.Stop();
Console.WriteLine(sample.KolmogorovSmirnovTest(d).RightProbability);
//Console.WriteLine(sum);
Console.WriteLine(timer.ElapsedMilliseconds);
}
private void GenerateIndividual_Click(object sender, RoutedEventArgs e)
{
var xCount = int.Parse(XCountRandom.Text);
var alternativesCount = int.Parse(AltCountRandom.Text);
var constraintsCount = int.Parse(ConstraintCountRandom.Text);
var optDirection = OptDirectionComboBoxRandom.SelectedIndex == 0 ? "max" : "min";
var distributionTypeIndex = DistributionType.SelectedIndex;
CustomDistribution distribution;
switch (distributionTypeIndex)
{
case 0: distribution = new BetaDistribution(double.Parse(BetaA.Text), double.Parse(BetaB.Text)); break;
case 1: distribution = new ChiDistribution(int.Parse(ChiK.Text)); break;
case 2: distribution = new GammaDistribution(double.Parse(GammaShape.Text), double.Parse(GammaRate.Text)); break;
case 3: distribution = new NormalDistribution(double.Parse(NormalMean.Text), double.Parse(NormalStdDev.Text)); break;
case 4: distribution = new UniformDistribution(double.Parse(UniformMin.Text), double.Parse(UniformMax.Text)); break;
default: distribution = new NormalDistribution(double.Parse(NormalMean.Text), double.Parse(NormalStdDev.Text)); break;
}
_viewModel.GenerateIndividualProblem(xCount, alternativesCount, constraintsCount, optDirection, distribution);
ResultsSaveStackPanel.Visibility = Visibility.Visible;
}
public void DensityFunctionTest()
{
double shape = 0.4;
double scale = 4.2;
double[] pdf =
{
double.PositiveInfinity, 0.987114, 0.635929, 0.486871, 0.400046,
0.341683, 0.299071, 0.266236, 0.239956, 0.218323, 0.200126
};
GammaDistribution target = new GammaDistribution(scale, shape);
for (int i = 0; i < 11; i++)
{
double x = i / 10.0;
double actual = target.ProbabilityDensityFunction(x);
double expected = pdf[i];
Assert.AreEqual(expected, actual, 1e-6);
Assert.IsFalse(double.IsNaN(actual));
double logActual = target.LogProbabilityDensityFunction(x);
double logExpected = Math.Log(pdf[i]);
Assert.AreEqual(logExpected, logActual, 1e-5);
Assert.IsFalse(double.IsNaN(logActual));
}
}
protected override void EndProcessing()
{
var dist = new GammaDistribution(Theta, K);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
static double GAMMADIST(double x, double alpha, double beta, bool cumulative)
{
GammaDistribution dist = new GammaDistribution(alpha, beta);
return(cumulative
? dist.CumulativeDistribution(x)
: dist.ProbabilityDensity(x));
}
public void IRID205_GammaDistInvCdfSmallAlphaLargeTheta()
{
double alpha = 0.016512683231958761;
double theta = 73076944.560563684;
GammaDistribution gamma_dist = new GammaDistribution(alpha, theta);
double left_tail = gamma_dist.InverseCumulativeDistribution(0.001);
Assert.That(left_tail, Is.Not.NaN);
}
public RndB2(Distribution t)
: base(t)
{
_gamma = new GammaDistribution(t.AlphaRev, 2);
_unif1 = new UniformContinuousDistribution(T.Beta, T.d(T.X2));
double cxn = 1 + t.Bn * t.AlphaRev / Math.E;
_unif2 = new UniformContinuousDistribution(0, cxn);
}
public void TestGammaRoundTrip()
{
// arrange
var expected = new GammaDistribution(1d, 1d, 0.3, 0.7);
// act
var serialized = expected.ToString();
var deserialized = Distribution.DeserializeDistribution(serialized);
var distribution = deserialized.IfNone(() => { Assert.Fail(); return(default !); });
public void MedianTest()
{
double shape = 0.4;
double scale = 4.2;
GammaDistribution target = new GammaDistribution(scale, shape);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
public void GammaDistributionConstructorTest2()
{
#region doc_ctor
// Create a Γ-distribution with k = 2 and θ = 4
var gamma = new GammaDistribution(theta: 4, k: 2);
// Common measures
double mean = gamma.Mean; // 8.0
double median = gamma.Median; // 6.7133878418421506
double var = gamma.Variance; // 32.0
double mode = gamma.Mode; // 4.0
// Cumulative distribution functions
double cdf = gamma.DistributionFunction(x: 0.27); // 0.002178158242390601
double ccdf = gamma.ComplementaryDistributionFunction(x: 0.27); // 0.99782184175760935
double icdf = gamma.InverseDistributionFunction(p: cdf); // 0.26999998689819171
// Probability density functions
double pdf = gamma.ProbabilityDensityFunction(x: 0.27); // 0.015773530285395465
double lpdf = gamma.LogProbabilityDensityFunction(x: 0.27); // -4.1494220422235433
// Hazard (failure rate) functions
double hf = gamma.HazardFunction(x: 0.27); // 0.015807962529274005
double chf = gamma.CumulativeHazardFunction(x: 0.27); // 0.0021805338793574793
// String representation
string str = gamma.ToString(CultureInfo.InvariantCulture); // "Γ(x; k = 2, θ = 4)"
#endregion
Assert.AreEqual(8.0, mean);
Assert.AreEqual(6.7133878418421506, median, 1e-6);
Assert.AreEqual(32.0, var);
Assert.AreEqual(4.0, mode);
Assert.AreEqual(0.0021805338793574793, chf, 1e-10);
Assert.AreEqual(0.002178158242390601, cdf, 1e-10);
Assert.AreEqual(0.015773530285395465, pdf, 1e-10);
Assert.AreEqual(-4.1494220422235433, lpdf, 1e-10);
Assert.AreEqual(0.015807962529274005, hf, 1e-10);
Assert.AreEqual(0.99782184175760935, ccdf, 1e-10);
Assert.AreEqual(0.26999998689819171, icdf, 1e-6);
Assert.AreEqual("Γ(x; k = 2, θ = 4)", str);
double p05 = gamma.DistributionFunction(median);
Assert.AreEqual(0.5, p05, 1e-6);
var range1 = gamma.GetRange(0.95);
var range2 = gamma.GetRange(0.99);
var range3 = gamma.GetRange(0.01);
Assert.AreEqual(1.4214460427946485, range1.Min, 1e-10);
Assert.AreEqual(18.975458073562308, range1.Max, 1e-10);
Assert.AreEqual(0.59421896101306348, range2.Min, 1e-10);
Assert.AreEqual(26.553408271975243, range2.Max, 1e-10);
Assert.AreEqual(0.59421896101306348, range3.Min, 1e-10);
Assert.AreEqual(26.553408271975243, range3.Max, 1e-10);
}
public RndC(Distribution t)
: base(t)
{
//var p1 = t.Bn / Math.E * t.AlphaRev;
var p1 = t.Bn / (1 - t.Beta) * t.AlphaRev;
_gamma = new GammaDistribution(t.AlphaRev, 2);
_unif1 = new UniformContinuousDistribution(t.d(t.X2), 1);
_unif2 = new UniformContinuousDistribution(0, 1 + p1);
}
public void TestGammaWithBoundsGetSample()
{
// arrange
var subject = new GammaDistribution(1d, 1d, 0.3, 0.7);
// act
var sample = subject.GetSample();
// assert
Assert.IsTrue(sample > 0.3 && sample < 0.7);
}
public void GammaDistributionGeneratorTest(int eta, double lambda,
double distributionEpsilon, double statEpsilon, int totalValues, int totalIntervals)
{
var dist = new GammaDistribution(eta, lambda);
var generator = new GammaDistributionGenerator(dist);
CheckAssert(
generator, dist,
distributionEpsilon, statEpsilon,
totalValues, totalIntervals);
}
public void TestGammaWithBoundsFillSamples()
{
// arrange
var subject = new GammaDistribution(1d, 1d, 0.3, 0.7);
var samples = Range(0, 42).Map(_ => NaN).ToArray();
// act
subject.FillSamples(samples);
// assert
Assert.IsTrue(samples.All(d => d > 0.3 && d < 0.7));
}
public void GenerateTest5()
{
Accord.Math.Tools.SetupGenerator(1);
var target = new GammaDistribution(42, 0.1337);
var samples = target.Generate(10000000);
var actual = GammaDistribution.Estimate(samples);
Assert.AreEqual(42, actual.Scale, 5e-2);
Assert.AreEqual(0.1337, actual.Shape, 5e-4);
}
public void FitTestOptions()
{
// Gamma Distribution Fit stalls for some arrays #301
// https://github.com/accord-net/framework/issues/301
double[] x = { 1.003, 1.012, 1.011, 1.057, 1.033, 1.051, 1.045, 1.045, 1.037, 1.059, 1.028, 1.032, 1.029, 1.031, 1.029, 1.023, 1.035 };
var gamma = GammaDistribution.Estimate(x, tol: 1e-2, iterations: 0);
Assert.AreEqual(1.0329411764705885, gamma.Mean, 1e-10);
Assert.AreEqual(4679.4730319532555, gamma.Shape, 1e-10);
Assert.AreEqual(0.00022073878178531338, gamma.Scale, 1e-10);
}
public void FitTest()
{
// Gamma Distribution Fit stalls for some arrays #159
// https://github.com/accord-net/framework/issues/159
double[] x = { 1275.56, 1239.44, 1237.92, 1237.22, 1237.1, 1238.41, 1238.62, 1237.05, 1237.19, 1236.51, 1264.6, 1238.19, 1237.39, 1235.79, 1236.53, 1236.8, 1238.06, 1236.5, 1235.32, 1236.44, 1236.58, 1236.3, 1237.91, 1238.6, 1238.49, 1239.21, 1238.57, 1244.63, 1236.06, 1236.4, 1237.88, 1237.56, 1236.66, 1236.59, 1236.53, 1236.32, 1238.29, 1237.79, 1237.86, 1236.42, 1236.23, 1236.37, 1237.18, 1237.63, 1245.8, 1238.04, 1238.55, 1238.39, 1236.75, 1237.07, 1250.78, 1238.6, 1238.36, 1236.58, 1236.82, 1238.4, 1257.68, 1237.78, 1236.52, 1234.9, 1237.9, 1238.58, 1238.12, 1237.89, 1236.54, 1236.55, 1238.37, 1237.29, 1237.64, 1236.8, 1237.73, 1236.71, 1238.23, 1237.84, 1236.26, 1237.58, 1238.31, 1238.4, 1237.08, 1236.61, 1235.92, 1236.41, 1237.89, 1237.98, 1246.75, 1237.92, 1237.1, 1237.97, 1238.69, 1237.05, 1236.96, 1239.44, 1238.49, 1237.88, 1236.01, 1236.57, 1236.44, 1235.76, 1237.62, 1238, 1263.14, 1237.66, 1237, 1236, 1261.96, 1238.58, 1237.77, 1237.06, 1236.31, 1238.63, 1237.23, 1236.85, 1236.23, 1236.46, 1236.9, 1237.85, 1238, 1237.02, 1236.19, 1236.05, 1235.73, 1258.3, 1235.98, 1237.76, 1246.93, 1239.1, 1237.72, 1237.67, 1236.79, 1237.61, 1238.41, 1238.29, 1238.11, 1237, 1236.52, 1236.6, 1236.31, 1237.77, 1238.58, 1237.88, 1247.35, 1236.14, 1236.83, 1236.15, 1237.93, 1238.16, 1237.34, 1236.78, 1238.66, 1237.76, 1237.19, 1236.7, 1236.04, 1236.66, 1237.86, 1238.54, 1238.05, 1238.41, 1236.94, 1240.95, 1261.01, 1237.72, 1237.91, 1238.2, 1235.68, 1236.89, 1235.12, 1271.31, 1236.97, 1270.76, 1238.52, 1238.19, 1238.6, 1237.16, 1236.72, 1236.71, 1237.14, 1238.48, 1237.95, 1237.42, 1235.86, 1236.39, 1236.13, 1236.58, 1237.95, 1237.76, 1237.39, 1238.16, 1236.31, 1236.41, 1236.12, 1238.7, 1236.48, 1237.84, 1236.38, 1237.95, 1238.48, 1236.51, 1236.56 };
var gamma = GammaDistribution.Estimate(x);
Assert.AreEqual(1238.8734170854279, gamma.Mean);
Assert.AreEqual(41566.439533445438, gamma.Shape);
Assert.AreEqual(0.029804655654680219, gamma.Scale);
}
public void NegativeValueTest()
{
double[] samples = NormalDistribution.Standard.Generate(100);
try
{
GammaDistribution.Estimate(samples);
Assert.Fail();
}
catch (ArgumentException)
{
}
}
public void GenerateTest6()
{
// https://github.com/accord-net/framework/issues/281
Accord.Math.Random.Generator.Seed = 1;
var target = new GammaDistribution(1.5, 0.9);
var samples = target.Generate(10000000);
var actual = GammaDistribution.Estimate(samples);
Assert.AreEqual(1.5, actual.Scale, 5e-2);
Assert.AreEqual(0.9, actual.Shape, 5e-4);
}
public void GenerateTest2()
{
Accord.Math.Tools.SetupGenerator(0);
GammaDistribution target = new GammaDistribution(5, 2);
double[] samples = target.Generate(10000000);
var actual = GammaDistribution.Estimate(samples);
Assert.AreEqual(5, actual.Scale, 1e-3);
Assert.AreEqual(2, actual.Shape, 1e-3);
}
public async Task TestGammaCumulativeDistributionAtBounds()
{
// arrange
var subject = new GammaDistribution(1d, 1d, 0.3, 0.7);
var expectedLowerP = (await GetNumDataAsync("pgamma(0.3, 1.0)"))[0].Data[0];
var expectedUpperP = (await GetNumDataAsync("pgamma(0.7, 1.0)"))[0].Data[0];
// act
var(actualLowerP, actualUpperP) = subject.CumulativeDistributionAtBounds;
// assert
Assert.AreEqual(expectedLowerP, actualLowerP, Base.Constant.TOLERANCE);
Assert.AreEqual(expectedUpperP, actualUpperP, Base.Constant.TOLERANCE);
}
public void GammaDistributionConstructorTest2()
{
var gamma = new GammaDistribution(theta: 4, k: 2);
double mean = gamma.Mean; // 8.0
double median = gamma.Median; // 6.7133878418421506
double var = gamma.Variance; // 32.0
double mode = gamma.Mode; // 4.0
double cdf = gamma.DistributionFunction(x: 0.27); // 0.002178158242390601
double pdf = gamma.ProbabilityDensityFunction(x: 0.27); // 0.015773530285395465
double lpdf = gamma.LogProbabilityDensityFunction(x: 0.27); // -4.1494220422235433
double ccdf = gamma.ComplementaryDistributionFunction(x: 0.27); // 0.99782184175760935
double icdf = gamma.InverseDistributionFunction(p: cdf); // 0.26999998689819171
double hf = gamma.HazardFunction(x: 0.27); // 0.015807962529274005
double chf = gamma.CumulativeHazardFunction(x: 0.27); // 0.0021805338793574793
string str = gamma.ToString(CultureInfo.InvariantCulture); // "Γ(x; k = 2, θ = 4)"
Assert.AreEqual(8.0, mean);
Assert.AreEqual(6.7133878418421506, median, 1e-6);
Assert.AreEqual(32.0, var);
Assert.AreEqual(4.0, mode);
Assert.AreEqual(0.0021805338793574793, chf);
Assert.AreEqual(0.002178158242390601, cdf);
Assert.AreEqual(0.015773530285395465, pdf);
Assert.AreEqual(-4.1494220422235433, lpdf);
Assert.AreEqual(0.015807962529274005, hf);
Assert.AreEqual(0.99782184175760935, ccdf);
Assert.AreEqual(0.26999998689819171, icdf, 1e-6);
Assert.AreEqual("Γ(x; k = 2, θ = 4)", str);
double p05 = gamma.DistributionFunction(median);
Assert.AreEqual(0.5, p05, 1e-6);
var range1 = gamma.GetRange(0.95);
var range2 = gamma.GetRange(0.99);
var range3 = gamma.GetRange(0.01);
Assert.AreEqual(1.4214460427946485, range1.Min);
Assert.AreEqual(18.975458073562308, range1.Max);
Assert.AreEqual(0.59421896101306348, range2.Min);
Assert.AreEqual(26.553408271975243, range2.Max);
Assert.AreEqual(0.59421896101306348, range3.Min);
Assert.AreEqual(26.553408271975243, range3.Max);
}
public void GammaDistributionConstructorTest()
{
double shape = 0.4;
double scale = 4.2;
double[] expected =
{
double.NegativeInfinity, 0.987114, 0.635929, 0.486871, 0.400046,
0.341683, 0.299071, 0.266236, 0.239956, 0.218323, 0.200126
};
GammaDistribution target = new GammaDistribution(scale, shape);
Assert.AreEqual(shape, target.Shape);
Assert.AreEqual(scale, target.Scale);
Assert.AreEqual(shape * scale, target.Mean);
Assert.AreEqual(shape * scale * scale, target.Variance);
}
public void GenerateTest5()
{
Accord.Math.Tools.SetupGenerator(1);
var target = new GammaDistribution(42, 0.1337);
var samples = target.Generate(10000000);
var actual = GammaDistribution.Estimate(samples);
Assert.AreEqual(42, actual.Scale, 5e-2);
Assert.AreEqual(0.1337, actual.Shape, 5e-4);
}
public void GenerateTest6()
{
// https://github.com/accord-net/framework/issues/281
Accord.Math.Random.Generator.Seed = 1;
var target = new GammaDistribution(1.5, 0.9);
var samples = target.Generate(10000000);
var actual = GammaDistribution.Estimate(samples);
Assert.AreEqual(1.5, actual.Scale, 5e-2);
Assert.AreEqual(0.9, actual.Shape, 5e-4);
}
/// <summary>
/// Returns a new line chart plotting the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <returns>A new chart.</returns>
public static ChartControl ToChart( GammaDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
ChartControl chart = GetDefaultChart();
Update( ref chart, dist, function, numInterpolatedValues );
return chart;
}
/// <summary>
/// Shows a new chart in a default form.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <remarks>
/// Equivalent to:
/// <code>
/// NMathStatsChart.Show( ToChart( dist, function, numInterpolatedValues ) );
/// </code>
/// </remarks>
public static void Show( GammaDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
Show( ToChart( dist, function, numInterpolatedValues ) );
}
//---------------------------------------------------------------------
private static double GenerateRandomNum(Distribution dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
if(dist == Distribution.normal)
{
NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == Distribution.lognormal)
{
LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == Distribution.gamma)
{
GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Theta = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == Distribution.Weibull)
{
WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Lambda = parameter2; // std dev
randomNum = randVar.NextDouble();
}
return randomNum;
}
/* public Distribution(
DistributionType name,
double value1,
double value2
)
{
this.name = name;
this.value1 = value1;
this.value2 = value2;
}*/
//---------------------------------------------------------------------
public static double GenerateRandomNum(DistributionType dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
/*if(dist == DistributionType.Normal)
{
NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Lognormal)
{
LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}*/
if(dist == DistributionType.Weibull)
{
WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Lambda = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Gamma)
{
GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Theta = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Beta)
{
BetaDistribution randVar = new BetaDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Beta = parameter2; // std dev
randomNum = randVar.NextDouble();
}
return randomNum;
}
public void MedianTest()
{
double shape = 0.4;
double scale = 4.2;
GammaDistribution target = new GammaDistribution(scale, shape);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
public void DensityFunctionTest()
{
double shape = 0.4;
double scale = 4.2;
double[] pdf =
{
double.PositiveInfinity, 0.987114, 0.635929, 0.486871, 0.400046,
0.341683, 0.299071, 0.266236, 0.239956, 0.218323, 0.200126
};
GammaDistribution target = new GammaDistribution(scale, shape);
for (int i = 0; i < 11; i++)
{
double x = i / 10.0;
double actual = target.ProbabilityDensityFunction(x);
double expected = pdf[i];
Assert.AreEqual(expected, actual, 1e-6);
Assert.IsFalse(double.IsNaN(actual));
double logActual = target.LogProbabilityDensityFunction(x);
double logExpected = Math.Log(pdf[i]);
Assert.AreEqual(logExpected, logActual, 1e-5);
Assert.IsFalse(double.IsNaN(logActual));
}
}
public void CumulativeFunctionTest()
{
double shape = 0.4;
double scale = 4.2;
double[] cdf =
{
0, 0.251017, 0.328997, 0.38435, 0.428371, 0.465289,
0.497226, 0.525426, 0.55069, 0.573571, 0.594469
};
GammaDistribution target = new GammaDistribution(scale, shape);
for (int i = 0; i < 11; i++)
{
double x = i / 10.0;
double actual = target.DistributionFunction(x);
double expected = cdf[i];
Assert.AreEqual(expected, actual, 1e-5);
Assert.IsFalse(double.IsNaN(actual));
}
}
public void GenerateTest2()
{
Accord.Math.Tools.SetupGenerator(0);
GammaDistribution target = new GammaDistribution(5, 2);
double[] samples = target.Generate(1000000);
var actual = GammaDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(5, actual.Scale, 0.02);
Assert.AreEqual(2, actual.Shape, 0.01);
}
/// <summary>
/// Updates the given chart with the specified distribution.
/// </summary>
/// <param name="chart">A chart.</param>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <returns>A new chart.</returns>
/// <remarks>
/// Plots the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// <br/>
/// Titles are added only if chart does not currently contain any titles.
/// <br/>
/// chart.Series[0] is replaced, or added if necessary.
/// </remarks>
public static void Update( ref ChartControl chart, GammaDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
List<string> titles = new List<string>()
{
"GammaDistribution",
String.Format("\u03B1={0}, \u03B2={1}", dist.Alpha, dist.Beta)
};
UpdateContinuousDistribution( ref chart, dist, titles, function, numInterpolatedValues );
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(GammaDistribution obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public void GenerateTest3()
{
Accord.Math.Tools.SetupGenerator(1);
GammaDistribution target = new GammaDistribution(4, 2);
double[] samples = new double[1000000];
for (int i = 0; i < samples.Length; i++)
samples[i] = target.Generate();
var actual = GammaDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(4, actual.Scale, 0.01);
Assert.AreEqual(2, actual.Shape, 0.01);
}
