FastRng/FastRngTests/MultiThreadedRngTests.cs

using System;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Threading.Tasks;
using FastRng;
using FastRng.Distributions;
using NUnit.Framework;

namespace FastRngTests;

[ExcludeFromCodeCoverage]
public class MultiThreadedRngTests
{
    private readonly IRandom<float> rng = new MultiThreadedRng<float>();
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange01Uint()
    {
        var dist = new Uniform<float>(this.rng);
        for (uint n = 0; n < 1_000_000; n++)
            Assert.That(dist.NextNumber(n, 100_000 + n), Is.InRange(n, 100_000 + n));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange01Ulong()
    {
        var dist = new Uniform<float>(this.rng);
        for (ulong n = 0; n < 1_000_000; n++)
            Assert.That(dist.NextNumber (n, 100_000 + n), Is.InRange(n, 100_000 + n));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange01Float()
    {
        var dist = new Uniform<float>(this.rng);
        for (var n = 0.0f; n < 1e6f; n++)
            Assert.That(dist.NextNumber (n, 100_000 + n), Is.InRange(n, 100_000 + n));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange02Uint()
    {
        var dist = new Uniform<float>(this.rng);
        Assert.That(dist.NextNumber (5, 5), Is.EqualTo(5));
        Assert.That(dist.NextNumber (0, 0), Is.EqualTo(0));
        Assert.That(dist.NextNumber (3_000_000_000, 3_000_000_000), Is.EqualTo(3_000_000_000));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange02Ulong()
    {
        var dist = new Uniform<float>(this.rng);
        Assert.That(dist.NextNumber (5UL, 5), Is.EqualTo(5));
        Assert.That(dist.NextNumber (0UL, 0), Is.EqualTo(0));
        Assert.That(dist.NextNumber (3_000_000_000UL, 3_000_000_000), Is.EqualTo(3_000_000_000));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange02Float()
    {
        var dist = new Uniform<float>(this.rng);
        Assert.That(dist.NextNumber (5f, 5f), Is.EqualTo(5));
        Assert.That(dist.NextNumber (0f, 0f), Is.EqualTo(0));
        Assert.That(dist.NextNumber (3e9f, 3e9f), Is.EqualTo(3e9f));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange03Uint()
    {
        var dist = new Uniform<float>(this.rng);
        Assert.That(dist.NextNumber (5, 6), Is.InRange(5, 6));
        Assert.That(dist.NextNumber (0, 1), Is.InRange(0, 1));
        Assert.That(dist.NextNumber (3_000_000_000, 3_000_000_002), Is.InRange(3_000_000_000, 3_000_000_002));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange03Ulong()
    {
        var dist = new Uniform<float>(this.rng);
        Assert.That(dist.NextNumber (5UL, 6), Is.InRange(5, 6));
        Assert.That(dist.NextNumber (0UL, 1), Is.InRange(0, 1));
        Assert.That(dist.NextNumber (3_000_000_000UL, 3_000_000_002), Is.InRange(3_000_000_000, 3_000_000_002));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange03Float()
    {
        var dist = new Uniform<float>(this.rng);
        Assert.That(dist.NextNumber (5f, 6f), Is.InRange(5f, 6f));
        Assert.That(dist.NextNumber (0f, 1f), Is.InRange(0f, 1f));
        Assert.That(dist.NextNumber (3e9f, 3e9f+2f), Is.InRange(3e9f, 3e9f+2f));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange04Uint()
    {
        var distUniform = new Uniform<float>(this.rng);
        var distNormal = new NormalS02M05<float>(this.rng);
            
        Assert.That(distUniform.NextNumber(10, 1), Is.InRange(1, 10));
        Assert.That(distNormal.NextNumber(10, 1), Is.InRange(1, 10));
            
        Assert.That(distUniform.NextNumber(20, 1), Is.InRange(1, 20));
        Assert.That(distNormal.NextNumber(20, 1), Is.InRange(1, 20));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange04Ulong()
    {
        var distUniform = new Uniform<float>(this.rng);
        var distNormal = new NormalS02M05<float>(this.rng);
            
        Assert.That(distUniform.NextNumber(10UL, 1), Is.InRange(1, 10));
        Assert.That(distNormal.NextNumber(10UL, 1), Is.InRange(1, 10));
            
        Assert.That(distUniform.NextNumber(20UL, 1), Is.InRange(1, 20));
        Assert.That(distNormal.NextNumber(20UL, 1), Is.InRange(1, 20));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestRange04Float()
    {
        var distUniform = new Uniform<float>(this.rng);
        var distNormal = new NormalS02M05<float>(this.rng);
            
        Assert.That(distUniform.NextNumber(10.0f, 1), Is.InRange(1, 10));
        Assert.That(distNormal.NextNumber(10.0f, 1), Is.InRange(1, 10));
            
        Assert.That(distUniform.NextNumber(20.0f, 1), Is.InRange(1, 20));
        Assert.That(distNormal.NextNumber(20.0f, 1), Is.InRange(1, 20));
    }
        
    [Test]
    [Category(TestCategories.LONG_RUNNING)]
    public void TestRange05()
    {
        var distUniform = new Uniform<float>(this.rng);
        var distLorentz = new CauchyLorentzX1<float>(this.rng);

        var rngContains0 = false;
        var rngContains1 = false;
            
        var uniformContains0 = false;
        var uniformContains1 = false;
            
        var lorentzContains0 = false;
        var lorentzContains1 = false;

        for (int i = 0; i < 100_000_000; i++)
        {
            var rngValue = this.rng.GetUniform();
            var uniform = distUniform.NextNumber();
            var lorentz = distLorentz.NextNumber();

            switch (rngValue)
            {
                case 0.0f:
                    rngContains0 = true;
                    break;
                case 1.0f:
                    rngContains1 = true;
                    break;
            }
                
            switch (uniform)
            {
                case 0.0f:
                    uniformContains0 = true;
                    break;
                case 1.0f:
                    uniformContains1 = true;
                    break;
            }
                
            switch (lorentz)
            {
                case 0.0f:
                    lorentzContains0 = true;
                    break;
                case 1.0f:
                    lorentzContains1 = true;
                    break;
            }
        }
            
        TestContext.WriteLine($"Uniform generator contained 0? {rngContains0} (expected=false)");
        TestContext.WriteLine($"Uniform generator contained 1? {rngContains1} (expected=true)");
        TestContext.WriteLine($"Uniform distribution contained 0? {uniformContains0} (expected=false)");
        TestContext.WriteLine($"Uniform distribution contained 1? {uniformContains1} (expected=true)");
        TestContext.WriteLine($"Lorentz distribution contained 0? {lorentzContains0} (expected=false)");
        TestContext.WriteLine($"Lorentz distribution contained 1? {lorentzContains1} (expected=true)");
            
        Assert.That(rngContains0, Is.False, "Uniform generator contained 0");
        Assert.That(rngContains1, Is.True, "Uniform generator does not contained 1");
            
        Assert.That(uniformContains0, Is.False, "Uniform distribution contained 0");
        Assert.That(uniformContains1, Is.True, "Uniform distribution does not contained 1");
            
        Assert.That(lorentzContains0, Is.False, "Lorentz distribution contained 0");
        Assert.That(lorentzContains1, Is.True, "Lorentz distribution does not contained 1");
    }
    
    [Test]
    [Category(TestCategories.LONG_RUNNING)]
    public void TestMultiThreadedConsumer()
    {
        var job1 = Task.Factory.StartNew(Run, TaskCreationOptions.LongRunning);
        var job2 = Task.Factory.StartNew(Run, TaskCreationOptions.LongRunning);
        var job3 = Task.Factory.StartNew(Run, TaskCreationOptions.LongRunning);
        
        Assert.DoesNotThrowAsync(async () => await job1);
        Assert.DoesNotThrowAsync(async () => await job2);
        Assert.DoesNotThrowAsync(async () => await job3);
        return;

        float Run()
        {
            var sum = 0f;
            var distLorentz = new CauchyLorentzX1<float>(this.rng);
            for (int i = 0; i < 100_000_000; i++)
            {
                sum += distLorentz.NextNumber();
            }

            return sum;
        }
    }

    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestStoppingProducers01()
    {
        var rng2 = new MultiThreadedRng<float>();
        rng2.Dispose();

        var masterToken = new CancellationTokenSource(TimeSpan.FromSeconds(16)).Token;
        var wasCanceled = false;
            
        while(true)
        {
            var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));
            rng2.GetUniform(tokenSource.Token);
            if (tokenSource.IsCancellationRequested)
            {
                wasCanceled = true;
                break;
            }

            if (masterToken.IsCancellationRequested)
            {
                break;
            }
        }
            
        Assert.That(masterToken.IsCancellationRequested, Is.False, "Master token was used to stop test");
        Assert.That(wasCanceled, Is.True, "The consumer was not canceled");
            
        var tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
        new NormalS02M05<float>(rng2).NextNumber(tokenSource2.Token);
        Assert.That(tokenSource2.IsCancellationRequested, Is.True);
            
        tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
        new NormalS02M05<float>(rng2).NextNumber(-1f, 1f, tokenSource2.Token);
        Assert.That(tokenSource2.IsCancellationRequested, Is.True);
            
        tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
        new NormalS02M05<float>(rng2).NextNumber(0u, 6u, tokenSource2.Token);
        Assert.That(tokenSource2.IsCancellationRequested, Is.True);
            
        tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3));
        new NormalS02M05<float>(rng2).NextNumber(0ul, 6ul, tokenSource2.Token);
        Assert.That(tokenSource2.IsCancellationRequested, Is.True);
    }

    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void OneSeed01()
    {
        using var rng1 = new MultiThreadedRng<float>(6);
        using var rng2 = new MultiThreadedRng<float>(6);
        using var rng3 = new MultiThreadedRng<float>(7);

        var rng1Sample = new float[10];
        for (var n = 0; n < rng1Sample.Length; n++)
            rng1Sample[n] = rng1.GetUniform();
            
        var rng2Sample = new float[10];
        for (var n = 0; n < rng2Sample.Length; n++)
            rng2Sample[n] = rng2.GetUniform();
            
        var rng3Sample = new float[10];
        for (var n = 0; n < rng3Sample.Length; n++)
            rng3Sample[n] = rng3.GetUniform();

        Assert.That(rng1Sample, Is.EquivalentTo(rng2Sample));
        Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
        Assert.That(rng2Sample, Is.Not.EquivalentTo(rng3Sample));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TwoSeeds01()
    {
        using var rng1 = new MultiThreadedRng<float>(3, 6);
        using var rng2 = new MultiThreadedRng<float>(3, 6);
        using var rng3 = new MultiThreadedRng<float>(3, 7);
        using var rng4 = new MultiThreadedRng<float>(6, 3);

        var rng1Sample = new float[10];
        for (var n = 0; n < rng1Sample.Length; n++)
            rng1Sample[n] = rng1.GetUniform();

        var rng2Sample = new float[10];
        for (var n = 0; n < rng2Sample.Length; n++)
            rng2Sample[n] = rng2.GetUniform();
            
        var rng3Sample = new float[10];
        for (var n = 0; n < rng3Sample.Length; n++)
            rng3Sample[n] = rng3.GetUniform();
            
        var rng4Sample = new float[10];
        for (var n = 0; n < rng4Sample.Length; n++)
            rng4Sample[n] = rng4.GetUniform();

        Assert.That(rng1Sample, Is.EquivalentTo(rng2Sample));
        Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
        Assert.That(rng1Sample, Is.Not.EquivalentTo(rng4Sample));
        Assert.That(rng2Sample, Is.Not.EquivalentTo(rng3Sample));
        Assert.That(rng2Sample, Is.Not.EquivalentTo(rng4Sample));
        Assert.That(rng3Sample, Is.Not.EquivalentTo(rng4Sample));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void NoSeed01()
    {
        using var rng1 = new MultiThreadedRng<float>();
        using var rng2 = new MultiThreadedRng<float>();
        using var rng3 = new MultiThreadedRng<float>();

        var rng1Sample = new float[10];
        for (var n = 0; n < rng1Sample.Length; n++)
            rng1Sample[n] = rng1.GetUniform();
            
        var rng2Sample = new float[10];
        for (var n = 0; n < rng2Sample.Length; n++)
            rng2Sample[n] = rng2.GetUniform();
            
        var rng3Sample = new float[10];
        for (var n = 0; n < rng3Sample.Length; n++)
            rng3Sample[n] = rng3.GetUniform();

        Assert.That(rng1Sample, Is.Not.EquivalentTo(rng2Sample));
        Assert.That(rng1Sample, Is.Not.EquivalentTo(rng3Sample));
        Assert.That(rng2Sample, Is.Not.EquivalentTo(rng3Sample));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestCancellation01()
    {
        var tokenSource = new CancellationTokenSource();
        var token = tokenSource.Token;
        tokenSource.Cancel();
            
        using var rng2 = new MultiThreadedRng<float>();
        var dist = new Uniform<float>(this.rng);
        Assert.That(dist.NextNumber (1, 100_000, token), Is.EqualTo(0));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestCancellation02()
    {
        var tokenSource = new CancellationTokenSource();
        var token = tokenSource.Token;
        tokenSource.Cancel();
            
        using var rng2 = new MultiThreadedRng<float>();
        Assert.That(rng2.GetUniform(token), Is.NaN);
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestDeterministic01()
    {
        using var rng2 = new MultiThreadedRng<float>(16);
            
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.12712699).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.5764246).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.06033641).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.6822646).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.61201024).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.17746393).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.33456334).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.96167856).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.12944269).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.64489424).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.109665975).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.18188846).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.36097932).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.48192585).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.1617974).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.24791045).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.43913218).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.3343723).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.9428737).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.55195147).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.027495692).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.9621458).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.55794334).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.69002056).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.86020225).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.88220626).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.68816894).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.8583311).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.003915685).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.83575225).Within(1e-7f));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestDeterministic02()
    {
        using var rng2 = new MultiThreadedRng<float>(16);
        var dist = new Uniform<float>(rng2);
            
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(13));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(58));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(6));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(68));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(61));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(18));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(34));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(96));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(13));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(64));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(11));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(19));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(36));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(48));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(17));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(25));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(44));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(34));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(94));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(55));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(3));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(96));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(56));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(69));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(86));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(88));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(69));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(85));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(83));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestDeterministic03()
    {
        using var rng2 = new MultiThreadedRng<float>(16);
        var dist = new CauchyLorentzX0<float>(rng2);

        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(11));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(17));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(2));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(18));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(14));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(65));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(11));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(22));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(3));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(37));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(9));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(12));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(4));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(10));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(8));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(22));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(2));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(3));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(20));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(4));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(84));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(9));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(19));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(2));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(10));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(4));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(56));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestDeterministic01b()
    {
        using var rng2 = new MultiThreadedRng<float>(16, 362_436_069);
            
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.12712699).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.5764246).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.06033641).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.6822646).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.61201024).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.17746393).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.33456334).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.96167856).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.12944269).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.64489424).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.109665975).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.18188846).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.36097932).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.48192585).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.1617974).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.24791045).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.43913218).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.3343723).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.9428737).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.55195147).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.027495692).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.9621458).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.55794334).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.69002056).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.86020225).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.88220626).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.68816894).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.8583311).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.003915685).Within(1e-7f));
        Assert.That(rng2.GetUniform(), Is.EqualTo(0.83575225).Within(1e-7f));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestDeterministic02b()
    {
        using var rng2 = new MultiThreadedRng<float>(16, 362_436_069);
        var dist = new Uniform<float>(rng2);
            
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(13));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(58));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(6));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(68));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(61));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(18));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(34));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(96));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(13));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(64));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(11));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(19));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(36));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(48));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(17));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(25));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(44));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(34));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(94));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(55));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(3));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(96));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(56));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(69));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(86));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(88));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(69));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(85));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(83));
    }
        
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    public void TestDeterministic03b()
    {
        using var rng2 = new MultiThreadedRng<float>(16, 362_436_069);
        var dist = new CauchyLorentzX0<float>(rng2);

        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(11));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(17));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(2));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(18));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(14));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(65));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(11));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(22));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(3));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(37));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(9));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(12));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(4));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(10));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(8));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(22));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(2));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(3));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(20));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(4));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(84));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(9));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(19));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(2));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(1));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(10));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(4));
        Assert.That(dist.NextNumber (1, 100), Is.EqualTo(56));
    }
}