/** 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));
}
/**
* Remove the occurrence of a given value in a copied slice of array defined by the array part
* from [begin, begin+length).
*
* @param values the input array
* @param begin start index of the array to include
* @param length number of elements to include from begin
* @param removedValue the value to be removed from the sliced array
* @return the copy of the sliced array after removing the removedValue
*/
private static double[] removeAndSlice(
final double[] values, final int begin, final int length, final double removedValue) {
MathArrays.verifyValues(values, begin, length);
final double[] temp;
// BitSet(length) to indicate where the removedValue is located
final BitSet bits = new BitSet(length);
for (int i = begin; i < begin + length; i++) {
if (Precision.equalsIncludingNaN(removedValue, values[i])) {
bits.set(i - begin);
}
}
// Check if empty then create a new copy
if (bits.isEmpty()) {
temp = copyOf(values, begin, length); // Nothing removed, just copy
} else if (bits.cardinality() == length) {
temp = new double[0]; // All removed, just empty
} else { // Some removable, so new
temp = new double[length - bits.cardinality()];
int start = begin; // start index from source array (i.e values)
int dest = 0; // dest index in destination array(i.e temp)
int nextOne = -1; // nextOne is the index of bit set of next one
int bitSetPtr = 0; // bitSetPtr is start index pointer of bitset
while ((nextOne = bits.nextSetBit(bitSetPtr)) != -1) {
final int lengthToCopy = nextOne - bitSetPtr;
System.arraycopy(values, start, temp, dest, lengthToCopy);
dest += lengthToCopy;
start = begin + (bitSetPtr = bits.nextClearBit(nextOne));
}
// Copy any residue past start index till begin+length
if (start < begin + length) {
System.arraycopy(values, start, temp, dest, begin + length - start);
}
}
return temp;
}
public void checkremoval(
DescriptiveStatistics dstat, int wsize, double mean1, double mean2, double mean3) {
dstat.setWindowSize(wsize);
dstat.clear();
for (int i = 1; i <= 6; ++i) {
dstat.addValue(i);
}
Assert.assertTrue(Precision.equalsIncludingNaN(mean1, dstat.getMean()));
dstat.replaceMostRecentValue(0);
Assert.assertTrue(Precision.equalsIncludingNaN(mean2, dstat.getMean()));
dstat.removeMostRecentValue();
Assert.assertTrue(Precision.equalsIncludingNaN(mean3, dstat.getMean()));
}
/**
* Replace every occurrence of a given value with a replacement value in a copied slice of array
* defined by array part from [begin, begin+length).
*
* @param values the input array
* @param begin start index of the array to include
* @param length number of elements to include from begin
* @param original the value to be replaced with
* @param replacement the value to be used for replacement
* @return the copy of sliced array with replaced values
*/
private static double[] replaceAndSlice(
final double[] values,
final int begin,
final int length,
final double original,
final double replacement) {
final double[] temp = copyOf(values, begin, length);
for (int i = 0; i < length; i++) {
temp[i] = Precision.equalsIncludingNaN(original, temp[i]) ? replacement : temp[i];
}
return temp;
}
@Test
public void testLInfDistanceDouble() {
double[] p1 = {2.5, 0.0};
double[] p2 = {-0.5, 4.0};
Assert.assertTrue(Precision.equals(4.0, MathArrays.distanceInf(p1, p2), 1));
}
@Test
public void testL2DistanceInt() {
int[] p1 = {3, 0};
int[] p2 = {0, 4};
Assert.assertTrue(Precision.equals(5, MathArrays.distance(p1, p2), 1));
}
