Exemple #1
0
        public void EmpiricalDistributionConstructorTest5()
        {
            double[] samples = { 5, 5, 1, 4, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 4, 3, 2, 3 };
            EmpiricalDistribution distribution = new EmpiricalDistribution(samples, FaultySmoothingRule(samples));


            double mean      = distribution.Mean;                                      // 3
            double median    = distribution.Median;                                    // 2.9999993064186787
            double var       = distribution.Variance;                                  // 1.2941176470588236
            double chf       = distribution.CumulativeHazardFunction(x: 4.2);          // 2.1972245773362191
            double cdf       = distribution.DistributionFunction(x: 4.2);              // 0.88888888888888884
            double pdf       = distribution.ProbabilityDensityFunction(x: 4.2);        // 0.15552784414141974
            double lpdf      = distribution.LogProbabilityDensityFunction(x: 4.2);     // -1.8609305013898356
            double hf        = distribution.HazardFunction(x: 4.2);                    // 1.3997505972727771
            double ccdf      = distribution.ComplementaryDistributionFunction(x: 4.2); //0.11111111111111116
            double icdf      = distribution.InverseDistributionFunction(p: cdf);       // 4.1999999999999993
            double smoothing = distribution.Smoothing;                                 // 1.9144923416414432

            string str = distribution.ToString();                                      // Fn(x; S)

            Assert.AreEqual(samples, distribution.Samples);
            Assert.AreEqual(1.9144923416414432, smoothing, 1.0e-15);
            Assert.AreEqual(3.0, mean);
            Assert.AreEqual(2.9999993064186787, median);
            Assert.AreEqual(1.2941176470588236, var);
            Assert.AreEqual(2.1972245773362191, chf);
            Assert.AreEqual(0.88888888888888884, cdf);
            Assert.AreEqual(0.15552784414141974, pdf, 1e-15);
            Assert.AreEqual(-1.8609305013898356, lpdf);
            Assert.AreEqual(1.3997505972727771, hf, 1e-15);
            Assert.AreEqual(0.11111111111111116, ccdf);
            Assert.AreEqual(4.1999999999999993, icdf);
            Assert.AreEqual("Fn(x; S)", str);
        }
        public void EmpiricalDistributionConstructorTest3()
        {
            double[] samples = { 5, 5, 1, 4, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 4, 3, 2, 3 };
            EmpiricalDistribution distribution = new EmpiricalDistribution(samples);

            double mean      = distribution.Mean;                                      // 3
            double median    = distribution.Median;                                    // 2.9999993064186787
            double var       = distribution.Variance;                                  // 1.2941176470588236
            double chf       = distribution.CumulativeHazardFunction(x: 4.2);          // 2.1972245773362191
            double cdf       = distribution.DistributionFunction(x: 4.2);              // 0.88888888888888884
            double pdf       = distribution.ProbabilityDensityFunction(x: 4.2);        // 0.181456280142802
            double lpdf      = distribution.LogProbabilityDensityFunction(x: 4.2);     // -1.7067405350495708
            double hf        = distribution.HazardFunction(x: 4.2);                    // 1.6331065212852196
            double ccdf      = distribution.ComplementaryDistributionFunction(x: 4.2); //0.11111111111111116
            double icdf      = distribution.InverseDistributionFunction(p: cdf);       // 4.1999999999999993
            double smoothing = distribution.Smoothing;                                 // 0.67595864392399474

            string str = distribution.ToString();                                      // Fn(x; S)

            Assert.AreEqual(samples, distribution.Samples);
            Assert.AreEqual(0.67595864392399474, smoothing);
            Assert.AreEqual(3.0, mean);
            Assert.AreEqual(2.9999993064186787, median);
            Assert.AreEqual(1.2941176470588236, var);
            Assert.AreEqual(2.1972245773362191, chf);
            Assert.AreEqual(0.88888888888888884, cdf);
            Assert.AreEqual(0.18145628014280227, pdf);
            Assert.AreEqual(-1.7067405350495708, lpdf);
            Assert.AreEqual(1.6331065212852196, hf);
            Assert.AreEqual(0.11111111111111116, ccdf);
            Assert.AreEqual(4.1999999999999993, icdf);
            Assert.AreEqual("Fn(x; S)", str);
        }
