示例#1
0
        protected override void EndProcessing()
        {
            var dist = new UniformContinuousDistribution(Minimum, Maximum);
            var obj  = DistributionHelper.AddConvinienceMethods(dist);

            WriteObject(obj);
        }
示例#2
0
        public AutoserviceGenerators()
        {
            var seed = new GeneratorSeed();

            _gen1 = new ExponencionalDistribution(seed.GetRandomSeed(), 300);
            _gen2 = new DiscreteEmpiricalDistribution(seed, new[]
            {
                new Duration(1, 1, 0.4), new Duration(2, 2, 0.15), new Duration(3, 3, 0.14), new Duration(4, 4, 0.12),
                new Duration(5, 5, 0.1), new Duration(6, 6, 0.09)
            });

            _gen3 = new UniformContinuousDistribution(seed.GetRandomSeed(), 70, 310);
            _gen4 = new UniformContinuousDistribution(seed.GetRandomSeed(), 80, 160);
            _gen5 = new TriangleUniformDistribution(seed.GetRandomSeed(), 120, 540, 240);
            _gen6 = new UniformContinuousDistribution(seed.GetRandomSeed(), 123, 257);
            _gen7 = new DiscreteEmpiricalDistribution(seed, new[]
            {
                new Duration(0, 0, 0.7), new Duration(0, 0, 0.2), new Duration(0, 0, 0.1)
            }, new IGenerators[]
            {
                new UniformDiscreteDistribution(seed.GetRandomSeed(), 2, 20),
                new DiscreteEmpiricalDistribution(seed,
                                                  new[] { new Duration(10, 40, 0.1), new Duration(41, 61, 0.6), new Duration(62, 100, 0.3) }),
                new UniformDiscreteDistribution(seed.GetRandomSeed(), 120, 260)
            });
        }
        public void ConstructorTest()
        {
            var uniform = new UniformContinuousDistribution(a: 0.42, b: 1.1);

            double mean = uniform.Mean;     // 0.76
            double median = uniform.Median; // 0.76
            double var = uniform.Variance;  // 0.03853333333333335

            double cdf = uniform.DistributionFunction(x: 0.9); // 0.70588235294117641
            double pdf = uniform.ProbabilityDensityFunction(x: 0.9); // 1.4705882352941173
            double lpdf = uniform.LogProbabilityDensityFunction(x: 0.9); // 0.38566248081198445

            double ccdf = uniform.ComplementaryDistributionFunction(x: 0.9); // 0.29411764705882359
            double icdf = uniform.InverseDistributionFunction(p: cdf); // 0.9

            double hf = uniform.HazardFunction(x: 0.9); // 4.9999999999999973
            double chf = uniform.CumulativeHazardFunction(x: 0.9); // 1.2237754316221154

            string str = uniform.ToString(CultureInfo.InvariantCulture); // "U(x; a = 0.42, b = 1.1)"

            Assert.AreEqual(0.76, mean);
            Assert.AreEqual(0.76, median);
            Assert.AreEqual(0.03853333333333335, var);
            Assert.AreEqual(1.2237754316221154, chf);
            Assert.AreEqual(0.70588235294117641, cdf);
            Assert.AreEqual(1.4705882352941173, pdf);
            Assert.AreEqual(0.38566248081198445, lpdf);
            Assert.AreEqual(4.9999999999999973, hf);
            Assert.AreEqual(0.29411764705882359, ccdf);
            Assert.AreEqual(0.9, icdf);
            Assert.AreEqual("U(x; a = 0.42, b = 1.1)", str);
        }
        public void KolmogorovSmirnovTestConstructorTest()
        {
            // Test against a standard Uniform distribution
            // References: http://www.math.nsysu.edu.tw/~lomn/homepage/class/92/kstest/kolmogorov.pdf

            double[] sample = { 0.621, 0.503, 0.203, 0.477, 0.710, 0.581, 0.329, 0.480, 0.554, 0.382 };

            UniformContinuousDistribution distribution = UniformContinuousDistribution.Standard;

            // Null hypothesis: the sample comes from a standard uniform distribution
            // Alternate: the sample is not from a standard uniform distribution

            var target = new KolmogorovSmirnovTest(sample, distribution);

            Assert.AreEqual(distribution, target.TheoreticalDistribution);
            Assert.AreEqual(KolmogorovSmirnovTestHypothesis.SampleIsDifferent, target.Hypothesis);
            Assert.AreEqual(DistributionTail.TwoTail, target.Tail);

            Assert.AreEqual(0.29, target.Statistic, 1e-16);
            Assert.AreEqual(0.3067, target.PValue, 1e-4);
            Assert.IsFalse(Double.IsNaN(target.Statistic));

            // The null hypothesis fails to be rejected:
            // sample can be from a uniform distribution
            Assert.IsFalse(target.Significant);
        }
        private const double dist = 0.0005396; //constant that is approximatively 60m in Earth coordinate

        /// <summary>
        /// Initializes a new instance of ClientCoordsGenerator class.
        /// </summary>
        /// <param name="nominatimClient">Nominatim client.</param>
        /// <param name="standardDeviation">Standard deviation for two dimensional uniform distribution.</param>
        public ClientCoordsGenerator(INominatimClient nominatimClient, double standardDeviation)
        {
            _nominatimClient = nominatimClient;
            var uniform = new UniformContinuousDistribution(-dist, +dist);

            _distribution = new Independent <UniformContinuousDistribution>(uniform, uniform);
        }
        public void TwoSampleKolmogorovSmirnovTestConstructorTest()
        {
            Accord.Math.Tools.SetupGenerator(0);

            // Create a K-S test to verify if two samples have been
            // drawn from different populations. In this example, we
            // will first generate a number of samples from different
            // distributions, and then check if the K-S test can indeed
            // see the difference:

            // Generate 15 points from a Normal distribution with mean 5 and sigma 2
            double[] sample1 = new NormalDistribution(mean: 5, stdDev: 1).Generate(25);

            // Generate 15 points from an uniform distribution from 0 to 10
            double[] sample2 = new UniformContinuousDistribution(a: 0, b: 10).Generate(25);

            // Now we can create a K-S test and test the unequal hypothesis:
            var test = new TwoSampleKolmogorovSmirnovTest(sample1, sample2,
                                                          TwoSampleKolmogorovSmirnovTestHypothesis.SamplesDistributionsAreUnequal);

            bool significant = test.Significant; // outputs true

            Assert.IsTrue(test.Significant);
            Assert.AreEqual(0.44, test.Statistic, 1e-15);
            Assert.IsFalse(Double.IsNaN(test.Statistic));
            Assert.AreEqual(0.00826, test.PValue, 1e-5);
        }
