public void TestEdgeCases()
{
// No elements
TDigest digest = new TDigest();
try {
digest.Quantile(.5);
Assert.Fail("Didn't throw exception when quantile() called before adding any elements");
}
catch (InvalidOperationException) {
}
// one element
digest.Add(50);
var v = digest.Quantile(.5);
Assert.AreEqual(50, v);
v = digest.Quantile(0);
Assert.AreEqual(50, v);
v = digest.Quantile(1);
Assert.AreEqual(50, v);
// Two elements
digest.Add(100);
v = digest.Quantile(1);
Assert.AreEqual(100, v);
}
public void Quantile()
{
var digest = new TDigest();
for (var i = 0; i <= 9; i++)
{
digest.Add(i);
}
Assert.Equal(2, digest.Quantile(.29999999));
Assert.Equal(3, digest.Quantile(.3));
Assert.Equal(3, digest.Quantile(.39999999));
Assert.Equal(8, digest.Quantile(.8));
Assert.Equal(9, digest.Quantile(.99999999));
}
private double GetAvgPercentileError(IList <double> all, TDigest digest)
{
return(Enumerable.Range(1, 999)
.Select(n => n / 1000.0)
.Select(q => Math.Abs(all.Quantile(q) - digest.Quantile(q)))
.Average());
}
public void TestSerialization()
{
Random r = new Random();
TDigest digestA = new TDigest();
for (int i = 0; i < 10000; i++)
{
var n = (r.Next() % 50) + (r.Next() % 50);
digestA.Add(n);
}
byte[] s = digestA.Serialize();
TDigest digestB = new TDigest(s);
var a = digestA.GetDistribution();
var b = digestB.GetDistribution();
for (int i = 0; i < a.Length; i++)
{
var ce = a[i].Count == b[i].Count;
var me = a[i].Value == b[i].Value;
Assert.IsTrue(ce && me, "Centroid means or counts are not equal after serialization");
}
Assert.AreEqual(digestA.Average, digestB.Average, "Averages are not equal after serialization");
Assert.AreEqual(digestA.Count, digestB.Count, "Counts are not equal after serialization");
Assert.AreEqual(digestA.CentroidCount, digestB.CentroidCount, "Centroid Counts are not equal after serialization");
Assert.AreEqual(digestA.CompressionConstant, digestB.CompressionConstant, "Compression Constants are not equal after serialization");
Assert.AreEqual(digestA.Accuracy, digestB.Accuracy, "Accuracies are not equal after serialization");
var differences = Enumerable.Range(1, 999)
.Select(n => n / 1000.0)
.Where(q => digestA.Quantile(q) != digestB.Quantile(q))
.Select(q => new { q, A = digestA.Quantile(q), B = digestB.Quantile(q) })
.ToList();
var areEqual = !differences.Any();
Assert.IsTrue(areEqual, "Serialized TDigest is not the same as original");
}
public void QuantileEdges()
{
var digest = new TDigest();
var min = Double.MaxValue;
var max = Double.MinValue;
for (var i = 100; i > 0; i--)
{
var value = new Random().NextDouble();
if (value > max)
{
max = value;
}
if (value < min)
{
min = value;
}
digest.Add(value);
}
Assert.Equal(min, digest.Quantile(0.001));
Assert.Equal(max, digest.Quantile(1));
}
public void TestFixForNegativeQuantileBug()
{
var r = new Random();
var numbers = new List <int>();
var digest = new TDigest();
for (var i = 0; i < 10 * 1000; i++)
{
var n = r.NextDouble() < 0.001 ? 10001 : r.Next(0, 100);
digest.Add(n);
numbers.Add(n);
var q99 = digest.Quantile(0.99);
Assert.IsTrue(q99 >= 0, string.Format("q99: {0}, numbers: {1}", q99, string.Join(",", numbers)));
}
}
public void TestNormalDistribution()
{
Random r = new Random();
TDigest digest = new TDigest();
List <double> actual = new List <double>();
for (int i = 0; i < 10000; i++)
{
var n = (r.Next() % 100) + (r.Next() % 100);
digest.Add(n);
actual.Add(n);
}
actual.Sort();
var z = digest.Quantile(0);
Assert.IsTrue(GetAvgError(actual, digest) < .01);
Assert.IsTrue(MaxIsEqual(actual, digest));
Assert.IsTrue(MinIsEqual(actual, digest));
var avgError = GetAvgPercentileError(actual, digest);
Assert.IsTrue(avgError < .5);
}
/// <summary>
/// Gets an estimate of the specified quantile of the distribution.
/// </summary>
/// <returns>The estimated value of the quantile.</returns>
/// <param name="quantile">The quantile.</param>
public double GetValue(double quantile)
{
return(Count == 0 ? Double.NaN : distribution.Quantile(quantile));
}
