@Override public FloatTimeSeries times(float factor) { final FloatTimeSeries result; synchronized (this) { result = new FloatTreeTimeSeries(this); } result.multiplyBy(factor); return result; }
@Override public final void setConstant(float value) { deleteValues(); setInterpolationMode(InterpolationMode.STEPS); addValue(Long.MIN_VALUE, new FloatValue(value)); addValue(0, new FloatValue(value)); }
/** * Apply the bi-linear operator on all points of this. Second operator input * is taken from values. Store the values in this. */ public void applyBilinearOperator(BilinearSampledValueOperator operator, ReadOnlyTimeSeries values) { // final FloatTimeSeries factors = new FloatTreeTimeSeries(values); final TimeSeriesMerger merger = new TimeSeriesMerger(this, values); // calculate the new values for this. final List<SampledValue> newValues = new ArrayList<>(merger.getTimestamps().size()); for (Long t : merger.getTimestamps()) { final SampledValue v1 = this.getValueSecure(t); final SampledValue v2 = getValueSecure(values, t); final SampledValue newValue = operator.apply(v1, v2); newValues.add(newValue); } // replace values in this with new values and set interpolation mode. deleteValues(); addValues(newValues); setInterpolationMode(merger.getInterpolationMode()); }
@Override public List<SampledValue> downsample(long t0, long t1, long minimumInterval) { List<SampledValue> newValues = new ArrayList<SampledValue>(); if (t1 < t0) return newValues; List<SampledValue> values = getValues(t0, t1); // List<SampledValue> oldValues = new ArrayList<SampledValue>(); // if (values.isEmpty() || t0 < values.get(0).getTimestamp()) { // SampledValue sv = getValue(t0); // if (sv != null) // oldValues.add(sv); // } // oldValues.addAll(values); // SampledValue sv = getValue(t1); // if (t1 > t0 && sv != null) // oldValues.add(sv); // // split into sub intervals // long lastT = Long.MIN_VALUE; // Quality lastQuality = Quality.GOOD; // InterpolationMode mode = getInterpolationMode(); // List<SampledValue> currentList = new ArrayList<SampledValue>(); // for (int i = 0;i<oldValues.size(); i++) { // SampledValue sv0 = oldValues.get(i); // long ta = sv.getTimestamp(); // Quality qual = sv.getQuality(); // if (qual != lastQuality || (qual == Quality.GOOD && t0 - lastT >= minimumInterval)) { InterpolationMode mode = getInterpolationMode(); return downsample(t0, t1, minimumInterval, values, getValue(t0), getValue(t1),mode); }
/** * Apply an operator V->V to all points in this time series. * * @param operator */ public void applyLinearOperator(LinearSampledValueOperator operator) { final SortedSet<SampledValue> values = getValues(); final List<SampledValue> newValues = new ArrayList<>(values.size()); for (SampledValue value : values) { final SampledValue newValue = operator.apply(value); newValues.add(newValue); } deleteValues(); addValues(newValues); }
throw new IllegalArgumentException("start time > endTime: " + startTime + ", " + endTime); if (schedules.isEmpty()) return new FloatTreeTimeSeries(); InterpolationMode targetMode = forcedMode; boolean allModesEqual = true; final List<SampledValue> values = genericSum(iterator, ignoreGaps, doAverage, sz, forcedMode, modes, Math.max(schedules.iterator().next().size(startTime, endTime),8)); final FloatTreeTimeSeries ts = new FloatTreeTimeSeries(); ts.addValues(values, System.currentTimeMillis()); if (generateNaNForStartEndGaps) { final SampledValue start = ts.getValue(startTime); final SampledValue end = ts.getValue(endTime); if (start == null) ts.addValue(new SampledValue(new FloatValue(Float.NaN), startTime, Quality.BAD)); if (end == null) ts.addValue(new SampledValue(new FloatValue(Float.NaN), endTime, Quality.BAD)); ts.setInterpolationMode(targetMode); return ts;
@Override public FloatTimeSeries getAbsolute() { final FloatTimeSeries result = new FloatTreeTimeSeries(); result.setInterpolationMode(getInterpolationMode()); if (getValues().isEmpty()) { return result; } if (getInterpolationMode() == InterpolationMode.LINEAR) { return getAbsoluteLinear(result); } for (SampledValue value : getValues()) { final float x = value.getValue().getFloatValue(); if (x >= 0) { result.addValue(value); } else { result.addValue(new SampledValue(new FloatValue(-x), value.getTimestamp(), value.getQuality())); } } return result; }
@Override public synchronized SampledValue getMin(long t0, long t1) { final FloatTreeTimeSeries f = new FloatTreeTimeSeries(this); f.multiplyBy(-1.f); final SampledValue negMax = f.getMax(t0, t1); return new SampledValue(new FloatValue(negMax.getValue().getFloatValue()), negMax.getTimestamp(), negMax .getQuality()); }
@Override public float getAverage(long t0, long t1) { if (t1 == t0) { SampledValue sv = getValue(t0); if (sv == null || sv.getQuality() == Quality.BAD) return Float.NaN; else return sv.getValue().getFloatValue(); } if (getInterpolationMode() == InterpolationMode.NONE) { int count = 0; float val = 0; List<SampledValue> values; if (t0 < t1) values = getValues(t0, t1); else values = getValues(t1, t0); for (SampledValue sv: values) { if (sv.getQuality() != Quality.BAD) { count++; val += sv.getValue().getFloatValue(); } } if (count == 0) return Float.NaN; else return val / count; } return integrate(t0,t1) / (t1 - t0); }
final List<SampledValue> values = getValues(t0, t1); values.add(getValue(t0)); if (dt > 1) { values.add(getValue(t1 - 1)); if (getInterpolationMode() == InterpolationMode.NEAREST) { SampledValue previous = getPreviousValue(t); if (previous != null && previous.getQuality() == Quality.GOOD) { result = getValue(maxStamp);
/** * Copy constructor. */ public FloatTreeTimeSeries(FloatTimeSeries other) { super(other.getValueType()); addValues(other.getValues(Long.MIN_VALUE)); setInterpolationMode(other.getInterpolationMode()); }
@Override public FloatTimeSeries times(ReadOnlyTimeSeries other) { final FloatTimeSeries result; synchronized (this) { result = new FloatTreeTimeSeries(this); } result.multiplyBy(other); return result; }
@Override public FloatTimeSeries plus(float addend) { final FloatTimeSeries result; synchronized (this) { result = new FloatTreeTimeSeries(this); } result.add(addend); return result; }
@Override public FloatTimeSeries plus(FloatTimeSeries other) { final FloatTimeSeries result; synchronized (this) { result = new FloatTreeTimeSeries(this); } result.add(other); return result; }
private static ReadOnlyTimeSeries deserialize(final TimeseriesDTO dto) { final TreeTimeSeries ts = new FloatTreeTimeSeries(); if (dto.values == null || dto.timestamps == null) throw new NullPointerException("Timestamps or values are null"); if (dto.values.size() != dto.timestamps.size()) throw new IllegalStateException("Nr of timestamps does not equal nr of values"); final Iterator<Long> tIt = dto.timestamps.iterator(); final Iterator<Float> vIt = dto.values.iterator(); final List<SampledValue> values = new ArrayList<>(dto.timestamps.size()); while (tIt.hasNext()) { values.add(new SampledValue(new FloatValue(vIt.next()), tIt.next(), Quality.GOOD)); } ts.addValues(values); return ts; }
public Aggregation(List<EvaluationInput> input, List<ResultType> requestedResults, Collection<ConfigurationInstance> configurations, EvaluationListener listener, long time) { super(input, requestedResults, configurations, listener, time); this.id = "AggregationEvaluation_" + counter.incrementAndGet(); final List<TimeSeriesData> list = new ArrayList<>(); list.addAll(input.iterator().next().getInputData()); this.input = Collections.unmodifiableList(list); this.inputSize = this.input.size(); values = new HashMap<>(inputSize); integrationBuffer = new HashMap<>(inputSize); intervalBuffer = new HashMap<>(inputSize); nanBuffer = new HashMap<>(inputSize); lastValues = new HashMap<>(inputSize + requestedResults.size()); for (int i=0;i<inputSize;i++) { values.put(i, requestedResults.stream() .collect(Collectors.toMap(type -> (AggregationType) type, type -> { final FloatTimeSeries ts = (FloatTimeSeries) new FloatTreeTimeSeries(); ts.setInterpolationMode(InterpolationMode.STEPS); return ts; }))); integrationBuffer.put(i, new HashMap<>(requestedResults.size())); intervalBuffer.put(i, new HashMap<>(requestedResults.size())); // lastValidValues.put(i, new HashMap<>(requestedResults.size())); nanBuffer.put(i, new HashMap<>(requestedResults.size())); } }
/** * Get a reduced set of points for the specified interval [t0,t1], obtained by downsampling * the original set to a minimum time interval between adjacent points. * @param schedule * @param t0 * @param t1 * @param minimumInterval * @return */ public static List<SampledValue> downsample(ReadOnlyTimeSeries schedule, long t0, long t1, long minimumInterval) { FloatTimeSeries fts = new FloatTreeTimeSeries(); fts.readWithBoundaries(schedule, t0, t1); return fts.downsample(t0, t1, minimumInterval); }
@Override public FloatTimeSeries times(ReadOnlyTimeSeries other) { if (isFloatTimeSeries) return ((FloatTimeSeries) input).times(other); final FloatTimeSeries result = new FloatTreeTimeSeries(); result.read(input); result.times(other); return result; }
@Override public List<TimeInterval> getPositiveDomain(TimeInterval searchInterval) { if (isFloatTimeSeries) return ((FloatTimeSeries) input).getPositiveDomain(searchInterval); final FloatTimeSeries result = new FloatTreeTimeSeries(); result.read(input); return result.getPositiveDomain(searchInterval); }
@Override public FloatTimeSeries plus(float addend) { if (isFloatTimeSeries) return ((FloatTimeSeries) input).plus(addend); final FloatTimeSeries result = new FloatTreeTimeSeries(); result.read(input); result.plus(addend); return result; }