public void CanCreateHypergeometric(int population, int success, int draws)
 {
     var d = new Hypergeometric(population, success, draws);
     Assert.AreEqual(population, d.Population);
     Assert.AreEqual(success, d.Success);
     Assert.AreEqual(draws, d.Draws);
 }

 public void CanCreateHypergeometric(int size, int m, int n)
 {
     var d = new Hypergeometric(size, m, n);
     Assert.AreEqual(size, d.PopulationSize);
     Assert.AreEqual(m, d.M);
     Assert.AreEqual(n, d.N);
 }

 public void CanCreateHypergeometric([Values(0, 1, 2, 2, 10, 10)] int size, [Values(0, 1, 1, 2, 1, 5)] int m, [Values(0, 1, 1, 2, 1, 3)] int n)
 {
     var d = new Hypergeometric(size, m, n);
     Assert.AreEqual(size, d.PopulationSize);
     Assert.AreEqual(m, d.M);
     Assert.AreEqual(n, d.N);
 }

 public void CanCreateHypergeometric(int N, int m, int n)
 {
     var d = new Hypergeometric(N, m, n);
     Assert.AreEqual<double>(N, d.PopulationSize);
     Assert.AreEqual<double>(m, d.M);
     Assert.AreEqual<double>(n, d.N);
 }

 public void SetSuccessFails(int success)
 {
     var d = new Hypergeometric(10, 1, 1);
     Assert.Throws<ArgumentOutOfRangeException>(() => d.Success = success);
 }

 public void SetPopulationFails(int population)
 {
     var d = new Hypergeometric(10, 1, 1);
     Assert.Throws<ArgumentOutOfRangeException>(() => d.Population = population);
 }

 public void ValidateEntropy()
 {
     var d = new Hypergeometric(10, 1, 1);
     var e = d.Entropy;
 }

 public void ValidateToString()
 {
     var d = new Hypergeometric(10, 1, 1);
     Assert.AreEqual("Hypergeometric(N = 10, M = 1, n = 1)", d.ToString());
 }

 public void ValidateProbabilityLn(int population, int success, int draws, int x)
 {
     var d = new Hypergeometric(population, success, draws);
     Assert.AreEqual(Math.Log(d.Probability(x)), d.ProbabilityLn(x));
 }

 public void ValidateMode(int population, int success, int draws)
 {
     var d = new Hypergeometric(population, success, draws);
     Assert.AreEqual((draws + 1)*(success + 1)/(population + 2), d.Mode);
 }

 public void ValidateMedianThrowsNotSupportedException()
 {
     var d = new Hypergeometric(10, 1, 1);
     Assert.Throws<NotSupportedException>(() => { var m = d.Median; });
 }

 public void ValidateSkewness(int N, int m, int n)
 {
     var d = new Hypergeometric(N, m, n);
     Assert.AreEqual<double>((Math.Sqrt(N - 1.0) * (N - 2 * n) * (N - 2 * m)) / (Math.Sqrt(n * m * (N - m) * (N - n)) * (N - 2.0)), d.Skewness);
 }

 public void ValidateProbabilityLn(int N, int m, int n, int x)
 {
     var d = new Hypergeometric(N, m, n);
     Assert.AreEqual(Math.Log(d.Probability(x)), d.ProbabilityLn(x));
 }

 public void ValidateProbability(int N, int m, int n, int x)
 {
     var d = new Hypergeometric(N, m, n);
     Assert.AreEqual<double>(SpecialFunctions.Binomial(m, x) * SpecialFunctions.Binomial(N - m, n - x) / SpecialFunctions.Binomial(N, n), d.Probability(x));
 }

 public void ValidateMode(int N, int m, int n)
 {
     var d = new Hypergeometric(N, m, n);
     Assert.AreEqual<double>((n + 1) * (m + 1) / (N + 2), d.Mode);
 }

 public void ValidateMinimum(int N, int m, int n)
 {
     var d = new Hypergeometric(N, m, n);
     Assert.AreEqual(Math.Max(0, n + m - N), d.Minimum);
 }

 public void ValidateMedian()
 {
     var d = new Hypergeometric(10, 1, 1);
     var m = d.Median;
 }

 public void ValidateCumulativeDistribution(int population, int success, int draws, double x, double cdf)
 {
     var d = new Hypergeometric(population, success, draws);
     AssertHelpers.AlmostEqual(cdf, d.CumulativeDistribution(x), 10);
 }

 public void ValidateEntropyThrowsNotSupportedException()
 {
     var d = new Hypergeometric(10, 1, 1);
     Assert.Throws<NotSupportedException>(() => { var e = d.Entropy; });
 }

 public void CanSetm(int m)
 {
     var d = new Hypergeometric(10, 1, 1);
     d.M = m;
 }