Refactored setting IRandom to distribution

FastRng/Double/Distributions/BetaA2B2.cs

@@ -10,6 +10,10 @@ namespace FastRng.Double.Distributions
         private const double BETA = 2;
         private const double CONSTANT = 4;
 
+        public BetaA2B2(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * Math.Pow(x, ALPHA - 1) * Math.Pow(1 - x, BETA - 1);
     }
 }

FastRng/Double/Distributions/BetaA2B5.cs

@@ -10,6 +10,10 @@ namespace FastRng.Double.Distributions
         private const double BETA = 5;
         private const double CONSTANT = 12.2;
 
+        public BetaA2B5(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * Math.Pow(x, ALPHA - 1) * Math.Pow(1 - x, BETA - 1);
     }
 }

FastRng/Double/Distributions/BetaA5B2.cs

@@ -10,6 +10,10 @@ namespace FastRng.Double.Distributions
         private const double BETA = 2;
         private const double CONSTANT = 12.2;
 
+        public BetaA5B2(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * Math.Pow(x, ALPHA - 1) * Math.Pow(1 - x, BETA - 1);
     }
 }

FastRng/Double/Distributions/CauchyLorentzX0.cs

@@ -10,6 +10,10 @@ namespace FastRng.Double.Distributions
         private const double SCALE = 0.1;
         private const double MEDIAN = 0.0;
 
+        public CauchyLorentzX0(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * (1.0 / (Math.PI * SCALE)) * ((SCALE * SCALE) / (Math.Pow(x - MEDIAN, 2) + (SCALE * SCALE)));
     }
 }

FastRng/Double/Distributions/CauchyLorentzX1.cs

@@ -10,6 +10,10 @@ namespace FastRng.Double.Distributions
         private const double SCALE = 0.1;
         private const double MEDIAN = 1.0;
 
+        public CauchyLorentzX1(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * (1.0 / (Math.PI * SCALE)) * ((SCALE * SCALE) / (Math.Pow(x - MEDIAN, 2) + (SCALE * SCALE)));
     }
 }

FastRng/Double/Distributions/ChiSquareK1.cs

@@ -20,6 +20,10 @@ namespace FastRng.Double.Distributions
             DIVISOR = twoToTheKHalf * gammaKHalf;
         }
 
+        public ChiSquareK1(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * ((Math.Pow(x, K_HALF_MINUS_ONE) * Math.Exp(-x * 0.5d)) / DIVISOR);
     }
 }

FastRng/Double/Distributions/ChiSquareK10.cs

@@ -20,6 +20,10 @@ namespace FastRng.Double.Distributions
             DIVISOR = twoToTheKHalf * gammaKHalf;
         }
         
+        public ChiSquareK10(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => CONSTANT * ((Math.Pow(x, K_HALF_MINUS_ONE) * Math.Exp(-x * 0.5d)) / DIVISOR);
     }
 }

FastRng/Double/Distributions/ChiSquareK4.cs

@@ -20,6 +20,10 @@ namespace FastRng.Double.Distributions
             DIVISOR = twoToTheKHalf * gammaKHalf;
         }
         
+        public ChiSquareK4(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => CONSTANT * ((Math.Pow(x, K_HALF_MINUS_ONE) * Math.Exp(-x * 0.5d)) / DIVISOR);
     }
 }

FastRng/Double/Distributions/Distribution.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -5,30 +6,20 @@ namespace FastRng.Double.Distributions
 {
     public abstract class Distribution : IDistribution
     {
-        private ShapeFitter fitter;
+        private readonly ShapeFitter fitter;
-        private IRandom random;
+        private readonly IRandom random;
 
-        public IRandom Random
+        protected Distribution(IRandom rng)
         {
-            get => this.random;
+            if (rng == null)
-            set
+                throw new ArgumentNullException(nameof(rng), "An IRandom implementation is needed.");
-            {
-                if(this.random != null)
-                    return;
                 
-                this.random = value;
+            this.random = rng;
-                this.fitter = new ShapeFitter(this.ShapeFunction, this.random, 100);
+            this.fitter = new ShapeFitter(this.ShapeFunction, this.random, 100);
-            }
         }
 
         protected abstract double ShapeFunction(double x);
         
-        public async ValueTask<double> GetDistributedValue(CancellationToken token = default)
+        public async ValueTask<double> GetDistributedValue(CancellationToken token = default) => await this.fitter.NextNumber(token);
-        {
-            if (this.Random == null)
-                return double.NaN;
-            
-            return await this.fitter.NextNumber(token);
-        }
     }
 }

FastRng/Double/Distributions/ExponentialLa10.cs

@@ -9,6 +9,10 @@ namespace FastRng.Double.Distributions
         private const double LAMBDA = 10.0;
         private const double CONSTANT = 0.1106;
 
+        public ExponentialLa10(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * LAMBDA * Math.Exp(-LAMBDA * x);
     }
 }

FastRng/Double/Distributions/ExponentialLa5.cs

@@ -9,6 +9,10 @@ namespace FastRng.Double.Distributions
         private const double LAMBDA = 5.0;
         private const double CONSTANT = 0.2103;
 
+        public ExponentialLa5(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * LAMBDA * Math.Exp(-LAMBDA * x);
     }
 }

FastRng/Double/Distributions/GammaA5B15.cs

@@ -19,6 +19,10 @@ namespace FastRng.Double.Distributions
             BETA_TO_THE_ALPHA = Math.Pow(BETA, ALPHA);
         }
         
+        public GammaA5B15(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => CONSTANT * ((BETA_TO_THE_ALPHA * Math.Pow(x, ALPHA - 1.0d) * Math.Exp(-BETA * x)) / GAMMA_ALPHA);
     }
 }

FastRng/Double/Distributions/IDistribution.cs

@@ -5,8 +5,6 @@ namespace FastRng.Double.Distributions
 {
     public interface IDistribution
     {
-        public IRandom Random { get; set; }
-
         public ValueTask<double> GetDistributedValue(CancellationToken token);
     }
 }

FastRng/Double/Distributions/InverseExponentialLa10.cs

@@ -9,6 +9,10 @@ namespace FastRng.Double.Distributions
         private const double LAMBDA = 10.0;
         private const double CONSTANT = 4.539992976248453e-06;
 
+        public InverseExponentialLa10(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * LAMBDA * Math.Exp(LAMBDA * x);
     }
 }

FastRng/Double/Distributions/InverseExponentialLa5.cs

@@ -9,6 +9,10 @@ namespace FastRng.Double.Distributions
         private const double LAMBDA = 5.0;
         private const double CONSTANT = 0.001347589399817;
 
+        public InverseExponentialLa5(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * LAMBDA * Math.Exp(LAMBDA * x);
     }
 }

FastRng/Double/Distributions/InverseGammaA3B05.cs

@@ -20,6 +20,10 @@ namespace FastRng.Double.Distributions
             FACTOR_LEFT = CONSTANT * (betaToTheAlpha / gammaAlpha);
         }
         
+        public InverseGammaA3B05(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => FACTOR_LEFT * Math.Pow(x, -ALPHA - 1.0d) * Math.Exp(-BETA / x);
     }
 }

FastRng/Double/Distributions/LaplaceB01M0.cs

@@ -17,6 +17,10 @@ namespace FastRng.Double.Distributions
             FACTOR_LEFT = CONSTANT / (2.0d * B);
         }
         
+        public LaplaceB01M0(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => FACTOR_LEFT * Math.Exp(-Math.Abs(x - MU) / B);
     }
 }

FastRng/Double/Distributions/LaplaceB01M05.cs

@@ -17,6 +17,10 @@ namespace FastRng.Double.Distributions
             FACTOR_LEFT = CONSTANT / (2.0d * B);
         }
         
+        public LaplaceB01M05(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => FACTOR_LEFT * Math.Exp(-Math.Abs(x - MU) / B);
     }
 }

FastRng/Double/Distributions/LogNormalS1M0.cs

@@ -17,6 +17,10 @@ namespace FastRng.Double.Distributions
             FACTOR = SIGMA * Math.Sqrt(2 * Math.PI);
         }
         
+        public LogNormalS1M0(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => (CONSTANT / (x * FACTOR)) * Math.Exp( -(Math.Pow(Math.Log(x) - MU, 2) / (2 * Math.Pow(SIGMA, 2))));
     }
 }

FastRng/Double/Distributions/NormalS02M05.cs

@@ -11,6 +11,10 @@ namespace FastRng.Double.Distributions
         private const double STDDEV = 0.2;
         private const double MEAN = 0.5;
 
+        public NormalS02M05(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => 1.0 / (STDDEV * SQRT_2_PI) * Math.Exp(-0.5 * Math.Pow((x - MEAN) / STDDEV, 2.0));
     }
 }

FastRng/Double/Distributions/StudentTNu1.cs

@@ -22,6 +22,10 @@ namespace FastRng.Double.Distributions
             EXPONENT = -((NU + 1.0d) * 0.5d);
         }
         
