@Test
public void testAggregateSpecialValues() {
double[] totalSample = {Double.POSITIVE_INFINITY, 2, 3, Double.NaN, 5};
double[][] subSamples = {{Double.POSITIVE_INFINITY, 2}, {3}, {Double.NaN}, {5}};
// Compute combined stats directly
SummaryStatistics totalStats = new SummaryStatistics();
for (int i = 0; i < totalSample.length; i++) {
totalStats.addValue(totalSample[i]);
}
// Now compute subsample stats individually and aggregate
SummaryStatistics[] subSampleStats = new SummaryStatistics[5];
for (int i = 0; i < 4; i++) {
subSampleStats[i] = new SummaryStatistics();
}
Collection<SummaryStatistics> aggregate = new ArrayList<SummaryStatistics>();
for (int i = 0; i < 4; i++) {
for (int j = 0; j < subSamples[i].length; j++) {
subSampleStats[i].addValue(subSamples[i][j]);
}
aggregate.add(subSampleStats[i]);
}
// Compare values
StatisticalSummaryValues aggregatedStats = AggregateSummaryStatistics.aggregate(aggregate);
assertEquals(totalStats.getSummary(), aggregatedStats, 10E-12);
}
/** Similar to {@link #testAggregate()} but operating on {@link StatisticalSummary} instead. */
@Test
public void testAggregateStatisticalSummary() {
// Generate a random sample and random partition
double[] totalSample = generateSample();
double[][] subSamples = generatePartition(totalSample);
int nSamples = subSamples.length;
// Compute combined stats directly
SummaryStatistics totalStats = new SummaryStatistics();
for (int i = 0; i < totalSample.length; i++) {
totalStats.addValue(totalSample[i]);
}
// Now compute subsample stats individually and aggregate
SummaryStatistics[] subSampleStats = new SummaryStatistics[nSamples];
for (int i = 0; i < nSamples; i++) {
subSampleStats[i] = new SummaryStatistics();
}
Collection<StatisticalSummary> aggregate = new ArrayList<StatisticalSummary>();
for (int i = 0; i < nSamples; i++) {
for (int j = 0; j < subSamples[i].length; j++) {
subSampleStats[i].addValue(subSamples[i][j]);
}
aggregate.add(subSampleStats[i].getSummary());
}
// Compare values
StatisticalSummary aggregatedStats = AggregateSummaryStatistics.aggregate(aggregate);
assertEquals(totalStats.getSummary(), aggregatedStats, 10E-12);
}
/**
* Verify that aggregating over a partition gives the same results as direct computation.
*
* <p>1) Randomly generate a dataset of 10-100 values from [-100, 100] 2) Divide the dataset it
* into 2-5 partitions 3) Create an AggregateSummaryStatistic and ContributingStatistics for each
* partition 4) Compare results from the AggregateSummaryStatistic with values returned by a
* single SummaryStatistics instance that is provided the full dataset
*/
@Test
public void testAggregationConsistency() {
// Generate a random sample and random partition
double[] totalSample = generateSample();
double[][] subSamples = generatePartition(totalSample);
int nSamples = subSamples.length;
// Create aggregator and total stats for comparison
AggregateSummaryStatistics aggregate = new AggregateSummaryStatistics();
SummaryStatistics totalStats = new SummaryStatistics();
// Create array of component stats
SummaryStatistics componentStats[] = new SummaryStatistics[nSamples];
for (int i = 0; i < nSamples; i++) {
// Make componentStats[i] a contributing statistic to aggregate
componentStats[i] = aggregate.createContributingStatistics();
// Add values from subsample
for (int j = 0; j < subSamples[i].length; j++) {
componentStats[i].addValue(subSamples[i][j]);
}
}
// Compute totalStats directly
for (int i = 0; i < totalSample.length; i++) {
totalStats.addValue(totalSample[i]);
}
/*
* Compare statistics in totalStats with aggregate.
* Note that guaranteed success of this comparison depends on the
* fact that <aggregate> gets values in exactly the same order
* as <totalStats>.
*
*/
Assert.assertEquals(totalStats.getSummary(), aggregate.getSummary());
}
/**
* Get the Variance of all the stats that are watched, for all the stats added with add() since
* the last call to clear() (in JSON).
*
* @return The Variance of all the stats since last clear() in JSON.
*/
public String getVarianceJSON() {
String str =
String.format(
FakeUserStats.jsonMediaStreamStatsTemplate,
-1, // ssrc not needed here
downloadJitterMs.getVariance(),
downloadPercentLoss.getVariance(),
downloadRateKiloBitPerSec.getVariance(),
jitterBufferDelayMs.getVariance(),
jitterBufferDelayPackets.getVariance(),
nbDiscarded.getVariance(),
nbDiscardedFull.getVariance(),
nbDiscardedLate.getVariance(),
nbDiscardedReset.getVariance(),
nbDiscardedShrink.getVariance(),
nbFec.getVariance(),
nbPackets.getVariance(),
nbPacketsLost.getVariance(),
nbReceivedBytes.getVariance(),
nbSentBytes.getVariance(),
packetQueueCountPackets.getVariance(),
packetQueueSize.getVariance(),
percentDiscarded.getVariance(),
rttMs.getVariance(),
uploadJitterMs.getVariance(),
uploadPercentLoss.getVariance(),
uploadRateKiloBitPerSec.getVariance());
return str;
}
/**
* Add the stats contained by <tt>stats<tt> to their corresponding <tt>SummaryStats</tt>
* objects.
*
* @param stats the stats of a stream that will be added.
*/
public void add(MediaStreamStats stats) {
downloadJitterMs.addValue(stats.getDownloadJitterMs());
downloadPercentLoss.addValue(stats.getDownloadPercentLoss());
downloadRateKiloBitPerSec.addValue(stats.getDownloadRateKiloBitPerSec());
jitterBufferDelayMs.addValue(stats.getJitterBufferDelayMs());
jitterBufferDelayPackets.addValue(stats.getJitterBufferDelayPackets());
nbDiscarded.addValue(stats.getNbDiscarded());
nbDiscardedFull.addValue(stats.getNbDiscardedFull());
nbDiscardedLate.addValue(stats.getNbDiscardedLate());
nbDiscardedReset.addValue(stats.getNbDiscardedReset());
nbDiscardedShrink.addValue(stats.getNbDiscardedShrink());
nbFec.addValue(stats.getNbFec());
nbPackets.addValue(stats.getNbPackets());
nbPacketsLost.addValue(stats.getNbPacketsLost());
nbReceivedBytes.addValue(stats.getNbReceivedBytes());
nbSentBytes.addValue(stats.getNbSentBytes());
packetQueueCountPackets.addValue(stats.getPacketQueueCountPackets());
packetQueueSize.addValue(stats.getPacketQueueSize());
percentDiscarded.addValue(stats.getPercentDiscarded());
rttMs.addValue(stats.getRttMs());
uploadJitterMs.addValue(stats.getUploadJitterMs());
uploadPercentLoss.addValue(stats.getUploadPercentLoss());
uploadRateKiloBitPerSec.addValue(stats.getUploadRateKiloBitPerSec());
}
/** Tests the standard aggregation behavior */
@Test
public void testAggregation() {
AggregateSummaryStatistics aggregate = new AggregateSummaryStatistics();
SummaryStatistics setOneStats = aggregate.createContributingStatistics();
SummaryStatistics setTwoStats = aggregate.createContributingStatistics();
Assert.assertNotNull("The set one contributing stats are null", setOneStats);
Assert.assertNotNull("The set two contributing stats are null", setTwoStats);
Assert.assertNotSame("Contributing stats objects are the same", setOneStats, setTwoStats);
setOneStats.addValue(2);
setOneStats.addValue(3);
setOneStats.addValue(5);
setOneStats.addValue(7);
setOneStats.addValue(11);
Assert.assertEquals("Wrong number of set one values", 5, setOneStats.getN());
Assert.assertTrue(
"Wrong sum of set one values", Precision.equals(28.0, setOneStats.getSum(), 1));
setTwoStats.addValue(2);
setTwoStats.addValue(4);
setTwoStats.addValue(8);
Assert.assertEquals("Wrong number of set two values", 3, setTwoStats.getN());
Assert.assertTrue(
"Wrong sum of set two values", Precision.equals(14.0, setTwoStats.getSum(), 1));
Assert.assertEquals("Wrong number of aggregate values", 8, aggregate.getN());
Assert.assertTrue("Wrong aggregate sum", Precision.equals(42.0, aggregate.getSum(), 1));
}
