return packedTime; Duration unitDur = unit.getDuration(); if (unitDur.getSeconds() > SECONDS_PER_DAY) { throw new UnsupportedTemporalTypeException("Unit is too large to be used for truncation");
public AggregationType(long duration, TemporalUnit unit) { Objects.requireNonNull(unit); if (duration <= 0) throw new IllegalArgumentException("Duration must be positive, got " + duration); this.duration = duration; this.unit = unit; this.hash = (int) duration * unit.hashCode(); this.totalDuration = Duration.ofMillis(unit.getDuration().toMillis() * duration); }
public StandardIntervalTimeSeries(ReadOnlyTimeSeries timeSeries, Class<?> type, TemporalUnit unit, long duration, ZoneId zoneId, InterpolationMode mode, boolean ignoreGaps, long minGapDuration) { this.timeSeries = timeSeries; this.zoneId = zoneId; this.type = type; this.unit = unit; this.duration = duration; this.mode = mode; this.totalDuration = unit.getDuration().multipliedBy(duration); this.ignoreGaps = ignoreGaps; this.minGapDuration = minGapDuration; }
/** * The total amount of time in this time period measured in seconds, the base SI unit of time. * * @return the total amount of time in this time period measured in seconds. */ public double totalSeconds() { final double nanoSecondsPerSecond = 1E9; Duration thisDuration = this.timeUnit.getDuration(); double seconds = thisDuration.getSeconds() * this.periodLength; double nanos = thisDuration.getNano(); nanos = (nanos * this.periodLength); nanos = (nanos / nanoSecondsPerSecond); return seconds + nanos; }
public ReadOnlyTimeSeries build() { return new StandardIntervalTimeSeries(timeSeries, Float.class, unit, duration, timeZone, mode, ignoreGaps, minGapDuration != null ? minGapDuration : (2L * unit.getDuration().multipliedBy(duration).toMillis())); }
private static long getNext(long time, TemporalUnit unit, long multiplier, ZoneId zoneId) { final long end; try { if (!unit.isDateBased()) end = time + unit.getDuration().multipliedBy(multiplier).toMillis(); else end = ZonedDateTime.ofInstant(Instant.ofEpochMilli(time), zoneId).plus(multiplier, unit).toInstant().toEpochMilli(); } catch (ArithmeticException e) { return multiplier > 0 ? Long.MAX_VALUE : Long.MIN_VALUE; } if (multiplier > 0 && end < time) return Long.MAX_VALUE; else if (multiplier < 0 && end > time) return Long.MIN_VALUE; return end; }
return this; Duration unitDur = unit.getDuration(); if (unitDur.getSeconds() > LocalTime.SECONDS_PER_DAY) { throw new DateTimeException("Unit is too large to be used for truncation");
@Override public EvaluationInstance newEvaluation(String id, EvaluationProvider provider, List<EvaluationInput> input, List<ResultType> requestedResults, Collection<ConfigurationInstance> configurations) { final EvaluationInstance instance = provider.newEvaluation(id, input, requestedResults, configurations); Long timestep = null; if (configurations != null) { timestep = configurations.stream() .filter(cfg -> cfg.getConfigurationType() == TimestepConfiguration.INSTANCE) .map(cfg -> { GenericDurationConfiguration durationCfg = (GenericDurationConfiguration) cfg; final long d = durationCfg.getDuration(); final String unit0 = durationCfg.getUnit(); TemporalUnit unit = ChronoUnit.MILLIS; try { unit = ChronoUnit.valueOf(unit0.toUpperCase()); } catch (Exception e) {} final long totalDuration = unit.getDuration().toMillis() * d; return totalDuration; }).findAny().orElse(null); } else { timestep = provider.requestedUpdateInterval(); } final Evaluation eval = new Evaluation(EvaluationUtils.getMultiTimeSeriesIterator(input, requestedResults, configurations, instance, timestep), instance); instance.addListener(eval); Executors.newSingleThreadExecutor().submit(eval); return instance; }
return this; Duration unitDur = unit.getDuration(); if (unitDur.getSeconds() > SECONDS_PER_DAY) { throw new DateTimeException("Unit is too large to be used for truncation");
long fromNanos = fromUnit.getDuration().toNanos(); long toNanos = toUnit.getDuration().toNanos(); if (fromNanos > toNanos) { long multiple = fromNanos / toNanos;
private final static long getAlignedIntervalStartTime(ReadOnlyTimeSeries timeSeries, long startTime, long samplingInterval, final ZoneId timeZone) { final Instant t0; if (timeSeries != null) { final SampledValue sv = timeSeries.getNextValue(startTime); if (sv == null) return startTime; t0 = Instant.ofEpochMilli(sv.getTimestamp()); } else { t0 = Instant.ofEpochMilli(startTime); } for (TemporalUnit unit :units) { if (samplingInterval == unit.getDuration().toMillis()) { if (!unit.isDateBased()) return t0.truncatedTo(unit).toEpochMilli(); else { final ZonedDateTime day = ZonedDateTime.ofInstant(t0, timeZone).truncatedTo(ChronoUnit.DAYS); final ZonedDateTime truncated; if (unit == ChronoUnit.WEEKS) truncated = day.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)); else if (unit == ChronoUnit.MONTHS) truncated = day.with(TemporalAdjusters.firstDayOfMonth()); else truncated = day.with(TemporalAdjusters.firstDayOfYear()); return truncated.toInstant().toEpochMilli(); } } } return startTime; }
return packedTime; Duration unitDur = unit.getDuration(); if (unitDur.getSeconds() > SECONDS_PER_DAY) { throw new UnsupportedTemporalTypeException("Unit is too large to be used for truncation");
case SECONDS: return plusSeconds(amountToAdd); return plusSeconds(Jdk8Methods.safeMultiply(unit.getDuration().seconds, amountToAdd)); Duration duration = unit.getDuration().multipliedBy(amountToAdd); return plusSeconds(duration.getSeconds()).plusNanos(duration.getNano());