+        public StudentTNu1(IRandom rng) : base(rng)
+        {
+        }
+
         protected override double ShapeFunction(double x) => CONSTANT * Math.Pow((DIVIDEND / DIVISOR) * Math.Pow(1.0d + Math.Pow(START + x * COMPRESS, 2) / NU, EXPONENT), COMPRESS);
     }
 }

FastRng/Double/Distributions/Uniform.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -5,8 +6,16 @@ namespace FastRng.Double.Distributions
 {
     public sealed class Uniform : IDistribution
     {
-        public IRandom Random { get; set; }
+        private readonly IRandom rng;
         
-        public async ValueTask<double> GetDistributedValue(CancellationToken token = default) => this.Random == null ? double.NaN : await this.Random.GetUniform(token);
+        public Uniform(IRandom rng)
+        {
+            if (rng == null)
+                throw new ArgumentNullException(nameof(rng), "An IRandom implementation is needed.");
+            
+            this.rng = rng;
+        }
+        
+        public async ValueTask<double> GetDistributedValue(CancellationToken token = default) => await this.rng.GetUniform(token);
     }
 }

FastRng/Double/Distributions/WeibullK05La1.cs

@@ -10,6 +10,10 @@ namespace FastRng.Double.Distributions
         private const double LAMBDA = 1.0;
         private const double CONSTANT = 0.221034183615129;
 
+        public WeibullK05La1(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override double ShapeFunction(double x) => CONSTANT * ( (K / LAMBDA) * Math.Pow(x / LAMBDA, K - 1.0d) * Math.Exp(-Math.Pow(x/LAMBDA, K)));
     }
 }

FastRng/Double/MultiThreadedRng.cs

@@ -309,8 +309,6 @@ namespace FastRng.Double
             }
             
             var range = rangeEnd - rangeStart;
-            distribution.Random ??= this;
-            
             var distributedValue = await distribution.GetDistributedValue(cancel);
             return (uint) ((distributedValue * range) + rangeStart);
         }
@@ -325,8 +323,6 @@ namespace FastRng.Double
             }
             
             var range = rangeEnd - rangeStart;
-            distribution.Random = this;
-            
             var distributedValue = await distribution.GetDistributedValue(cancel);
             return (ulong) ((distributedValue * range) + rangeStart);
         }
@@ -341,8 +337,6 @@ namespace FastRng.Double
             }
             
             var range = rangeEnd - rangeStart;
-            distribution.Random = this;
-            
             var distributedValue = await distribution.GetDistributedValue(cancel);
             return (distributedValue * range) + rangeStart;
         }

FastRng/Double/ShapeFitter.cs

@@ -15,11 +15,12 @@ namespace FastRng.Double
         private readonly IRandom rng;
         private readonly double max;
         private readonly double sampleSize;
-        private readonly IDistribution uniform = new Uniform();
+        private readonly IDistribution uniform;
 
         public ShapeFitter(Func<double, double> shapeFunction, IRandom rng, ushort sampleSize = 50)
         {
             this.rng = rng;
+            this.uniform = new Uniform(rng);
             this.sampleSize = sampleSize;
             this.probabilities = new double[sampleSize];
 

FastRng/Float/Distributions/BetaA2B2.cs

@@ -8,6 +8,10 @@ namespace FastRng.Float.Distributions
         private const float BETA = 2f;
         private const float CONSTANT = 4f;
 
+        public BetaA2B2(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * MathF.Pow(x, ALPHA - 1f) * MathF.Pow(1f - x, BETA - 1f);
     }
 }

FastRng/Float/Distributions/BetaA2B5.cs

@@ -8,6 +8,10 @@ namespace FastRng.Float.Distributions
         private const float BETA = 5f;
         private const float CONSTANT = 12.2f;
 
+        public BetaA2B5(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * MathF.Pow(x, ALPHA - 1f) * MathF.Pow(1f - x, BETA - 1f);
     }
 }

FastRng/Float/Distributions/BetaA5B2.cs

@@ -8,6 +8,10 @@ namespace FastRng.Float.Distributions
         private const float BETA = 2f;
         private const float CONSTANT = 12.2f;
 
+        public BetaA5B2(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * MathF.Pow(x, ALPHA - 1f) * MathF.Pow(1f - x, BETA - 1f);
     }
 }

FastRng/Float/Distributions/CauchyLorentzX0.cs

@@ -8,6 +8,10 @@ namespace FastRng.Float.Distributions
         private const float SCALE = 0.1f;
         private const float MEDIAN = 0.0f;
 
+        public CauchyLorentzX0(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * (1.0f / (MathF.PI * SCALE)) * ((SCALE * SCALE) / (MathF.Pow(x - MEDIAN, 2f) + (SCALE * SCALE)));
     }
 }

FastRng/Float/Distributions/CauchyLorentzX1.cs

@@ -8,6 +8,10 @@ namespace FastRng.Float.Distributions
         private const float SCALE = 0.1f;
         private const float MEDIAN = 1.0f;
 
+        public CauchyLorentzX1(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * (1.0f / (MathF.PI * SCALE)) * ((SCALE * SCALE) / (MathF.Pow(x - MEDIAN, 2f) + (SCALE * SCALE)));
     }
 }

FastRng/Float/Distributions/ChiSquareK1.cs

@@ -18,6 +18,10 @@ namespace FastRng.Float.Distributions
             DIVISOR = twoToTheKHalf * gammaKHalf;
         }
         
+        public ChiSquareK1(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => CONSTANT * ((MathF.Pow(x, K_HALF_MINUS_ONE) * MathF.Exp(-x * 0.5f)) / DIVISOR);
     }
 }

FastRng/Float/Distributions/ChiSquareK10.cs

@@ -18,6 +18,10 @@ namespace FastRng.Float.Distributions
             DIVISOR = twoToTheKHalf * gammaKHalf;
         }
         
+        public ChiSquareK10(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => CONSTANT * ((MathF.Pow(x, K_HALF_MINUS_ONE) * MathF.Exp(-x * 0.5f)) / DIVISOR);
     }
 }

FastRng/Float/Distributions/ChiSquareK4.cs

@@ -18,6 +18,10 @@ namespace FastRng.Float.Distributions
             DIVISOR = twoToTheKHalf * gammaKHalf;
         }
 
+        public ChiSquareK4(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => CONSTANT * ((MathF.Pow(x, K_HALF_MINUS_ONE) * MathF.Exp(-x * 0.5f)) / DIVISOR);
     }
 }

FastRng/Float/Distributions/Distribution.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -5,30 +6,20 @@ namespace FastRng.Float.Distributions
 {
     public abstract class Distribution : IDistribution
     {
-        private ShapeFitter fitter;
+        private readonly ShapeFitter fitter;
-        private IRandom random;
+        private readonly IRandom random;
 
-        public IRandom Random
+        protected Distribution(IRandom rng)
         {
-            get => this.random;
+            if (rng == null)
-            set
+                throw new ArgumentNullException(nameof(rng), "An IRandom implementation is needed.");
-            {
-                if(this.random != null)
-                    return;
                 
-                this.random = value;
+            this.random = rng;
-                this.fitter = new ShapeFitter(this.ShapeFunction, this.random, 100);
+            this.fitter = new ShapeFitter(this.ShapeFunction, this.random, 100);
-            }
         }
 
         protected abstract float ShapeFunction(float x);
         
-        public async ValueTask<float> GetDistributedValue(CancellationToken token = default)
+        public async ValueTask<float> GetDistributedValue(CancellationToken token = default) => await this.fitter.NextNumber(token);
-        {
-            if (this.Random == null)
-                return float.NaN;
-            
-            return await this.fitter.NextNumber(token);
-        }
     }
 }

FastRng/Float/Distributions/ExponentialLa10.cs

@@ -7,6 +7,10 @@ namespace FastRng.Float.Distributions
         private const float LAMBDA = 10.0f;
         private const float CONSTANT = 0.1106f;
 
+        public ExponentialLa10(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * LAMBDA * MathF.Exp(-LAMBDA * x);
     }
 }

FastRng/Float/Distributions/ExponentialLa5.cs

@@ -7,6 +7,10 @@ namespace FastRng.Float.Distributions
         private const float LAMBDA = 5.0f;
         private const float CONSTANT = 0.2103f;
 
+        public ExponentialLa5(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * LAMBDA * MathF.Exp(-LAMBDA * x);
     }
 }

FastRng/Float/Distributions/GammaA5B15.cs

@@ -17,6 +17,10 @@ namespace FastRng.Float.Distributions
             BETA_TO_THE_ALPHA = MathF.Pow(BETA, ALPHA);
         }
 
+        public GammaA5B15(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * ((BETA_TO_THE_ALPHA * MathF.Pow(x, ALPHA - 1.0f) * MathF.Exp(-BETA * x)) / GAMMA_ALPHA);
     }
 }

FastRng/Float/Distributions/IDistribution.cs

