private void VerifyPercsWithAbsoluteEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var target in _targets)
{
double n = a.Length;
int k = (int)(target.Quantile * n);
int lower = (int)((target.Quantile - target.Epsilon) * n);
if (lower < 1)
{
lower = 1;
}
int upper = (int)Math.Ceiling((target.Quantile + target.Epsilon) * n);
if (upper > a.Length)
{
upper = a.Length;
}
double w = a[k - 1];
double min = a[lower - 1];
double max = a[upper - 1];
double g = s.Query(target.Quantile);
Assert.True(g >= min, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
Assert.True(g <= max, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
}
}
void VerifyPercsWithAbsoluteEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var target in _targets)
{
var n = (double)a.Length;
var k = (int)(target.Quantile * n);
var lower = (int)((target.Quantile - target.Epsilon) * n);
if (lower < 1)
{
lower = 1;
}
var upper = (int)Math.Ceiling((target.Quantile + target.Epsilon) * n);
if (upper > a.Length)
{
upper = a.Length;
}
var w = a[k - 1];
var min = a[lower - 1];
var max = a[upper - 1];
var g = s.Query(target.Quantile);
// Assert.That(g, Is.GreaterThanOrEqualTo(min), $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
Assert.True(g >= min, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
// Assert.That(g, Is.LessThanOrEqualTo(max), $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
Assert.True(g <= max, $"q={target.Quantile}: want {w} [{min}, {max}], got {g}");
}
}
internal void ForkState(out long count, out double sum, double[] values)
{
_quantileStream.FlushBuffer();
for (int i = 0; i < Configuration.SortedObjectives.Length; i++)
{
double rank = Configuration.SortedObjectives[i];
double value = _quantileStream.Query(rank);
values[i] = value;
}
count = _count.Value;
sum = _sum.Value;
}
internal void Populate(CMetric cMetric, DateTime now)
{
var summary = new CSummary();
var quantiles = new CQuantile[_objectives.Count];
lock (_bufLock)
{
lock (_lock)
{
// Swap bufs even if hotBuf is empty to set new hotBufExpTime.
SwapBufs(now);
FlushColdBuf();
summary.SampleCount = _count;
summary.SampleSum = _sum;
for (var idx = 0; idx < _sortedObjectives.Length; idx++)
{
var rank = _sortedObjectives[idx];
var q = _headStream.Count == 0 ? double.NaN : _headStream.Query(rank);
quantiles[idx] = new CQuantile
{
Quantile = rank,
Value = q
};
}
}
}
if (quantiles.Length > 0)
{
Array.Sort(quantiles, _quantileComparer);
}
foreach (var quantile in quantiles)
{
summary.Quantiles.Add(quantile);
}
cMetric.CSummary = summary;
}
internal void Populate(Metric metric, DateTime now)
{
var summary = new Advanced.DataContracts.Summary();
var quantiles = new Quantile[_objectives.Count];
lock (_bufLock)
{
lock (_lock)
{
// Swap bufs even if hotBuf is empty to set new hotBufExpTime.
SwapBufs(now);
FlushColdBuf();
summary.sample_count = _count;
summary.sample_sum = _sum;
for (var idx = 0; idx < _sortedObjectives.Length; idx++)
{
var rank = _sortedObjectives[idx];
var q = _headStream.Count == 0 ? double.NaN : _headStream.Query(rank);
quantiles[idx] = new Quantile
{
quantile = rank,
value = q
};
}
}
}
if (quantiles.Length > 0)
{
Array.Sort(quantiles, _quantileComparer);
}
for (var i = 0; i < quantiles.Length; i++)
{
summary.quantile.Add(quantiles[i]);
}
metric.summary = summary;
}
void VerifyHighPercsWithRelativeEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var qu in _highQuantiles)
{
var n = (double)a.Length;
var k = (int)(qu * n);
var lowerRank = (int)((1 - (1 + RelativeEpsilon) * (1 - qu)) * n);
var upperRank = (int)(Math.Ceiling((1 - (1 - RelativeEpsilon) * (1 - qu)) * n));
var w = a[k - 1];
var min = a[lowerRank - 1];
var max = a[upperRank - 1];
var g = s.Query(qu);
Assert.IsTrue(g >= min, $"q={qu}: want {w} [{min}, {max}], got {g}");
Assert.IsTrue(g <= max, $"q={qu}: want {w} [{min}, {max}], got {g}");
}
}
private void VerifyHighPercsWithRelativeEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (double qu in _highQuantiles)
{
double n = a.Length;
int k = (int)(qu * n);
int lowerRank = (int)((1 - ((1 + _relativeEpsilon) * (1 - qu))) * n);
int upperRank = (int)Math.Ceiling((1 - ((1 - _relativeEpsilon) * (1 - qu))) * n);
double w = a[k - 1];
double min = a[lowerRank - 1];
double max = a[upperRank - 1];
double g = s.Query(qu);
Assert.True(g >= min, $"q={qu}: want {w} [{min}, {max}], got {g}");
Assert.True(g <= max, $"q={qu}: want {w} [{min}, {max}], got {g}");
}
}
internal void ForkState(DateTime now, out long count, out double sum, double[] values)
{
lock (_bufLock)
{
lock (_lock)
{
// FlushBuffer even if buffer is empty to set new bufferExpTime.
FlushBuffer(now);
for (int i = 0; i < Configuration.SortedObjectives.Count; i++)
{
double rank = Configuration.SortedObjectives[i];
double value = _headStream.Count == 0 ? double.NaN : _headStream.Query(rank);
values[i] = value;
}
count = _count;
sum = _sum;
}
}
}
void VerifyLowPercsWithRelativeEpsilon(double[] a, QuantileStream s)
{
Array.Sort(a);
foreach (var qu in _lowQuantiles)
{
var n = (double)a.Length;
var k = (int)(qu * n);
var lowerRank = (int)((1 - RelativeEpsilon) * qu * n);
var upperRank = (int)(Math.Ceiling((1 + RelativeEpsilon) * qu * n));
var w = a[k - 1];
var min = a[lowerRank - 1];
var max = a[upperRank - 1];
var g = s.Query(qu);
Assert.That(g, Is.GreaterThanOrEqualTo(min), $"q={qu}: want {w} [{min}, {max}], got {g}");
Assert.That(g, Is.LessThanOrEqualTo(max), $"q={qu}: want {w} [{min}, {max}], got {g}");
}
}
