public void MedianTest()
{
int trials = 5;
{
BinomialDistribution target = new BinomialDistribution(trials, 0.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 0.2);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 0.6);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 0.8);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 1.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
}
public virtual void Test(double tolerance)
{
double p1 = _dist.CDF(_a[2]);
Assert.AreEqual(_a[3], p1, Math.Abs(_a[3] * tolerance), "Unexpected result of CDF");
double d1 = _dist.PDF(_a[2]);
Assert.AreEqual(_a[4], d1, Math.Abs(_a[4] * tolerance), "Unexpected result of PDF");
int len = 1000000;
int suml = 0;
for (int i = 0; i < len; i++)
{
if (_dist.NextDouble() <= _a[2])
{
suml++;
}
}
double p1_tested = suml / (double)len;
double confidence = BinomialDistribution.CDF(suml, _a[3], len);
Assert.Greater(confidence, 0.01, string.Format("Unexpected result of distribution of generated values : outside (left) the 1% confidence limits, expected p={0}, actual p={1}, confidence={2}", _a[3], p1_tested, confidence));
Assert.Less(confidence, 0.99, string.Format("Unexpected result of distribution of generated values : outside (right) the 1% confidence limits, expected p={0}, actual p={1}, confidence={2}", _a[3], p1_tested, confidence));
}
public void ProbabilityMassFunctionTest()
{
double[] expected =
{
0.0, 0.0260838446329553, 0.104335628936830, 0.198238170750635,
0.237886375826922, 0.202203904741285, 0.129410809619744,
0.0647055601029058, 0.0258822861585249, 0.00841176318971187,
0.00224314223412042
};
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.ProbabilityMassFunction(i - 1);
Assert.AreEqual(expected[i], actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
double logActual = target.LogProbabilityMassFunction(i - 1);
Assert.AreEqual(Math.Log(expected[i]), logActual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void icdf()
{
int trials = 1;
BinomialDistribution dist = new BinomialDistribution(trials, 0.5);
double icdf000 = dist.InverseDistributionFunction(0.0);
Assert.AreEqual(0, icdf000);
double icdf001 = dist.InverseDistributionFunction(0.1);
Assert.AreEqual(0, icdf001);
double icdf050 = dist.InverseDistributionFunction(0.5); // important
Assert.AreEqual(0, icdf050);
double icdf090 = dist.InverseDistributionFunction(0.9);
Assert.AreEqual(1, icdf090);
double icdf100 = dist.InverseDistributionFunction(0.9);
Assert.AreEqual(1, icdf100);
Assert.AreEqual(dist.Median, icdf050);
}
public ReportStatistics CalculateStatistics(int ptAge, decimal tumourSize, Grade grade, int numLVISeen, Report previousReport)
{
ReportStatistics statistics = new ReportStatistics();
// The four sets of Bayes theorum calculations need to be performed sequentially for the entire statistics set to be correct
CalculateAgeBasedStatistics(statistics, ptAge);
CalculateSizeBasedStatistics(statistics, tumourSize);
CalculatePreTestProbability(statistics, grade);
CalculatePostTestProbability(statistics, numLVISeen);
// Calculate the cumulative values based on results of previously submitted cases
int numberOfUserReports = previousReport != null ? previousReport.UserReportNumber + 1 : 1;
if (previousReport != null)
{
statistics.CumulativeBayesForGrade = previousReport.Statistics.CumulativeBayesForGrade + statistics.BayesForGrade;
statistics.CumulativeAverageBayesForGrade = statistics.CumulativeBayesForGrade / numberOfUserReports;
statistics.CumulativeCasesWithLVIPos = previousReport.Statistics.CumulativeCasesWithLVIPos + (statistics.LVIPresent ? 1 : 0);
}
else
{
statistics.CumulativeBayesForGrade = statistics.BayesForGrade;
statistics.CumulativeAverageBayesForGrade = statistics.CumulativeBayesForGrade / numberOfUserReports;
statistics.CumulativeCasesWithLVIPos = statistics.LVIPresent ? 1 : 0;
}
BinomialDistribution binomDist = new BinomialDistribution(numberOfUserReports, (double)statistics.CumulativeAverageBayesForGrade);
statistics.BinomialDist = (decimal)binomDist.ProbabilityMassFunction(statistics.CumulativeCasesWithLVIPos);
return(statistics);
}
protected override void EndProcessing()
{
var dist = new BinomialDistribution(Trials, Probability);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public void ConstructorTest()
{
var bin = new BinomialDistribution(trials: 16, probability: 0.12);
double mean = bin.Mean; // 1.92
double median = bin.Median; // 2
double var = bin.Variance; // 1.6896
double mode = bin.Mode; // 2
double cdf = bin.DistributionFunction(k: 0); // 0.12933699143209909
double pdf = bin.ProbabilityMassFunction(k: 1); // 0.28218979948821621
double lpdf = bin.LogProbabilityMassFunction(k: 0); // -2.0453339441581582
double ccdf = bin.ComplementaryDistributionFunction(k: 0); // 0.87066300856790091
int icdf0 = bin.InverseDistributionFunction(p: 0.37); // 1
int icdf1 = bin.InverseDistributionFunction(p: 0.50); // 2
int icdf2 = bin.InverseDistributionFunction(p: 0.99); // 5
int icdf3 = bin.InverseDistributionFunction(p: 0.999); // 7
double hf = bin.HazardFunction(x: 0); // 1.3809523809523814
double chf = bin.CumulativeHazardFunction(x: 0); // 0.86750056770472328
string str = bin.ToString(CultureInfo.InvariantCulture); // "Binomial(x; n = 16, p = 0.12)"
double[] probabilities = new double[10];
for (int i = 0; i < probabilities.Length; i++)
{
probabilities[i] = bin.ProbabilityMassFunction(i);
}
Assert.AreEqual(1.92, mean);
Assert.AreEqual(2, median);
Assert.AreEqual(2, mode);
Assert.AreEqual(1.6896, var);
Assert.AreEqual(0.13850027875444251, chf, 1e-10);
Assert.AreEqual(0.12933699143209909, cdf, 1e-10);
Assert.AreEqual(0.28218979948821621, pdf, 1e-10);
Assert.AreEqual(-2.0453339441581582, lpdf);
Assert.AreEqual(0.14855000173354949, hf, 1e-10);
Assert.AreEqual(0.87066300856790091, ccdf, 1e-10);
Assert.AreEqual(1, icdf0);
Assert.AreEqual(2, icdf1);
Assert.AreEqual(5, icdf2);
Assert.AreEqual(7, icdf3);
Assert.AreEqual("Binomial(x; n = 16, p = 0.12)", str);
var range1 = bin.GetRange(0.95);
var range2 = bin.GetRange(0.99);
var range3 = bin.GetRange(0.01);
Assert.AreEqual(0.0, range1.Min);
Assert.AreEqual(4.0, range1.Max);
Assert.AreEqual(0.0, range2.Min);
Assert.AreEqual(5.0, range2.Max);
Assert.AreEqual(0.0, range3.Min);
Assert.AreEqual(5.0, range3.Max);
}
public void OverflowTest()
{
var binom = new BinomialDistribution(3779, 0.0638);
double expected = 0.021944019794458;
double actual = binom.ProbabilityMassFunction(250);
Assert.AreEqual(expected, actual, 1e-7);
}
public void ConstructorTest()
{
var bin = new BinomialDistribution(trials: 16, probability: 0.12);
double mean = bin.Mean; // 1.92
double median = bin.Median; // 2
double var = bin.Variance; // 1.6896
double mode = bin.Mode; // 2
double cdf = bin.DistributionFunction(k: 0); // 0.12933699143209909
double pdf = bin.ProbabilityMassFunction(k: 1); // 0.28218979948821621
double lpdf = bin.LogProbabilityMassFunction(k: 0); // -2.0453339441581582
double ccdf = bin.ComplementaryDistributionFunction(k: 0); // 0.87066300856790091
int icdf0 = bin.InverseDistributionFunction(p: 0.37); // 1
int icdf1 = bin.InverseDistributionFunction(p: 0.50); // 2
int icdf2 = bin.InverseDistributionFunction(p: 0.99); // 5
int icdf3 = bin.InverseDistributionFunction(p: 0.999); // 7
double hf = bin.HazardFunction(x: 0); // 1.3809523809523814
double chf = bin.CumulativeHazardFunction(x: 0); // 0.86750056770472328
string str = bin.ToString(CultureInfo.InvariantCulture); // "Binomial(x; n = 16, p = 0.12)"
double[] probabilities = new double[10];
for (int i = 0; i < probabilities.Length; i++)
probabilities[i] = bin.ProbabilityMassFunction(i);
Assert.AreEqual(1.92, mean);
Assert.AreEqual(2, median);
Assert.AreEqual(2, mode);
Assert.AreEqual(1.6896, var);
Assert.AreEqual(0.13850027875444251, chf, 1e-10);
Assert.AreEqual(0.12933699143209909, cdf, 1e-10);
Assert.AreEqual(0.28218979948821621, pdf, 1e-10);
Assert.AreEqual(-2.0453339441581582, lpdf);
Assert.AreEqual(0.14855000173354949, hf, 1e-10);
Assert.AreEqual(0.87066300856790091, ccdf, 1e-10);
Assert.AreEqual(1, icdf0);
Assert.AreEqual(2, icdf1);
Assert.AreEqual(5, icdf2);
Assert.AreEqual(7, icdf3);
Assert.AreEqual("Binomial(x; n = 16, p = 0.12)", str);
var range1 = bin.GetRange(0.95);
var range2 = bin.GetRange(0.99);
var range3 = bin.GetRange(0.01);
Assert.AreEqual(0.0, range1.Min);
Assert.AreEqual(4.0, range1.Max);
Assert.AreEqual(0.0, range2.Min);
Assert.AreEqual(5.0, range2.Max);
Assert.AreEqual(0.0, range3.Min);
Assert.AreEqual(5.0, range3.Max);
}
public void NextInt32_Distribution()
{
var M = 3;
var values = Enumerable.Repeat(false, 10000)
.Select(_ => BinomialDistribution.NextInt32(M))
.ToArray();
WriteSummary(values, 2 * M);
}
public void OverflowTest()
{
// http://stackoverflow.com/questions/23222097/accord-net-binomial-probability-mass-function-result-differs-from-excel-result
var binom = new BinomialDistribution(3779, 0.0638);
double expected = 0.021944019794458;
double actual = binom.ProbabilityMassFunction(250);
Assert.AreEqual(expected, actual, 1e-7);
}
public void GenerateTest2()
{
var target = new BinomialDistribution(4, 0.2);
double[] samples = target.Generate(1000000).ToDouble();
target.Fit(samples);
Assert.AreEqual(4, target.NumberOfTrials, 0.01);
Assert.AreEqual(0.2, target.ProbabilityOfSuccess, 1e-3);
}
public void BinomialDistributionConstructorTest()
{
int trials = 5;
double probability = 0.52;
BinomialDistribution target = new BinomialDistribution(trials, probability);
Assert.AreEqual(trials, target.NumberOfTrials);
Assert.AreEqual(probability, target.ProbabilityOfSuccess);
Assert.AreEqual(trials * probability, target.Mean);
Assert.AreEqual(trials * probability * (1 - probability), target.Variance);
}
public void NextInt32ByMinMax_Distribution()
{
var m = 11;
var M = 16;
var values = Enumerable.Repeat(false, 10000)
.Select(_ => BinomialDistribution.NextInt32ByMinMax(m, M))
.ToArray();
WriteSummary(values, M - m);
}
public void GenerateTest3()
{
var target = new BinomialDistribution(4);
int[] samples = { 1, 0, 3, 1, 2, 3 };
target.Fit(samples);
Assert.AreEqual(4, target.NumberOfTrials, 0.01);
Assert.AreEqual(0.41666666666666669, target.ProbabilityOfSuccess, 1e-3);
}
/// <summary>
/// This will perform a binomial hypothesis test.
/// </summary>
/// <param name="sampleSuccess">How many were successful</param>
/// <param name="n"></param>
/// <param name="p"></param>
/// <param name="tail">Perform test on upper or lower tail</param>
/// <param name="signLevel">Significance level.</param>
/// <returns>True means that there is enough evidence to reject the null hypothesis.</returns>
public static bool HypoTest(int sampleSuccess, int n, double p, AlternateHypo tail, double signLevel)
{
try
{
int[] x = Enumerable.Range(0, n + 1).ToArray();
BinomialDistribution distribution = new BinomialDistribution(n, p);
switch (tail)
{
case AlternateHypo.LessThan:
{
int criticalRegion = x.AsParallel()
.Where(num => distribution.DistributionFunction(num) < signLevel)
.OrderBy(num => num)
.First();
if (sampleSuccess <= criticalRegion)
{
return(true);
}
else
{
return(false);
}
}
default:
{
int criticalRegion = x.AsParallel()
.Where(num => (1 - distribution.DistributionFunction(num)) < signLevel)
.OrderBy(num => num)
.First();
if (sampleSuccess >= criticalRegion)
{
return(true);
}
else
{
return(false);
}
}
}
}
catch (InvalidOperationException)
{
return(false); //Because there is no evidence at all.
}
catch
{
throw;
}
}
public void NextInt32()
{
var M = 3;
var values = Enumerable.Repeat(false, 10000)
.Select(_ => BinomialDistribution.NextInt32(M));
foreach (var x in values)
{
Assert.IsTrue(Abs(x) <= M);
}
}
public void FitTest()
{
int trials = 5;
BinomialDistribution target = new BinomialDistribution(trials);
double[] observations = { 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0 };
double[] weights = null;
IFittingOptions options = null;
target.Fit(observations, weights, options);
Assert.AreEqual(4.0 / trials, target.ProbabilityOfSuccess);
}
public void NextInt32ByMinMax()
{
var m = 11;
var M = 16;
var values = Enumerable.Repeat(false, 10000)
.Select(_ => BinomialDistribution.NextInt32ByMinMax(m, M));
foreach (var x in values)
{
Assert.IsTrue(m <= x && x <= M);
}
}
public void BinomialNegativeBinomialRelation()
{
int k = 2;
int r = 3;
double p = 0.4;
NegativeBinomialDistribution nb = new NegativeBinomialDistribution(r, p);
int n = r + k;
BinomialDistribution b = new BinomialDistribution(p, n);
double nbP = nb.LeftInclusiveProbability(k);
double bP = b.LeftInclusiveProbability(k);
}
public void CloneTest()
{
int trials = 3;
double probability = 0.52;
BinomialDistribution target = new BinomialDistribution(trials, probability);
BinomialDistribution actual = (BinomialDistribution)target.Clone();
Assert.AreNotSame(target, actual);
Assert.AreNotEqual(target, actual);
Assert.AreEqual(target.NumberOfTrials, actual.NumberOfTrials);
Assert.AreEqual(target.ProbabilityOfSuccess, actual.ProbabilityOfSuccess);
}
public FuncionBinomial(double[] eventos) : base(eventos)
{
try
{
DistribucionDiscreta = new BinomialDistribution();
DistribucionDiscreta.Fit(eventos);
n = ((BinomialDistribution)DistribucionDiscreta).NumberOfTrials.ToString("0.0000");
p = ((BinomialDistribution)DistribucionDiscreta).ProbabilityOfSuccess.ToString("0.0000");
Resultado = new ResultadoAjuste(StringFDP, StringInversa, DistribucionDiscreta.StandardDeviation, DistribucionDiscreta.Mean, DistribucionDiscreta.Variance, this);
}
catch (Exception)
{
Resultado = null;
}
}
public void DistributionFunctionTest3()
{
// http://www.danielsoper.com/statcalc3/calc.aspx?id=70
double probability = 0.2;
int successes = 2;
int trials = 10;
BinomialDistribution target = new BinomialDistribution(trials, probability);
double actual = target.DistributionFunction(successes);
double expected = 0.67779953;
Assert.AreEqual(expected, actual, 1e-5);
}
public void DistributionFunctionTest()
{
// http://www.stat.yale.edu/Courses/1997-98/101/binom.htm
// Verified in http://stattrek.com/online-calculator/binomial.aspx
double[] pmf = { 0.0260838446329553, 0.10433562893683, 0.198238170750635, 0.237886375826923, 0.202203904741285 };
double[] cdfLess = { 0.0000000000000000, 0.0260838446329553, 0.130419473569785, 0.32865764432042, 0.566544020147343 };
double[] cdfLessEqual = { 0.0260838446329553, 0.130419473569785, 0.32865764432042, 0.566544020147343, 0.768747924888628 };
double[] cdfGreater = { 0.973916155367045, 0.869580526430215, 0.67134235567958, 0.433455979852657, 0.231252075111372 };
double[] cdfGreaterEqual = { 1.000000000000000, 0.973916155367045, 0.869580526430215, 0.67134235567958, 0.433455979852657 };
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < pmf.Length; i++)
{
{ // P(X = i)
double actual = target.ProbabilityMassFunction(i);
Assert.AreEqual(pmf[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X <= i)
double actual = target.DistributionFunction(i);
Assert.AreEqual(cdfLessEqual[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X < i)
double actual = target.DistributionFunction(i, inclusive: false);
Assert.AreEqual(cdfLess[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X > i)
double actual = target.ComplementaryDistributionFunction(i);
Assert.AreEqual(cdfGreater[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X >= i)
double actual = target.ComplementaryDistributionFunction(i, inclusive: true);
Assert.AreEqual(cdfGreaterEqual[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
}
}
public static List <double> BinomialRandMatrix(int size, int trials = 1, double p = 0.5)
{
BinomialDistribution rnd = new BinomialDistribution();
rnd.Alpha = p;
rnd.Beta = trials;
List <double> temp = new List <double>(size);
double layer;
for (int i = 0; i < size; i++)
{
layer = rnd.NextDouble();
temp.Add(layer);
}
return(temp);
}
public void InverseDistributionFunctionTest()
{
double[] pvalues = { 0.0260838, 0.130419, 0.3287, 0.5665, 0.7687, 0.8982, 0.9629, 0.9887, 0.9972, 0.9994 };
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < pvalues.Length; i++)
{
double p = pvalues[i] + 1e-4;
double actual = target.InverseDistributionFunction(p);
Assert.AreEqual(i + 1, actual);
}
}
public void DistributionFunctionTest()
{
// http://www.stat.yale.edu/Courses/1997-98/101/binom.htm
double[] expected = { 0.0261, 0.1304, 0.3287, 0.5665, 0.7687, 0.8982, 0.9629, 0.9887, 0.9972, 0.9994 };
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.DistributionFunction(i);
Assert.AreEqual(expected[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void BinomialGenerateTest()
{
// Create a Binomial with n = 4 and p = 0.2
var binomial = new BinomialDistribution(4, 0.2);
// Generate 1000000 samples from it
double[] samples = binomial.Generate(1000000).ToDouble();
// Try to estimate a new Binomial distribution from
// generated samples to check if they indeed match
var actual = new BinomialDistribution(4);
actual.Fit(samples);
string result = actual.ToString("N2"); // Binomial(x; n = 4.00, p = 0.20)
Assert.AreEqual("Binomial(x; n = 4.00, p = 0.20)", result);
}
public Form1()
{
InitializeComponent();
//--
mTranslations = new Dictionary <string, Translations>();
mPlainListWords = new PlainWords();
//--
mBinominalDistr = new BinomialDistribution();
mTriangleDistr = new TriangularDistribution();
mUniformDistr = new DiscreteUniformDistribution();
mContUniformDist = new ContinuousUniformDistribution();
mRnd = new Random();
mStopTimer = false;
}
public static Matrix BinomialRandMatrix(Tuple <int, int> size, int trials = 1, double p = 0.5)
{
BinomialDistribution rnd = new BinomialDistribution();
rnd.Alpha = p;
rnd.Beta = trials;
Matrix temp = new Matrix(size.Item1, size.Item2);
for (int i = 0; i < size.Item1; i++)
{
for (int j = 0; j < size.Item2; j++)
{
temp[i, j] = rnd.NextDouble();
}
}
return(temp);
}
public void BinomialGenerateTest()
{
// Create a Binomial with n = 4 and p = 0.2
var binomial = new BinomialDistribution(4, 0.2);
// Generate 1000000 samples from it
double[] samples = binomial.Generate(1000000).ToDouble();
// Try to estimate a new Binomial distribution from
// generated samples to check if they indeed match
var actual = new BinomialDistribution(4);
actual.Fit(samples);
string result = actual.ToString("N2"); // Binomial(x; n = 4.00, p = 0.20)
Assert.AreEqual("Binomial(x; n = 4.00, p = 0.20)", result);
}
public void TestBinomialDistribution()
{
double[][] para =
{
new double[] { 10, 0.75, 7, 0.4744071960449218750000000, 0.2502822875976562500000000 },
new double[] { 100, 0.375, 40, 0.7339137587545079200156959, 0.07115992585884902329546213 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new DiscDistTester(para[i], delegate(double a, double b)
{
var ret = new BinomialDistribution((int)a, b);
return(ret);
}
);
tester.Test(1E-12);
}
}
public void OverflowTest()
{
// http://stackoverflow.com/questions/23222097/accord-net-binomial-probability-mass-function-result-differs-from-excel-result
var binom = new BinomialDistribution(3779, 0.0638);
double expected = 0.021944019794458;
double actual = binom.ProbabilityMassFunction(250);
Assert.AreEqual(expected, actual, 1e-7);
}
public void MedianTest()
{
int trials = 5;
{
BinomialDistribution target = new BinomialDistribution(trials, 0.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 0.2);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 0.6);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 0.8);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BinomialDistribution target = new BinomialDistribution(trials, 1.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
}
public void DistributionFunctionTest3()
{
// http://www.danielsoper.com/statcalc3/calc.aspx?id=70
double probability = 0.2;
int successes = 2;
int trials = 10;
BinomialDistribution target = new BinomialDistribution(trials, probability);
double actual = target.DistributionFunction(successes);
double expected = 0.67779953;
Assert.AreEqual(expected, actual, 1e-5);
}
public void InverseDistributionFunctionTest()
{
double[] pvalues = { 0.0260838, 0.130419, 0.3287, 0.5665, 0.7687, 0.8982, 0.9629, 0.9887, 0.9972, 0.9994 };
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < pvalues.Length; i++)
{
double p = pvalues[i] + 1e-4;
double actual = target.InverseDistributionFunction(p);
Assert.AreEqual(i + 1, actual);
}
}
public void DistributionFunctionTest2()
{
// http://www.stat.yale.edu/Courses/1997-98/101/binom.htm
// Verified in http://stattrek.com/online-calculator/binomial.aspx
double[] expected = { 0.0260838, 0.130419, 0.3287, 0.5665, 0.7687, 0.8982, 0.9629, 0.9887, 0.9972, 0.9994 };
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.DistributionFunction(i);
Assert.AreEqual(expected[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void DistributionFunctionTest()
{
// http://www.stat.yale.edu/Courses/1997-98/101/binom.htm
// Verified in http://stattrek.com/online-calculator/binomial.aspx
double[] pmf = { 0.0260838446329553, 0.10433562893683, 0.198238170750635, 0.237886375826923, 0.202203904741285 };
double[] cdfLess = { 0.0000000000000000, 0.0260838446329553, 0.130419473569785, 0.32865764432042, 0.566544020147343 };
double[] cdfLessEqual = { 0.0260838446329553, 0.130419473569785, 0.32865764432042, 0.566544020147343, 0.768747924888628 };
double[] cdfGreater = { 0.973916155367045, 0.869580526430215, 0.67134235567958, 0.433455979852657, 0.231252075111372 };
double[] cdfGreaterEqual = { 1.000000000000000, 0.973916155367045, 0.869580526430215, 0.67134235567958, 0.433455979852657 };
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < pmf.Length; i++)
{
{ // P(X = i)
double actual = target.ProbabilityMassFunction(i);
Assert.AreEqual(pmf[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X <= i)
double actual = target.DistributionFunction(i);
Assert.AreEqual(cdfLessEqual[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X < i)
double actual = target.DistributionFunction(i, inclusive: false);
Assert.AreEqual(cdfLess[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X > i)
double actual = target.ComplementaryDistributionFunction(i);
Assert.AreEqual(cdfGreater[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
{ // P(X >= i)
double actual = target.ComplementaryDistributionFunction(i, inclusive: true);
Assert.AreEqual(cdfGreaterEqual[i], actual, 1e-4);
Assert.IsFalse(Double.IsNaN(actual));
}
}
}
public void CloneTest()
{
int trials = 3;
double probability = 0.52;
BinomialDistribution target = new BinomialDistribution(trials, probability);
BinomialDistribution actual = (BinomialDistribution)target.Clone();
Assert.AreNotSame(target, actual);
Assert.AreNotEqual(target, actual);
Assert.AreEqual(target.NumberOfTrials, actual.NumberOfTrials);
Assert.AreEqual(target.ProbabilityOfSuccess, actual.ProbabilityOfSuccess);
}
/// <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>
/// <remarks>
/// Equivalent to:
/// <code>
/// NMathStatsChart.Show( ToChart( dist, function ) );
/// </code>
/// </remarks>
public static void Show( BinomialDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
Show( ToChart( dist, function ) );
}
/// <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>
/// <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, BinomialDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
List<string> titles = new List<string>()
{
"BinomialDistribution",
String.Format("n={0}, p={1}", dist.N, dist.P)
};
UpdateDiscreteDistribution( ref chart, dist, titles, function );
}
public void GenerateTest2()
{
var target = new BinomialDistribution(4, 0.2);
double[] samples = target.Generate(1000000).ToDouble();
target.Fit(samples);
Assert.AreEqual(4, target.NumberOfTrials, 0.01);
Assert.AreEqual(0.2, target.ProbabilityOfSuccess, 1e-3);
}
/// <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>
/// <returns>A new chart.</returns>
public static ChartControl ToChart( BinomialDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
ChartControl chart = GetDefaultChart();
Update( ref chart, dist, function );
return chart;
}
public void GenerateTest3()
{
var target = new BinomialDistribution(4);
int[] samples = { 1, 0, 3, 1, 2, 3 };
target.Fit(samples);
Assert.AreEqual(4, target.NumberOfTrials, 0.01);
Assert.AreEqual(0.41666666666666669, target.ProbabilityOfSuccess, 1e-3);
}
public void ProbabilityMassFunctionTest()
{
double[] expected =
{
0.0, 0.0260838446329553, 0.104335628936830, 0.198238170750635,
0.237886375826922, 0.202203904741285, 0.129410809619744,
0.0647055601029058, 0.0258822861585249, 0.00841176318971187,
0.00224314223412042
};
int trials = 20;
double probability = 0.166667;
BinomialDistribution target = new BinomialDistribution(trials, probability);
for (int i = 0; i < expected.Length; i++)
{
double actual = target.ProbabilityMassFunction(i - 1);
Assert.AreEqual(expected[i], actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
double logActual = target.LogProbabilityMassFunction(i - 1);
Assert.AreEqual(Math.Log(expected[i]), logActual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void FitTest()
{
int trials = 5;
BinomialDistribution target = new BinomialDistribution(trials);
double[] observations = { 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0 };
double[] weights = null;
IFittingOptions options = null;
target.Fit(observations, weights, options);
Assert.AreEqual(5, target.NumberOfTrials);
Assert.AreEqual(0.066666666666666666, target.ProbabilityOfSuccess, 1e-10);
}
public void BinomialDistributionConstructorTest()
{
int trials = 5;
double probability = 0.52;
BinomialDistribution target = new BinomialDistribution(trials, probability);
Assert.AreEqual(trials, target.NumberOfTrials);
Assert.AreEqual(probability, target.ProbabilityOfSuccess);
Assert.AreEqual(trials * probability, target.Mean);
Assert.AreEqual(trials * probability * (1 - probability), target.Variance);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(BinomialDistribution obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public void OverflowTest()
{
var binom = new BinomialDistribution(3779, 0.0638);
double expected = 0.021944019794458;
double actual = binom.ProbabilityMassFunction(250);
Assert.AreEqual(expected, actual, 1e-7);
}