@@ -5,8 +5,6 @@ namespace FastRng.Float.Distributions
 {
     public interface IDistribution
     {
-        public IRandom Random { get; set; }
-
         public ValueTask<float> GetDistributedValue(CancellationToken token);
     }
 }

FastRng/Float/Distributions/InverseExponentialLa10.cs

@@ -7,6 +7,10 @@ namespace FastRng.Float.Distributions
         private const float LAMBDA = 10.0f;
         private const float CONSTANT = 4.539992976248453e-06f;
 
+        public InverseExponentialLa10(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * LAMBDA * MathF.Exp(LAMBDA * x);
     }
 }

FastRng/Float/Distributions/InverseExponentialLa5.cs

@@ -7,6 +7,10 @@ namespace FastRng.Float.Distributions
         private const float LAMBDA = 5.0f;
         private const float CONSTANT = 0.001347589399817f;
 
+        public InverseExponentialLa5(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * LAMBDA * MathF.Exp(LAMBDA * x);
     }
 }

FastRng/Float/Distributions/InverseGammaA3B05.cs

@@ -18,6 +18,10 @@ namespace FastRng.Float.Distributions
             FACTOR_LEFT = CONSTANT * (betaToTheAlpha / gammaAlpha);
         }
         
+        public InverseGammaA3B05(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => FACTOR_LEFT * MathF.Pow(x, -ALPHA - 1.0f) * MathF.Exp(-BETA / x);
     }
 }

FastRng/Float/Distributions/LaplaceB01M0.cs

@@ -15,6 +15,10 @@ namespace FastRng.Float.Distributions
             FACTOR_LEFT = CONSTANT / (2.0f * B);
         }
         
+        public LaplaceB01M0(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => FACTOR_LEFT * MathF.Exp(-MathF.Abs(x - MU) / B);
     }
 }

FastRng/Float/Distributions/LaplaceB01M05.cs

@@ -15,6 +15,10 @@ namespace FastRng.Float.Distributions
             FACTOR_LEFT = CONSTANT / (2.0f * B);
         }
         
+        public LaplaceB01M05(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => FACTOR_LEFT * MathF.Exp(-MathF.Abs(x - MU) / B);
     }
 }

FastRng/Float/Distributions/LogNormalS1M0.cs

@@ -15,6 +15,10 @@ namespace FastRng.Float.Distributions
             FACTOR = SIGMA * MathF.Sqrt(2f * MathF.PI);
         }
         
+        public LogNormalS1M0(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => (CONSTANT / (x * FACTOR)) * MathF.Exp( -(MathF.Pow(MathF.Log(x) - MU, 2f) / (2f * MathF.Pow(SIGMA, 2f))));
     }
 }

FastRng/Float/Distributions/NormalS02M05.cs

@@ -8,6 +8,10 @@ namespace FastRng.Float.Distributions
         private const float STDDEV = 0.2f;
         private const float MEAN = 0.5f;
 
+        public NormalS02M05(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => 1.0f / (STDDEV * SQRT_2_PI) * MathF.Exp(-0.5f * MathF.Pow((x - MEAN) / STDDEV, 2.0f));
     }
 }

FastRng/Float/Distributions/StudentTNu1.cs

@@ -20,6 +20,10 @@ namespace FastRng.Float.Distributions
             EXPONENT = -((NU + 1.0f) * 0.5f);
         }
         
+        public StudentTNu1(IRandom rng) : base(rng)
+        {
+        }
+
         protected override float ShapeFunction(float x) => CONSTANT * MathF.Pow((DIVIDEND / DIVISOR) * MathF.Pow(1.0f + MathF.Pow(START + x * COMPRESS, 2f) / NU, EXPONENT), COMPRESS);
     }
 }

FastRng/Float/Distributions/Uniform.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -5,8 +6,16 @@ namespace FastRng.Float.Distributions
 {
     public sealed class Uniform : IDistribution
     {
-        public IRandom Random { get; set; }
+        private readonly IRandom rng;
         
-        public async ValueTask<float> GetDistributedValue(CancellationToken token = default) => this.Random == null ? float.NaN : await this.Random.GetUniform(token);
+        public Uniform(IRandom rng)
+        {
+            if (rng == null)
+                throw new ArgumentNullException(nameof(rng), "An IRandom implementation is needed.");
+            
+            this.rng = rng;
+        }
+
+        public async ValueTask<float> GetDistributedValue(CancellationToken token = default) => await this.rng.GetUniform(token);
     }
 }

FastRng/Float/Distributions/WeibullK05La1.cs

@@ -8,6 +8,10 @@ namespace FastRng.Float.Distributions
         private const float LAMBDA = 1.0f;
         private const float CONSTANT = 0.221034183615129f;
 
+        public WeibullK05La1(IRandom rng) : base(rng)
+        {
+        }
+        
         protected override float ShapeFunction(float x) => CONSTANT * ( (K / LAMBDA) * MathF.Pow(x / LAMBDA, K - 1.0f) * MathF.Exp(-MathF.Pow(x/LAMBDA, K)));
     }
 }

FastRng/Float/MultiThreadedRng.cs

@@ -309,8 +309,6 @@ namespace FastRng.Float
             }
             
             var range = rangeEnd - rangeStart;
-            distribution.Random ??= this;
-            
             var distributedValue = await distribution.GetDistributedValue(cancel);
             return (uint) ((distributedValue * range) + rangeStart);
         }
@@ -325,8 +323,6 @@ namespace FastRng.Float
             }
             
             var range = rangeEnd - rangeStart;
-            distribution.Random = this;
-            
             var distributedValue = await distribution.GetDistributedValue(cancel);
             return (ulong) ((distributedValue * range) + rangeStart);
         }
@@ -341,8 +337,6 @@ namespace FastRng.Float
             }
             
             var range = rangeEnd - rangeStart;
-            distribution.Random = this;
-            
             var distributedValue = await distribution.GetDistributedValue(cancel);
             return (distributedValue * range) + rangeStart;
         }

FastRng/Float/ShapeFitter.cs

@@ -14,11 +14,12 @@ namespace FastRng.Float
         private readonly IRandom rng;
         private readonly float max;
         private readonly float sampleSize;
-        private readonly IDistribution uniform = new Uniform();
+        private readonly IDistribution uniform;
 
         public ShapeFitter(Func<float, float> shapeFunction, IRandom rng, ushort sampleSize = 50)
         {
             this.rng = rng;
+            this.uniform = new Uniform(rng);
             this.sampleSize = sampleSize;
             this.probabilities = new float[sampleSize];
 

FastRngTests/Double/Distributions/BetaA2B2.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.BetaA2B2();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.BetaA2B2(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.0396).Within(0.3));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.BetaA2B2();
+            var dist = new FastRng.Double.Distributions.BetaA2B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
 
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.BetaA2B2();
+            var dist = new FastRng.Double.Distributions.BetaA2B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestBetaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.BetaA2B2(null));
-            var dist = new FastRng.Double.Distributions.BetaA2B2 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.BetaA2B2();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/BetaA2B5.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.BetaA2B5();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.BetaA2B5(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.11719271).Within(0.3));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.BetaA2B5();
+            var dist = new FastRng.Double.Distributions.BetaA2B5(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
 
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.BetaA2B5();
+            var dist = new FastRng.Double.Distributions.BetaA2B5(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestBetaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.BetaA2B5(null));
-            var dist = new FastRng.Double.Distributions.BetaA2B5 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.BetaA2B5();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/BetaA5B2.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.BetaA5B2();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.BetaA5B2(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.0000001).Within(0.0000003));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.BetaA5B2();
+            var dist = new FastRng.Double.Distributions.BetaA5B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
 
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.BetaA5B2();
+            var dist = new FastRng.Double.Distributions.BetaA5B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestBetaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.BetaA5B2(null));
-            var dist = new FastRng.Double.Distributions.BetaA5B2 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.BetaA5B2();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/CauchyLorentzX0.cs

@@ -18,14 +18,13 @@ namespace FastRngTests.Double.Distributions
             // The properties of the cauchy distribution cannot be tested by mean, media or variance,  
             // cf. https://en.wikipedia.org/wiki/Cauchy_distribution#Explanation_of_undefined_moments
 
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.CauchyLorentzX0(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.976990739772031).Within(0.06));
@@ -52,13 +51,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.CauchyLorentzX0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
@@ -68,13 +66,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.CauchyLorentzX0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -82,28 +79,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestCauchyGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.CauchyLorentzX0(null));
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/CauchyLorentzX1.cs

@@ -18,14 +18,13 @@ namespace FastRngTests.Double.Distributions
             // The properties of the cauchy distribution cannot be tested by mean, media or variance,  
             // cf. https://en.wikipedia.org/wiki/Cauchy_distribution#Explanation_of_undefined_moments
 
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.CauchyLorentzX1(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.009966272570142).Within(0.003));
@@ -52,13 +51,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.CauchyLorentzX0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
@@ -68,13 +66,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.CauchyLorentzX0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -82,28 +79,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestCauchyGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.CauchyLorentzX1(null));
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX0 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.CauchyLorentzX1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/ChiSquareK1.cs

