org.xbib.metrics.common.WeightedSnapshot Maven / Gradle / Ivy
package org.xbib.metrics.common;
import org.xbib.metrics.api.Snapshot;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
/**
* A statistical snapshot of a {@link WeightedSnapshot}.
*/
public class WeightedSnapshot implements Snapshot {
private final long[] values;
private final double[] normWeights;
private final double[] quantiles;
/**
* Create a new {@link Snapshot} with the given values.
*
* @param values an unordered set of values in the reservoir
*/
public WeightedSnapshot(Collection values) {
final WeightedSample[] copy = values.toArray(new WeightedSample[]{});
Arrays.sort(copy, Comparator.comparingLong(o -> o.value));
this.values = new long[copy.length];
this.normWeights = new double[copy.length];
this.quantiles = new double[copy.length];
double sumWeight = 0.0f;
for (WeightedSample sample : copy) {
sumWeight += sample.weight;
}
for (int i = 0; i < copy.length; i++) {
this.values[i] = copy[i].value;
this.normWeights[i] = safeDivide(copy[i].weight, sumWeight);
}
for (int i = 1; i < copy.length; i++) {
this.quantiles[i] = this.quantiles[i - 1] + this.normWeights[i - 1];
}
}
private static double safeDivide(double dividend, double divisor) {
if (Double.compare(divisor, Double.NaN) == 0) {
return Double.NaN;
}
if (Double.compare(dividend, Double.NaN) == 0) {
return Double.NaN;
}
if (Double.compare(divisor, 0.0) == 0) {
if (Double.compare(dividend, 0.0) == -1) {
return Double.NEGATIVE_INFINITY;
}
return Double.POSITIVE_INFINITY;
}
if (Double.compare(divisor, -0.0) == 0) {
if (Double.compare(dividend, -0.0) == 1) {
return Double.NEGATIVE_INFINITY;
}
return Double.POSITIVE_INFINITY;
}
return dividend / divisor;
}
/**
* Returns the median value in the distribution.
*
* @return the median value
*/
@Override
public double getMedian() {
return getValue(0.5);
}
/**
* Returns the value at the 75th percentile in the distribution.
*
* @return the value at the 75th percentile
*/
@Override
public double get75thPercentile() {
return getValue(0.75);
}
/**
* Returns the value at the 95th percentile in the distribution.
*
* @return the value at the 95th percentile
*/
@Override
public double get95thPercentile() {
return getValue(0.95);
}
/**
* Returns the value at the 98th percentile in the distribution.
*
* @return the value at the 98th percentile
*/
@Override
public double get98thPercentile() {
return getValue(0.98);
}
/**
* Returns the value at the 99th percentile in the distribution.
*
* @return the value at the 99th percentile
*/
@Override
public double get99thPercentile() {
return getValue(0.99);
}
/**
* Returns the value at the 99.9th percentile in the distribution.
*
* @return the value at the 99.9th percentile
*/
@Override
public double get999thPercentile() {
return getValue(0.999);
}
/**
* Returns the value at the given quantile.
*
* @param quantile a given quantile, in {@code [0..1]}
* @return the value in the distribution at {@code quantile}
*/
@Override
public double getValue(double quantile) {
if (quantile < 0.0 || quantile > 1.0 || Double.isNaN(quantile)) {
throw new IllegalArgumentException(quantile + " is not in [0..1]");
}
if (values.length == 0) {
return 0.0;
}
int posx = Arrays.binarySearch(quantiles, quantile);
if (posx < 0) {
posx = ((-posx) - 1) - 1;
}
if (posx < 1) {
return values[0];
}
if (posx >= values.length) {
return values[values.length - 1];
}
return values[posx];
}
/**
* Returns the number of values in the snapshot.
*
* @return the number of values
*/
@Override
public int size() {
return values.length;
}
/**
* Returns the entire set of values in the snapshot.
*
* @return the entire set of values
*/
@Override
public long[] getValues() {
return Arrays.copyOf(values, values.length);
}
/**
* Returns the highest value in the snapshot.
*
* @return the highest value
*/
@Override
public long getMax() {
if (values.length == 0) {
return 0;
}
return values[values.length - 1];
}
/**
* Returns the lowest value in the snapshot.
*
* @return the lowest value
*/
@Override
public long getMin() {
if (values.length == 0) {
return 0;
}
return values[0];
}
/**
* Returns the weighted arithmetic mean of the values in the snapshot.
*
* @return the weighted arithmetic mean
*/
@Override
public double getMean() {
if (values.length == 0) {
return 0;
}
double sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i] * normWeights[i];
}
return sum;
}
/**
* Returns the weighted standard deviation of the values in the snapshot.
*
* @return the weighted standard deviation value
*/
@Override
public double getStdDev() {
// two-pass algorithm for variance, avoids numeric overflow
if (values.length <= 1) {
return 0;
}
final double mean = getMean();
double variance = 0;
for (int i = 0; i < values.length; i++) {
final double diff = values[i] - mean;
variance += normWeights[i] * diff * diff;
}
return Math.sqrt(variance);
}
/**
* Writes the values of the snapshot to the given stream.
*
* @param output an output stream
*/
@Override
public void dump(OutputStream output) {
try (PrintWriter out = new PrintWriter(new OutputStreamWriter(output, StandardCharsets.UTF_8))) {
for (long value : values) {
out.printf("%d%n", value);
}
}
}
/**
* A single sample item with value and its weights for {@link WeightedSnapshot}.
*/
public static class WeightedSample {
public final long value;
public final double weight;
public WeightedSample(long value, double weight) {
this.value = value;
this.weight = weight;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy