@Override public LocalDateDoubleTimeSeriesBuilder toBuilder() { return new LocalDateDoubleTimeSeriesBuilder(stream()); }
@Override public LocalDateDoubleTimeSeries tailSeries(int numPoints) { ArgChecker.notNegative(numPoints, "numPoints"); if (numPoints == 0) { return LocalDateDoubleTimeSeries.empty(); } else if (numPoints > size()) { return this; } int startPoint = findTailPoints(numPoints); return new DenseLocalDateDoubleTimeSeries( calculateDateFromPosition(startPoint), Arrays.copyOfRange(points, startPoint, points.length), dateCalculation); }
@Override public LocalDateDoubleTimeSeries mapValues(DoubleUnaryOperator mapper) { DoubleStream values = DoubleStream.of(points).map(d -> isValidPoint(d) ? applyMapper(mapper, d) : d); return new DenseLocalDateDoubleTimeSeries(startDate, values.toArray(), dateCalculation, true); }
@Override public Stream<LocalDateDoublePoint> stream() { return validIndices() .mapToObj(i -> LocalDateDoublePoint.of(calculateDateFromPosition(i), points[i])); }
@Override public LocalDateDoubleTimeSeries headSeries(int numPoints) { ArgChecker.notNegative(numPoints, "numPoints"); if (numPoints == 0) { return LocalDateDoubleTimeSeries.empty(); } else if (numPoints > size()) { return this; } int endPosition = findHeadPoints(numPoints); return new DenseLocalDateDoubleTimeSeries(startDate, Arrays.copyOf(points, endPosition), dateCalculation); }
@Override public LocalDateDoubleTimeSeries subSeries(LocalDate startInclusive, LocalDate endExclusive) { ArgChecker.notNull(startInclusive, "startInclusive"); ArgChecker.notNull(endExclusive, "endExclusive"); if (endExclusive.isBefore(startInclusive)) { throw new IllegalArgumentException( "Invalid sub series, end before start: " + startInclusive + " to " + endExclusive); } // special case when this is empty or when the dates are the same // or the series don't intersect if (isEmpty() || startInclusive.equals(endExclusive) || !startDate.isBefore(endExclusive) || startInclusive.isAfter(getLatestDate())) { return LocalDateDoubleTimeSeries.empty(); } LocalDate resolvedStart = dateCalculation.adjustDate(Ordering.natural().max(startInclusive, startDate)); int startIndex = dateCalculation.calculatePosition(startDate, resolvedStart); int endIndex = dateCalculation.calculatePosition(startDate, endExclusive); return new DenseLocalDateDoubleTimeSeries( resolvedStart, Arrays.copyOfRange(points, Math.max(0, startIndex), Math.min(points.length, endIndex)), dateCalculation, true); }
public void test_immutableViaBeanBuilder() { LocalDate startDate = DATE_2010_01_01; double[] values = {6, 5, 4}; BeanBuilder<? extends DenseLocalDateDoubleTimeSeries> builder = DenseLocalDateDoubleTimeSeries.meta().builder(); builder.set("startDate", startDate); builder.set("points", values); builder.set("dateCalculation", INCLUDE_WEEKENDS); DenseLocalDateDoubleTimeSeries test = builder.build(); values[0] = -1; LocalDateDoublePoint[] points = test.stream().toArray(LocalDateDoublePoint[]::new); assertEquals(points[0], LocalDateDoublePoint.of(DATE_2010_01_01, 6d)); assertEquals(points[1], LocalDateDoublePoint.of(DATE_2010_01_02, 5d)); assertEquals(points[2], LocalDateDoublePoint.of(DATE_2010_01_03, 4d)); }
private LocalDateDoubleTimeSeries createDenseSeries() { return DenseLocalDateDoubleTimeSeries.of( entries.firstKey(), entries.lastKey(), streamEntries(), determineCalculation()); }
@Override public DenseLocalDateDoubleTimeSeries build() { return new DenseLocalDateDoubleTimeSeries( startDate, points, dateCalculation); }
@Override public boolean containsDate(LocalDate date) { return get(date).isPresent(); }
@Override public LocalDateDoubleTimeSeries mapDates(Function<? super LocalDate, ? extends LocalDate> mapper) { List<LocalDate> dates = dates().map(mapper).collect(toImmutableList()); dates.stream().reduce(this::checkAscending); return LocalDateDoubleTimeSeries.builder().putAll(dates, Doubles.asList(points)).build(); }
public void test_coverage() { TestHelper.coverImmutableBean( (ImmutableBean) DenseLocalDateDoubleTimeSeries.of(DATE_2015_01_05, DATE_2015_01_05, Stream.of(LocalDateDoublePoint.of(DATE_2015_01_05, 1d)), SKIP_WEEKENDS)); }
@Override public void forEach(ObjDoubleConsumer<LocalDate> action) { validIndices().forEach(i -> action.accept(calculateDateFromPosition(i), points[i])); }
/** * Package protected factory method intended to be called * by the {@link LocalDateDoubleTimeSeriesBuilder}. As such * all the information passed is assumed to be consistent. * * @param startDate the earliest date included in the time-series * @param endDate the latest date included in the time-series * @param values stream holding the time-series points * @param dateCalculation the date calculation method to be used * @return a new time-series */ static LocalDateDoubleTimeSeries of( LocalDate startDate, LocalDate endDate, Stream<LocalDateDoublePoint> values, DenseTimeSeriesCalculation dateCalculation) { double[] points = new double[dateCalculation.calculatePosition(startDate, endDate) + 1]; Arrays.fill(points, Double.NaN); values.forEach(pt -> points[dateCalculation.calculatePosition(startDate, pt.getDate())] = pt.getValue()); return new DenseLocalDateDoubleTimeSeries(startDate, points, dateCalculation, true); }
@Override public LocalDateDoubleTimeSeries filter(ObjDoublePredicate<LocalDate> predicate) { Stream<LocalDateDoublePoint> filteredPoints = stream().filter(pt -> predicate.test(pt.getDate(), pt.getValue())); // As we may have changed the density of the series by filtering // go via the builder to get the best implementation return new LocalDateDoubleTimeSeriesBuilder(filteredPoints).build(); }