@@ -15,9 +15,9 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK1(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
             {
@@ -25,8 +25,6 @@ namespace FastRngTests.Double.Distributions
                 fqa.CountThis(value);
             }
             
-            rng.StopProducer();
-            
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.00032041964207).Within(0.004));
@@ -53,13 +51,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK1();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK1(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -69,13 +66,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK1();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK1(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -83,28 +79,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestChiSquareGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.ChiSquareK1(null));
-            var dist = new FastRng.Double.Distributions.ChiSquareK1 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.ChiSquareK1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/ChiSquareK10.cs

@@ -15,9 +15,9 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK10();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK10(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
             {
@@ -25,8 +25,6 @@ namespace FastRngTests.Double.Distributions
                 fqa.CountThis(value);
             }
             
-            rng.StopProducer();
-            
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000000164021588).Within(0.0000002));
@@ -53,13 +51,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK10(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -69,13 +66,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK10(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -83,28 +79,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestChiSquareGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.ChiSquareK10(null));
-            var dist = new FastRng.Double.Distributions.ChiSquareK10 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.ChiSquareK10();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/ChiSquareK4.cs

@@ -15,15 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK4();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK4(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
-            
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.016417705906679).Within(0.02));
@@ -50,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK4();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK4(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -66,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.ChiSquareK4();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ChiSquareK4(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -80,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestChiSquareGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.ChiSquareK4(null));
-            var dist = new FastRng.Double.Distributions.ChiSquareK4 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.ChiSquareK4();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/ExponentialLa10.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa10();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ExponentialLa10(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.00075018434777).Within(0.05));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ExponentialLa10(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ExponentialLa10(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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 TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.ExponentialLa10 { 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");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa10();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.ExponentialLa10(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/ExponentialLa5.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa5();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ExponentialLa5(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.0002177398625).Within(0.05));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ExponentialLa5(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.ExponentialLa5(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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 TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.ExponentialLa5 { 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");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Double.Distributions.ExponentialLa5();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.ExponentialLa5(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/GammaA5B15.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestGammaDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.GammaA5B15();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.GammaA5B15(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000929594237282).Within(0.0008));
@@ -44,35 +43,17 @@ namespace FastRngTests.Double.Distributions
             Assert.That(result[99], Is.EqualTo(0.0033038503429554).Within(0.008));
         }
 
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task TestGammaGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.GammaA5B15 { 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 TestGammaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.GammaA5B15();
+            var dist = new FastRng.Double.Distributions.GammaA5B15(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
@@ -82,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestGammaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.GammaA5B15();
+            var dist = new FastRng.Double.Distributions.GammaA5B15(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -96,11 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Double.Distributions.GammaA5B15();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.GammaA5B15(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/InverseExponentialLa10.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa10();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseExponentialLa10(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000501746820562).Within(0.0003));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseExponentialLa10(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseExponentialLa10(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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 TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa10 { 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");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa10();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.InverseExponentialLa10(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/InverseExponentialLa5.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa5();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseExponentialLa5(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.007083408929052).Within(0.008));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseExponentialLa5(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseExponentialLa5(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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 TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa5 { 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");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Double.Distributions.InverseExponentialLa5();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.InverseExponentialLa5(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/InverseGammaA3B05.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestInverseGammaDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.InverseGammaA3B05();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.InverseGammaA3B05(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000000000000003).Within(0.0000001));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestInverseGammaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.InverseGammaA3B05();
+            var dist = new FastRng.Double.Distributions.InverseGammaA3B05(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestInverseGammaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.InverseGammaA3B05();
+            var dist = new FastRng.Double.Distributions.InverseGammaA3B05(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestInverseGammaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.InverseGammaA3B05(null));
-            var dist = new FastRng.Double.Distributions.InverseGammaA3B05 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.InverseGammaA3B05();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/LaplaceB01M0.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.LaplaceB01M0();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.LaplaceB01M0(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.0000000000000000).Within(0.05));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.LaplaceB01M0();
+            var dist = new FastRng.Double.Distributions.LaplaceB01M0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.LaplaceB01M0();
+            var dist = new FastRng.Double.Distributions.LaplaceB01M0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestLaplaceGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.LaplaceB01M0(null));
-            var dist = new FastRng.Double.Distributions.LaplaceB01M0 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.LaplaceB01M0();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/LaplaceB01M05.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.LaplaceB01M05();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.LaplaceB01M05(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0074465830709244).Within(0.004));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.LaplaceB01M05();
+            var dist = new FastRng.Double.Distributions.LaplaceB01M05(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.LaplaceB01M05();
+            var dist = new FastRng.Double.Distributions.LaplaceB01M05(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestLaplaceGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.LaplaceB01M05(null));
-            var dist = new FastRng.Double.Distributions.LaplaceB01M05 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.LaplaceB01M05();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/LogNormalS1M0.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLogNormalDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.LogNormalS1M0();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.LogNormalS1M0(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.001505531).Within(0.003));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLogNormalGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.LogNormalS1M0();
+            var dist = new FastRng.Double.Distributions.LogNormalS1M0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLogNormalGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.LogNormalS1M0();
+            var dist = new FastRng.Double.Distributions.LogNormalS1M0(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestLogNormalGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.LogNormalS1M0(null));
-            var dist = new FastRng.Double.Distributions.LogNormalS1M0 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.LogNormalS1M0();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/NormalS02M05.cs

@@ -18,10 +18,10 @@ namespace FastRngTests.Double.Distributions
             const double MEAN = 0.5;
             const double STANDARD_DEVIATION = 0.2;
             
-            var dist = new FastRng.Double.Distributions.NormalS02M05();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.NormalS02M05(rng);
             var stats = new RunningStatistics();
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
             {
@@ -30,7 +30,6 @@ namespace FastRngTests.Double.Distributions
                 fra.CountThis(nextNumber);
             }
 
-            rng.StopProducer();
             fra.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}");
@@ -45,13 +44,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestNormalGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.NormalS02M05();
+            var dist = new FastRng.Double.Distributions.NormalS02M05(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
@@ -61,13 +59,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestNormalGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.NormalS02M05();
+            var dist = new FastRng.Double.Distributions.NormalS02M05(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -75,28 +72,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestNormalGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.NormalS02M05(null));
-            var dist = new FastRng.Double.Distributions.NormalS02M05 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.NormalS02M05();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/StudentTNu1.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestStudentTDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.StudentTNu1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.StudentTNu1(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.000000000).Within(0.2));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestStudentTGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.StudentTNu1();
+            var dist = new FastRng.Double.Distributions.StudentTNu1(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestStudentTGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.StudentTNu1();
+            var dist = new FastRng.Double.Distributions.StudentTNu1(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestStudentTGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.StudentTNu1(null));
-            var dist = new FastRng.Double.Distributions.StudentTNu1 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.StudentTNu1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/Distributions/Uniform.cs

@@ -10,8 +10,6 @@ namespace FastRngTests.Double.Distributions
     [ExcludeFromCodeCoverage]
     public class Uniform
     {
-        private readonly IRandom rng = new MultiThreadedRng();
-        
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
@@ -24,7 +22,7 @@ namespace FastRngTests.Double.Distributions
             
             var stats = new RunningStatistics();
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
             {
@@ -33,7 +31,6 @@ namespace FastRngTests.Double.Distributions
                 fra.CountThis(value);
             }
 
-            rng.StopProducer();
             fra.NormalizeAndPlotEvents(TestContext.WriteLine);
             fra.PlotOccurence(TestContext.WriteLine);
             TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}");
@@ -61,13 +58,12 @@ namespace FastRngTests.Double.Distributions
             const double P_HIGH = 1.0 - 0.25 * FAILURE_PROBABILITY;
             
             var samples = new double[NUM_ROUNDS];
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             int n;
              
             for (n = 0; n != NUM_ROUNDS; ++n)
                 samples[n] = await rng.GetUniform();
  
-            rng.StopProducer();
             Array.Sort(samples);
 
             var jMinus = 0;
@@ -120,11 +116,11 @@ namespace FastRngTests.Double.Distributions
         public async Task TestUniformGeneratorWithRange01()
         {
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng(); 
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max is out of range");
         }
@@ -135,7 +131,8 @@ namespace FastRngTests.Double.Distributions
         public async Task TestUniformGeneratorWithRange02()
         {
             var samples = new double[1_000];
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
@@ -143,34 +140,16 @@ 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();
+            using 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");
         }
@@ -180,7 +159,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestRange05Uint()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -195,7 +175,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestRange05Ulong()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -210,7 +191,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestRange05Float()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -224,7 +206,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestDistribution001Uint()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -237,7 +220,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestDistribution001Ulong()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -250,7 +234,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestDistribution001Float()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -263,7 +248,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.LONG_RUNNING)]
         public async Task TestDistribution002Uint()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 100_000_000;
             for (var n = 0; n < runs; n++)
@@ -276,7 +262,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.LONG_RUNNING)]
         public async Task TestDistribution002Ulong()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 100_000_000;
             for (var n = 0; n < runs; n++)