示例#7
0
        public void LogProbabilityDensityFunctionTest()
        {
            double a = -5;
            double b = 11;
            UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);
            double x        = 4.2;
            double expected = System.Math.Log(0.0625);
            double actual   = target.LogProbabilityDensityFunction(x);

            Assert.AreEqual(expected, actual);

            x        = -5;
            expected = System.Math.Log(0.0625);
            actual   = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);

            x        = -6;
            expected = System.Math.Log(0.0);
            actual   = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);

            x        = 11;
            expected = System.Math.Log(0.0625);
            actual   = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);

            x        = 12;
            expected = System.Math.Log(0.0);
            actual   = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);
        }
        public void TwoSampleKolmogorovSmirnovTestConstructorTest()
        {
            Accord.Math.Tools.SetupGenerator(0);

            // Create a K-S test to verify if two samples have been
            // drawn from different populations. In this example, we
            // will first generate a number of samples from different
            // distributions, and then check if the K-S test can indeed
            // see the difference:

            // Generate 15 points from a Normal distribution with mean 5 and sigma 2
            double[] sample1 = new NormalDistribution(mean: 5, stdDev: 1).Generate(25);

            // Generate 15 points from an uniform distribution from 0 to 10
            double[] sample2 = new UniformContinuousDistribution(a: 0, b: 10).Generate(25);

            // Now we can create a K-S test and test the unequal hypothesis:
            var test = new TwoSampleKolmogorovSmirnovTest(sample1, sample2,
                TwoSampleKolmogorovSmirnovTestHypothesis.SamplesDistributionsAreUnequal);

            bool significant = test.Significant; // outputs true

            Assert.IsTrue(test.Significant);
            Assert.AreEqual(0.44, test.Statistic, 1e-15);
            Assert.IsFalse(Double.IsNaN(test.Statistic));
            Assert.AreEqual(0.00826, test.PValue, 1e-5);
        }
