296 lines
11 KiB
C#
296 lines
11 KiB
C#
using System;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using FastRng;
|
|
using NUnit.Framework;
|
|
|
|
namespace FastRngTests.Distributions;
|
|
|
|
[ExcludeFromCodeCoverage]
|
|
public class Uniform
|
|
{
|
|
[Test]
|
|
[Category(TestCategories.COVER)]
|
|
[Category(TestCategories.NORMAL)]
|
|
public void 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);
|
|
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var stats = new RunningStatistics();
|
|
var fra = new FrequencyAnalysis();
|
|
|
|
for (var n = 0; n < 100_000; n++)
|
|
{
|
|
var value = rng.GetUniform();
|
|
stats.Push(value);
|
|
fra.CountThis(value);
|
|
}
|
|
|
|
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];
|
|
using var rng = new MultiThreadedRng<float>();
|
|
int n;
|
|
|
|
for (n = 0; n != NUM_ROUNDS; ++n)
|
|
samples[n] = rng.GetUniform();
|
|
|
|
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 void TestUniformGeneratorWithRange01()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var samples = new float[1_000];
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
for (var n = 0; n < samples.Length; n++)
|
|
samples[n] = dist.NextNumber(-1.0f, 1.0f);
|
|
|
|
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 void TestUniformGeneratorWithRange02()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var samples = new float[1_000];
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
for (var n = 0; n < samples.Length; n++)
|
|
samples[n] = dist.NextNumber(0.0f, 1.0f);
|
|
|
|
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 void TestUniformGeneratorWithRange04()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var samples = new float[1_000];
|
|
for (var n = 0; n < samples.Length; n++)
|
|
samples[n] = rng.GetUniform();
|
|
|
|
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 void TestRange05Uint()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 1_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[dist.NextNumber(0, 100)]++;
|
|
|
|
for (var n = 0; n < distribution.Length - 1; n++)
|
|
Assert.That(distribution[n], Is.GreaterThan(0));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.COVER)]
|
|
[Category(TestCategories.NORMAL)]
|
|
public void TestRange05Ulong()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 1_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[dist.NextNumber(0UL, 100)]++;
|
|
|
|
for (var n = 0; n < distribution.Length - 1; n++)
|
|
Assert.That(distribution[n], Is.GreaterThan(0));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.COVER)]
|
|
[Category(TestCategories.NORMAL)]
|
|
public void TestRange05Float()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 1_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[(uint)MathF.Floor(dist.NextNumber(0.0f, 100.0f))]++;
|
|
|
|
for (var n = 0; n < distribution.Length - 1; n++)
|
|
Assert.That(distribution[n], Is.GreaterThan(0));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.NORMAL)]
|
|
public void TestDistribution001Uint()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 1_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[dist.NextNumber(0, 100)]++;
|
|
|
|
Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 600));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.NORMAL)]
|
|
public void TestDistribution001Ulong()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 1_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[dist.NextNumber(0UL, 100)]++;
|
|
|
|
Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 600));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.NORMAL)]
|
|
public void TestDistribution001Float()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 1_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[(uint)MathF.Floor(dist.NextNumber(0.0f, 100.0f))]++;
|
|
|
|
Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 600));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.LONG_RUNNING)]
|
|
public void TestDistribution002Uint()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 100_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[dist.NextNumber(0, 100)]++;
|
|
|
|
Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 6_000));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.LONG_RUNNING)]
|
|
public void TestDistribution002Ulong()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 100_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[dist.NextNumber(0UL, 100)]++;
|
|
|
|
Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 6_000));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.LONG_RUNNING)]
|
|
public void TestDistribution002Float()
|
|
{
|
|
using var rng = new MultiThreadedRng<float>();
|
|
var dist = new FastRng.Distributions.Uniform<float>(rng);
|
|
var distribution = new uint[101];
|
|
var runs = 100_000_000;
|
|
for (var n = 0; n < runs; n++)
|
|
distribution[(uint)MathF.Floor(dist.NextNumber(0.0f, 100.0f))]++;
|
|
|
|
Assert.That(distribution[..^1].Max() - distribution[..^1].Min(), Is.InRange(0, 6_000));
|
|
}
|
|
|
|
[Test]
|
|
[Category(TestCategories.COVER)]
|
|
[Category(TestCategories.NORMAL)]
|
|
public void NoRandomNumberGenerator01()
|
|
{
|
|
Assert.Throws<ArgumentNullException>(() => new FastRng.Distributions.Uniform<float>(null));
|
|
}
|
|
} |