Examples with EvictingQueue org.elasticsearch.common.collect.EvictingQueue used on opensource projects

Example 6 with EvictingQueue

use of org.elasticsearch.common.collect.EvictingQueue in project elasticsearch by elastic.

the class MovAvgUnitTests method testEWMAMovAvgModel.

public void testEWMAMovAvgModel() {
    double alpha = randomDouble();
    MovAvgModel model = new EwmaModel(alpha);
    int numValues = randomIntBetween(1, 100);
    int windowSize = randomIntBetween(1, 50);
    EvictingQueue<Double> window = new EvictingQueue<>(windowSize);
    for (int i = 0; i < numValues; i++) {
        double randValue = randomDouble();
        if (i == 0) {
            window.offer(randValue);
            continue;
        }
        double avg = 0;
        boolean first = true;
        for (double value : window) {
            if (first) {
                avg = value;
                first = false;
            } else {
                avg = (value * alpha) + (avg * (1 - alpha));
            }
        }
        double expected = avg;
        double actual = model.next(window);
        assertThat(Double.compare(expected, actual), equalTo(0));
        window.offer(randValue);
    }
}

Example 7 with EvictingQueue

use of org.elasticsearch.common.collect.EvictingQueue in project elasticsearch by elastic.

the class SerialDiffPipelineAggregator method reduce.

@Override
public InternalAggregation reduce(InternalAggregation aggregation, ReduceContext reduceContext) {
    MultiBucketsAggregation histo = (MultiBucketsAggregation) aggregation;
    List<? extends Bucket> buckets = histo.getBuckets();
    HistogramFactory factory = (HistogramFactory) histo;
    List<Bucket> newBuckets = new ArrayList<>();
    EvictingQueue<Double> lagWindow = new EvictingQueue<>(lag);
    int counter = 0;
    for (Bucket bucket : buckets) {
        Double thisBucketValue = resolveBucketValue(histo, bucket, bucketsPaths()[0], gapPolicy);
        Bucket newBucket = bucket;
        counter += 1;
        // Still under the initial lag period, add nothing and move on
        Double lagValue;
        if (counter <= lag) {
            lagValue = Double.NaN;
        } else {
            // Peek here, because we rely on add'ing to always move the window
            lagValue = lagWindow.peek();
        }
        // Normalize null's to NaN
        if (thisBucketValue == null) {
            thisBucketValue = Double.NaN;
        }
        // Both have values, calculate diff and replace the "empty" bucket
        if (!Double.isNaN(thisBucketValue) && !Double.isNaN(lagValue)) {
            double diff = thisBucketValue - lagValue;
            List<InternalAggregation> aggs = StreamSupport.stream(bucket.getAggregations().spliterator(), false).map((p) -> {
                return (InternalAggregation) p;
            }).collect(Collectors.toList());
            aggs.add(new InternalSimpleValue(name(), diff, formatter, new ArrayList<PipelineAggregator>(), metaData()));
            newBucket = factory.createBucket(factory.getKey(bucket), bucket.getDocCount(), new InternalAggregations(aggs));
        }
        newBuckets.add(newBucket);
        lagWindow.add(thisBucketValue);
    }
    return factory.createAggregation(newBuckets);
}

Example 8 with EvictingQueue

use of org.elasticsearch.common.collect.EvictingQueue in project elasticsearch by elastic.

the class MovAvgUnitTests method testLinearPredictionModel.

public void testLinearPredictionModel() {
    MovAvgModel model = new LinearModel();
    int windowSize = randomIntBetween(1, 50);
    int numPredictions = randomIntBetween(1, 50);
    EvictingQueue<Double> window = new EvictingQueue<>(windowSize);
    for (int i = 0; i < windowSize; i++) {
        window.offer(randomDouble());
    }
    double[] actual = model.predict(window, numPredictions);
    double[] expected = new double[numPredictions];
    double avg = 0;
    long totalWeight = 1;
    long current = 1;
    for (double value : window) {
        avg += value * current;
        totalWeight += current;
        current += 1;
    }
    avg = avg / totalWeight;
    Arrays.fill(expected, avg);
    for (int i = 0; i < numPredictions; i++) {
        assertThat(Double.compare(expected[i], actual[i]), equalTo(0));
    }
}

Example 9 with EvictingQueue

use of org.elasticsearch.common.collect.EvictingQueue in project elasticsearch by elastic.

the class MovAvgUnitTests method testHoltWintersAdditiveModel.