示例#9
0
        public void UniformTest()
        {
            var target  = new TukeyLambdaDistribution(lambda: 1);
            var uniform = new UniformContinuousDistribution(-1, +1);

            compare(target, uniform, 1e-10);
        }
 public void UniformDistributionConstructorTest()
 {
     double a = 1;
     double b = 5;
     UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);
     Assert.AreEqual(target.Minimum, a);
     Assert.AreEqual(target.Maximum, b);
 }
示例#11
0
 public RndB(Distribution t)
     : base(t)
 {
     //_d = 1 - t.Bn * t.AlphaRev / (Math.E - 1) / (1 - t.Beta);
     //_d = 1 / _d;
     _d    = 1;
     _unif = new UniformContinuousDistribution(t.d(t.X1 * _d), t.d(t.X2 * _d));
 }
示例#12
0
        public void MedianTest()
        {
            double a = 1;
            double b = 6;
            UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);

            Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
        }
示例#13
0
        public RndB2(Distribution t)
            : base(t)
        {
            _gamma = new GammaDistribution(t.AlphaRev, 2);
            _unif1 = new UniformContinuousDistribution(T.Beta, T.d(T.X2));
            double cxn = 1 + t.Bn * t.AlphaRev / Math.E;

            _unif2 = new UniformContinuousDistribution(0, cxn);
        }
 /// <summary>
 /// Remove duplicate dates and sort the list
 /// </summary>
 public override void Prepare(Date anchorDate)
 {
     _anchorDate       = anchorDate;
     _allRequiredDates = _allRequiredDates.Distinct().ToList();
     _allRequiredDates.Sort();
     _normal        = new NormalDistribution();
     _uniform       = new UniformContinuousDistribution();
     Generator.Seed = -533776581; // This magic number is: "DeterministicCreditWithFXJump".GetHashCode();
 }
        private static void generator3(GeneratorSeed seed)
        {
            //Cas potrebny na prevzatie objednavky od zakaznika
            //o = 190 s +- 120 s
            //Spojite rovnomerne - <70, 310>
            var gen3 = new UniformContinuousDistribution(seed.GetRandomSeed(), 70, 310);

            TestDistributionsToFileDouble(gen3, "generator_3_spojite_uniform_min_70_max_310.dst");
        }
 public void MeanTest()
 {
     double a = -1;
     double b = 5;
     UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);
     double expected = (a + b) / 2.0;
     double actual = target.Mean;
     Assert.AreEqual(expected, actual);
 }
 public void VarianceTest()
 {
     double a = 5;
     double b = 10;
     UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);
     double actual = target.Variance;
     double expected = System.Math.Pow(b - a, 2) / 12.0;
     Assert.AreEqual(expected, actual);
 }
 public void EntropyTest()
 {
     double a = 1;
     double b = 6;
     UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);
     double expected = System.Math.Log(b - a);
     double actual = target.Entropy;
     Assert.AreEqual(expected, actual);
 }
 public void FitTest()
 {
     UniformContinuousDistribution target = new UniformContinuousDistribution();
     double[] observations = { -1, 2, 5, 2, 3, 1, 4 };
     double[] weights = null;
     target.Fit(observations, weights);
     Assert.AreEqual(-1.0, target.Minimum);
     Assert.AreEqual(5.0, target.Maximum);
 }
        private static void generator4(GeneratorSeed seed)
        {
            //cas potrebny na prevzatie auta od zakaznika
            //p = 120s +- 40 s
            // diskretne uniform = <80, 160>
            var gen4 = new UniformContinuousDistribution(seed.GetRandomSeed(), 80, 160);

            TestDistributionsToFileDouble(gen4, "generator_4_spojite_uniform_min_80_max_160.dst");
        }
        private static void generator6(GeneratorSeed seed)
        {
            //prevzatie opraveneho auta trva s = 190 s +- 67s
            //diskretne uniform = <123, 257>
            var gen6 = new UniformContinuousDistribution(seed.GetRandomSeed() + seed.GetRandomSeed(), 123,
                                                         257);

            TestDistributionsToFileDouble(gen6, "generator_6_spojite_uniform_min_123_max_257.dst");
        }
