Add LocationEstimatorSimulation

Author: AndreyAkinshin

src/Perfolizer/Perfolizer.Simulations/LocationEstimatorSimulation.cs

@@ -0,0 +1,31 @@
+using Perfolizer.Mathematics.Distributions.ContinuousDistributions;
+using Perfolizer.Mathematics.GenericEstimators;
+using Perfolizer.Mathematics.LocationEstimators;
+using Perfolizer.Mathematics.QuantileEstimators;
+using Perfolizer.Simulations.Util;
+
+namespace Perfolizer.Simulations;
+
+public class LocationEstimatorSimulation
+{
+    public void Run(string[] args)
+    {
+        var simulation =
+            new EfficiencySimulation<ILocationEstimator>((estimator, sample) => estimator.Location(sample))
+                .AddEstimator("Mean", MeanEstimator.Instance)
+                .AddEstimator("Median", SimpleQuantileEstimator.Instance.ToLocationEstimator())
+                .AddEstimator("HL", HodgesLehmannEstimator.Instance)
+                .AddDistribution("Normal", NormalDistribution.Standard.Random(1729))
+                .AddSampleSizes(Enumerable.Range(2, 99).ToArray());
+
+        var rows = simulation.Simulate();
+
+        foreach (var row in rows)
+        {
+            Console.WriteLine(row.Distribution + " / N = " + row.SampleSize);
+            foreach ((string key, double value) in row.RelativeEfficiency)
+                Console.WriteLine("  " + key.PadRight(6) + " : " + Math.Round(value * 100, 1) + "%");
+            Console.WriteLine();
+        }
+    }
+}

src/Perfolizer/Perfolizer.Simulations/Program.cs

@@ -2,10 +2,11 @@
 
 static class Program
 {
-    private static readonly Dictionary<string, Action<string[]>> Simulations = new Dictionary<string, Action<string[]>>
+    private static readonly Dictionary<string, Action<string[]>> Simulations = new()
     {
-        {"RqqPelt", args => new RqqPeltSimulation().Run(args)},
-        {"QuantileCi", args => new QuantileCiSimulation().Run(args)},
+        { "RqqPelt", args => new RqqPeltSimulation().Run(args) },
+        { "QuantileCi", args => new QuantileCiSimulation().Run(args) },
+        { "Location", args => new LocationEstimatorSimulation().Run(args) },
     };
 
     private static void PrintAvailableSimulations()

src/Perfolizer/Perfolizer.Simulations/Util/EfficiencySimulation.cs

@@ -0,0 +1,94 @@
+using Perfolizer.Collections;
+using Perfolizer.Common;
+using Perfolizer.Mathematics.Randomization;
+
+namespace Perfolizer.Simulations.Util;
+
+public class EfficiencySimulation<TEstimator>(
+    Func<TEstimator, Sample, double> estimate,
+    int sampleCount = EfficiencySimulation<TEstimator>.DefaultSampleCount)
+    where TEstimator : notnull
+{
+    private const int DefaultSampleCount = 100_000;
+
+    private readonly Dictionary<string, TEstimator> estimators = new();
+    private readonly Dictionary<string, RandomGenerator> distributions = new();
+    private readonly HashSet<int> sampleSizes = new();
+
+    public EfficiencySimulation<TEstimator> AddEstimator(string name, TEstimator estimator)
+    {
+        if (!estimators.TryAdd(name, estimator))
+            throw new ArgumentException($"Estimator '{name}' is already registered");
+        return this;
+    }
+
+    public EfficiencySimulation<TEstimator> AddDistribution(string name, RandomGenerator randomGenerator)
+    {
+        if (!distributions.TryAdd(name, randomGenerator))
+            throw new ArgumentException($"Distribution '{name}' is already registered");
+        return this;
+    }
+
+    public EfficiencySimulation<TEstimator> AddSampleSizes(params int[] sizes)
+    {
+        foreach (int sampleSize in sizes)
+        {
+            Assertion.Positive(nameof(sizes), sampleSize);
+            sampleSizes.Add(sampleSize);
+        }
+        return this;
+    }
+
+    public class SimulationRow(
+        string distribution,
+        int sampleSize,
+        IReadOnlyDictionary<string, double> relativeEfficiency)
+    {
+        public string Distribution { get; init; } = distribution;
+        public int SampleSize { get; init; } = sampleSize;
+        public IReadOnlyDictionary<string, double> RelativeEfficiency { get; init; } = relativeEfficiency;
+    }
+
+    public IEnumerable<SimulationRow> Simulate()
+    {
+        if (distributions.IsEmpty())
+            throw new InvalidOperationException("No distributions provided");
+        if (estimators.IsEmpty())
+            throw new InvalidOperationException("No estimators provided");
+        if (sampleSizes.IsEmpty())
+            throw new InvalidOperationException("No sample sizes provided");
+
+        foreach ((string distributionName, var randomGenerator) in distributions)
+        foreach (int sampleSize in sampleSizes)
+        {
+            var samplingDistributions = new Dictionary<string, double[]>();
+            foreach (string estimatorName in estimators.Keys)
+                samplingDistributions[estimatorName] = new double[sampleCount];
+
+            for (int i = 0; i < sampleCount; i++)
+            {
+                var sample = new Sample(randomGenerator.Next(sampleSize));
+                foreach ((string estimatorName, var estimator) in estimators)
+                    samplingDistributions[estimatorName][i] = estimate(estimator, sample);
+            }
+
+            var mses = new Dictionary<string, double>();
+            foreach (string estimatorName in estimators.Keys)
+                mses[estimatorName] = Mse(samplingDistributions[estimatorName]);
+            double minMse = mses.Values.Min();
+            var relativeEfficiency = new Dictionary<string, double>();
+            foreach (string estimatorName in estimators.Keys)
+                relativeEfficiency[estimatorName] = minMse / mses[estimatorName];
+
+            var row = new SimulationRow(distributionName, sampleSize, relativeEfficiency);
+            yield return row;
+        }
+    }
+
+    // The mean squared error (MSE)
+    private static double Mse(double[] values)
+    {
+        double mean = values.Average();
+        return values.Sum(x => (x - mean) * (x - mean)) / values.Length;
+    }
+}

src/Perfolizer/Perfolizer/Mathematics/GenericEstimators/HodgesLehmannEstimator.cs

@@ -1,5 +1,6 @@
 using Perfolizer.Common;
 using Perfolizer.Mathematics.Common;
+using Perfolizer.Mathematics.LocationEstimators;
 using Perfolizer.Mathematics.QuantileEstimators;
 
 namespace Perfolizer.Mathematics.GenericEstimators;
@@ -13,7 +14,7 @@ namespace Perfolizer.Mathematics.GenericEstimators;
 /// The weighted version is based on https://aakinshin.net/posts/whl/
 /// </summary>
 public class HodgesLehmannEstimator(IQuantileEstimator quantileEstimator)
-    : IShiftEstimator, IMedianEstimator, IRatioEstimator
+    : IShiftEstimator, IMedianEstimator, IRatioEstimator, ILocationEstimator
 {
     public static readonly HodgesLehmannEstimator Instance = new(SimpleQuantileEstimator.Instance);
 
@@ -29,4 +30,6 @@ public double Median(Sample x) =>
 
     private double Estimate(Sample x, Sample y, Func<double, double, double> func) =>
         PairwiseEstimatorHelper.Estimate(x, y, func, quantileEstimator, Probability.Median);
+
+    public double Location(Sample x) => Median(x);
 }

src/Perfolizer/Perfolizer/Mathematics/GenericEstimators/ILocationEstimator.cs

@@ -0,0 +1,6 @@
+namespace Perfolizer.Mathematics.GenericEstimators;
+
+public interface ILocationEstimator
+{
+    double Location(Sample x);
+}

src/Perfolizer/Perfolizer/Mathematics/LocationEstimators/MeanEstimator.cs

@@ -0,0 +1,9 @@
+using Perfolizer.Mathematics.GenericEstimators;
+
+namespace Perfolizer.Mathematics.LocationEstimators;
+
+public class MeanEstimator : ILocationEstimator
+{
+    public static readonly MeanEstimator Instance = new();
+    public double Location(Sample x) => x.Values.Average();
+}

src/Perfolizer/Perfolizer/Mathematics/LocationEstimators/MedianLocationEstimator.cs

@@ -0,0 +1,9 @@
+using Perfolizer.Mathematics.GenericEstimators;
+using Perfolizer.Mathematics.QuantileEstimators;
+
+namespace Perfolizer.Mathematics.LocationEstimators;
+
+public class MedianLocationEstimator(IQuantileEstimator quantileEstimator) : ILocationEstimator
+{
+    public double Location(Sample x) => quantileEstimator.Median(x);
+}

src/Perfolizer/Perfolizer/Mathematics/QuantileEstimators/QuantileEstimatorExtensions.cs

@@ -1,5 +1,7 @@
 using Perfolizer.Common;
 using Perfolizer.Mathematics.Common;
+using Perfolizer.Mathematics.GenericEstimators;
+using Perfolizer.Mathematics.LocationEstimators;
 
 namespace Perfolizer.Mathematics.QuantileEstimators;
 
@@ -43,4 +45,9 @@ public static double[] Quantiles(
     {
         return estimator.Quantiles(new Sample(values), probabilities);
     }
+
+    public static ILocationEstimator ToLocationEstimator(this IQuantileEstimator estimator)
+    {
+        return new MedianLocationEstimator(estimator);
+    }
 }

src/Perfolizer/Perfolizer/Sample.cs

@@ -27,7 +27,7 @@ public class Sample : IWithUnits
     public IReadOnlyList<double> SortedWeights => lazySortedData.Value.SortedWeights;
 
     /// <summary>
-    /// Sample size
+    /// Sample size (always positive)
     /// </summary>
     public int Size => Values.Count;