public void BetaVosePERTTest_ModeEqualMean()
        {
            // Create a Beta from a minimum, maximum and most likely value
            var b = GeneralizedBetaDistribution.Vose(min: 1, max: 3, mode: 2);

            double mean   = b.Mean;
            double median = b.Median;
            double var    = b.Variance;
            double mode   = b.Mode;

            double min   = b.Min;
            double max   = b.Max;
            double alpha = b.Alpha;
            double beta  = b.Beta;

            Assert.AreEqual(mean, median);
            Assert.AreEqual(mean, mode);

            Assert.AreEqual(2, mean);
            Assert.AreEqual(2, median);
            Assert.AreEqual(2, mode);
            Assert.AreEqual(0.055555555555555552, var);
            Assert.AreEqual(1, min);
            Assert.AreEqual(3, max);
            Assert.AreEqual(4, alpha);
            Assert.AreEqual(4, beta);
        }
        public void BetaMLEFitTest1()
        {
            double[] x = samples;

            {
                var target  = GeneralizedBetaDistribution.Standard(1, 1);
                var options = new BetaOptions()
                {
                    Method = BetaEstimationMethod.Moments
                };
                target.Fit(x, options);

                Assert.AreEqual(1, target.Alpha, 0.04);
                Assert.AreEqual(3, target.Beta, 0.5);
            }

            {
                var target  = GeneralizedBetaDistribution.Standard(0, 1);
                var options = new BetaOptions()
                {
                    Method = BetaEstimationMethod.MaximumLikelihood
                };
                target.Fit(x, options);

                Assert.AreEqual(1, target.Alpha, 0.04);
                Assert.AreEqual(3, target.Beta, 0.55);
            }
        }
        public void BetaPERTTest()
        {
            // Create a Beta from a minimum, maximum and most likely value
            var b = GeneralizedBetaDistribution.Pert(min: 1, max: 3, mode: 2);

            double mean   = b.Mean;     // 2
            double median = b.Median;   // 2
            double mode   = b.Mode;     // 2
            double var    = b.Variance; // 0.071428571428571425

            double min   = b.Min;
            double max   = b.Max;
            double alpha = b.Alpha;
            double beta  = b.Beta;

            Assert.AreEqual(mean, median);
            Assert.AreEqual(mean, mode);

            Assert.AreEqual(2, mean);
            Assert.AreEqual(2, median);
            Assert.AreEqual(2.0, mode);

            Assert.AreEqual(0.071428571428571425, var);
            Assert.AreEqual(1.0, min);
            Assert.AreEqual(3, max);
            Assert.AreEqual(3, alpha);
            Assert.AreEqual(3, beta);
        }
