Added test for the default parameters of distributions

FastRngTests/Double/Distributions/Beta.cs

@@ -66,6 +66,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestBetaGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Beta { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/CauchyLorentz.cs

@@ -46,6 +46,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestCauchyGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.CauchyLorentz { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/ChiSquare.cs

@@ -64,6 +64,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestChiSquareGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquare { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/Exponential.cs

@@ -63,6 +63,21 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
 
+        [Test] [Category(TestCategories.COVER)] [Category(TestCategories.NORMAL)]
+        public async Task TestExponentialGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Exponential { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/Gamma.cs

@@ -62,6 +62,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(stats.Variance, Is.EqualTo(VARIANCE).Within(0.1), "Variance is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestGammaGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Gamma { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+        
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/InverseGamma.cs

@@ -65,6 +65,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestInverseGammaGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseGamma { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/Laplace.cs

@@ -64,6 +64,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestLaplaceGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Laplace { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/LogNormal.cs

@@ -65,6 +65,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestLogNormalGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.LogNormal { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/Normal.cs

@@ -63,6 +63,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestNormalGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Normal { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/StudentT.cs

@@ -64,6 +64,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestStudentTGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.StudentT { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/Uniform.cs

@@ -134,6 +134,38 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestUniformGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+        
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestUniformGeneratorWithRange04()
+        {
+            var rng = new MultiThreadedRng();
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await rng.GetUniform();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+        
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]

FastRngTests/Double/Distributions/Weibull.cs

@@ -65,6 +65,23 @@ namespace FastRngTests.Double.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
         
+        [Test]
+        [Category(TestCategories.COVER)]
+        [Category(TestCategories.NORMAL)]
+        public async Task TestWeibullGeneratorWithRange03()
+        {
+            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Weibull { Random = rng }; // Test default parameters
+            
+            var samples = new double[1_000];
+            for (var n = 0; n < samples.Length; n++)
+                samples[n] = await dist.GetDistributedValue();
+            
+            rng.StopProducer();
+            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0), "Min is out of range");
+            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
+        }
+
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]