Added possibility to get integers out of the RNG

FastRngTests/GetIntTests.cs

@@ -0,0 +1,327 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading.Tasks;
+
+using FastRng;
+using FastRng.Distributions;
+
+using NUnit.Framework;
+
+namespace FastRngTests;
+
+[ExcludeFromCodeCoverage]
+public class GetIntTests
+{
+    #region Channel-Based
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void ChannelGetMax()
+    {
+        var random = new Random();
+        var randomMax = random.Next();
+        
+        using var rng = new MultiChannelRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMax);
+            Assert.That(value, Is.GreaterThanOrEqualTo(0));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void ChannelGetMaxDistributionCheck()
+    {
+        var random = new Random();
+        var randomMax = random.Next(3, 33);
+        var freqCheck = new IntFrequencyAnalysis(randomMax);
+        using var rng = new MultiChannelRng<float>();
+        
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMax);
+            freqCheck.CountThis(value);
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(0));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+        
+        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
+        var max = distribution.Max();
+        var min = distribution.Min();
+        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void ChannelGetMinMax()
+    {
+        var random = new Random();
+        var randomMin = random.Next();
+        int randomMax;
+        do
+        {
+            randomMax = random.Next();
+        } while (randomMax < randomMin);
+        
+        using var rng = new MultiChannelRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMin, randomMax);
+            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void ChannelGetMinMaxDistributionCheck()
+    {
+        var random = new Random();
+        var randomMin = random.Next(0, 16);
+        var randomMax = random.Next(randomMin + 10, 33);
+        
+        var freqCheck = new IntFrequencyAnalysis(randomMax - randomMin);
+        using var rng = new MultiChannelRng<float>();
+        
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMin, randomMax);
+            freqCheck.CountThis(value - randomMin);
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+        
+        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
+        var max = distribution.Max();
+        var min = distribution.Min();
+        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void ChannelCheckMinMax01()
+    {
+        var expectedMax = 3;
+
+        var max = int.MinValue;
+        var min = int.MaxValue;
+        using var rng = new MultiChannelRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(expectedMax);
+            if (value < min)
+                min = value;
+            
+            if (value > max)
+                max = value;
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(0));
+            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
+        }
+        
+        Assert.That(min, Is.EqualTo(0));
+        Assert.That(max, Is.EqualTo(expectedMax - 1));
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void ChannelCheckMinMax02()
+    {
+        var expectedMin = 2;
+        var expectedMax = 6;
+
+        var max = int.MinValue;
+        var min = int.MaxValue;
+        using var rng = new MultiChannelRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(expectedMin, expectedMax);
+            if (value < min)
+                min = value;
+            
+            if (value > max)
+                max = value;
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(expectedMin));
+            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
+        }
+        
+        Assert.That(min, Is.EqualTo(expectedMin));
+        Assert.That(max, Is.EqualTo(expectedMax - 1));
+    }
+    
+    #endregion
+    
+    #region Multithreaded
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void MultithreadedGetMax()
+    {
+        var random = new Random();
+        var randomMax = random.Next();
+        
+        using var rng = new MultiThreadedRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMax);
+            Assert.That(value, Is.GreaterThanOrEqualTo(0));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void MultithreadedGetMaxDistributionCheck()
+    {
+        var random = new Random();
+        var randomMax = random.Next(3, 33);
+        var freqCheck = new IntFrequencyAnalysis(randomMax);
+        using var rng = new MultiThreadedRng<float>();
+        
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMax);
+            freqCheck.CountThis(value);
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(0));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+        
+        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
+        var max = distribution.Max();
+        var min = distribution.Min();
+        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void MultithreadedGetMinMax()
+    {
+        var random = new Random();
+        var randomMin = random.Next();
+        int randomMax;
+        do
+        {
+            randomMax = random.Next();
+        } while (randomMax < randomMin);
+        
+        using var rng = new MultiThreadedRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMin, randomMax);
+            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void MultithreadedGetMinMaxDistributionCheck()
+    {
+        var random = new Random();
+        var randomMin = random.Next(0, 16);
+        var randomMax = random.Next(randomMin + 10, 33);
+        
+        var freqCheck = new IntFrequencyAnalysis(randomMax - randomMin);
+        using var rng = new MultiThreadedRng<float>();
+        
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(randomMin, randomMax);
+            freqCheck.CountThis(value - randomMin);
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
+            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
+        }
+        
+        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
+        var max = distribution.Max();
+        var min = distribution.Min();
+        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void MultithreadedCheckMinMax01()
+    {
+        var expectedMax = 3;
+
+        var max = int.MinValue;
+        var min = int.MaxValue;
+        using var rng = new MultiThreadedRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(expectedMax);
+            if (value < min)
+                min = value;
+            
+            if (value > max)
+                max = value;
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(0));
+            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
+        }
+        
+        Assert.That(min, Is.EqualTo(0));
+        Assert.That(max, Is.EqualTo(expectedMax - 1));
+    }
+    
+    [Test]
+    [Category(TestCategories.COVER)]
+    [Category(TestCategories.NORMAL)]
+    [Category(TestCategories.INT)]
+    public void MultithreadedCheckMinMax02()
+    {
+        var expectedMin = 2;
+        var expectedMax = 6;
+
+        var max = int.MinValue;
+        var min = int.MaxValue;
+        using var rng = new MultiThreadedRng<float>();
+        for(var n = 0; n < 10_000; n++)
+        {
+            var value = rng.GetUniformInt(expectedMin, expectedMax);
+            if (value < min)
+                min = value;
+            
+            if (value > max)
+                max = value;
+            
+            Assert.That(value, Is.GreaterThanOrEqualTo(expectedMin));
+            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
+        }
+        
+        Assert.That(min, Is.EqualTo(expectedMin));
+        Assert.That(max, Is.EqualTo(expectedMax - 1));
+    }
+    
+    #endregion
+}

FastRngTests/TestCategories.cs

@@ -5,6 +5,7 @@ public static class TestCategories
     public const string COVER = "cover";
     public const string PERFORMANCE = "performance";
     public const string NORMAL = "normal";
+    public const string INT = "int";
     public const string EXAMPLE = "example";
     public const string LONG_RUNNING = "long running";
 }