Exemple #3
0
        public void WeightedEmpiricalDistributionConstructorTest()
        {
            double[] original     = { 5, 5, 1, 4, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 4, 3, 2, 3 };
            var      distribution = new EmpiricalDistribution(original);

            int[]    weights = { 2, 1, 1, 1, 2, 3, 1, 3, 1, 1, 1, 1 };
            double[] samples = { 5, 1, 4, 1, 2, 3, 4, 3, 4, 3, 2, 3 };
            var      target  = new EmpiricalDistribution(samples, weights);

            Assert.AreEqual(distribution.Entropy, target.Entropy, 1e-10);
            Assert.AreEqual(distribution.Mean, target.Mean);
            Assert.AreEqual(distribution.Median, target.Median);
            Assert.AreEqual(distribution.Mode, target.Mode);
            Assert.AreEqual(distribution.Quartiles.Min, target.Quartiles.Min);
            Assert.AreEqual(distribution.Quartiles.Max, target.Quartiles.Max);
            Assert.AreEqual(distribution.Smoothing, target.Smoothing);
            Assert.AreEqual(distribution.StandardDeviation, target.StandardDeviation);
            Assert.AreEqual(distribution.Support.Min, target.Support.Min);
            Assert.AreEqual(distribution.Support.Max, target.Support.Max);
            Assert.AreEqual(distribution.Variance, target.Variance);
            Assert.IsTrue(target.Weights.IsEqual(weights.Divide(weights.Sum())));
            Assert.AreEqual(target.Samples, samples);

            for (double x = 0; x < 6; x += 0.1)
            {
                double actual, expected;
                expected = distribution.ComplementaryDistributionFunction(x);
                actual   = target.ComplementaryDistributionFunction(x);
                Assert.AreEqual(expected, actual);

                expected = distribution.CumulativeHazardFunction(x);
                actual   = target.CumulativeHazardFunction(x);
                Assert.AreEqual(expected, actual);

                expected = distribution.DistributionFunction(x);
                actual   = target.DistributionFunction(x);
                Assert.AreEqual(expected, actual);

                expected = distribution.HazardFunction(x);
                actual   = target.HazardFunction(x);
                Assert.AreEqual(expected, actual, 1e-15);

                expected = distribution.InverseDistributionFunction(Accord.Math.Tools.Scale(0, 6, 0, 1, x));
                actual   = target.InverseDistributionFunction(Accord.Math.Tools.Scale(0, 6, 0, 1, x));
                Assert.AreEqual(expected, actual);

                expected = distribution.LogProbabilityDensityFunction(x);
                actual   = target.LogProbabilityDensityFunction(x);
                Assert.AreEqual(expected, actual, 1e-15);

                expected = distribution.ProbabilityDensityFunction(x);
                actual   = target.ProbabilityDensityFunction(x);
                Assert.AreEqual(expected, actual, 1e-15);

                expected = distribution.QuantileDensityFunction(Accord.Math.Tools.Scale(0, 6, 0, 1, x));
                actual   = target.QuantileDensityFunction(Accord.Math.Tools.Scale(0, 6, 0, 1, x));
                Assert.AreEqual(expected, actual, 1e-10);
            }
        }
Exemple #4
0
        public void ProbabilityDensityFunctionTest()
        {
            double[] samples             = { 1, 5, 2, 5, 1, 7, 1, 9, 4, 2 };
            EmpiricalDistribution target = new EmpiricalDistribution(samples, 1);

            Assert.AreEqual(1.0, target.Smoothing);

            double actual;

            actual = target.ProbabilityDensityFunction(1);
            Assert.AreEqual(0.16854678051819402, actual);

            actual = target.ProbabilityDensityFunction(2);
            Assert.AreEqual(0.15866528844260089, actual, 1e-15);

            actual = target.ProbabilityDensityFunction(3);
            Assert.AreEqual(0.0996000842425018, actual, 1e-15);

            actual = target.ProbabilityDensityFunction(4);
            Assert.AreEqual(0.1008594542833362, actual);

            actual = target.ProbabilityDensityFunction(6);
            Assert.AreEqual(0.078460710909263, actual, 1e-15);

            actual = target.ProbabilityDensityFunction(8);
            Assert.AreEqual(0.049293898826709738, actual, 1e-15);
        }