Exemplo n.º 4
0
        public void BetaVosePERTTest()
        {
            #region doc_pert2
            // Create a Beta from a minimum, maximum and most likely value
            var b = GeneralizedBetaDistribution.Vose(min: 1, max: 3, mode: 1.42);

            double mean   = b.Mean;     // 1.6133333333333333
            double median = b.Median;   // 1.5727889200146494
            double mode   = b.Mode;     // 1.4471823077804513
            double var    = b.Variance; // 0.055555555555555546
            #endregion

            double min   = b.Min;
            double max   = b.Max;
            double alpha = b.Alpha;
            double beta  = b.Beta;

            Assert.AreEqual(1.6133333333333333, mean);
            Assert.AreEqual(1.5727889200146494, median);
            Assert.AreEqual(0.055555555555555546, var);
            Assert.AreEqual(1.4471823077804513, mode);
            Assert.AreEqual(1, min);
            Assert.AreEqual(3, max);
            Assert.AreEqual(2.0406826666666666, alpha);
            Assert.AreEqual(4.6137173333333337, beta);
        }
        public void BetaRandomTest2()
        {
            Accord.Math.Tools.SetupGenerator(0);

            int n = 100000;

            double[] samples = GeneralizedBetaDistribution
                               .Random(alpha: 2, beta: 3, min: 10, max: 15, samples: n);

            for (int i = 0; i < samples.Length; i++)
            {
                Assert.IsTrue(samples[i] > 10);
                Assert.IsTrue(samples[i] < 15);
            }

            Assert.AreEqual(n, samples.Length);

            var actual = GeneralizedBetaDistribution.Estimate(samples, 10, 15,
                                                              new GeneralizedBetaOptions {
                Method = BetaEstimationMethod.MaximumLikelihood
            });

            Assert.AreEqual(2, actual.Alpha, 0.015);
            Assert.AreEqual(3, actual.Beta, 0.03);
        }
        public void BetaDistributionConstructorTest()
        {
            double expected, actual;

            {
                var target = new GeneralizedBetaDistribution(1.73, 4.2);
                actual   = target.ProbabilityDensityFunction(-1);
                expected = 0;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual   = target.ProbabilityDensityFunction(0);
                expected = 0;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual   = target.ProbabilityDensityFunction(1);
                expected = 0;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual   = target.ProbabilityDensityFunction(0.2);
                expected = 2.27095841;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual   = target.ProbabilityDensityFunction(0.4);
                expected = 1.50022749;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));
            }
        }
        public void BetaDistributionConstructorTest()
        {
            double expected, actual;

            {
                var target = new GeneralizedBetaDistribution(1.73, 4.2);
                actual = target.ProbabilityDensityFunction(-1);
                expected = 0;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual = target.ProbabilityDensityFunction(0);
                expected = 0;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual = target.ProbabilityDensityFunction(1);
                expected = 0;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual = target.ProbabilityDensityFunction(0.2);
                expected = 2.27095841;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));

                actual = target.ProbabilityDensityFunction(0.4);
                expected = 1.50022749;
                Assert.AreEqual(expected, actual, 1e-7);
                Assert.IsFalse(Double.IsNaN(actual));
            }
        }
        public void MedianTest()
        {
            double alpha = 0.42;
            double beta  = 1.57;

            var target = new GeneralizedBetaDistribution(alpha, beta);

            Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
        }
        public void MedianTest()
        {
            double alpha = 0.42;
            double beta = 1.57;

            var target = new GeneralizedBetaDistribution(alpha, beta);

            Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
        }
Exemplo n.º 10
0
        public void BetaMeanTest()
        {
            #region doc_create2
            double alpha = 0.42;
            double beta  = 1.57;

            var betaDistribution = new GeneralizedBetaDistribution(alpha, beta);

            double mean   = betaDistribution.Mean;                                                     // 0.21105527638190955
            double median = betaDistribution.Median;                                                   // 0.11577706212908731
            double var    = betaDistribution.Variance;                                                 // 0.055689279830523512
            double mode   = betaDistribution.Mode;                                                     // 57.999999999999957

            double chf  = betaDistribution.CumulativeHazardFunction(x: 0.27);                          // 1.1828193992944409
            double cdf  = betaDistribution.DistributionFunction(x: 0.27);                              // 0.69358638272337991
            double pdf  = betaDistribution.ProbabilityDensityFunction(x: 0.27);                        // 0.94644031936694828
            double lpdf = betaDistribution.LogProbabilityDensityFunction(x: 0.27);                     // -0.055047364344046057
            double hf   = betaDistribution.HazardFunction(x: 0.27);                                    // 3.0887671630877072
            double ccdf = betaDistribution.ComplementaryDistributionFunction(x: 0.27);                 // 0.30641361727662009
            double icdf = betaDistribution.InverseDistributionFunction(p: cdf);                        // 0.26999999068687469

            string str = betaDistribution.ToString(System.Globalization.CultureInfo.InvariantCulture); // "B(x; α = 0.42, β = 1.57)
            #endregion

            Assert.AreEqual(0.21105527638190955, mean);
            Assert.AreEqual(0.11577706212908731, median);
            Assert.AreEqual(57.999999999999957, mode);
            Assert.AreEqual(0.055689279830523512, var);
            Assert.AreEqual(1.1828193992944409, chf);
            Assert.AreEqual(0.69358638272337991, cdf);
            Assert.AreEqual(0.94644031936694828, pdf);
            Assert.AreEqual(-0.055047364344046057, lpdf);
            Assert.AreEqual(3.0887671630877072, hf);
            Assert.AreEqual(0.30641361727662009, ccdf);
            Assert.AreEqual(0.27, icdf, 1e-10);
            Assert.AreEqual("B(x; α = 0.42, β = 1.57, min = 0, max = 1)", str);

            Assert.IsFalse(Double.IsNaN(median));

            var range1 = betaDistribution.GetRange(0.95);
            var range2 = betaDistribution.GetRange(0.99);
            var range3 = betaDistribution.GetRange(0.01);

            Assert.AreEqual(0.00045925525776717733, range1.Min);
            Assert.AreEqual(0.72381020663218609, range1.Max);
            Assert.AreEqual(0.0000099485893745082635, range2.Min);
            Assert.AreEqual(0.89625688707910811, range2.Max);
            Assert.AreEqual(0.0000099485893745082432, range3.Min);
            Assert.AreEqual(0.89625688707910811, range3.Max);


            Assert.AreEqual(0, betaDistribution.Support.Min);
            Assert.AreEqual(1, betaDistribution.Support.Max);

            Assert.AreEqual(betaDistribution.InverseDistributionFunction(0), betaDistribution.Support.Min);
            Assert.AreEqual(betaDistribution.InverseDistributionFunction(1), betaDistribution.Support.Max);
        }
        public void BetaFitTest1()
        {
            double[] x = { 0.1, 0.5, 0.3, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9, 0.9 };

            var target = GeneralizedBetaDistribution.Standard(0, 1);

            target.Fit(x);

            Assert.AreEqual(1.1810718232044195, target.Alpha, 1e-10);
            Assert.AreEqual(0.60843093922651903, target.Beta, 1e-10);
        }
