public void TestStarUniformDistribution()
 {
     IContinuousDistribution distribution = new Gamma(9, 1/5000.0);
     Console.WriteLine(distribution.CumulativeDistribution(30000));
     //IContinuousDistribution distribution = new Gamma(3, 0.05);
     for (double d = 0; d < 50000; d = d + 1000)
     {
         //Console.WriteLine(Gamma.PDF(3, 0.05, d));
         //Console.WriteLine(Gamma.CDF(3, 0.05, d));
         Console.WriteLine("" + d + ": " + distribution.CumulativeDistribution(d));
     }
 }

        public void SetupDistributions()
        {
            dists = new IDistribution[8];

            dists[0] = new Beta(1.0, 1.0);
            dists[1] = new ContinuousUniform(0.0, 1.0);
            dists[2] = new Gamma(1.0, 1.0);
            dists[3] = new Normal(0.0, 1.0);
            dists[4] = new Bernoulli(0.6);
            dists[5] = new Weibull(1.0, 1.0);
            dists[6] = new DiscreteUniform(1, 10);
            dists[7] = new LogNormal(1.0, 1.0);
        }

 public void SetShapeFailsWithNegativeShape()
 {
     var n = new Gamma(1.0, 1.0);
     n.Shape = -1.0;
 }

 public void CanCreateGamma(double shape, double invScale)
 {
     var n = new Gamma(shape, invScale);
     Assert.AreEqual(shape, n.Shape);
     Assert.AreEqual(invScale, n.Rate);
 }

 public void ValidateToString()
 {
     var n = new Gamma(1d, 2d);
     Assert.AreEqual("Gamma(α = 1, β = 2)", n.ToString());
 }

 public void ValidateSkewness(double shape, double invScale, double skewness)
 {
     var n = new Gamma(shape, invScale);
     AssertHelpers.AlmostEqualRelative(skewness, n.Skewness, 15);
 }

 public void ValidateMinimum()
 {
     var n = new Gamma(1.0, 1.0);
     Assert.AreEqual(0.0, n.Minimum);
 }

 public void ValidateMean(double shape, double invScale, double mean)
 {
     var n = new Gamma(shape, invScale);
     Assert.AreEqual(mean, n.Mean);
 }

 public void ValidateInverseCumulativeDistribution(int shape, double invScale, double x, double cdf)
 {
     var gamma = new Gamma(shape, invScale);
     Assert.That(gamma.InverseCumulativeDistribution(cdf), Is.EqualTo(x).Within(10));
     Assert.That(Gamma.InvCDF(shape, invScale, cdf), Is.EqualTo(x).Within(10));
 }

 public void ValidateCumulativeDistribution(int shape, double invScale, double x, double cdf)
 {
     var n = new Gamma(shape, invScale);
     AssertHelpers.AlmostEqual(cdf, n.CumulativeDistribution(x), 14);
     AssertHelpers.AlmostEqual(cdf, Gamma.CDF(shape, invScale, x), 14);
 }

 public void CanCreateGamma(double shape, double invScale)
 {
     var n = new Gamma(shape, invScale);
     AssertEx.AreEqual<double>(shape, n.Shape);
     AssertEx.AreEqual<double>(invScale, n.InvScale);
 }

 public void ValidateToString()
 {
     var n = new Gamma(1.0, 2.0);
     AssertEx.AreEqual<string>("Gamma(Shape = 1, Inverse Scale = 2)", n.ToString());
 }

 public void ValidateMedian(double shape, double invScale)
 {
     var n = new Gamma(shape, invScale);
     var median = n.Median;
 }

 public void ValidateMaximum()
 {
     var n = new Gamma(1.0, 1.0);
     AssertEx.AreEqual<double>(System.Double.PositiveInfinity, n.Maximum);
 }

 public void ValidateDensityLn(double shape, double invScale, double x, double pdfln)
 {
     var n = new Gamma(shape, invScale);
     AssertHelpers.AlmostEqual(pdfln, n.DensityLn(x), 14);
 }

 public void ValidateDensityLn(int shape, double invScale, double x, double pdfln)
 {
     var n = new Gamma(shape, invScale);
     AssertHelpers.AlmostEqualRelative(pdfln, n.DensityLn(x), 13);
     AssertHelpers.AlmostEqualRelative(pdfln, Gamma.PDFLn(shape, invScale, x), 13);
 }

 public void ValidateEntropy(double shape, double invScale, double entropy)
 {
     var n = new Gamma(shape, invScale);
     AssertHelpers.AlmostEqualRelative(entropy, n.Entropy, 12);
 }

 public void ValidateDensity(int shape, double invScale, double x, double pdf)
 {
     var n = new Gamma(shape, invScale);
     AssertHelpers.AlmostEqual(pdf, n.Density(x), 14);
     AssertHelpers.AlmostEqual(pdf, Gamma.PDF(shape, invScale, x), 14);
 }

 public void ValidateMaximum()
 {
     var n = new Gamma(1.0, 1.0);
     Assert.AreEqual(Double.PositiveInfinity, n.Maximum);
 }

 public void SetInvScaleFailsWithNegativeInvScale()
 {
     var n = new Gamma(1.0, 1.0);
     Assert.Throws<ArgumentOutOfRangeException>(() => n.Rate = -1.0);
 }