示例#22
0
        public RndC(Distribution t)
            : base(t)
        {
            //var p1 = t.Bn / Math.E * t.AlphaRev;
            var p1 = t.Bn / (1 - t.Beta) * t.AlphaRev;

            _gamma = new GammaDistribution(t.AlphaRev, 2);
            _unif1 = new UniformContinuousDistribution(t.d(t.X2), 1);
            _unif2 = new UniformContinuousDistribution(0, 1 + p1);
        }
示例#23
0
 public RndSum2(Distribution t)
     : base(t)
 {
     _a    = new RndA(t);
     _b    = new RndB2_2(t);
     _c    = new RndC2(t);
     _sg1  = t.Beta;
     _sg2  = _sg1 + IntG_B(-1);
     _unif = new UniformContinuousDistribution(0, 1);
 }
示例#24
0
 public RndSum(Distribution t)
     : base(t)
 {
     _a  = new RndA(t);
     _b  = new RndB(t);
     _c  = new RndC(t);
     _p2 = 1 - (1 - t.Beta) / Math.E - t.Bn * t.AlphaRev / Math.E;
     //t.Beta + (Math.E - 1) * (1 - t.Beta) / Math.E - t.Bn * t.AlphaRev / Math.E;
     _unif = new UniformContinuousDistribution(0, 1);
 }
 public void UniformDistributionConstructorTest1()
 {
     double a = 6;
     double b = 5;
     
     bool thrown = false;
     try { UniformContinuousDistribution target = new UniformContinuousDistribution(a, b); }
     catch (ArgumentOutOfRangeException) { thrown = true; }
     
     Assert.IsTrue(thrown);
 }
        public void GenerateTest()
        {
            UniformContinuousDistribution target = new UniformContinuousDistribution(2, 5);

            double[] samples = target.Generate(1000000);

            var actual = UniformContinuousDistribution.Estimate(samples);

            actual.Fit(samples);

            Assert.AreEqual(2, actual.Minimum, 1e-4);
            Assert.AreEqual(5, actual.Maximum, 1e-4);
        }
