Files
Febe/tests/Febe.Tests/Pacing/DistributionsTests.cs
T

167 lines
6.4 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using Febe.Core.Abstractions;
using Febe.Core.Domain;
using Febe.Core.Pacing;
namespace Febe.Tests.Pacing;
[TestClass]
public sealed class DistributionsTests
{
private const int Samples = 40_000;
[TestMethod]
public void BoxMullerGivesAStandardNormal()
{
var random = new SeededRandom(1);
var values = Enumerable.Range(0, Samples).Select(_ => random.StandardNormal()).ToArray();
var mean = values.Average();
var sd = Math.Sqrt(values.Select(v => (v - mean) * (v - mean)).Average());
Assert.AreEqual(0, mean, 0.03);
Assert.AreEqual(1, sd, 0.03);
Assert.IsTrue(values.All(double.IsFinite));
}
[TestMethod]
public void BetweenStaysInsideTheIntervalWithGeometricMedian()
{
var random = new SeededRandom(2);
var values = Enumerable.Range(0, Samples).Select(_ => random.Between(1, 100)).Order().ToArray();
Assert.IsTrue(values[0] >= 1 && values[^1] <= 100, "Every value must lie in [a, b].");
Assert.AreEqual(10, Quantile(values, 0.5), 0.5, "Median must be √(a·b).");
// σ = ln(b/a)/4; truncation at ±2σ puts the quartiles at about ±0.640σ in log space.
var sigma = Math.Log(100) / 4;
var median = Quantile(values, 0.5);
Assert.AreEqual(0.640 * sigma, Math.Log(Quantile(values, 0.75) / median), 0.05);
Assert.AreEqual(0.640 * sigma, Math.Log(median / Quantile(values, 0.25)), 0.05);
}
[TestMethod]
public void BetweenHonoursAnExplicitMedianAndIsNotUniform()
{
var random = new SeededRandom(3);
var values = Enumerable.Range(0, Samples).Select(_ => random.Between(1000, 6000, 2200)).Order().ToArray();
Assert.IsTrue(values[0] >= 1000 && values[^1] <= 6000);
Assert.AreEqual(2200, Quantile(values, 0.5), 2200 * 0.03);
// A uniform draw would put 1/5 of the mass in each fifth; the log-normal crowds the lower part.
var lowFifth = values.Count(v => v < 2000) / (double)values.Length;
var highFifth = values.Count(v => v > 5000) / (double)values.Length;
Assert.IsTrue(lowFifth > 0.35, $"Lower fifth holds {lowFifth:P1}.");
Assert.IsTrue(highFifth < 0.05, $"Upper fifth holds {highFifth:P1}.");
}
[TestMethod]
public void TimeSpanOverloadUsesTheSameDistribution()
{
var random = new SeededRandom(4);
var values = Enumerable.Range(0, 5_000)
.Select(_ => random.Between(TimeSpan.FromSeconds(0.4), TimeSpan.FromSeconds(4), TimeSpan.FromSeconds(1.1)).TotalSeconds)
.Order()
.ToArray();
Assert.IsTrue(values[0] >= 0.4 && values[^1] <= 4);
Assert.AreEqual(1.1, Quantile(values, 0.5), 0.06);
}
[TestMethod]
public void SessionMoodHasMedianOneAndStaysInRange()
{
var random = new SeededRandom(5);
var values = Enumerable.Range(0, Samples).Select(_ => random.SessionMood()).Order().ToArray();
Assert.IsTrue(values[0] >= 0.7 && values[^1] <= 1.5);
Assert.AreEqual(1, Quantile(values, 0.5), 0.02);
var logSd = Math.Sqrt(values.Select(v => Math.Log(v) * Math.Log(v)).Average());
Assert.IsTrue(logSd is > 0.15 and < 0.21, $"σ of ln(mood) is {logSd:F3}.");
Assert.IsTrue(values.Count(v => v < 0.8) > 0 && values.Count(v => v > 1.3) > 0, "Slow and fast sessions both occur.");
}
[TestMethod]
public void NextCheckJitterHasMedianOneAndStaysInRange()
{
var random = new SeededRandom(6);
var values = Enumerable.Range(0, Samples).Select(_ => random.NextCheckJitter()).Order().ToArray();
Assert.IsTrue(values[0] >= 0.6 && values[^1] <= 1.8);
Assert.AreEqual(1, Quantile(values, 0.5), 0.02);
var interval = TimeSpan.FromHours(3);
var jittered = random.JitteredInterval(interval);
Assert.IsTrue(jittered >= interval * 0.6 && jittered <= interval * 1.8);
}
[TestMethod]
public void CountBetweenReachesBothEndsAndFavoursTheMiddle()
{
var random = new SeededRandom(7);
var counts = new int[11];
for (var i = 0; i < Samples; i++)
{
counts[random.CountBetween(3, 8)]++;
}
Assert.AreEqual(Samples, counts.Skip(3).Take(6).Sum(), "Every value lies in [3, 8].");
Assert.IsTrue(counts[3] > 0 && counts[8] > 0, "Both ends are reachable.");
Assert.IsTrue(counts[5] > counts[3] && counts[5] > counts[8], "Not uniform: the middle is more frequent.");
}
[TestMethod]
public void SameSeedSameSequence()
{
var a = new SeededRandom(42);
var b = new SeededRandom(42);
for (var i = 0; i < 100; i++)
{
Assert.AreEqual(a.Between(1, 6, 2.2), b.Between(1, 6, 2.2));
}
}
[TestMethod]
public void ChanceMatchesItsProbability()
{
var random = new SeededRandom(8);
var hits = Enumerable.Range(0, Samples).Count(_ => random.Chance(0.08));
Assert.AreEqual(0.08, hits / (double)Samples, 0.006);
Assert.IsFalse(random.Chance(0));
}
[TestMethod]
public void InvalidIntervalsAreRefused()
{
var random = new SeededRandom(9);
Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => random.Between(0, 10));
Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => random.Between(5, 1));
Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => random.Between(1, 6, 7));
Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => random.LogNormal(-1, 0.2));
Assert.AreEqual(3, random.Between(3, 3));
}
[TestMethod]
public void DegenerateSourceFallsBackToTheMedian()
{
// A source that always returns the same value cannot loop forever.
var constant = new ConstantRandom(0.999999);
var value = constant.TruncatedLogNormal(1, 3, 0.9, 1.1);
Assert.IsTrue(value is >= 0.9 and <= 1.1);
}
[TestMethod]
public void PaceFactorsOrderSlowNaturalBrisk()
{
Assert.AreEqual(1.0, GesturePaceFactors.For(GesturePace.Natural));
Assert.IsTrue(GesturePaceFactors.For(GesturePace.Slow) > 1.0);
Assert.IsTrue(GesturePaceFactors.For(GesturePace.Brisk) < 1.0);
}
private static double Quantile(double[] sorted, double q) => sorted[(int)Math.Clamp(q * (sorted.Length - 1), 0, sorted.Length - 1)];
private sealed class ConstantRandom(double value) : IRandomSource
{
public double NextDouble() => value;
}
}