@@ -289,7 +276,8 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.LONG_RUNNING)]
         public async Task TestDistribution002Float()
         {
-            var dist = new FastRng.Double.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 100_000_000;
             for (var n = 0; n < runs; n++)

FastRngTests/Double/Distributions/WeibullK05La1.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestWeibullDistribution01()
         {
-            var dist = new FastRng.Double.Distributions.WeibullK05La1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Double.Distributions.WeibullK05La1(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.000000000).Within(0.2));
@@ -49,13 +48,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestWeibullGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.WeibullK05La1();
+            var dist = new FastRng.Double.Distributions.WeibullK05La1(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0, 1.0, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Double.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestWeibullGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Double.Distributions.WeibullK05La1();
+            var dist = new FastRng.Double.Distributions.WeibullK05La1(rng);
             var samples = new double[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0, 1.0, dist);
             
-            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");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Double.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestWeibullGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Double.Distributions.WeibullK05La1(null));
-            var dist = new FastRng.Double.Distributions.WeibullK05La1 { 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 NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Double.Distributions.WeibullK05La1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Double/MultiThreadedRngTests.cs

@@ -18,7 +18,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange01Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             for (uint n = 0; n < 1_000_000; n++)
                 Assert.That(await rng.NextNumber(n, 100_000 + n, dist), Is.InRange(n, 100_000 + n));
         }
@@ -28,7 +28,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange01Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             for (ulong n = 0; n < 1_000_000; n++)
                 Assert.That(await rng.NextNumber(n, 100_000 + n, dist), Is.InRange(n, 100_000 + n));
         }
@@ -38,7 +38,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange01Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             for (var n = 0.0; n < 1e6; n++)
                 Assert.That(await rng.NextNumber(n, 100_000 + n, dist), Is.InRange(n, 100_000 + n));
         }
@@ -48,7 +48,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange02Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5, 5, dist), Is.EqualTo(5));
             Assert.That(await rng.NextNumber(0, 0, dist), Is.EqualTo(0));
             Assert.That(await rng.NextNumber(3_000_000_000, 3_000_000_000, dist), Is.EqualTo(3_000_000_000));
@@ -59,7 +59,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange02Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5UL, 5, dist), Is.EqualTo(5));
             Assert.That(await rng.NextNumber(0UL, 0, dist), Is.EqualTo(0));
             Assert.That(await rng.NextNumber(3_000_000_000UL, 3_000_000_000, dist), Is.EqualTo(3_000_000_000));
@@ -70,7 +70,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange02Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5f, 5f, dist), Is.EqualTo(5));
             Assert.That(await rng.NextNumber(0f, 0f, dist), Is.EqualTo(0));
             Assert.That(await rng.NextNumber(3e9, 3e9, dist), Is.EqualTo(3e9));
@@ -81,7 +81,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange03Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5, 6, dist), Is.InRange(5, 6));
             Assert.That(await rng.NextNumber(0, 1, dist), Is.InRange(0, 1));
             Assert.That(await rng.NextNumber(3_000_000_000, 3_000_000_002, dist), Is.InRange(3_000_000_000, 3_000_000_002));
@@ -92,7 +92,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange03Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5UL, 6, dist), Is.InRange(5, 6));
             Assert.That(await rng.NextNumber(0UL, 1, dist), Is.InRange(0, 1));
             Assert.That(await rng.NextNumber(3_000_000_000UL, 3_000_000_002, dist), Is.InRange(3_000_000_000, 3_000_000_002));
@@ -103,7 +103,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange03Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5f, 6, dist), Is.InRange(5, 6));
             Assert.That(await rng.NextNumber(0f, 1, dist), Is.InRange(0, 1));
             Assert.That(await rng.NextNumber(3e9, 3e9+2, dist), Is.InRange(3e9, 3e9+2));
@@ -114,7 +114,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange04Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(10, 1, dist), Is.InRange(1, 10));
             Assert.That(await rng.NextNumber(20, 1, dist), Is.InRange(1, 20));
         }
@@ -124,7 +124,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange04Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(10UL, 1, dist), Is.InRange(1, 10));
             Assert.That(await rng.NextNumber(20UL, 1, dist), Is.InRange(1, 20));
         }
@@ -134,7 +134,7 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestRange04Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(10.0, 1, dist), Is.InRange(1, 10));
             Assert.That(await rng.NextNumber(20.0, 1, dist), Is.InRange(1, 20));
         }
@@ -144,8 +144,8 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TestStoppingProducers01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng2 = new MultiThreadedRng();
-            rng.StopProducer();
+            rng2.StopProducer();
 
             var masterToken = new CancellationTokenSource(TimeSpan.FromSeconds(16)).Token;
             var wasCanceled = false;