示例#27
0
        public AutoserviceGenerators(int gen1,
                                     double gen213,
                                     double gen223,
                                     double gen233,
                                     double gen243,
                                     double gen253,
                                     double gen263,
                                     int gen31, int gen32,
                                     int gen41, int gen42,
                                     int gen51, int gen52, int gen53,
                                     int gen61, int gen62,
                                     double gen71, double gen72, double gen73,
                                     int gen711, int gen712,
                                     int gen721, int gen722, double gen723,
                                     int gen731, int gen732, double gen733,
                                     int gen741, int gen742, double gen743,
                                     int gen751, int gen752
                                     )
        {
            var seed = new GeneratorSeed();

            _gen1 = new ExponencionalDistribution(seed.GetRandomSeed(), gen1);
            _gen2 = new DiscreteEmpiricalDistribution(seed, new[]
            {
                new Duration(1, 1, gen213),
                new Duration(2, 2, gen223),
                new Duration(3, 3, gen233),
                new Duration(4, 4, gen243),
                new Duration(5, 5, gen253),
                new Duration(6, 6, gen263)
            });

            _gen3 = new UniformContinuousDistribution(seed.GetRandomSeed(), gen31, gen32);
            _gen4 = new UniformContinuousDistribution(seed.GetRandomSeed(), gen41, gen42);
            _gen5 = new TriangleUniformDistribution(seed.GetRandomSeed(), gen51, gen52, gen53);
            _gen6 = new UniformContinuousDistribution(seed.GetRandomSeed(), gen61, gen62);
            _gen7 = new DiscreteEmpiricalDistribution(seed, new[]
            {
                new Duration(0, 0, gen71), new Duration(0, 0, gen72), new Duration(0, 0, gen73)
            }, new IGenerators[]
            {
                new UniformDiscreteDistribution(seed.GetRandomSeed(), gen711, gen712),
                new DiscreteEmpiricalDistribution(seed,
                                                  new[]
                {
                    new Duration(gen721, gen722, gen723), new Duration(gen731, gen732, gen733),
                    new Duration(gen741, gen742, gen743)
                }),
                new UniformDiscreteDistribution(seed.GetRandomSeed(), gen751, gen752)
            });
        }
        public void IntervalTest()
        {
            var target = new UniformContinuousDistribution(-10, 10);

            for (int k = -15; k < 15; k++)
            {
                double a = target.DistributionFunction(k);
                double b = target.DistributionFunction(k + 1);
                double c = b - a;

                double actual = target.DistributionFunction(k, k + 1);
                Assert.AreEqual(c, actual, 1e-15);
            }
        }
示例#29
0
 public FuncionUniforme(double[] eventos) : base(eventos)
 {
     try
     {
         DistribucionContinua = new UniformContinuousDistribution();
         DistribucionContinua.Fit(eventos);
         A         = ((UniformContinuousDistribution)DistribucionContinua).Minimum.ToString("0.0000");
         B         = ((UniformContinuousDistribution)DistribucionContinua).Maximum.ToString("0.0000");
         Resultado = new ResultadoAjuste(StringFDP, StringInversa, DistribucionContinua.StandardDeviation, DistribucionContinua.Mean, DistribucionContinua.Variance, this);
     }
     catch (Exception)
     {
         Resultado = null;
     }
 }
示例#30
0
        public void CloneTest()
        {
            double a = 12;
            double b = 72;
            UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);

            UniformContinuousDistribution clone = (UniformContinuousDistribution)target.Clone();

            Assert.AreNotSame(target, clone);
            Assert.AreEqual(target.Entropy, clone.Entropy);
            Assert.AreEqual(target.Maximum, clone.Maximum);
            Assert.AreEqual(target.Minimum, clone.Minimum);
            Assert.AreEqual(target.StandardDeviation, clone.StandardDeviation);
            Assert.AreEqual(target.Variance, clone.Variance);
        }