public void testHoltWintersAdditiveModel() {
    double alpha = randomDouble();
    double beta = randomDouble();
    double gamma = randomDouble();
    int period = randomIntBetween(1, 10);
    MovAvgModel model = new HoltWintersModel(alpha, beta, gamma, period, HoltWintersModel.SeasonalityType.ADDITIVE, false);
    // HW requires at least two periods of data
    int windowSize = randomIntBetween(period * 2, 50);
    EvictingQueue<Double> window = new EvictingQueue<>(windowSize);
    for (int i = 0; i < windowSize; i++) {
        window.offer(randomDouble());
    }
    // Smoothed value
    double s = 0;
    double last_s = 0;
    // Trend value
    double b = 0;
    double last_b = 0;
    // Seasonal value
    double[] seasonal = new double[windowSize];
    int counter = 0;
    double[] vs = new double[windowSize];
    for (double v : window) {
        vs[counter] = v;
        counter += 1;
    }
    // Calculate the slopes between first and second season for each period
    for (int i = 0; i < period; i++) {
        s += vs[i];
        b += (vs[i + period] - vs[i]) / period;
    }
    s /= period;
    b /= period;
    last_s = s;
    // Calculate first seasonal
    if (Double.compare(s, 0.0) == 0 || Double.compare(s, -0.0) == 0) {
        Arrays.fill(seasonal, 0.0);
    } else {
        for (int i = 0; i < period; i++) {
            seasonal[i] = vs[i] / s;
        }
    }
    for (int i = period; i < vs.length; i++) {
        s = alpha * (vs[i] - seasonal[i - period]) + (1.0d - alpha) * (last_s + last_b);
        b = beta * (s - last_s) + (1 - beta) * last_b;
        seasonal[i] = gamma * (vs[i] - (last_s - last_b)) + (1 - gamma) * seasonal[i - period];
        last_s = s;
        last_b = b;
    }
    int idx = window.size() - period + (0 % period);
    double expected = s + (1 * b) + seasonal[idx];
    double actual = model.next(window);
    assertThat(Double.compare(expected, actual), equalTo(0));
}

Example 10 with EvictingQueue

use of org.elasticsearch.common.collect.EvictingQueue in project elasticsearch by elastic.

the class MovAvgUnitTests method testHoltWintersMultiplicativePadModel.

public void testHoltWintersMultiplicativePadModel() {
    double alpha = randomDouble();
    double beta = randomDouble();
    double gamma = randomDouble();
    int period = randomIntBetween(1, 10);
    MovAvgModel model = new HoltWintersModel(alpha, beta, gamma, period, HoltWintersModel.SeasonalityType.MULTIPLICATIVE, true);
    // HW requires at least two periods of data
    int windowSize = randomIntBetween(period * 2, 50);
    EvictingQueue<Double> window = new EvictingQueue<>(windowSize);
    for (int i = 0; i < windowSize; i++) {
        window.offer(randomDouble());
    }
    // Smoothed value
    double s = 0;
    double last_s = 0;
    // Trend value
    double b = 0;
    double last_b = 0;
    // Seasonal value
    double[] seasonal = new double[windowSize];
    int counter = 0;
    double[] vs = new double[windowSize];
    for (double v : window) {
        vs[counter] = v + 0.0000000001;
        counter += 1;
    }
    // Calculate the slopes between first and second season for each period
    for (int i = 0; i < period; i++) {
        s += vs[i];
        b += (vs[i + period] - vs[i]) / period;
    }
    s /= period;
    b /= period;
    last_s = s;
    // Calculate first seasonal
    if (Double.compare(s, 0.0) == 0 || Double.compare(s, -0.0) == 0) {
        Arrays.fill(seasonal, 0.0);
    } else {
        for (int i = 0; i < period; i++) {
            seasonal[i] = vs[i] / s;
        }
    }
    for (int i = period; i < vs.length; i++) {
        s = alpha * (vs[i] / seasonal[i - period]) + (1.0d - alpha) * (last_s + last_b);
        b = beta * (s - last_s) + (1 - beta) * last_b;
        seasonal[i] = gamma * (vs[i] / (last_s + last_b)) + (1 - gamma) * seasonal[i - period];
        last_s = s;
        last_b = b;
    }
    int idx = window.size() - period + (0 % period);
    double expected = (s + (1 * b)) * seasonal[idx];
    double actual = model.next(window);
    assertThat(Double.compare(expected, actual), equalTo(0));
}