Exemplo n.º 12
0
        public int Sample()
        {
            if (null == _distribution)
            {
                _distribution = GeneralizedBetaDistribution.Vose(Min, Max, Mode);
            }

            var value = (int)Math.Round(_distribution.Generate());

            return(value);
        }
        public void BetaFit_IntWeights()
        {
            double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 };
            int[]    w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 };

            var target = new GeneralizedBetaDistribution(1, 1);

            target.Fit(x, w);

            Assert.AreEqual(1.1810718232044195, target.Alpha);
            Assert.AreEqual(0.60843093922651903, target.Beta, 1e-8);
        }
        public void BetaFit_RealWeights()
        {
            double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 };
            int[]    w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 };

            var target = new GeneralizedBetaDistribution(1, 1);

            target.Fit(x, w.ToDouble());

            Assert.AreEqual(1.1401591160220996, target.Alpha);
            Assert.AreEqual(0.58735469613259694, target.Beta);
        }
Exemplo n.º 15
0
        public void NoncentralBetaMeanTest()
        {
            #region doc_create
            // Create a 4-parameter Beta distribution with the following parameters (α, β, a, b):
            var beta = new GeneralizedBetaDistribution(alpha: 1.42, beta: 1.57, min: 1, max: 4.2);

            double mean   = beta.Mean;                                                     // 2.5197324414715716
            double median = beta.Median;                                                   // 2.4997705845160225
            double var    = beta.Variance;                                                 // 0.19999664152943961
            double mode   = beta.Mode;                                                     // 2.3575757575757574
            double h      = beta.Entropy;                                                  // -0.050654548091478513

            double cdf  = beta.DistributionFunction(x: 2.27);                              // 0.40828630817664596
            double pdf  = beta.ProbabilityDensityFunction(x: 2.27);                        // 1.2766172921464953
            double lpdf = beta.LogProbabilityDensityFunction(x: 2.27);                     // 0.2442138392176838

            double chf = beta.CumulativeHazardFunction(x: 2.27);                           // 0.5247323897609667
            double hf  = beta.HazardFunction(x: 2.27);                                     // 2.1574915534109484

            double ccdf = beta.ComplementaryDistributionFunction(x: 2.27);                 // 0.59171369182335409
            double icdf = beta.InverseDistributionFunction(p: cdf);                        // 2.27

            string str = beta.ToString(System.Globalization.CultureInfo.InvariantCulture); // "B(x; α = 1.42, β = 1.57, min = 1, max = 4.2)"
            #endregion

            Assert.AreEqual(2.5197324414715716, mean);
            Assert.AreEqual(2.4997705845160225, median);
            Assert.AreEqual(2.3575757575757574, mode);
            Assert.AreEqual(-0.050654548091478513, h);
            Assert.AreEqual(0.19999664152943961, var);
            Assert.AreEqual(0.5247323897609667, chf);
            Assert.AreEqual(0.40828630817664596, cdf);
            Assert.AreEqual(0.39894290379577979, pdf);
            Assert.AreEqual(-0.91893697058799706, lpdf);
            Assert.AreEqual(0.67421611044092133, hf);
            Assert.AreEqual(0.59171369182335409, ccdf);
            Assert.AreEqual(2.27, icdf, 1e-10);
            Assert.AreEqual("B(x; α = 1.42, β = 1.57, min = 1, max = 4.2)", str);

            Assert.IsFalse(Double.IsNaN(median));

            var range1 = beta.GetRange(0.95);
            var range2 = beta.GetRange(0.99);
            var range3 = beta.GetRange(0.01);

            Assert.AreEqual(1.2650560572620337, range1.Min);
            Assert.AreEqual(3.8411806104750186, range1.Max);
            Assert.AreEqual(1.0841613594568846, range2.Min);
            Assert.AreEqual(4.0728683052205534, range2.Max);
            Assert.AreEqual(1.0841613594568846, range3.Min);
            Assert.AreEqual(4.0728683052205534, range3.Max);
        }
        public void BetaRandomTest()
        {
            Accord.Math.Tools.SetupGenerator(0);

            int n = 100000;

            double[] samples = GeneralizedBetaDistribution
                               .Random(alpha: 2, beta: 3, min: 0, max: 1, samples: n);

            Assert.AreEqual(n, samples.Length);

            var actual = GeneralizedBetaDistribution.Estimate(samples, 0, 1);

            Assert.AreEqual(2, actual.Alpha, 1e-2);
            Assert.AreEqual(3, actual.Beta, 1e-2);
        }
        public void BetaMLEFit_IntWeights()
        {
            double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 };
            int[]    w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 };

            var target = GeneralizedBetaDistribution.Standard(0, 1);


            var options = new BetaOptions()
            {
                Method = BetaEstimationMethod.MaximumLikelihood
            };

            target.Fit(x, w, options);

            Assert.AreEqual(1.1810718232044195, target.Alpha);
            Assert.AreEqual(0.60843093922651903, target.Beta, 1e-10);
        }
        public void BetaMLEFit_RealWeights()
        {
            double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 };
            int[]    w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 };

            var target = new GeneralizedBetaDistribution(1, 1);


            var options = new BetaOptions()
            {
                Method = BetaEstimationMethod.MaximumLikelihood
            };

            target.Fit(x, w.ToDouble(), options);

            Assert.AreEqual(1.1401591160220996, target.Alpha);
            Assert.AreEqual(0.58735469613259694, target.Beta);
        }
        public void BetaMeanTest2()
        {
            int trials    = 161750;
            int successes = 10007;

            var betaDistribution = GeneralizedBetaDistribution.Standard(successes, trials);

            double mean   = betaDistribution.Mean;                                  // 0.06187249616697166
            double median = betaDistribution.Median;                                // 0.06187069085946604
            double p025   = betaDistribution.InverseDistributionFunction(p: 0.025); // 0.06070354581334864
            double p975   = betaDistribution.InverseDistributionFunction(p: 0.975); // 0.0630517079399996

            string str = betaDistribution.ToString();

            Assert.AreEqual(0.06187249616697166, mean);
            Assert.AreEqual(0.06187069085946604, median, 1e-6);
            Assert.AreEqual(0.06070354581334864, p025, 1e-6);
            Assert.AreEqual(0.0630517079399996, p975, 1e-6);
            Assert.AreEqual("B(x; α = 10008, β = 151744, min = 0, max = 1)", str);
        }
        public void BetaGenerateTest2()
        {
            Accord.Math.Tools.SetupGenerator(0);

            int n = 100000;

            var beta = new GeneralizedBetaDistribution(alpha: 2, beta: 3, min: 0, max: 1);

            double[] samples = new double[n];

            for (int i = 0; i < n; i++)
            {
                samples[i] = beta.Generate();
            }

            var actual = GeneralizedBetaDistribution.Estimate(samples, 0, 1);

            Assert.AreEqual(2, actual.Alpha, 3e-2);
            Assert.AreEqual(3, actual.Beta, 3e-2);
        }
        public void BetaMeanTest3()
        {
            int trials    = 100;
            int successes = 78;

            var betaDistribution = GeneralizedBetaDistribution.Standard(successes, trials);

            double mean   = betaDistribution.Mean;                                  // 0.77450980392156865
            double median = betaDistribution.Median;                                // 0.77630912598534851
            double p025   = betaDistribution.InverseDistributionFunction(p: 0.025); // 0.68899653915764347
            double p975   = betaDistribution.InverseDistributionFunction(p: 0.975); // 0.84983461640764513

            double orig025 = betaDistribution.DistributionFunction(p025);
            double orig975 = betaDistribution.DistributionFunction(p975);

            Assert.AreEqual(0.025, orig025, 1e-8);
            Assert.AreEqual(0.975, orig975, 1e-8);
            Assert.AreEqual(0.77450980392156865, mean, 1e-9);
            Assert.AreEqual(0.7763091275412235, median, 1e-9);
            Assert.AreEqual(0.68899667463246894, p025, 1e-6);
            Assert.AreEqual(0.84983461640764513, p975, 1e-6);
        }