示例#31
0
        public void RNGVentura_LillieforsTest_Has_Significant_Deviation_From_Normal_Distribution()
        {
            double[] sample = GenerateFloatingPointNumberArray();

            var distribution  = UniformContinuousDistribution.Estimate(sample);
            var ndistribution = NormalDistribution.Estimate(sample);

            var lillie  = new LillieforsTest(sample, distribution);
            var nlillie = new LillieforsTest(sample, ndistribution);

            // no significant deviation from a uniform continuous distribution estimate
            lillie.Significant.Should().BeFalse();
            // significant deviation from a normal distribution
            nlillie.Significant.Should().BeTrue();
        }
        public void GenerateTest2()
        {
            UniformContinuousDistribution target = new UniformContinuousDistribution(0, 2);

            double[] samples = new double[1000000];

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

            UniformContinuousDistribution newTarget = new UniformContinuousDistribution();
            newTarget.Fit(samples);

            Assert.AreEqual(0, newTarget.Minimum, 1e-5);
            Assert.AreEqual(2, newTarget.Maximum, 1e-5);
        }
        public void GenerateTest2()
        {
            UniformContinuousDistribution target = new UniformContinuousDistribution(-1, 4);

            double[] samples = new double[1000000];
            for (int i = 0; i < samples.Length; i++)
                samples[i] = target.Generate();

            var actual = UniformContinuousDistribution.Estimate(samples);
            actual.Fit(samples);

            Assert.AreEqual(-1, actual.Minimum, 1e-4);
            Assert.AreEqual(4, actual.Maximum, 1e-4);
        }
        public void MedianTest()
        {
            double a = 1;
            double b = 6;
            UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);

            Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
        }
        public void LogProbabilityDensityFunctionTest()
        {
            double a = -5;
            double b = 11;
            UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);
            double x = 4.2;
            double expected = System.Math.Log(0.0625);
            double actual = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);

            x = -5;
            expected = System.Math.Log(0.0625);
            actual = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);

            x = -6;
            expected = System.Math.Log(0.0);
            actual = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);

            x = 11;
            expected = System.Math.Log(0.0625);
            actual = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);

            x = 12;
            expected =System.Math.Log( 0.0);
            actual = target.LogProbabilityDensityFunction(x);
            Assert.AreEqual(expected, actual);
        }
        public void IntervalTest()
        {
            var target = new UniformContinuousDistribution(-10, 10);

            for (int k = -15; k < 15; k++)
            {
                double expected = target.ProbabilityDensityFunction(k);

                double a = target.DistributionFunction(k);
                double b = target.DistributionFunction(k - 1);
                double c = a - b;

                Assert.AreEqual(expected, c, 1e-15);
                Assert.AreEqual(c, target.DistributionFunction(k - 1, k), 1e-15);
            }
        }
        public void DistributionFunctionTest()
        {
            double a = -2;
            double b = 2;
            UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);

            double actual;

            actual = target.DistributionFunction(-2);
            Assert.AreEqual(0, actual);

            actual = target.DistributionFunction(-1);
            Assert.AreEqual(0.25, actual);

            actual = target.DistributionFunction(0);
            Assert.AreEqual(0.5, actual);

            actual = target.DistributionFunction(1);
            Assert.AreEqual(0.75, actual);

            actual = target.DistributionFunction(2);
            Assert.AreEqual(1, actual);
        }
        public void CloneTest()
        {
            double a = 12; 
            double b = 72; 
            UniformContinuousDistribution target = new UniformContinuousDistribution(a, b);
            
            UniformContinuousDistribution clone = (UniformContinuousDistribution)target.Clone();

            Assert.AreNotSame(target, clone);
            Assert.AreEqual(target.Entropy, clone.Entropy);
            Assert.AreEqual(target.Maximum, clone.Maximum);
            Assert.AreEqual(target.Minimum, clone.Minimum);
            Assert.AreEqual(target.StandardDeviation, clone.StandardDeviation);
            Assert.AreEqual(target.Variance, clone.Variance);
        }
        public void UniformTest2()
        {
            var target = new TukeyLambdaDistribution(lambda: 2);
            var uniform = new UniformContinuousDistribution(-0.5, +0.5);

            compare(target, uniform, 1e-10);
        }
        public void GenerateTest()
        {
            UniformContinuousDistribution target = new UniformContinuousDistribution(2, 5);

            double[] samples = target.Generate(1000000);

            var actual = UniformContinuousDistribution.Estimate(samples);
            actual.Fit(samples);

            Assert.AreEqual(2, actual.Minimum, 1e-4);
            Assert.AreEqual(5, actual.Maximum, 1e-4);
        }