@@ -153,7 +153,7 @@ namespace FastRngTests.Double
             while(true)
             {
                 var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-                await rng.GetUniform(tokenSource.Token);
+                await rng2.GetUniform(tokenSource.Token);
                 if (tokenSource.IsCancellationRequested)
                 {
                     wasCanceled = true;
@@ -170,19 +170,19 @@ namespace FastRngTests.Double
             Assert.That(wasCanceled, Is.True, "The consumer was not canceled");
             
             var tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
             
             tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(-1d, 1d, new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(-1d, 1d, new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
             
             tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(0u, 6u, new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(0u, 6u, new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
             
             tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(0ul, 6ul, new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(0ul, 6ul, new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
         }
 
@@ -191,9 +191,9 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task OneSeed01()
         {
-            var rng1 = new MultiThreadedRng(6);
+            using var rng1 = new MultiThreadedRng(6);
-            var rng2 = new MultiThreadedRng(6);
+            using var rng2 = new MultiThreadedRng(6);
-            var rng3 = new MultiThreadedRng(7);
+            using var rng3 = new MultiThreadedRng(7);
 
             var rng1Sample = new double[10];
             for (var n = 0; n < rng1Sample.Length; n++)
@@ -207,10 +207,6 @@ namespace FastRngTests.Double
             for (var n = 0; n < rng3Sample.Length; n++)
                 rng3Sample[n] = await rng3.GetUniform();
 
-            rng1.StopProducer();
-            rng2.StopProducer();
-            rng3.StopProducer();
-            
             Assert.That(rng1Sample, Is.EquivalentTo(rng2Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
             Assert.That(rng2Sample, Is.Not.EquivalentTo(rng3Sample));
@@ -221,10 +217,10 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task TwoSeeds01()
         {
-            var rng1 = new MultiThreadedRng(3, 6);
+            using var rng1 = new MultiThreadedRng(3, 6);
-            var rng2 = new MultiThreadedRng(3, 6);
+            using var rng2 = new MultiThreadedRng(3, 6);
-            var rng3 = new MultiThreadedRng(3, 7);
+            using var rng3 = new MultiThreadedRng(3, 7);
-            var rng4 = new MultiThreadedRng(6, 3);
+            using var rng4 = new MultiThreadedRng(6, 3);
 
             var rng1Sample = new double[10];
             for (var n = 0; n < rng1Sample.Length; n++)
@@ -242,11 +238,6 @@ namespace FastRngTests.Double
             for (var n = 0; n < rng4Sample.Length; n++)
                 rng4Sample[n] = await rng4.GetUniform();
 
-            rng1.StopProducer();
-            rng2.StopProducer();
-            rng3.StopProducer();
-            rng4.StopProducer();
-            
             Assert.That(rng1Sample, Is.EquivalentTo(rng2Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng4Sample));
@@ -260,9 +251,9 @@ namespace FastRngTests.Double
         [Category(TestCategories.NORMAL)]
         public async Task NoSeed01()
         {
-            var rng1 = new MultiThreadedRng();
+            using var rng1 = new MultiThreadedRng();
-            var rng2 = new MultiThreadedRng();
+            using var rng2 = new MultiThreadedRng();
-            var rng3 = new MultiThreadedRng();
+            using var rng3 = new MultiThreadedRng();
 
             var rng1Sample = new double[10];
             for (var n = 0; n < rng1Sample.Length; n++)
@@ -276,10 +267,6 @@ namespace FastRngTests.Double
             for (var n = 0; n < rng3Sample.Length; n++)
                 rng3Sample[n] = await rng3.GetUniform();
 
-            rng1.StopProducer();
-            rng2.StopProducer();
-            rng3.StopProducer();
-            
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng2Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
             Assert.That(rng2Sample, Is.Not.EquivalentTo(rng3Sample));
@@ -295,7 +282,7 @@ namespace FastRngTests.Double
             tokenSource.Cancel();
             
             using var rng2 = new MultiThreadedRng();
-            var dist = new Uniform();
+            var dist = new Uniform(rng2);
             Assert.That(await rng2.NextNumber(1, 100_000, dist, token), Is.EqualTo(0));
         }
         

FastRngTests/Double/PerformanceTests.cs

@@ -39,7 +39,7 @@ namespace FastRngTests.Double
         public async Task Generate1MNormal()
         {
             using var rng = new MultiThreadedRng();
-            var dist = new NormalS02M05();
+            var dist = new NormalS02M05(rng);
             var data = new double[1_000_000];
             var stopwatch = new Stopwatch();
             Thread.Sleep(TimeSpan.FromSeconds(10)); // Warm-up phase of generator
@@ -49,7 +49,6 @@ namespace FastRngTests.Double
                 data[n] = await rng.NextNumber(dist);
             
             stopwatch.Stop();
-            rng.StopProducer();
             
             TestContext.WriteLine($"Generated 1M normal distributed random numbers in {stopwatch.Elapsed.Minutes} minute(s), {stopwatch.Elapsed.Seconds} second(s), and {stopwatch.Elapsed.Milliseconds} milliseconds.");
         }
@@ -59,7 +58,7 @@ namespace FastRngTests.Double
         public async Task Generate1MChiSquare()
         {
             using var rng = new MultiThreadedRng();
-            var dist = new ChiSquareK4();
+            var dist = new ChiSquareK4(rng);
             var data = new double[1_000_000];
             var stopwatch = new Stopwatch();
             Thread.Sleep(TimeSpan.FromSeconds(10)); // Warm-up phase of generator

FastRngTests/Float/Distributions/BetaA2B2.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
@@ -14,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.BetaA2B2();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.BetaA2B2(rng);
             var fqa = new Float.FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.0396f).Within(0.3f));
@@ -48,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.BetaA2B2();
+            var dist = new FastRng.Float.Distributions.BetaA2B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
 
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -64,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.BetaA2B2();
+            var dist = new FastRng.Float.Distributions.BetaA2B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -78,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestBetaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.BetaA2B2(null));
-            var dist = new FastRng.Float.Distributions.BetaA2B2 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.BetaA2B2();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/BetaA2B5.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
@@ -14,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.BetaA2B5();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.BetaA2B5(rng);
             var fqa = new Float.FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.11719271f).Within(0.3f));
@@ -48,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.BetaA2B5();
+            var dist = new FastRng.Float.Distributions.BetaA2B5(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
 
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -64,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.BetaA2B5();
+            var dist = new FastRng.Float.Distributions.BetaA2B5(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -78,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestBetaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.BetaA2B5(null));
-            var dist = new FastRng.Float.Distributions.BetaA2B5 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.BetaA2B5();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/BetaA5B2.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.BetaA5B2();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.BetaA5B2(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.0000001f).Within(0.0000003f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.BetaA5B2();
+            var dist = new FastRng.Float.Distributions.BetaA5B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
 
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestBetaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.BetaA5B2();
+            var dist = new FastRng.Float.Distributions.BetaA5B2(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestBetaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.BetaA5B2(null));
-            var dist = new FastRng.Float.Distributions.BetaA5B2 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.BetaA5B2();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/CauchyLorentzX0.cs

@@ -18,14 +18,13 @@ namespace FastRngTests.Float.Distributions
             // The properties of the cauchy distribution cannot be tested by mean, media or variance,  
             // cf. https://en.wikipedia.org/wiki/Cauchy_distribution#Explanation_of_undefined_moments
             
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.CauchyLorentzX0(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.976990739772031f).Within(0.06f));
@@ -52,13 +51,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.CauchyLorentzX0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -68,13 +66,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.CauchyLorentzX0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -82,28 +79,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestCauchyGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.CauchyLorentzX0(null));
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/CauchyLorentzX1.cs

@@ -18,14 +18,13 @@ namespace FastRngTests.Float.Distributions
             // The properties of the cauchy distribution cannot be tested by mean, media or variance,  
             // cf. https://en.wikipedia.org/wiki/Cauchy_distribution#Explanation_of_undefined_moments
             
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.CauchyLorentzX1(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             Assert.That(result[0], Is.EqualTo(0.009966272570142f).Within(0.003f));
@@ -52,13 +51,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.CauchyLorentzX0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -68,13 +66,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestCauchyGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.CauchyLorentzX0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -82,28 +79,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestCauchyGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.CauchyLorentzX1(null));
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX0 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.CauchyLorentzX1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/ChiSquareK1.cs

@@ -15,9 +15,9 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK1(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
             {
@@ -25,8 +25,6 @@ namespace FastRngTests.Float.Distributions
                 fqa.CountThis(value);
             }
             
-            rng.StopProducer();
-            
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.00032041964207f).Within(0.004f));
@@ -53,13 +51,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK1();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK1(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -69,13 +66,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK1();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK1(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -83,28 +79,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestChiSquareGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.ChiSquareK1(null));
-            var dist = new FastRng.Float.Distributions.ChiSquareK1 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.ChiSquareK1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/ChiSquareK10.cs

@@ -15,9 +15,9 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK10();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK10(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
             {
@@ -25,8 +25,6 @@ namespace FastRngTests.Float.Distributions
                 fqa.CountThis(value);
             }
             
-            rng.StopProducer();
-            
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000000164021588f).Within(0.0000002f));
@@ -53,13 +51,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK10(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -69,13 +66,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK10(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -83,28 +79,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestChiSquareGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.ChiSquareK10(null));
-            var dist = new FastRng.Float.Distributions.ChiSquareK10 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.ChiSquareK10();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/ChiSquareK4.cs

@@ -15,15 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK4();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK4(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
 
-            rng.StopProducer();
-            
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.016417705906679f).Within(0.02f));
@@ -50,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK4();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK4(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -66,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestChiSquareGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.ChiSquareK4();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ChiSquareK4(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -80,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestChiSquareGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.ChiSquareK4(null));
-            var dist = new FastRng.Float.Distributions.ChiSquareK4 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.ChiSquareK4();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/ExponentialLa10.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa10();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ExponentialLa10(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.00075018434777f).Within(0.05f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ExponentialLa10(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ExponentialLa10(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test] [Category(TestCategories.COVER)] [Category(TestCategories.NORMAL)]
-        public async Task TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.ExponentialLa10 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa10();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.ExponentialLa10(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/ExponentialLa5.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa5();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ExponentialLa5(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.0002177398625f).Within(0.05f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ExponentialLa5(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.ExponentialLa5(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test] [Category(TestCategories.COVER)] [Category(TestCategories.NORMAL)]
-        public async Task TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.ExponentialLa5 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Float.Distributions.ExponentialLa5();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.ExponentialLa5(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/GammaA5B15.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestGammaDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.GammaA5B15();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.GammaA5B15(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000929594237282f).Within(0.0008f));
@@ -44,35 +43,17 @@ namespace FastRngTests.Float.Distributions
             Assert.That(result[99], Is.EqualTo(0.0033038503429554f).Within(0.008f));
         }
 
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task TestGammaGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.GammaA5B15 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-        
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
         public async Task TestGammaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.GammaA5B15();
+            var dist = new FastRng.Float.Distributions.GammaA5B15(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -82,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestGammaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.GammaA5B15();
+            var dist = new FastRng.Float.Distributions.GammaA5B15(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -96,11 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Float.Distributions.GammaA5B15();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.GammaA5B15(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/InverseExponentialLa10.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa10();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.InverseExponentialLa10(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000501746820562f).Within(0.0003f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.InverseExponentialLa10(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa10();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.InverseExponentialLa10(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test] [Category(TestCategories.COVER)] [Category(TestCategories.NORMAL)]
-        public async Task TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa10 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa10();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.InverseExponentialLa10(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/InverseExponentialLa5.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa5();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.InverseExponentialLa5(rng);
             var fqa = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fqa.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.007083408929052f).Within(0.008f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange01()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.InverseExponentialLa5(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,28 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestExponentialGeneratorWithRange02()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa5();
+            using var rng = new MultiThreadedRng();
-            var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.InverseExponentialLa5(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test] [Category(TestCategories.COVER)] [Category(TestCategories.NORMAL)]
-        public async Task TestExponentialGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa5 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -94,11 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
+        public void NoRandomNumberGenerator01()
         {
-            var dist = new FastRng.Float.Distributions.InverseExponentialLa5();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.InverseExponentialLa5(null));
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/InverseGammaA3B05.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestInverseGammaDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.InverseGammaA3B05();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.InverseGammaA3B05(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0000000000000003f).Within(0.0000001f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestInverseGammaGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.InverseGammaA3B05();
+            var dist = new FastRng.Float.Distributions.InverseGammaA3B05(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestInverseGammaGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.InverseGammaA3B05();
+            var dist = new FastRng.Float.Distributions.InverseGammaA3B05(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestInverseGammaGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.InverseGammaA3B05(null));
-            var dist = new FastRng.Float.Distributions.InverseGammaA3B05 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.InverseGammaA3B05();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/LaplaceB01M0.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.LaplaceB01M0();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.LaplaceB01M0(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.0000000000000000f).Within(0.05f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.LaplaceB01M0();
+            var dist = new FastRng.Float.Distributions.LaplaceB01M0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.LaplaceB01M0();
+            var dist = new FastRng.Float.Distributions.LaplaceB01M0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestLaplaceGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.LaplaceB01M0(null));
-            var dist = new FastRng.Float.Distributions.LaplaceB01M0 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.LaplaceB01M0();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/LaplaceB01M05.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.LaplaceB01M05();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.LaplaceB01M05(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.0074465830709244f).Within(0.004f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.LaplaceB01M05();
+            var dist = new FastRng.Float.Distributions.LaplaceB01M05(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLaplaceGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.LaplaceB01M05();
+            var dist = new FastRng.Float.Distributions.LaplaceB01M05(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestLaplaceGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.LaplaceB01M05(null));
-            var dist = new FastRng.Float.Distributions.LaplaceB01M05 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.LaplaceB01M05();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/LogNormalS1M0.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLogNormalDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.LogNormalS1M0();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.LogNormalS1M0(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(0.001505531f).Within(0.003f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLogNormalGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.LogNormalS1M0();
+            var dist = new FastRng.Float.Distributions.LogNormalS1M0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestLogNormalGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.LogNormalS1M0();
+            var dist = new FastRng.Float.Distributions.LogNormalS1M0(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestLogNormalGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.LogNormalS1M0(null));
-            var dist = new FastRng.Float.Distributions.LogNormalS1M0 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.LogNormalS1M0();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/NormalS02M05.cs

@@ -18,10 +18,10 @@ namespace FastRngTests.Float.Distributions
             const float MEAN = 0.5f;
             const float STANDARD_DEVIATION = 0.2f;
 
-            var dist = new FastRng.Float.Distributions.NormalS02M05();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.NormalS02M05(rng);
             var stats = new RunningStatistics();
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
             {
@@ -30,7 +30,6 @@ namespace FastRngTests.Float.Distributions
                 fra.CountThis(nextNumber);
             }
 
-            rng.StopProducer();
             fra.NormalizeAndPlotEvents(TestContext.WriteLine);
             
             TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}");
@@ -45,13 +44,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestNormalGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.NormalS02M05();
+            var dist = new FastRng.Float.Distributions.NormalS02M05(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -61,13 +59,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestNormalGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.NormalS02M05();
+            var dist = new FastRng.Float.Distributions.NormalS02M05(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -75,28 +72,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestNormalGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.NormalS02M05(null));
-            var dist = new FastRng.Float.Distributions.NormalS02M05 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.NormalS02M05();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/StudentTNu1.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestStudentTDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.StudentTNu1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.StudentTNu1(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
 
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.000000000f).Within(0.2f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestStudentTGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.StudentTNu1();
+            var dist = new FastRng.Float.Distributions.StudentTNu1(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestStudentTGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.StudentTNu1();
+            var dist = new FastRng.Float.Distributions.StudentTNu1(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestStudentTGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.StudentTNu1(null));
-            var dist = new FastRng.Float.Distributions.StudentTNu1 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.StudentTNu1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/Distributions/Uniform.cs

@@ -10,8 +10,6 @@ namespace FastRngTests.Float.Distributions
     [ExcludeFromCodeCoverage]
     public class Uniform
     {
-        private readonly IRandom rng = new MultiThreadedRng();
-        
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
@@ -22,9 +20,9 @@ namespace FastRngTests.Float.Distributions
             const float MEAN = 0.5f * (A + B);
             const float VARIANCE = (1.0f / 12.0f) * (B - A) * (B - A);
 
+            using var rng = new MultiThreadedRng();
             var stats = new RunningStatistics();
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
             {
@@ -33,7 +31,6 @@ namespace FastRngTests.Float.Distributions
                 fra.CountThis(value);
             }
 
-            rng.StopProducer();
             fra.NormalizeAndPlotEvents(TestContext.WriteLine);
             fra.PlotOccurence(TestContext.WriteLine);
             TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}");
@@ -61,13 +58,12 @@ namespace FastRngTests.Float.Distributions
             const float P_HIGH = 1.0f - 0.25f * FAILURE_PROBABILITY;
             
             var samples = new float[NUM_ROUNDS];
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             int n;
              
             for (n = 0; n != NUM_ROUNDS; ++n)
                 samples[n] = await rng.GetUniform();
  
-            rng.StopProducer();
             Array.Sort(samples);
 
             var jMinus = 0;
@@ -119,12 +115,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestUniformGeneratorWithRange01()
         {
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.Uniform();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -134,8 +130,9 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestUniformGeneratorWithRange02()
         {
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
-            var dist = new FastRng.Float.Distributions.Uniform();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
@@ -143,34 +140,16 @@ namespace FastRngTests.Float.Distributions
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
 
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task TestUniformGeneratorWithRange03()
-        {
-            var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.Uniform { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-        
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
         public async Task TestUniformGeneratorWithRange04()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.GetUniform();
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -180,7 +159,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestRange05Uint()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -195,7 +175,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestRange05Ulong()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -210,7 +191,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestRange05Float()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -224,7 +206,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestDistribution001Uint()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -237,7 +220,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestDistribution001Ulong()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -250,7 +234,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestDistribution001Float()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 1_000_000;
             for (var n = 0; n < runs; n++)
@@ -263,7 +248,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.LONG_RUNNING)]
         public async Task TestDistribution002Uint()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 100_000_000;
             for (var n = 0; n < runs; n++)
@@ -276,7 +262,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.LONG_RUNNING)]
         public async Task TestDistribution002Ulong()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 100_000_000;
             for (var n = 0; n < runs; n++)
@@ -289,7 +276,8 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.LONG_RUNNING)]
         public async Task TestDistribution002Float()
         {
-            var dist = new FastRng.Float.Distributions.Uniform();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.Uniform(rng);
             var distribution = new uint[101];
             var runs = 100_000_000;
             for (var n = 0; n < runs; n++)

FastRngTests/Float/Distributions/WeibullK05La1.cs

@@ -15,14 +15,13 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestWeibullDistribution01()
         {
-            var dist = new FastRng.Float.Distributions.WeibullK05La1();
+            using var rng = new MultiThreadedRng();
+            var dist = new FastRng.Float.Distributions.WeibullK05La1(rng);
             var fra = new FrequencyAnalysis();
-            var rng = new MultiThreadedRng();
             
             for (var n = 0; n < 100_000; n++)
                 fra.CountThis(await rng.NextNumber(dist));
             
-            rng.StopProducer();
             var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
 
             Assert.That(result[0], Is.EqualTo(1.000000000f).Within(0.2f));
@@ -49,13 +48,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestWeibullGeneratorWithRange01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.WeibullK05La1();
+            var dist = new FastRng.Float.Distributions.WeibullK05La1(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(-1.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(-1.0f), "Min out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max out of range");
         }
@@ -65,13 +63,12 @@ namespace FastRngTests.Float.Distributions
         [Category(TestCategories.NORMAL)]
         public async Task TestWeibullGeneratorWithRange02()
         {
-            var rng = new MultiThreadedRng();
+            using var rng = new MultiThreadedRng();
-            var dist = new FastRng.Float.Distributions.WeibullK05La1();
+            var dist = new FastRng.Float.Distributions.WeibullK05La1(rng);
             var samples = new float[1_000];
             for (var n = 0; n < samples.Length; n++)
                 samples[n] = await rng.NextNumber(0.0f, 1.0f, dist);
             
-            rng.StopProducer();
             Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
             Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
         }
@@ -79,28 +76,9 @@ namespace FastRngTests.Float.Distributions
         [Test]
         [Category(TestCategories.COVER)]
         [Category(TestCategories.NORMAL)]
-        public async Task TestWeibullGeneratorWithRange03()
+        public void NoRandomNumberGenerator01()
         {
-            var rng = new MultiThreadedRng();
+            Assert.Throws<ArgumentNullException>(() => new FastRng.Float.Distributions.WeibullK05La1(null));
-            var dist = new FastRng.Float.Distributions.WeibullK05La1 { Random = rng }; // Test default parameters
-            
-            var samples = new float[1_000];
-            for (var n = 0; n < samples.Length; n++)
-                samples[n] = await dist.GetDistributedValue();
-            
-            rng.StopProducer();
-            Assert.That(samples.Min(), Is.GreaterThanOrEqualTo(0.0f), "Min is out of range");
-            Assert.That(samples.Max(), Is.LessThanOrEqualTo(1.0f), "Max is out of range");
-        }
-
-        [Test]
-        [Category(TestCategories.COVER)]
-        [Category(TestCategories.NORMAL)]
-        public async Task NoRandomNumberGenerator01()
-        {
-            var dist = new FastRng.Float.Distributions.WeibullK05La1();
-            Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue());
-            Assert.That(await dist.GetDistributedValue(), Is.NaN);
         }
     }
 }

FastRngTests/Float/MultiThreadedRngTests.cs

@@ -18,7 +18,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange01Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             for (uint n = 0; n < 1_000_000; n++)
                 Assert.That(await rng.NextNumber(n, 100_000 + n, dist), Is.InRange(n, 100_000 + n));
         }
@@ -28,7 +28,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange01Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             for (ulong n = 0; n < 1_000_000; n++)
                 Assert.That(await rng.NextNumber(n, 100_000 + n, dist), Is.InRange(n, 100_000 + n));
         }
@@ -38,7 +38,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange01Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             for (var n = 0.0f; n < 1e6f; n++)
                 Assert.That(await rng.NextNumber(n, 100_000 + n, dist), Is.InRange(n, 100_000 + n));
         }
@@ -48,7 +48,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange02Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5, 5, dist), Is.EqualTo(5));
             Assert.That(await rng.NextNumber(0, 0, dist), Is.EqualTo(0));
             Assert.That(await rng.NextNumber(3_000_000_000, 3_000_000_000, dist), Is.EqualTo(3_000_000_000));
@@ -59,7 +59,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange02Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5UL, 5, dist), Is.EqualTo(5));
             Assert.That(await rng.NextNumber(0UL, 0, dist), Is.EqualTo(0));
             Assert.That(await rng.NextNumber(3_000_000_000UL, 3_000_000_000, dist), Is.EqualTo(3_000_000_000));
@@ -70,7 +70,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange02Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5f, 5f, dist), Is.EqualTo(5));
             Assert.That(await rng.NextNumber(0f, 0f, dist), Is.EqualTo(0));
             Assert.That(await rng.NextNumber(3e9f, 3e9f, dist), Is.EqualTo(3e9f));
@@ -81,7 +81,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange03Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5, 6, dist), Is.InRange(5, 6));
             Assert.That(await rng.NextNumber(0, 1, dist), Is.InRange(0, 1));
             Assert.That(await rng.NextNumber(3_000_000_000, 3_000_000_002, dist), Is.InRange(3_000_000_000, 3_000_000_002));
@@ -92,7 +92,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange03Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5UL, 6, dist), Is.InRange(5, 6));
             Assert.That(await rng.NextNumber(0UL, 1, dist), Is.InRange(0, 1));
             Assert.That(await rng.NextNumber(3_000_000_000UL, 3_000_000_002, dist), Is.InRange(3_000_000_000, 3_000_000_002));
@@ -103,7 +103,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange03Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(5f, 6f, dist), Is.InRange(5f, 6f));
             Assert.That(await rng.NextNumber(0f, 1f, dist), Is.InRange(0f, 1f));
             Assert.That(await rng.NextNumber(3e9f, 3e9f+2f, dist), Is.InRange(3e9f, 3e9f+2f));
@@ -114,7 +114,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange04Uint()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(10, 1, dist), Is.InRange(1, 10));
             Assert.That(await rng.NextNumber(20, 1, dist), Is.InRange(1, 20));
         }
@@ -124,7 +124,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange04Ulong()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(10UL, 1, dist), Is.InRange(1, 10));
             Assert.That(await rng.NextNumber(20UL, 1, dist), Is.InRange(1, 20));
         }
@@ -134,7 +134,7 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestRange04Float()
         {
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng.NextNumber(10.0f, 1f, dist), Is.InRange(1f, 10f));
             Assert.That(await rng.NextNumber(20.0f, 1f, dist), Is.InRange(1f, 20f));
         }
@@ -144,8 +144,8 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TestStoppingProducers01()
         {
-            var rng = new MultiThreadedRng();
+            using var rng2 = new MultiThreadedRng();
-            rng.StopProducer();
+            rng2.StopProducer();
 
             var masterToken = new CancellationTokenSource(TimeSpan.FromSeconds(16)).Token;
             var wasCanceled = false;
@@ -153,7 +153,7 @@ namespace FastRngTests.Float
             while(true)
             {
                 var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-                await rng.GetUniform(tokenSource.Token);
+                await rng2.GetUniform(tokenSource.Token);
                 if (tokenSource.IsCancellationRequested)
                 {
                     wasCanceled = true;
@@ -170,19 +170,19 @@ namespace FastRngTests.Float
             Assert.That(wasCanceled, Is.True, "The consumer was not canceled");
             
             var tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
             
             tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(-1f, 1f, new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(-1f, 1f, new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
             
             tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(0u, 6u, new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(0u, 6u, new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
             
             tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
-            await rng.NextNumber(0ul, 6ul, new NormalS02M05(), tokenSource2.Token);
+            await rng2.NextNumber(0ul, 6ul, new NormalS02M05(rng2), tokenSource2.Token);
             Assert.That(tokenSource2.IsCancellationRequested, Is.True);
         }
 
@@ -191,9 +191,9 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task OneSeed01()
         {
-            var rng1 = new MultiThreadedRng(6);
+            using var rng1 = new MultiThreadedRng(6);
-            var rng2 = new MultiThreadedRng(6);
+            using var rng2 = new MultiThreadedRng(6);
-            var rng3 = new MultiThreadedRng(7);
+            using var rng3 = new MultiThreadedRng(7);
 
             var rng1Sample = new float[10];
             for (var n = 0; n < rng1Sample.Length; n++)
@@ -207,10 +207,6 @@ namespace FastRngTests.Float
             for (var n = 0; n < rng3Sample.Length; n++)
                 rng3Sample[n] = await rng3.GetUniform();
 
-            rng1.StopProducer();
-            rng2.StopProducer();
-            rng3.StopProducer();
-            
             Assert.That(rng1Sample, Is.EquivalentTo(rng2Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
             Assert.That(rng2Sample, Is.Not.EquivalentTo(rng3Sample));
@@ -221,10 +217,10 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task TwoSeeds01()
         {
-            var rng1 = new MultiThreadedRng(3, 6);
+            using var rng1 = new MultiThreadedRng(3, 6);
-            var rng2 = new MultiThreadedRng(3, 6);
+            using var rng2 = new MultiThreadedRng(3, 6);
-            var rng3 = new MultiThreadedRng(3, 7);
+            using var rng3 = new MultiThreadedRng(3, 7);
-            var rng4 = new MultiThreadedRng(6, 3);
+            using var rng4 = new MultiThreadedRng(6, 3);
 
             var rng1Sample = new float[10];
             for (var n = 0; n < rng1Sample.Length; n++)
@@ -242,11 +238,6 @@ namespace FastRngTests.Float
             for (var n = 0; n < rng4Sample.Length; n++)
                 rng4Sample[n] = await rng4.GetUniform();
 
-            rng1.StopProducer();
-            rng2.StopProducer();
-            rng3.StopProducer();
-            rng4.StopProducer();
-            
             Assert.That(rng1Sample, Is.EquivalentTo(rng2Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng4Sample));
@@ -260,9 +251,9 @@ namespace FastRngTests.Float
         [Category(TestCategories.NORMAL)]
         public async Task NoSeed01()
         {
-            var rng1 = new MultiThreadedRng();
+            using var rng1 = new MultiThreadedRng();
-            var rng2 = new MultiThreadedRng();
+            using var rng2 = new MultiThreadedRng();
-            var rng3 = new MultiThreadedRng();
+            using var rng3 = new MultiThreadedRng();
 
             var rng1Sample = new float[10];
             for (var n = 0; n < rng1Sample.Length; n++)
@@ -276,10 +267,6 @@ namespace FastRngTests.Float
             for (var n = 0; n < rng3Sample.Length; n++)
                 rng3Sample[n] = await rng3.GetUniform();
 
-            rng1.StopProducer();
-            rng2.StopProducer();
-            rng3.StopProducer();
-            
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng2Sample));
             Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
             Assert.That(rng2Sample, Is.Not.EquivalentTo(rng3Sample));
@@ -295,7 +282,7 @@ namespace FastRngTests.Float
             tokenSource.Cancel();
             
             using var rng2 = new MultiThreadedRng();
-            var dist = new Uniform();
+            var dist = new Uniform(this.rng);
             Assert.That(await rng2.NextNumber(1, 100_000, dist, token), Is.EqualTo(0));
         }
         

FastRngTests/Float/PerformanceTests.cs

@@ -39,7 +39,7 @@ namespace FastRngTests.Float
         public async Task Generate1MNormal()
         {
             using var rng = new MultiThreadedRng();
-            var dist = new NormalS02M05();
+            var dist = new NormalS02M05(rng);
             var data = new float[1_000_000];
             var stopwatch = new Stopwatch();
             Thread.Sleep(TimeSpan.FromSeconds(10)); // Warm-up phase of generator
@@ -59,7 +59,7 @@ namespace FastRngTests.Float
         public async Task Generate1MChiSquare()
         {
             using var rng = new MultiThreadedRng();
-            var dist = new ChiSquareK4(); // TODO: Check the impact, when the rng gets set on ctor
+            var dist = new ChiSquareK4(rng);
             var data = new float[1_000_000];
             var stopwatch = new Stopwatch();
             Thread.Sleep(TimeSpan.FromSeconds(10)); // Warm-up phase of generator