public void UniformDistributionConstructorTest()
 {
     double a = 1;
     double b = 5;
     ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
     Assert.AreEqual(target.Minimum, a);
     Assert.AreEqual(target.Maximum, b);
 }
 public void UniformDistributionConstructorTest1()
 {
     double a = 6;
     double b = 5;
     
     bool thrown = false;
     try { ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b); }
     catch (ArgumentOutOfRangeException) { thrown = true; }
     
     Assert.IsTrue(thrown);
 }
        public void DistributionFunctionTest()
        {
            double a = -2;
            double b = 2;
            ContinuousUniformDistribution target = new ContinuousUniformDistribution(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; 
            ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
            
            ContinuousUniformDistribution clone = (ContinuousUniformDistribution)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 FitTest()
 {
     ContinuousUniformDistribution target = new ContinuousUniformDistribution();
     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);
 }
        public void LogProbabilityDensityFunctionTest()
        {
            double a = -5;
            double b = 11;
            ContinuousUniformDistribution target = new ContinuousUniformDistribution(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 EntropyTest()
 {
     double a = 1;
     double b = 6;
     ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
     double expected = System.Math.Log(b - a);
     double actual = target.Entropy;
     Assert.AreEqual(expected, actual);
 }
 public void MeanTest()
 {
     double a = -1;
     double b = 5;
     ContinuousUniformDistribution target = new ContinuousUniformDistribution(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;
     ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
     double actual = target.Variance;
     double expected = System.Math.Pow(b - a, 2) / 12.0;
     Assert.AreEqual(expected, actual);
 }