Exemplo n.º 22
0
        public void small_alpha_beta()
        {
            double alpha = 1e-150;
            double beta  = 1e-150;

            var betaDistribution = new GeneralizedBetaDistribution(alpha, beta);

            double mean = betaDistribution.Mean;

            Assert.Throws <ArithmeticException>(() => { double median = betaDistribution.Median; });
            double var  = betaDistribution.Variance;
            double mode = betaDistribution.Mode;

            double cdf  = betaDistribution.DistributionFunction(x: 0.27);
            double pdf  = betaDistribution.ProbabilityDensityFunction(x: 0.27);
            double lpdf = betaDistribution.LogProbabilityDensityFunction(x: 0.27);
            double ccdf = betaDistribution.ComplementaryDistributionFunction(x: 0.27);
            double icdf = betaDistribution.InverseDistributionFunction(p: cdf);

            Assert.AreEqual(0.5, mean);
            Assert.AreEqual(0.5, mode);
            Assert.AreEqual(0.25, var);
            Assert.AreEqual(0.5, cdf, 1e-5);
            Assert.AreEqual(2.5367833587011923E-150, pdf);
            Assert.AreEqual(-344.45686706484332, lpdf);
            Assert.AreEqual(0.49999999999999989, ccdf);
            Assert.AreEqual(0, icdf, 1e-10);

            Assert.Throws <ArithmeticException>(() => betaDistribution.GetRange(0.95));

            Assert.AreEqual(1, betaDistribution.Support.Length);
            Assert.AreEqual(0, betaDistribution.Support.Min);
            Assert.AreEqual(1, betaDistribution.Support.Max);

            Assert.AreEqual(betaDistribution.InverseDistributionFunction(0), betaDistribution.Support.Min);
            Assert.AreEqual(betaDistribution.InverseDistributionFunction(1), betaDistribution.Support.Max);
        }
        public void BetaPERTTest2()
        {
            // Create a Beta from a minimum, maximum and most likely value
            var b = GeneralizedBetaDistribution.Pert(min: 1, max: 3, mode: 1.5);

            double mean   = b.Mean;     // 1.6666666666666667
            double median = b.Median;   // 1.6276203409113952
            double var    = b.Variance; // 0.063492063492063516
            double mode   = b.Mode;     // 1.5

            double min   = b.Min;       // 1.0
            double max   = b.Max;       // 3.0
            double alpha = b.Alpha;     // 1.9999999999999993
            double beta  = b.Beta;      // 3.9999999999999982

            Assert.AreEqual(1.6666666666666667, mean);
            Assert.AreEqual(1.6276203409113952, median);
            Assert.AreEqual(0.063492063492063516, var);
            Assert.AreEqual(1.5, mode);
            Assert.AreEqual(1.0, min);
            Assert.AreEqual(3.0, max);
            Assert.AreEqual(1.9999999999999993, alpha);
            Assert.AreEqual(3.9999999999999982, beta);
        }
        public void BetaMeanTest()
        {
            double alpha = 0.42;
            double beta = 1.57;

            var betaDistribution = new GeneralizedBetaDistribution(alpha, beta);

            double mean = betaDistribution.Mean; // 0.21105527638190955
            double median = betaDistribution.Median; // 0.11577706212908731
            double var = betaDistribution.Variance; // 0.055689279830523512
            double mode = betaDistribution.Mode;    // 57.999999999999957

            double chf = betaDistribution.CumulativeHazardFunction(x: 0.27); // 1.1828193992944409
            double cdf = betaDistribution.DistributionFunction(x: 0.27); // 0.69358638272337991
            double pdf = betaDistribution.ProbabilityDensityFunction(x: 0.27); // 0.94644031936694828
            double lpdf = betaDistribution.LogProbabilityDensityFunction(x: 0.27); // -0.055047364344046057
            double hf = betaDistribution.HazardFunction(x: 0.27); // 3.0887671630877072
            double ccdf = betaDistribution.ComplementaryDistributionFunction(x: 0.27); // 0.30641361727662009
            double icdf = betaDistribution.InverseDistributionFunction(p: cdf); // 0.26999999068687469

            string str = betaDistribution.ToString(System.Globalization.CultureInfo.InvariantCulture); // "B(x; α = 0.42, β = 1.57)

            Assert.AreEqual(0.21105527638190955, mean);
            Assert.AreEqual(0.11577706212908731, median);
            Assert.AreEqual(57.999999999999957, mode);
            Assert.AreEqual(0.055689279830523512, var);
            Assert.AreEqual(1.1828193992944409, chf);
            Assert.AreEqual(0.69358638272337991, cdf);
            Assert.AreEqual(0.94644031936694828, pdf);
            Assert.AreEqual(-0.055047364344046057, lpdf);
            Assert.AreEqual(3.0887671630877072, hf);
            Assert.AreEqual(0.30641361727662009, ccdf);
            Assert.AreEqual(0.27, icdf, 1e-10);
            Assert.AreEqual("B(x; α = 0.42, β = 1.57, min = 0, max = 1)", str);

            Assert.IsFalse(Double.IsNaN(median));

            var range1 = betaDistribution.GetRange(0.95);
            var range2 = betaDistribution.GetRange(0.99);
            var range3 = betaDistribution.GetRange(0.01);

            Assert.AreEqual(0.00045925525776717733, range1.Min);
            Assert.AreEqual(0.72381020663218609, range1.Max);
            Assert.AreEqual(0.0000099485893745082635, range2.Min);
            Assert.AreEqual(0.89625688707910811, range2.Max);
            Assert.AreEqual(0.0000099485893745082432, range3.Min);
            Assert.AreEqual(0.89625688707910811, range3.Max);
        }
        public void BetaGenerateTest2()
        {
            Accord.Math.Tools.SetupGenerator(0);

            int n = 100000;

            var beta = new GeneralizedBetaDistribution(alpha: 2, beta: 3, min: 0, max: 1);
            double[] samples = new double[n];

            for (int i = 0; i < n; i++)
                samples[i] = beta.Generate();

            var actual = GeneralizedBetaDistribution.Estimate(samples, 0, 1);

            Assert.AreEqual(2, actual.Alpha, 3e-2);
            Assert.AreEqual(3, actual.Beta, 3e-2);
        }
        public void BetaGenerateTest1()
        {
            Accord.Math.Tools.SetupGenerator(0);

            int n = 100000;

            var beta = new GeneralizedBetaDistribution(alpha: 2, beta: 3, min: 0, max: 1);
            double[] samples = beta.Generate(samples: n);

            Assert.AreEqual(n, samples.Length);

            var actual = GeneralizedBetaDistribution.Estimate(samples, 0, 1);

            Assert.AreEqual(2, actual.Alpha, 1e-2);
            Assert.AreEqual(3, actual.Beta, 1e-2);
        }
        public void BetaMLEFit_RealWeights()
        {
            double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 };
            int[] w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 };

            var target = new GeneralizedBetaDistribution(1, 1);


            var options = new BetaOptions()
            {
                Method = BetaEstimationMethod.MaximumLikelihood
            };

            target.Fit(x, w.ToDouble(), options);

            Assert.AreEqual(1.1401591160220996, target.Alpha);
            Assert.AreEqual(0.58735469613259694, target.Beta);
        }
        public void BetaFit_IntWeights()
        {
            double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 };
            int[] w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 };

            var target = new GeneralizedBetaDistribution(1, 1);

            target.Fit(x, w);

            Assert.AreEqual(1.1810718232044195, target.Alpha);
            Assert.AreEqual(0.60843093922651903, target.Beta, 1e-8);
        }
        public void BetaFit_RealWeights()
        {
            double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 };
            int[] w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 };

            var target = new GeneralizedBetaDistribution(1, 1);

            target.Fit(x, w.ToDouble());

            Assert.AreEqual(1.1401591160220996, target.Alpha);
            Assert.AreEqual(0.58735469613259694, target.Beta);
        }
        public void NoncentralBetaMeanTest()
        {
            // Create a 4-parameter Beta distribution with the following parameters (α, β, a, b):
            var beta = new GeneralizedBetaDistribution(alpha: 1.42, beta: 1.57, min: 1, max: 4.2);

            double mean = beta.Mean;     // 2.5197324414715716
            double median = beta.Median; // 2.4997705845160225
            double var = beta.Variance;  // 0.19999664152943961
            double mode = beta.Mode;     // 2.3575757575757574
            double h = beta.Entropy;     // -0.050654548091478513

            double cdf = beta.DistributionFunction(x: 2.27);           // 0.40828630817664596
            double pdf = beta.ProbabilityDensityFunction(x: 2.27);     // 1.2766172921464953
            double lpdf = beta.LogProbabilityDensityFunction(x: 2.27); // 0.2442138392176838

            double chf = beta.CumulativeHazardFunction(x: 2.27);       // 0.5247323897609667
            double hf = beta.HazardFunction(x: 2.27);                  // 2.1574915534109484

            double ccdf = beta.ComplementaryDistributionFunction(x: 2.27); // 0.59171369182335409
            double icdf = beta.InverseDistributionFunction(p: cdf);        // 2.27

            string str = beta.ToString(System.Globalization.CultureInfo.InvariantCulture); // "B(x; α = 1.42, β = 1.57, min = 1, max = 4.2)"

            Assert.AreEqual(2.5197324414715716, mean);
            Assert.AreEqual(2.4997705845160225, median);
            Assert.AreEqual(2.3575757575757574, mode);
            Assert.AreEqual(-0.050654548091478513, h);
            Assert.AreEqual(0.19999664152943961, var);
            Assert.AreEqual(0.5247323897609667, chf);
            Assert.AreEqual(0.40828630817664596, cdf);
            Assert.AreEqual(1.2766172921464953, pdf);
            Assert.AreEqual(0.2442138392176838, lpdf);
            Assert.AreEqual(2.1574915534109484, hf);
            Assert.AreEqual(0.59171369182335409, ccdf);
            Assert.AreEqual(2.27, icdf, 1e-10);
            Assert.AreEqual("B(x; α = 1.42, β = 1.57, min = 1, max = 4.2)", str);

            Assert.IsFalse(Double.IsNaN(median));

            var range1 = beta.GetRange(0.95);
            var range2 = beta.GetRange(0.99);
            var range3 = beta.GetRange(0.01);

            Assert.AreEqual(1.2650560572620337, range1.Min);
            Assert.AreEqual(3.8411806104750186, range1.Max);
            Assert.AreEqual(1.0841613594568846, range2.Min);
            Assert.AreEqual(4.0728683052205534, range2.Max);
            Assert.AreEqual(1.0841613594568846, range3.Min);
            Assert.AreEqual(4.0728683052205534, range3.Max);
        }