From 54c9e790d9ef454e59b6e59dfd0d7257f8f92cae Mon Sep 17 00:00:00 2001 From: Thorsten Sommer Date: Sun, 1 Nov 2020 10:52:42 +0100 Subject: [PATCH] Added float implementations --- FastRngTests/Float/Distributions/BetaA2B2.cs | 105 ++++++ FastRngTests/Float/Distributions/BetaA2B5.cs | 105 ++++++ FastRngTests/Float/Distributions/BetaA5B2.cs | 106 ++++++ .../Float/Distributions/CauchyLorentzX0.cs | 109 ++++++ .../Float/Distributions/CauchyLorentzX1.cs | 109 ++++++ .../Float/Distributions/ChiSquareK1.cs | 110 ++++++ .../Float/Distributions/ChiSquareK10.cs | 110 ++++++ .../Float/Distributions/ChiSquareK4.cs | 107 ++++++ .../Float/Distributions/ExponentialLa10.cs | 104 ++++++ .../Float/Distributions/ExponentialLa5.cs | 104 ++++++ .../Float/Distributions/GammaA5B15.cs | 106 ++++++ .../Distributions/InverseExponentialLa10.cs | 104 ++++++ .../Distributions/InverseExponentialLa5.cs | 104 ++++++ .../Float/Distributions/InverseGammaA3B05.cs | 106 ++++++ .../Float/Distributions/LaplaceB01M0.cs | 106 ++++++ .../Float/Distributions/LaplaceB01M05.cs | 106 ++++++ .../Float/Distributions/LogNormalS1M0.cs | 106 ++++++ .../Float/Distributions/NormalS02M05.cs | 102 ++++++ .../Float/Distributions/StudentTNu1.cs | 106 ++++++ FastRngTests/Float/Distributions/Uniform.cs | 301 ++++++++++++++++ .../Float/Distributions/WeibullK05La1.cs | 106 ++++++ FastRngTests/Float/FrequencyAnalysis.cs | 82 +++++ FastRngTests/Float/MathToolsTests.cs | 341 ++++++++++++++++++ FastRngTests/Float/MultiThreadedRngTests.cs | 288 +++++++++++++++ FastRngTests/Float/RunningStatistics.cs | 47 +++ 25 files changed, 3180 insertions(+) create mode 100644 FastRngTests/Float/Distributions/BetaA2B2.cs create mode 100644 FastRngTests/Float/Distributions/BetaA2B5.cs create mode 100644 FastRngTests/Float/Distributions/BetaA5B2.cs create mode 100644 FastRngTests/Float/Distributions/CauchyLorentzX0.cs create mode 100644 FastRngTests/Float/Distributions/CauchyLorentzX1.cs create mode 100644 FastRngTests/Float/Distributions/ChiSquareK1.cs create mode 100644 FastRngTests/Float/Distributions/ChiSquareK10.cs create mode 100644 FastRngTests/Float/Distributions/ChiSquareK4.cs create mode 100644 FastRngTests/Float/Distributions/ExponentialLa10.cs create mode 100644 FastRngTests/Float/Distributions/ExponentialLa5.cs create mode 100644 FastRngTests/Float/Distributions/GammaA5B15.cs create mode 100644 FastRngTests/Float/Distributions/InverseExponentialLa10.cs create mode 100644 FastRngTests/Float/Distributions/InverseExponentialLa5.cs create mode 100644 FastRngTests/Float/Distributions/InverseGammaA3B05.cs create mode 100644 FastRngTests/Float/Distributions/LaplaceB01M0.cs create mode 100644 FastRngTests/Float/Distributions/LaplaceB01M05.cs create mode 100644 FastRngTests/Float/Distributions/LogNormalS1M0.cs create mode 100644 FastRngTests/Float/Distributions/NormalS02M05.cs create mode 100644 FastRngTests/Float/Distributions/StudentTNu1.cs create mode 100644 FastRngTests/Float/Distributions/Uniform.cs create mode 100644 FastRngTests/Float/Distributions/WeibullK05La1.cs create mode 100644 FastRngTests/Float/FrequencyAnalysis.cs create mode 100644 FastRngTests/Float/MathToolsTests.cs create mode 100644 FastRngTests/Float/MultiThreadedRngTests.cs create mode 100644 FastRngTests/Float/RunningStatistics.cs diff --git a/FastRngTests/Float/Distributions/BetaA2B2.cs b/FastRngTests/Float/Distributions/BetaA2B2.cs new file mode 100644 index 0000000..68739f2 --- /dev/null +++ b/FastRngTests/Float/Distributions/BetaA2B2.cs @@ -0,0 +1,105 @@ +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class BetaA2B2 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaDistribution01() + { + var dist = new FastRng.Float.Distributions.BetaA2B2(); + 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)); + Assert.That(result[1], Is.EqualTo(0.0784f).Within(0.3f)); + Assert.That(result[2], Is.EqualTo(0.1164f).Within(0.3f)); + + Assert.That(result[21], Is.EqualTo(0.6864f).Within(0.3f)); + Assert.That(result[22], Is.EqualTo(0.7084f).Within(0.3f)); + Assert.That(result[23], Is.EqualTo(0.7296f).Within(0.3f)); + + Assert.That(result[50], Is.EqualTo(0.9996f).Within(0.3f)); + + Assert.That(result[75], Is.EqualTo(0.7296f).Within(0.3f)); + Assert.That(result[85], Is.EqualTo(0.4816f).Within(0.3f)); + Assert.That(result[90], Is.EqualTo(0.3276f).Within(0.3f)); + + Assert.That(result[97], Is.EqualTo(0.0784f).Within(0.3f)); + Assert.That(result[98], Is.EqualTo(0.0396f).Within(0.3f)); + Assert.That(result[99], Is.EqualTo(0.0000f).Within(0.3f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.BetaA2B2(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.BetaA2B2(); + 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 TestBetaGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/BetaA2B5.cs b/FastRngTests/Float/Distributions/BetaA2B5.cs new file mode 100644 index 0000000..f70eef1 --- /dev/null +++ b/FastRngTests/Float/Distributions/BetaA2B5.cs @@ -0,0 +1,105 @@ +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class BetaA2B5 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaDistribution01() + { + var dist = new FastRng.Float.Distributions.BetaA2B5(); + 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)); + Assert.That(result[1], Is.EqualTo(0.22505783f).Within(0.3f)); + Assert.That(result[2], Is.EqualTo(0.32401717f).Within(0.3f)); + + Assert.That(result[21], Is.EqualTo(0.99348410f).Within(0.3f)); + Assert.That(result[22], Is.EqualTo(0.98639433f).Within(0.3f)); + Assert.That(result[23], Is.EqualTo(0.97684451f).Within(0.3f)); + + Assert.That(result[50], Is.EqualTo(0.35868592f).Within(0.3f)); + + Assert.That(result[75], Is.EqualTo(0.03076227f).Within(0.03f)); + Assert.That(result[85], Is.EqualTo(0.00403061f).Within(0.03f)); + Assert.That(result[90], Is.EqualTo(0.00109800f).Within(0.01f)); + + Assert.That(result[97], Is.EqualTo(0.00000191f).Within(0.000003f)); + Assert.That(result[98], Is.EqualTo(0.00000012f).Within(0.0000003f)); + Assert.That(result[99], Is.EqualTo(0.00000000f).Within(0.0000003f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.BetaA2B5(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.BetaA2B5(); + 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 TestBetaGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/BetaA5B2.cs b/FastRngTests/Float/Distributions/BetaA5B2.cs new file mode 100644 index 0000000..462f5c9 --- /dev/null +++ b/FastRngTests/Float/Distributions/BetaA5B2.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class BetaA5B2 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaDistribution01() + { + var dist = new FastRng.Float.Distributions.BetaA5B2(); + 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)); + Assert.That(result[1], Is.EqualTo(0.0000019f).Within(0.00001f)); + Assert.That(result[2], Is.EqualTo(0.0000096f).Within(0.0004f)); + + Assert.That(result[21], Is.EqualTo(0.0222918f).Within(0.03f)); + Assert.That(result[22], Is.EqualTo(0.0262883f).Within(0.03f)); + Assert.That(result[23], Is.EqualTo(0.0307623f).Within(0.03f)); + + Assert.That(result[50], Is.EqualTo(0.4044237f).Within(0.2f)); + + Assert.That(result[75], Is.EqualTo(0.9768445f).Within(0.15f)); + Assert.That(result[85], Is.EqualTo(0.9552714f).Within(0.15f)); + Assert.That(result[90], Is.EqualTo(0.8004420f).Within(0.35f)); + + Assert.That(result[97], Is.EqualTo(0.2250578f).Within(0.03f)); + Assert.That(result[98], Is.EqualTo(0.1171927f).Within(0.03f)); + Assert.That(result[99], Is.EqualTo(0f).Within(0.0004f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.BetaA5B2(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestBetaGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.BetaA5B2(); + 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 TestBetaGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/CauchyLorentzX0.cs b/FastRngTests/Float/Distributions/CauchyLorentzX0.cs new file mode 100644 index 0000000..3d37fb5 --- /dev/null +++ b/FastRngTests/Float/Distributions/CauchyLorentzX0.cs @@ -0,0 +1,109 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class CauchyLorentzX0 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestCauchyDistribution01() + { + // 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(); + 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)); + Assert.That(result[1], Is.EqualTo(0.948808314586299f).Within(0.06f)); + Assert.That(result[2], Is.EqualTo(0.905284997403441f).Within(0.06f)); + + Assert.That(result[21], Is.EqualTo(0.168965864241396f).Within(0.04f)); + Assert.That(result[22], Is.EqualTo(0.156877686354491f).Within(0.04f)); + Assert.That(result[23], Is.EqualTo(0.145970509936354f).Within(0.04f)); + + Assert.That(result[50], Is.EqualTo(0.036533159835978f).Within(0.01f)); + + Assert.That(result[75], Is.EqualTo(0.016793067514802f).Within(0.01f)); + Assert.That(result[85], Is.EqualTo(0.01316382933791f).Within(0.005f)); + Assert.That(result[90], Is.EqualTo(0.011773781734516f).Within(0.005f)); + + Assert.That(result[97], Is.EqualTo(0.010168596941156f).Within(0.005f)); + Assert.That(result[98], Is.EqualTo(0.009966272570142f).Within(0.005f)); + Assert.That(result[99], Is.EqualTo(0.00976990739772f).Within(0.005f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestCauchyGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.CauchyLorentzX0(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestCauchyGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.CauchyLorentzX0(); + var rng = new MultiThreadedRng(); + 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 TestCauchyGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/CauchyLorentzX1.cs b/FastRngTests/Float/Distributions/CauchyLorentzX1.cs new file mode 100644 index 0000000..364ddfb --- /dev/null +++ b/FastRngTests/Float/Distributions/CauchyLorentzX1.cs @@ -0,0 +1,109 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class CauchyLorentzX1 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestCauchyDistribution01() + { + // 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(); + 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)); + Assert.That(result[1], Is.EqualTo(0.010168596941156f).Within(0.004f)); + Assert.That(result[2], Is.EqualTo(0.010377123221893f).Within(0.005f)); + + Assert.That(result[21], Is.EqualTo(0.015956672819692f).Within(0.005f)); + Assert.That(result[22], Is.EqualTo(0.016366904083094f).Within(0.005f)); + Assert.That(result[23], Is.EqualTo(0.016793067514802f).Within(0.005f)); + + Assert.That(result[50], Is.EqualTo(0.039454644029179f).Within(0.015f)); + + Assert.That(result[75], Is.EqualTo(0.145970509936354f).Within(0.03f)); + Assert.That(result[85], Is.EqualTo(0.333365083503296f).Within(0.1f)); + Assert.That(result[90], Is.EqualTo(0.545171628270584f).Within(0.1f)); + + Assert.That(result[97], Is.EqualTo(0.948808314586302f).Within(0.06f)); + Assert.That(result[98], Is.EqualTo(0.976990739772032f).Within(0.03f)); + Assert.That(result[99], Is.EqualTo(0.986760647169751f).Within(0.02f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestCauchyGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.CauchyLorentzX0(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestCauchyGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.CauchyLorentzX0(); + var rng = new MultiThreadedRng(); + 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 TestCauchyGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/ChiSquareK1.cs b/FastRngTests/Float/Distributions/ChiSquareK1.cs new file mode 100644 index 0000000..6e0dde9 --- /dev/null +++ b/FastRngTests/Float/Distributions/ChiSquareK1.cs @@ -0,0 +1,110 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class ChiSquareK1 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareDistribution01() + { + var dist = new FastRng.Float.Distributions.ChiSquareK1(); + var fqa = new FrequencyAnalysis(); + var rng = new MultiThreadedRng(); + + for (var n = 0; n < 100_000; n++) + { + var value = await rng.NextNumber(dist); + fqa.CountThis(value); + } + + rng.StopProducer(); + + var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine); + + Assert.That(result[0], Is.EqualTo(1.00032041964207f).Within(0.004f)); + Assert.That(result[1], Is.EqualTo(0.70380551227703f).Within(0.05f)); + Assert.That(result[2], Is.EqualTo(0.571788691668126f).Within(0.05f)); + + Assert.That(result[21], Is.EqualTo(0.192011337664754f).Within(0.07f)); + Assert.That(result[22], Is.EqualTo(0.186854182385981f).Within(0.07f)); + Assert.That(result[23], Is.EqualTo(0.182007652359976f).Within(0.07f)); + + Assert.That(result[50], Is.EqualTo(0.109088865614875f).Within(0.06f)); + + Assert.That(result[75], Is.EqualTo(0.07886274821701f).Within(0.02f)); + Assert.That(result[85], Is.EqualTo(0.070520397849883f).Within(0.02f)); + Assert.That(result[90], Is.EqualTo(0.066863009640287f).Within(0.02f)); + + Assert.That(result[97], Is.EqualTo(0.062214737436948f).Within(0.02f)); + Assert.That(result[98], Is.EqualTo(0.061590997922187f).Within(0.02f)); + Assert.That(result[99], Is.EqualTo(0.060976622578824f).Within(0.02f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.ChiSquareK1(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.ChiSquareK1(); + var rng = new MultiThreadedRng(); + 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 TestChiSquareGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/ChiSquareK10.cs b/FastRngTests/Float/Distributions/ChiSquareK10.cs new file mode 100644 index 0000000..bd73119 --- /dev/null +++ b/FastRngTests/Float/Distributions/ChiSquareK10.cs @@ -0,0 +1,110 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class ChiSquareK10 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareDistribution01() + { + var dist = new FastRng.Float.Distributions.ChiSquareK10(); + var fqa = new FrequencyAnalysis(); + var rng = new MultiThreadedRng(); + + for (var n = 0; n < 100_000; n++) + { + var value = await rng.NextNumber(dist); + fqa.CountThis(value); + } + + rng.StopProducer(); + + var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine); + + Assert.That(result[0], Is.EqualTo(0.0000000164021588f).Within(0.0000002f)); + Assert.That(result[1], Is.EqualTo(0.0000002611256437f).Within(0.000003f)); + Assert.That(result[2], Is.EqualTo(0.0000013153553250f).Within(0.00002f)); + + Assert.That(result[21], Is.EqualTo(0.003459320622874f).Within(0.005f)); + Assert.That(result[22], Is.EqualTo(0.004111875573379f).Within(0.005f)); + Assert.That(result[23], Is.EqualTo(0.004850674298859f).Within(0.005f)); + + Assert.That(result[50], Is.EqualTo(0.086418773275056f).Within(0.05f)); + + Assert.That(result[75], Is.EqualTo(0.376092741436046f).Within(0.08f)); + Assert.That(result[85], Is.EqualTo(0.586569751611096f).Within(0.08f)); + Assert.That(result[90], Is.EqualTo(0.717189736168766f).Within(0.08f)); + + Assert.That(result[97], Is.EqualTo(0.931477764640217f).Within(0.08f)); + Assert.That(result[98], Is.EqualTo(0.965244855212136f).Within(0.08f)); + Assert.That(result[99], Is.EqualTo(0.999827884370044f).Within(0.08f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.ChiSquareK10(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.ChiSquareK10(); + var rng = new MultiThreadedRng(); + 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 TestChiSquareGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/ChiSquareK4.cs b/FastRngTests/Float/Distributions/ChiSquareK4.cs new file mode 100644 index 0000000..15ec668 --- /dev/null +++ b/FastRngTests/Float/Distributions/ChiSquareK4.cs @@ -0,0 +1,107 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class ChiSquareK4 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareDistribution01() + { + var dist = new FastRng.Float.Distributions.ChiSquareK4(); + 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)); + Assert.That(result[1], Is.EqualTo(0.032671644513723f).Within(0.02f)); + Assert.That(result[2], Is.EqualTo(0.048763041010352f).Within(0.02f)); + + Assert.That(result[21], Is.EqualTo(0.32518779111264f).Within(0.05f)); + Assert.That(result[22], Is.EqualTo(0.338273451612642f).Within(0.05f)); + Assert.That(result[23], Is.EqualTo(0.351220492939994f).Within(0.05f)); + + Assert.That(result[50], Is.EqualTo(0.65209223303425f).Within(0.08f)); + + Assert.That(result[75], Is.EqualTo(0.857562207152294f).Within(0.099f)); + Assert.That(result[85], Is.EqualTo(0.923072405412387f).Within(0.099f)); + Assert.That(result[90], Is.EqualTo(0.952623623874265f).Within(0.099f)); + + Assert.That(result[97], Is.EqualTo(0.990616879396201f).Within(0.099f)); + Assert.That(result[98], Is.EqualTo(0.995734077068522f).Within(0.099f)); + Assert.That(result[99], Is.EqualTo(1.00077558852585f).Within(0.1f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.ChiSquareK4(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestChiSquareGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.ChiSquareK4(); + var rng = new MultiThreadedRng(); + 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 TestChiSquareGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/ExponentialLa10.cs b/FastRngTests/Float/Distributions/ExponentialLa10.cs new file mode 100644 index 0000000..213684f --- /dev/null +++ b/FastRngTests/Float/Distributions/ExponentialLa10.cs @@ -0,0 +1,104 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class ExponentialLa10 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialDistribution01() + { + var dist = new FastRng.Float.Distributions.ExponentialLa10(); + 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)); + Assert.That(result[1], Is.EqualTo(0.905516212904248f).Within(0.05f)); + Assert.That(result[2], Is.EqualTo(0.81934495207398f).Within(0.05f)); + + Assert.That(result[21], Is.EqualTo(0.122548293148741f).Within(0.12f)); + Assert.That(result[22], Is.EqualTo(0.110886281157421f).Within(0.12f)); + Assert.That(result[23], Is.EqualTo(0.10033405633809f).Within(0.12f)); + + Assert.That(result[50], Is.EqualTo(0.00674300170146f).Within(0.005f)); + + Assert.That(result[75], Is.EqualTo(0.000553499285385f).Within(0.001f)); + Assert.That(result[85], Is.EqualTo(0.000203621007796f).Within(0.001f)); + Assert.That(result[90], Is.EqualTo(0.00012350238419f).Within(0.001f)); + + Assert.That(result[97], Is.EqualTo(0.0000613294689720f).Within(0.0008f)); + Assert.That(result[98], Is.EqualTo(0.0000554931983541f).Within(0.0008f)); + Assert.That(result[99], Is.EqualTo(0.0000502123223173f).Within(0.0008f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.ExponentialLa10(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.ExponentialLa10(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task NoRandomNumberGenerator01() + { + var dist = new FastRng.Float.Distributions.ExponentialLa10(); + Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue()); + Assert.That(await dist.GetDistributedValue(), Is.NaN); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/ExponentialLa5.cs b/FastRngTests/Float/Distributions/ExponentialLa5.cs new file mode 100644 index 0000000..e0c88bd --- /dev/null +++ b/FastRngTests/Float/Distributions/ExponentialLa5.cs @@ -0,0 +1,104 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class ExponentialLa5 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialDistribution01() + { + var dist = new FastRng.Float.Distributions.ExponentialLa5(); + 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)); + Assert.That(result[1], Is.EqualTo(0.951436545064811f).Within(0.05f)); + Assert.That(result[2], Is.EqualTo(0.905034437210948f).Within(0.05f)); + + Assert.That(result[21], Is.EqualTo(0.35001394450853f).Within(0.05f)); + Assert.That(result[22], Is.EqualTo(0.332943563002074f).Within(0.05f)); + Assert.That(result[23], Is.EqualTo(0.31670571382568f).Within(0.05f)); + + Assert.That(result[50], Is.EqualTo(0.082102871800213f).Within(0.01f)); + + Assert.That(result[75], Is.EqualTo(0.023522866606758f).Within(0.01f)); + Assert.That(result[85], Is.EqualTo(0.014267339801329f).Within(0.01f)); + Assert.That(result[90], Is.EqualTo(0.011111415409621f).Within(0.01f)); + + Assert.That(result[97], Is.EqualTo(0.007830082099077f).Within(0.008f)); + Assert.That(result[98], Is.EqualTo(0.007448204488898f).Within(0.008f)); + Assert.That(result[99], Is.EqualTo(0.007084951269538f).Within(0.008f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.ExponentialLa5(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.ExponentialLa5(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task NoRandomNumberGenerator01() + { + var dist = new FastRng.Float.Distributions.ExponentialLa5(); + Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue()); + Assert.That(await dist.GetDistributedValue(), Is.NaN); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/GammaA5B15.cs b/FastRngTests/Float/Distributions/GammaA5B15.cs new file mode 100644 index 0000000..ae84e66 --- /dev/null +++ b/FastRngTests/Float/Distributions/GammaA5B15.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class GammaA5B15 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestGammaDistribution01() + { + var dist = new FastRng.Float.Distributions.GammaA5B15(); + 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)); + Assert.That(result[1], Is.EqualTo(0.0012801746797876f).Within(0.002f)); + Assert.That(result[2], Is.EqualTo(0.0055781488254349f).Within(0.004f)); + + Assert.That(result[21], Is.EqualTo(0.9331608887752720f).Within(0.09f)); + Assert.That(result[22], Is.EqualTo(0.9594734828891280f).Within(0.09f)); + Assert.That(result[23], Is.EqualTo(0.9790895765535350f).Within(0.09f)); + + Assert.That(result[50], Is.EqualTo(0.3478287795336570f).Within(0.06f)); + + Assert.That(result[75], Is.EqualTo(0.0403399049422936f).Within(0.009f)); + Assert.That(result[85], Is.EqualTo(0.0163628388658126f).Within(0.009f)); + Assert.That(result[90], Is.EqualTo(0.0097147611446660f).Within(0.005f)); + + Assert.That(result[97], Is.EqualTo(0.0041135143233153f).Within(0.008f)); + Assert.That(result[98], Is.EqualTo(0.0036872732029996f).Within(0.008f)); + 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(); + var dist = new FastRng.Float.Distributions.GammaA5B15(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestGammaGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.GammaA5B15(); + 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 NoRandomNumberGenerator01() + { + var dist = new FastRng.Float.Distributions.GammaA5B15(); + Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue()); + Assert.That(await dist.GetDistributedValue(), Is.NaN); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/InverseExponentialLa10.cs b/FastRngTests/Float/Distributions/InverseExponentialLa10.cs new file mode 100644 index 0000000..6594a16 --- /dev/null +++ b/FastRngTests/Float/Distributions/InverseExponentialLa10.cs @@ -0,0 +1,104 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class InverseExponentialLa10 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialDistribution01() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa10(); + 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)); + Assert.That(result[1], Is.EqualTo(0.0000554515994322f).Within(0.0003f)); + Assert.That(result[2], Is.EqualTo(0.0000612834950532f).Within(0.0003f)); + + Assert.That(result[21], Is.EqualTo(0.00040973497898f).Within(0.00045f)); + Assert.That(result[22], Is.EqualTo(0.000452827182887f).Within(0.00050f)); + Assert.That(result[23], Is.EqualTo(0.000500451433441f).Within(0.00051f)); + + Assert.That(result[50], Is.EqualTo(0.007446583070924f).Within(0.003f)); + + Assert.That(result[75], Is.EqualTo(0.090717953289412f).Within(0.02f)); + Assert.That(result[85], Is.EqualTo(0.246596963941606f).Within(0.05f)); + Assert.That(result[90], Is.EqualTo(0.406569659740598f).Within(0.08f)); + + Assert.That(result[97], Is.EqualTo(0.81873075307798f).Within(0.08f)); + Assert.That(result[98], Is.EqualTo(0.904837418035957f).Within(0.08f)); + Assert.That(result[99], Is.EqualTo(0.999999999999999f).Within(0.08f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa10(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa10(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task NoRandomNumberGenerator01() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa10(); + Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue()); + Assert.That(await dist.GetDistributedValue(), Is.NaN); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/InverseExponentialLa5.cs b/FastRngTests/Float/Distributions/InverseExponentialLa5.cs new file mode 100644 index 0000000..c525565 --- /dev/null +++ b/FastRngTests/Float/Distributions/InverseExponentialLa5.cs @@ -0,0 +1,104 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class InverseExponentialLa5 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialDistribution01() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa5(); + 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)); + Assert.That(result[1], Is.EqualTo(0.007446583070924f).Within(0.008f)); + Assert.That(result[2], Is.EqualTo(0.007828377549226f).Within(0.008f)); + + Assert.That(result[21], Is.EqualTo(0.020241911445804f).Within(0.05f)); + Assert.That(result[22], Is.EqualTo(0.021279736438377f).Within(0.05f)); + Assert.That(result[23], Is.EqualTo(0.022370771856166f).Within(0.05f)); + + Assert.That(result[50], Is.EqualTo(0.08629358649937f).Within(0.02f)); + + Assert.That(result[75], Is.EqualTo(0.301194211912202f).Within(0.03f)); + Assert.That(result[85], Is.EqualTo(0.496585303791409f).Within(0.05f)); + Assert.That(result[90], Is.EqualTo(0.637628151621772f).Within(0.06f)); + + Assert.That(result[97], Is.EqualTo(0.904837418035959f).Within(0.08f)); + Assert.That(result[98], Is.EqualTo(0.951229424500713f).Within(0.08f)); + Assert.That(result[99], Is.EqualTo(1f).Within(0.08f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange01() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa5(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestExponentialGeneratorWithRange02() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa5(); + var rng = new MultiThreadedRng(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task NoRandomNumberGenerator01() + { + var dist = new FastRng.Float.Distributions.InverseExponentialLa5(); + Assert.DoesNotThrowAsync(async () => await dist.GetDistributedValue()); + Assert.That(await dist.GetDistributedValue(), Is.NaN); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/InverseGammaA3B05.cs b/FastRngTests/Float/Distributions/InverseGammaA3B05.cs new file mode 100644 index 0000000..909d6ad --- /dev/null +++ b/FastRngTests/Float/Distributions/InverseGammaA3B05.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class InverseGammaA3B05 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestInverseGammaDistribution01() + { + var dist = new FastRng.Float.Distributions.InverseGammaA3B05(); + 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)); + Assert.That(result[1], Is.EqualTo(0.0000011605257228f).Within(0.00001f)); + Assert.That(result[2], Is.EqualTo(0.0009536970016103f).Within(0.0015f)); + + Assert.That(result[21], Is.EqualTo(0.5880485243048120f).Within(0.05f)); + Assert.That(result[22], Is.EqualTo(0.5433842148912880f).Within(0.05f)); + Assert.That(result[23], Is.EqualTo(0.5017780549216030f).Within(0.05f)); + + Assert.That(result[50], Is.EqualTo(0.0741442015957425f).Within(0.009f)); + + Assert.That(result[75], Is.EqualTo(0.0207568945092484f).Within(0.006f)); + Assert.That(result[85], Is.EqualTo(0.0136661506653688f).Within(0.006f)); + Assert.That(result[90], Is.EqualTo(0.0112550619601327f).Within(0.006f)); + + Assert.That(result[97], Is.EqualTo(0.0087026933539773f).Within(0.005f)); + Assert.That(result[98], Is.EqualTo(0.0083995375385004f).Within(0.005f)); + Assert.That(result[99], Is.EqualTo(0.0081094156379928f).Within(0.005f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestInverseGammaGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.InverseGammaA3B05(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestInverseGammaGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.InverseGammaA3B05(); + 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 TestInverseGammaGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/LaplaceB01M0.cs b/FastRngTests/Float/Distributions/LaplaceB01M0.cs new file mode 100644 index 0000000..4f4c15b --- /dev/null +++ b/FastRngTests/Float/Distributions/LaplaceB01M0.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class LaplaceB01M0 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLaplaceDistribution01() + { + var dist = new FastRng.Float.Distributions.LaplaceB01M0(); + 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)); + Assert.That(result[1], Is.EqualTo(0.9048374180359590f).Within(0.05f)); + Assert.That(result[2], Is.EqualTo(0.8187307530779810f).Within(0.05f)); + + Assert.That(result[21], Is.EqualTo(0.1224564282529820f).Within(0.05f)); + Assert.That(result[22], Is.EqualTo(0.1108031583623340f).Within(0.05f)); + Assert.That(result[23], Is.EqualTo(0.1002588437228040f).Within(0.05f)); + + Assert.That(result[50], Is.EqualTo(0.0067379469990855f).Within(0.003f)); + + Assert.That(result[75], Is.EqualTo(0.0005530843701478f).Within(0.0015f)); + Assert.That(result[85], Is.EqualTo(0.0002034683690106f).Within(0.0015f)); + Assert.That(result[90], Is.EqualTo(0.0001234098040867f).Within(0.0015f)); + + Assert.That(result[97], Is.EqualTo(0.0000612834950532f).Within(0.0002f)); + Assert.That(result[98], Is.EqualTo(0.0000554515994322f).Within(0.0002f)); + Assert.That(result[99], Is.EqualTo(0.0000501746820562f).Within(0.0002f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLaplaceGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.LaplaceB01M0(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLaplaceGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.LaplaceB01M0(); + 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 TestLaplaceGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/LaplaceB01M05.cs b/FastRngTests/Float/Distributions/LaplaceB01M05.cs new file mode 100644 index 0000000..9b39b58 --- /dev/null +++ b/FastRngTests/Float/Distributions/LaplaceB01M05.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class LaplaceB01M05 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLaplaceDistribution01() + { + var dist = new FastRng.Float.Distributions.LaplaceB01M05(); + 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)); + Assert.That(result[1], Is.EqualTo(0.0082297470490200f).Within(0.004f)); + Assert.That(result[2], Is.EqualTo(0.0090952771016958f).Within(0.01f)); + + Assert.That(result[21], Is.EqualTo(0.0608100626252180f).Within(0.02f)); + Assert.That(result[22], Is.EqualTo(0.0672055127397498f).Within(0.02f)); + Assert.That(result[23], Is.EqualTo(0.0742735782143340f).Within(0.02f)); + + Assert.That(result[50], Is.EqualTo(1.0000000000000000f).Within(0.2f)); + + Assert.That(result[75], Is.EqualTo(0.0742735782143335f).Within(0.01f)); + Assert.That(result[85], Is.EqualTo(0.0273237224472924f).Within(0.01f)); + Assert.That(result[90], Is.EqualTo(0.0165726754017612f).Within(0.01f)); + + Assert.That(result[97], Is.EqualTo(0.0082297470490200f).Within(0.004f)); + Assert.That(result[98], Is.EqualTo(0.0074465830709243f).Within(0.004f)); + Assert.That(result[99], Is.EqualTo(0.0067379469990854f).Within(0.004f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLaplaceGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.LaplaceB01M05(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLaplaceGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.LaplaceB01M05(); + 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 TestLaplaceGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/LogNormalS1M0.cs b/FastRngTests/Float/Distributions/LogNormalS1M0.cs new file mode 100644 index 0000000..482c2a3 --- /dev/null +++ b/FastRngTests/Float/Distributions/LogNormalS1M0.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class LogNormalS1M0 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLogNormalDistribution01() + { + var dist = new FastRng.Float.Distributions.LogNormalS1M0(); + 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)); + Assert.That(result[1], Is.EqualTo(0.014408709f).Within(0.01f)); + Assert.That(result[2], Is.EqualTo(0.043222256f).Within(0.02f)); + + Assert.That(result[21], Is.EqualTo(0.876212056f).Within(0.15f)); + Assert.That(result[22], Is.EqualTo(0.895582226f).Within(0.15f)); + Assert.That(result[23], Is.EqualTo(0.912837250f).Within(0.15f)); + + Assert.That(result[50], Is.EqualTo(0.948062005f).Within(0.2f)); + + Assert.That(result[75], Is.EqualTo(0.768584762f).Within(0.089f)); + Assert.That(result[85], Is.EqualTo(0.697303612f).Within(0.089f)); + Assert.That(result[90], Is.EqualTo(0.663570581f).Within(0.089f)); + + Assert.That(result[97], Is.EqualTo(0.618792767f).Within(0.089f)); + Assert.That(result[98], Is.EqualTo(0.612636410f).Within(0.089f)); + Assert.That(result[99], Is.EqualTo(0.606540679f).Within(0.089f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLogNormalGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.LogNormalS1M0(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestLogNormalGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.LogNormalS1M0(); + 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 TestLogNormalGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/NormalS02M05.cs b/FastRngTests/Float/Distributions/NormalS02M05.cs new file mode 100644 index 0000000..da5145d --- /dev/null +++ b/FastRngTests/Float/Distributions/NormalS02M05.cs @@ -0,0 +1,102 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class NormalS02M05 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestNormalDistribution01() + { + const float MEAN = 0.5f; + const float STANDARD_DEVIATION = 0.2f; + + var dist = new FastRng.Float.Distributions.NormalS02M05(); + var stats = new RunningStatistics(); + var fra = new FrequencyAnalysis(); + var rng = new MultiThreadedRng(); + + for (var n = 0; n < 100_000; n++) + { + var nextNumber = await rng.NextNumber(dist); + stats.Push(nextNumber); + fra.CountThis(nextNumber); + } + + rng.StopProducer(); + fra.NormalizeAndPlotEvents(TestContext.WriteLine); + + TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}"); + TestContext.WriteLine($"variance={STANDARD_DEVIATION * STANDARD_DEVIATION} vs {stats.Variance}"); + + Assert.That(stats.Mean, Is.EqualTo(MEAN).Within(0.01f), "Mean is out of range"); + Assert.That(stats.Variance, Is.EqualTo(STANDARD_DEVIATION*STANDARD_DEVIATION).Within(0.01f), "Variance is out of range"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestNormalGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.NormalS02M05(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestNormalGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.NormalS02M05(); + 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 TestNormalGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/StudentTNu1.cs b/FastRngTests/Float/Distributions/StudentTNu1.cs new file mode 100644 index 0000000..2c8b053 --- /dev/null +++ b/FastRngTests/Float/Distributions/StudentTNu1.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class StudentTNu1 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestStudentTDistribution01() + { + var dist = new FastRng.Float.Distributions.StudentTNu1(); + 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)); + Assert.That(result[1], Is.EqualTo(0.999700120f).Within(0.2f)); + Assert.That(result[2], Is.EqualTo(0.999200719f).Within(0.2f)); + + Assert.That(result[21], Is.EqualTo(0.953929798f).Within(0.2f)); + Assert.That(result[22], Is.EqualTo(0.949852788f).Within(0.2f)); + Assert.That(result[23], Is.EqualTo(0.945631619f).Within(0.2f)); + + Assert.That(result[50], Is.EqualTo(0.793667169f).Within(0.095f)); + + Assert.That(result[75], Is.EqualTo(0.633937627f).Within(0.09f)); + Assert.That(result[85], Is.EqualTo(0.574902276f).Within(0.09f)); + Assert.That(result[90], Is.EqualTo(0.547070729f).Within(0.09f)); + + Assert.That(result[97], Is.EqualTo(0.510150990f).Within(0.09f)); + Assert.That(result[98], Is.EqualTo(0.505075501f).Within(0.09f)); + Assert.That(result[99], Is.EqualTo(0.500050000f).Within(0.09f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestStudentTGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.StudentTNu1(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestStudentTGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.StudentTNu1(); + 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 TestStudentTGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/Uniform.cs b/FastRngTests/Float/Distributions/Uniform.cs new file mode 100644 index 0000000..18333eb --- /dev/null +++ b/FastRngTests/Float/Distributions/Uniform.cs @@ -0,0 +1,301 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class Uniform + { + private readonly IRandom rng = new MultiThreadedRng(); + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestUniformDistribution01() + { + const float A = 0.0f; + const float B = 1.0f; + const float MEAN = 0.5f * (A + B); + const float VARIANCE = (1.0f / 12.0f) * (B - A) * (B - A); + + var stats = new RunningStatistics(); + var fra = new FrequencyAnalysis(); + var rng = new MultiThreadedRng(); + + for (var n = 0; n < 100_000; n++) + { + var value = await rng.GetUniform(); + stats.Push(value); + fra.CountThis(value); + } + + rng.StopProducer(); + fra.NormalizeAndPlotEvents(TestContext.WriteLine); + fra.PlotOccurence(TestContext.WriteLine); + TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}"); + TestContext.WriteLine($"variance={VARIANCE} vs {stats.Variance}"); + + Assert.That(stats.Mean, Is.EqualTo(MEAN).Within(0.01f), "Mean is out of range"); + Assert.That(stats.Variance, Is.EqualTo(VARIANCE).Within(0.001f), "Variance is out of range"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task KolmogorovSmirnovTest() + { + // Kolmogorov-Smirnov test for distributions. + // See Knuth volume 2, page 48-51 (third edition). + // This test should *fail* on average one time in 1000 runs. + // That's life with random number generators: if the test passed all the time, + // the source wouldn't be random enough! If the test were to fail more frequently, + // the most likely explanation would be a bug in the code. + + const int NUM_ROUNDS = 10_000; + const float FAILURE_PROBABILITY = 0.001f; // probability of test failing with normal distributed input + const float P_LOW = 0.25f * FAILURE_PROBABILITY; + const float P_HIGH = 1.0f - 0.25f * FAILURE_PROBABILITY; + + var samples = new float[NUM_ROUNDS]; + 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; + var jPlus = 0; + var kPlus = -float.MaxValue; + var kMinus = -float.MaxValue; + + for (n = 0; n != NUM_ROUNDS; ++n) + { + var cdf = samples[n]; + var temp = (n + 1.0f) / NUM_ROUNDS - cdf; + + if (kPlus < temp) + { + kPlus = temp; + jPlus = n; + } + + temp = cdf - (n + 0.0f) / NUM_ROUNDS; + if (kMinus < temp) + { + kMinus = temp; + jMinus = n; + } + } + + var sqrtNumReps = MathF.Sqrt(NUM_ROUNDS); + kPlus *= sqrtNumReps; + kMinus *= sqrtNumReps; + + // We divide the failure probability by four because we have four tests: + // left and right tests for K+ and K-. + var cutoffLow = MathF.Sqrt(0.5f * MathF.Log(1.0f / (1.0f - P_LOW))) - 1.0f / (6.0f * sqrtNumReps); + var cutoffHigh = MathF.Sqrt(0.5f * MathF.Log(1.0f / (1.0f - P_HIGH))) - 1.0f / (6.0f * sqrtNumReps); + + TestContext.WriteLine($"K+ = {kPlus} | K- = {kMinus}"); + TestContext.WriteLine($"K+ max at position {jPlus} = {samples[jPlus]}"); + TestContext.WriteLine($"K- max at position {jMinus} = {samples[jMinus]}"); + TestContext.WriteLine($"Acceptable interval: [{cutoffLow}, {cutoffHigh}]"); + + Assert.That(kPlus, Is.GreaterThanOrEqualTo(cutoffLow), "K+ is lower than low cutoff"); + Assert.That(kPlus, Is.LessThanOrEqualTo(cutoffHigh), "K+ is higher than high cutoff"); + Assert.That(kMinus, Is.GreaterThanOrEqualTo(cutoffLow), "K- is lower than low cutoff"); + Assert.That(kMinus, Is.LessThanOrEqualTo(cutoffHigh), "K- is lower than high cutoff"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestUniformGeneratorWithRange01() + { + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.Uniform(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestUniformGeneratorWithRange02() + { + var samples = new float[1_000]; + var dist = new FastRng.Float.Distributions.Uniform(); + for (var n = 0; n < samples.Length; n++) + samples[n] = await rng.NextNumber(0.0f, 1.0f, dist); + + 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 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(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange05Uint() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 1_000_000; + for (var n = 0; n < runs; n++) + distribution[await rng.NextNumber(0, 100, dist)]++; + + for (var n = 0; n < distribution.Length - 1; n++) + Assert.That(distribution[n], Is.GreaterThan(0)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange05Ulong() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 1_000_000; + for (var n = 0; n < runs; n++) + distribution[await rng.NextNumber(0UL, 100, dist)]++; + + for (var n = 0; n < distribution.Length - 1; n++) + Assert.That(distribution[n], Is.GreaterThan(0)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange05Float() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 1_000_000; + for (var n = 0; n < runs; n++) + distribution[(uint)MathF.Floor(await rng.NextNumber(0.0f, 100.0f, dist))]++; + + for (var n = 0; n < distribution.Length - 1; n++) + Assert.That(distribution[n], Is.GreaterThan(0)); + } + + [Test] + [Category(TestCategories.NORMAL)] + public async Task TestDistribution001Uint() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 1_000_000; + for (var n = 0; n < runs; n++) + distribution[await rng.NextNumber(0, 100, dist)]++; + + Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 600)); + } + + [Test] + [Category(TestCategories.NORMAL)] + public async Task TestDistribution001Ulong() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 1_000_000; + for (var n = 0; n < runs; n++) + distribution[await rng.NextNumber(0UL, 100, dist)]++; + + Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 600)); + } + + [Test] + [Category(TestCategories.NORMAL)] + public async Task TestDistribution001Float() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 1_000_000; + for (var n = 0; n < runs; n++) + distribution[(uint)MathF.Floor(await rng.NextNumber(0.0f, 100.0f, dist))]++; + + Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 600)); + } + + [Test] + [Category(TestCategories.LONG_RUNNING)] + public async Task TestDistribution002Uint() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 100_000_000; + for (var n = 0; n < runs; n++) + distribution[await rng.NextNumber(0, 100, dist)]++; + + Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 6_000)); + } + + [Test] + [Category(TestCategories.LONG_RUNNING)] + public async Task TestDistribution002Ulong() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 100_000_000; + for (var n = 0; n < runs; n++) + distribution[await rng.NextNumber(0UL, 100, dist)]++; + + Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 6_000)); + } + + [Test] + [Category(TestCategories.LONG_RUNNING)] + public async Task TestDistribution002Float() + { + var dist = new FastRng.Float.Distributions.Uniform(); + var distribution = new uint[101]; + var runs = 100_000_000; + for (var n = 0; n < runs; n++) + distribution[(uint)MathF.Floor(await rng.NextNumber(0.0f, 100.0f, dist))]++; + + Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 6_000)); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/Distributions/WeibullK05La1.cs b/FastRngTests/Float/Distributions/WeibullK05La1.cs new file mode 100644 index 0000000..e0be1b8 --- /dev/null +++ b/FastRngTests/Float/Distributions/WeibullK05La1.cs @@ -0,0 +1,106 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Threading.Tasks; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float.Distributions +{ + [ExcludeFromCodeCoverage] + public class WeibullK05La1 + { + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestWeibullDistribution01() + { + var dist = new FastRng.Float.Distributions.WeibullK05La1(); + 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)); + Assert.That(result[1], Is.EqualTo(0.678415772f).Within(0.09f)); + Assert.That(result[2], Is.EqualTo(0.536595233f).Within(0.09f)); + + Assert.That(result[21], Is.EqualTo(0.147406264f).Within(0.02f)); + Assert.That(result[22], Is.EqualTo(0.142654414f).Within(0.02f)); + Assert.That(result[23], Is.EqualTo(0.138217760f).Within(0.02f)); + + Assert.That(result[50], Is.EqualTo(0.075769787f).Within(0.095f)); + + Assert.That(result[75], Is.EqualTo(0.053016799f).Within(0.05f)); + Assert.That(result[85], Is.EqualTo(0.047144614f).Within(0.05f)); + Assert.That(result[90], Is.EqualTo(0.044629109f).Within(0.05f)); + + Assert.That(result[97], Is.EqualTo(0.041484591f).Within(0.05f)); + Assert.That(result[98], Is.EqualTo(0.041067125f).Within(0.05f)); + Assert.That(result[99], Is.EqualTo(0.040656966f).Within(0.05f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestWeibullGeneratorWithRange01() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.WeibullK05La1(); + 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"); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestWeibullGeneratorWithRange02() + { + var rng = new MultiThreadedRng(); + var dist = new FastRng.Float.Distributions.WeibullK05La1(); + 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 TestWeibullGeneratorWithRange03() + { + var rng = new MultiThreadedRng(); + 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); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/FrequencyAnalysis.cs b/FastRngTests/Float/FrequencyAnalysis.cs new file mode 100644 index 0000000..7320c61 --- /dev/null +++ b/FastRngTests/Float/FrequencyAnalysis.cs @@ -0,0 +1,82 @@ +using System; +using System.Linq; +using System.Text; + +namespace FastRngTests.Float +{ + public sealed class FrequencyAnalysis + { + private readonly uint[] data; + + public FrequencyAnalysis(int samples = 100) + { + this.data = new uint[samples]; + } + + public void CountThis(float value) + { + var bucket = (int)MathF.Floor(value * this.data.Length); + this.data[bucket]++; + } + + public float[] GetNormalizedEvents() + { + var max = (float) this.data.Max(); + var result = new float[this.data.Length]; + for (var n = 0; n < this.data.Length; n++) + { + result[n] = this.data[n] / max; + } + + return result; + } + + private float[] Normalize() + { + var max = (float)this.data.Max(); + var result = new float[this.data.Length]; + for (var n = 0; n < this.data.Length; n++) + result[n] = this.data[n] / max; + + return result; + } + + public float[] NormalizeAndPlotEvents(Action writer) + { + var result = this.Normalize(); + FrequencyAnalysis.Plot(result, writer, "Event Distribution"); + + return result; + } + + public void PlotOccurence(Action writer) + { + var data = this.data.Select(n => n > 0f ? 1.0f : 0.0f).ToArray(); + FrequencyAnalysis.Plot(data, writer, "Occurrence Distribution"); + } + + private static void Plot(float[] data, Action writer, string name) + { + const int HEIGHT = 16; + + var values = new float[data.Length]; + for (var n = 0; n < data.Length; n++) + { + values[n] = data[n] * HEIGHT; + } + + var sb = new StringBuilder(); + for (var line = HEIGHT; line > 0; line--) + { + for (var column = 0; column < data.Length; column++) + sb.Append(values[column] >= line ? '█' : '░'); + + writer.Invoke(sb.ToString()); + sb.Clear(); + } + + writer.Invoke(name); + writer.Invoke(string.Empty); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/MathToolsTests.cs b/FastRngTests/Float/MathToolsTests.cs new file mode 100644 index 0000000..778647d --- /dev/null +++ b/FastRngTests/Float/MathToolsTests.cs @@ -0,0 +1,341 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using FastRng.Float; +using NUnit.Framework; + +namespace FastRngTests.Float +{ + [ExcludeFromCodeCoverage] + public class MathToolsTests + { + #region Gamma + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest01() + { + Assert.That(MathTools.Gamma(-0.5f), Is.EqualTo(-3.544907701811087f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest02() + { + Assert.That(MathTools.Gamma(0.1f), Is.EqualTo(9.51350975f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest03() + { + Assert.That(MathTools.Gamma(0.5f), Is.EqualTo(1.772453850905517f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest04() + { + Assert.That(MathTools.Gamma(1.0f), Is.EqualTo(1.0f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest05() + { + Assert.That(MathTools.Gamma(1.5f), Is.EqualTo(0.8862269254527587f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest06() + { + Assert.That(MathTools.Gamma(2.0f), Is.EqualTo(1.0f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest07() + { + Assert.That(MathTools.Gamma(3.0f), Is.EqualTo(2.0f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest08() + { + Assert.That(MathTools.Gamma(10.0f), Is.EqualTo(362_880.719f).Within(1e-6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest09() + { + Assert.That(MathTools.Gamma(140.0f), Is.EqualTo(float.NaN)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void GammaTest10() + { + Assert.That(MathTools.Gamma(170.0f), Is.EqualTo(float.NaN)); + } + + #endregion + + #region Factorial (integer) + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger01() + { + Assert.That(MathTools.Factorial(0), Is.EqualTo(1)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger02() + { + Assert.That(MathTools.Factorial(1), Is.EqualTo(1)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger03() + { + Assert.That(MathTools.Factorial(2), Is.EqualTo(2)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger04() + { + Assert.That(MathTools.Factorial(3), Is.EqualTo(6)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger05() + { + Assert.That(MathTools.Factorial(4), Is.EqualTo(24)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger06() + { + Assert.That(MathTools.Factorial(5), Is.EqualTo(120)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger07() + { + Assert.That(MathTools.Factorial(6), Is.EqualTo(720)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger08() + { + Assert.That(MathTools.Factorial(7), Is.EqualTo(5_040)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger09() + { + Assert.That(MathTools.Factorial(8), Is.EqualTo(40_320)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger10() + { + Assert.That(MathTools.Factorial(9), Is.EqualTo(362_880)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger11() + { + Assert.That(MathTools.Factorial(10), Is.EqualTo(3_628_800)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger12() + { + Assert.That(MathTools.Factorial(11), Is.EqualTo(39_916_800)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger13() + { + Assert.That(MathTools.Factorial(12), Is.EqualTo(479_001_600)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger14() + { + Assert.That(MathTools.Factorial(13), Is.EqualTo(6_227_020_800)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger15() + { + Assert.That(MathTools.Factorial(14), Is.EqualTo(87_178_291_200)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger16() + { + Assert.That(MathTools.Factorial(15), Is.EqualTo(1_307_674_368_000)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger17() + { + Assert.That(MathTools.Factorial(16), Is.EqualTo(20_922_789_888_000)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger18() + { + Assert.That(MathTools.Factorial(17), Is.EqualTo(355_687_428_096_000)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger19() + { + Assert.That(MathTools.Factorial(18), Is.EqualTo(6_402_373_705_728_000)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger20() + { + Assert.That(MathTools.Factorial(19), Is.EqualTo(121_645_100_408_832_000)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger21() + { + Assert.That(MathTools.Factorial(20), Is.EqualTo(2_432_902_008_176_640_000)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger22() + { + Assert.Throws(() => MathTools.Factorial(21)); + + // Note: 21! is not possible in C# until we got 128 bit integers, since: + // ulong.max == 18_446_744_073_709_551_615 < 51_090_942_171_709_400_000 + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger23() + { + Assert.Throws(() => MathTools.Factorial(45_646)); + + // Note: 45_646! is not possible in C# since: + // ulong.max == 18_446_744_073_709_551_615 + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger24() + { + Assert.Throws(() => MathTools.Factorial(-1)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialInteger25() + { + Assert.Throws(() => MathTools.Factorial(-6_565)); + } + + #endregion + + #region Factorial (floating point) + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialFloatingPoint01() + { + Assert.That(MathTools.Factorial(0.5f), Is.EqualTo(0.886226925f).Within(1e6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialFloatingPoint02() + { + Assert.That(MathTools.Factorial(1.5f), Is.EqualTo(1.329340388f).Within(1e6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialFloatingPoint03() + { + Assert.That(MathTools.Factorial(-1.5f), Is.EqualTo(-1.329340388f).Within(1e6f)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public void FactorialFloatingPoint04() + { + Assert.That(MathTools.Factorial(7.5f), Is.EqualTo(14_034.407293483f).Within(1e6f)); + } + + #endregion + } +} \ No newline at end of file diff --git a/FastRngTests/Float/MultiThreadedRngTests.cs b/FastRngTests/Float/MultiThreadedRngTests.cs new file mode 100644 index 0000000..e666135 --- /dev/null +++ b/FastRngTests/Float/MultiThreadedRngTests.cs @@ -0,0 +1,288 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Threading; +using System.Threading.Tasks; +using FastRng.Float; +using FastRng.Float.Distributions; +using NUnit.Framework; + +namespace FastRngTests.Float +{ + [ExcludeFromCodeCoverage] + public class MultiThreadedRngTests + { + private readonly IRandom rng = new MultiThreadedRng(); + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange01Uint() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange01Ulong() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange01Float() + { + var dist = new Uniform(); + for (var n = 0.0f; n < 1e6f; n++) + Assert.That(await rng.NextNumber(n, 100_000 + n, dist), Is.InRange(n, 100_000 + n)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange02Uint() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange02Ulong() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange02Float() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange03Uint() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange03Ulong() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange03Float() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange04Uint() + { + var dist = new Uniform(); + Assert.That(await rng.NextNumber(10, 1, dist), Is.InRange(1, 10)); + Assert.That(await rng.NextNumber(20, 1, dist), Is.InRange(1, 20)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange04Ulong() + { + var dist = new Uniform(); + Assert.That(await rng.NextNumber(10UL, 1, dist), Is.InRange(1, 10)); + Assert.That(await rng.NextNumber(20UL, 1, dist), Is.InRange(1, 20)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestRange04Float() + { + var dist = new Uniform(); + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TestStoppingProducers01() + { + var rng = new MultiThreadedRng(); + rng.StopProducer(); + + var masterToken = new CancellationTokenSource(TimeSpan.FromSeconds(16)).Token; + var wasCanceled = false; + + while(true) + { + var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3)); + await rng.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)); + await rng.NextNumber(new NormalS02M05(), tokenSource2.Token); + Assert.That(tokenSource2.IsCancellationRequested, Is.True); + + tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3)); + await rng.NextNumber(-1f, 1f, new NormalS02M05(), tokenSource2.Token); + Assert.That(tokenSource2.IsCancellationRequested, Is.True); + + tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3)); + await rng.NextNumber(0u, 6u, new NormalS02M05(), tokenSource2.Token); + Assert.That(tokenSource2.IsCancellationRequested, Is.True); + + tokenSource2 = new CancellationTokenSource(TimeSpan.FromSeconds(3)); + await rng.NextNumber(0ul, 6ul, new NormalS02M05(), tokenSource2.Token); + Assert.That(tokenSource2.IsCancellationRequested, Is.True); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task OneSeed01() + { + var rng1 = new MultiThreadedRng(6); + var rng2 = new MultiThreadedRng(6); + var rng3 = new MultiThreadedRng(7); + + var rng1Sample = new float[10]; + for (var n = 0; n < rng1Sample.Length; n++) + rng1Sample[n] = await rng1.GetUniform(); + + var rng2Sample = new float[10]; + for (var n = 0; n < rng2Sample.Length; n++) + rng2Sample[n] = await rng2.GetUniform(); + + var rng3Sample = new float[10]; + 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)); + } + + [Test] + [Category(TestCategories.COVER)] + [Category(TestCategories.NORMAL)] + public async Task TwoSeeds01() + { + var rng1 = new MultiThreadedRng(3, 6); + var rng2 = new MultiThreadedRng(3, 6); + var rng3 = new MultiThreadedRng(3, 7); + var rng4 = new MultiThreadedRng(6, 3); + + var rng1Sample = new float[10]; + for (var n = 0; n < rng1Sample.Length; n++) + rng1Sample[n] = await rng1.GetUniform(); + + var rng2Sample = new float[10]; + for (var n = 0; n < rng2Sample.Length; n++) + rng2Sample[n] = await rng2.GetUniform(); + + var rng3Sample = new float[10]; + for (var n = 0; n < rng3Sample.Length; n++) + rng3Sample[n] = await rng3.GetUniform(); + + var rng4Sample = new float[10]; + 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)); + 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 async Task NoSeed01() + { + var rng1 = new MultiThreadedRng(); + var rng2 = new MultiThreadedRng(); + var rng3 = new MultiThreadedRng(); + + var rng1Sample = new float[10]; + for (var n = 0; n < rng1Sample.Length; n++) + rng1Sample[n] = await rng1.GetUniform(); + + var rng2Sample = new float[10]; + for (var n = 0; n < rng2Sample.Length; n++) + rng2Sample[n] = await rng2.GetUniform(); + + var rng3Sample = new float[10]; + 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)); + } + } +} \ No newline at end of file diff --git a/FastRngTests/Float/RunningStatistics.cs b/FastRngTests/Float/RunningStatistics.cs new file mode 100644 index 0000000..41a2f4c --- /dev/null +++ b/FastRngTests/Float/RunningStatistics.cs @@ -0,0 +1,47 @@ +using System; + +namespace FastRngTests.Float +{ + internal sealed class RunningStatistics + { + private float previousM; + private float previousS; + private float nextM; + private float nextS; + + public RunningStatistics() + { + } + + public int NumberRecords { get; private set; } = 0; + + public void Clear() => this.NumberRecords = 0; + + public void Push(float x) + { + this.NumberRecords++; + + // See Knuth TAOCP vol 2, 3rd edition, page 232 + if (this.NumberRecords == 1) + { + this.previousM = this.nextM = x; + this.previousS = 0.0f; + } + else + { + this.nextM = this.previousM + (x - this.previousM) / this.NumberRecords; + this.nextS = this.previousS + (x - this.previousM) * (x - this.nextM); + + // set up for next iteration + this.previousM = this.nextM; + this.previousS = this.nextS; + } + } + + public float Mean => this.NumberRecords > 0 ? this.nextM : 0.0f; + + public float Variance => this.NumberRecords > 1 ? this.nextS / (this.NumberRecords - 1f) : 0.0f; + + public float StandardDeviation => MathF.Sqrt(this.Variance); + } +} \ No newline at end of file