Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
167 lines
6.4 KiB
C#
167 lines
6.4 KiB
C#
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;
|
||
}
|
||
}
|