// -------------------------------------------------------------------------
public void test_forEach() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, VALUES_10_14).build();
AtomicInteger counter = new AtomicInteger();
base.forEach((date, value) -> counter.addAndGet((int) value));
assertEquals(counter.get(), 10 + 11 + 12 + 13 + 14);
}
public void test_equals_notEqual() {
LocalDateDoubleTimeSeries series1 = LocalDateDoubleTimeSeries.of(DATE_2014_01_01, 1d);
LocalDateDoubleTimeSeries series2 = LocalDateDoubleTimeSeries.of(DATE_2013_06_01, 1d);
LocalDateDoubleTimeSeries series3 = LocalDateDoubleTimeSeries.of(DATE_2014_01_01, 3d);
assertNotEquals(series1, series2);
assertNotEquals(series1, series3);
}
// -------------------------------------------------------------------------
public void test_dateStream() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_12, VALUES_10_12).build();
LocalDate[] test = base.dates().toArray(LocalDate[]::new);
assertEquals(test[0], DATE_2010_01_01);
assertEquals(test[1], DATE_2011_01_01);
assertEquals(test[2], DATE_2012_01_01);
}
public void test_valueStream() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_12, VALUES_10_12).build();
double[] test = base.values().toArray();
assertEquals(test[0], 10, TOLERANCE);
assertEquals(test[1], 11, TOLERANCE);
assertEquals(test[2], 12, TOLERANCE);
}
// -------------------------------------------------------------------------
public void test_mapValues_addConstantToSeries() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, VALUES_10_14).build();
LocalDateDoubleTimeSeries test = base.mapValues(d -> d + 5);
List<Double> expectedValues = values(15, 16, 17, 18, 19);
assertEquals(
test, LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, expectedValues).build());
}
// -------------------------------------------------------------------------
public void test_stream() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_12, VALUES_10_12).build();
Object[] test = base.stream().toArray();
assertEquals(test[0], LocalDateDoublePoint.of(DATE_2010_01_01, 10));
assertEquals(test[1], LocalDateDoublePoint.of(DATE_2011_01_01, 11));
assertEquals(test[2], LocalDateDoublePoint.of(DATE_2012_01_01, 12));
}
public void test_mapValues_multiplySeries() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, VALUES_10_14).build();
LocalDateDoubleTimeSeries test = base.mapValues(d -> d * 5);
List<Double> expectedValues = values(50, 55, 60, 65, 70);
assertEquals(
test, LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, expectedValues).build());
}
public void test_mapValues_invertSeries() {
List<Double> values = values(1, 2, 4, 5, 8);
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, values).build();
LocalDateDoubleTimeSeries test = base.mapValues(d -> 1 / d);
List<Double> expectedValues = values(1, 0.5, 0.25, 0.2, 0.125);
assertEquals(
test, LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, expectedValues).build());
}
public void test_immutableValuesViaBeanGet() {
LocalDateDoubleTimeSeries test =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_12, VALUES_10_12).build();
double[] array = (double[]) ((Bean) test).property("values").get();
array[0] = -1;
LocalDateDoublePoint[] points = test.stream().toArray(LocalDateDoublePoint[]::new);
assertEquals(points[0], LocalDateDoublePoint.of(DATE_2010_01_01, 10d));
assertEquals(points[1], LocalDateDoublePoint.of(DATE_2011_01_01, 11d));
assertEquals(points[2], LocalDateDoublePoint.of(DATE_2012_01_01, 12d));
}
// -------------------------------------------------------------------------
public void test_combineWith_intersectionWithNoMatchingElements() {
LocalDateDoubleTimeSeries series1 =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, VALUES_10_14).build();
List<LocalDate> dates2 =
dates(DATE_2010_06_01, DATE_2011_06_01, DATE_2012_06_01, DATE_2013_06_01, DATE_2014_06_01);
LocalDateDoubleTimeSeries series2 =
LocalDateDoubleTimeSeries.builder().putAll(dates2, VALUES_10_14).build();
LocalDateDoubleTimeSeries test = series1.intersection(series2, Double::sum);
assertEquals(test, LocalDateDoubleTimeSeries.empty());
}
// -------------------------------------------------------------------------
public void test_of_singleton() {
LocalDateDoubleTimeSeries test = LocalDateDoubleTimeSeries.of(DATE_2011_01_01, 2d);
assertEquals(test.isEmpty(), false);
assertEquals(test.size(), 1);
assertEquals(test.containsDate(DATE_2010_01_01), false);
assertEquals(test.containsDate(DATE_2011_01_01), true);
assertEquals(test.containsDate(DATE_2012_01_01), false);
assertEquals(test.get(DATE_2010_01_01), OptionalDouble.empty());
assertEquals(test.get(DATE_2011_01_01), OptionalDouble.of(2d));
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.empty());
assertEquals(test.dates().toArray(), new Object[] {DATE_2011_01_01});
assertEquals(test.values().toArray(), new double[] {2d});
}
// -------------------------------------------------------------------------
public void test_immutableViaBeanBuilder() {
LocalDate[] dates = {DATE_2010_01_01, DATE_2011_01_01, DATE_2012_01_01};
double[] values = {6, 5, 4};
BeanBuilder<? extends LocalDateDoubleTimeSeries> builder =
SparseLocalDateDoubleTimeSeries.meta().builder();
builder.set("dates", dates);
builder.set("values", values);
LocalDateDoubleTimeSeries test = builder.build();
dates[0] = DATE_2012_01_01;
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_2011_01_01, 5d));
assertEquals(points[2], LocalDateDoublePoint.of(DATE_2012_01_01, 4d));
}
// -------------------------------------------------------------------------
public void test_of_map() {
Map<LocalDate, Double> map = new HashMap<>();
map.put(DATE_2011_01_01, 2d);
map.put(DATE_2012_01_01, 3d);
LocalDateDoubleTimeSeries test = LocalDateDoubleTimeSeries.builder().putAll(map).build();
assertEquals(test.isEmpty(), false);
assertEquals(test.size(), 2);
assertEquals(test.containsDate(DATE_2010_01_01), false);
assertEquals(test.containsDate(DATE_2011_01_01), true);
assertEquals(test.containsDate(DATE_2012_01_01), true);
assertEquals(test.get(DATE_2010_01_01), OptionalDouble.empty());
assertEquals(test.get(DATE_2011_01_01), OptionalDouble.of(2d));
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.of(3d));
assertEquals(test.dates().toArray(), new Object[] {DATE_2011_01_01, DATE_2012_01_01});
assertEquals(test.values().toArray(), new double[] {2d, 3d});
}
public void test_of_collection_collectionNull() {
assertThrowsIllegalArg(
() ->
LocalDateDoubleTimeSeries.builder()
.putAll(((List<LocalDateDoublePoint>) null))
.build());
}
// -------------------------------------------------------------------------
public void test_of_collectionCollection() {
Collection<LocalDate> dates = dates(DATE_2011_01_01, DATE_2012_01_01);
Collection<Double> values = values(2d, 3d);
LocalDateDoubleTimeSeries test =
LocalDateDoubleTimeSeries.builder().putAll(dates, values).build();
assertEquals(test.isEmpty(), false);
assertEquals(test.size(), 2);
assertEquals(test.containsDate(DATE_2010_01_01), false);
assertEquals(test.containsDate(DATE_2011_01_01), true);
assertEquals(test.containsDate(DATE_2012_01_01), true);
assertEquals(test.get(DATE_2010_01_01), OptionalDouble.empty());
assertEquals(test.get(DATE_2011_01_01), OptionalDouble.of(2d));
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.of(3d));
assertEquals(test.dates().toArray(), new Object[] {DATE_2011_01_01, DATE_2012_01_01});
assertEquals(test.values().toArray(), new double[] {2d, 3d});
}
public void test_of_collectionCollection_dateCollectionNull() {
Collection<Double> values = values(2d, 3d);
assertThrowsIllegalArg(
() ->
LocalDateDoubleTimeSeries.builder()
.putAll((Collection<LocalDate>) null, values)
.build());
}
// -------------------------------------------------------------------------
public void test_of_collection() {
Collection<LocalDateDoublePoint> points =
Arrays.asList(
LocalDateDoublePoint.of(DATE_2011_01_01, 2d),
LocalDateDoublePoint.of(DATE_2012_01_01, 3d));
LocalDateDoubleTimeSeries test =
LocalDateDoubleTimeSeries.builder().putAll(points.stream()).build();
assertEquals(test.isEmpty(), false);
assertEquals(test.size(), 2);
assertEquals(test.containsDate(DATE_2010_01_01), false);
assertEquals(test.containsDate(DATE_2011_01_01), true);
assertEquals(test.containsDate(DATE_2012_01_01), true);
assertEquals(test.get(DATE_2010_01_01), OptionalDouble.empty());
assertEquals(test.get(DATE_2011_01_01), OptionalDouble.of(2d));
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.of(3d));
assertEquals(test.dates().toArray(), new Object[] {DATE_2011_01_01, DATE_2012_01_01});
assertEquals(test.values().toArray(), new double[] {2d, 3d});
}
public void test_stream_withCollector() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_12, VALUES_10_12).build();
LocalDateDoubleTimeSeries test =
base.stream()
.map(point -> point.withValue(1.5d))
.collect(LocalDateDoubleTimeSeries.collector());
assertEquals(test.size(), 3);
assertEquals(test.get(DATE_2010_01_01), OptionalDouble.of(1.5));
assertEquals(test.get(DATE_2011_01_01), OptionalDouble.of(1.5));
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.of(1.5));
}
/**
* Build the time-series from the builder.
*
* @return a time-series containing the entries from the builder
*/
public LocalDateDoubleTimeSeries build() {
if (entries.isEmpty()) {
return LocalDateDoubleTimeSeries.empty();
}
// Depending on how dense the data is, judge which type of time series
// is the best fit
return density() > DENSITY_THRESHOLD ? createDenseSeries() : createSparseSeries();
}
public void test_earliestLatest_whenEmpty() {
LocalDateDoubleTimeSeries test = LocalDateDoubleTimeSeries.empty();
TestHelper.assertThrows(() -> test.getEarliestDate(), NoSuchElementException.class);
TestHelper.assertThrows(() -> test.getEarliestValue(), NoSuchElementException.class);
TestHelper.assertThrows(() -> test.getLatestDate(), NoSuchElementException.class);
TestHelper.assertThrows(() -> test.getLatestValue(), NoSuchElementException.class);
}
public void partition() {
List<LocalDate> dates =
dates(DATE_2010_01_01, DATE_2011_06_01, DATE_2012_01_01, DATE_2013_06_01, DATE_2014_01_01);
LocalDateDoubleTimeSeries series =
LocalDateDoubleTimeSeries.builder().putAll(dates, VALUES_10_14).build();
Pair<LocalDateDoubleTimeSeries, LocalDateDoubleTimeSeries> partition =
series.partition((ld, d) -> ld.getYear() % 2 == 0);
LocalDateDoubleTimeSeries even = partition.getFirst();
LocalDateDoubleTimeSeries odd = partition.getSecond();
assertThat(even.size()).isEqualTo(3);
assertThat(odd.size()).isEqualTo(2);
assertThat(even.get(DATE_2010_01_01)).hasValue(10);
assertThat(even.get(DATE_2012_01_01)).hasValue(12);
assertThat(even.get(DATE_2014_01_01)).hasValue(14);
assertThat(odd.get(DATE_2011_06_01)).hasValue(11);
assertThat(odd.get(DATE_2013_06_01)).hasValue(13);
}
public void partitionByValue() {
List<LocalDate> dates =
dates(DATE_2010_01_01, DATE_2011_06_01, DATE_2012_01_01, DATE_2013_06_01, DATE_2014_01_01);
LocalDateDoubleTimeSeries series =
LocalDateDoubleTimeSeries.builder().putAll(dates, VALUES_10_14).build();
Pair<LocalDateDoubleTimeSeries, LocalDateDoubleTimeSeries> partition =
series.partitionByValue(d -> d > 10 && d < 14);
LocalDateDoubleTimeSeries mid = partition.getFirst();
LocalDateDoubleTimeSeries extreme = partition.getSecond();
assertThat(mid.size()).isEqualTo(3);
assertThat(extreme.size()).isEqualTo(2);
assertThat(mid.get(DATE_2011_06_01)).hasValue(11);
assertThat(mid.get(DATE_2012_01_01)).hasValue(12);
assertThat(mid.get(DATE_2013_06_01)).hasValue(13);
assertThat(extreme.get(DATE_2010_01_01)).hasValue(10);
assertThat(extreme.get(DATE_2014_01_01)).hasValue(14);
}
// -------------------------------------------------------------------------
public void test_filter_byDate() {
List<LocalDate> dates =
dates(DATE_2010_01_01, DATE_2011_06_01, DATE_2012_01_01, DATE_2013_06_01, DATE_2014_01_01);
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(dates, VALUES_10_14).build();
LocalDateDoubleTimeSeries test = base.filter((ld, v) -> ld.getMonthValue() != 6);
assertEquals(test.size(), 3);
assertEquals(test.get(DATE_2010_01_01), OptionalDouble.of(10d));
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.of(12d));
assertEquals(test.get(DATE_2014_01_01), OptionalDouble.of(14d));
}
public void test_combineWith_intersectionWithSomeMatchingElements() {
LocalDateDoubleTimeSeries series1 =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, VALUES_10_14).build();
List<LocalDate> dates2 =
dates(DATE_2010_01_01, DATE_2011_06_01, DATE_2012_01_01, DATE_2013_06_01, DATE_2014_01_01);
List<Double> values2 = values(1.0, 1.1, 1.2, 1.3, 1.4);
LocalDateDoubleTimeSeries series2 =
LocalDateDoubleTimeSeries.builder().putAll(dates2, values2).build();
LocalDateDoubleTimeSeries test = series1.intersection(series2, Double::sum);
assertEquals(test.size(), 3);
assertEquals(test.get(DATE_2010_01_01), OptionalDouble.of(11.0));
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.of(13.2));
assertEquals(test.get(DATE_2014_01_01), OptionalDouble.of(15.4));
}
// -------------------------------------------------------------------------
public void test_earliestLatest() {
LocalDateDoubleTimeSeries test =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_12, VALUES_10_12).build();
assertEquals(test.getEarliestDate(), DATE_2010_01_01);
assertEquals(test.getEarliestValue(), 10d, TOLERANCE);
assertEquals(test.getLatestDate(), DATE_2012_01_01);
assertEquals(test.getLatestValue(), 12d, TOLERANCE);
}
public void test_filter_byValue() {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, VALUES_10_14).build();
LocalDateDoubleTimeSeries test = base.filter((ld, v) -> v % 2 == 1);
assertEquals(test.size(), 2);
assertEquals(test.get(DATE_2011_01_01), OptionalDouble.of(11d));
assertEquals(test.get(DATE_2013_01_01), OptionalDouble.of(13d));
}
// -------------------------------------------------------------------------
public void test_equals_similarSeriesAreEqual() {
LocalDateDoubleTimeSeries series1 = LocalDateDoubleTimeSeries.of(DATE_2014_01_01, 1d);
LocalDateDoubleTimeSeries series2 =
LocalDateDoubleTimeSeries.builder().putAll(dates(DATE_2014_01_01), values(1d)).build();
assertEquals(series1.size(), 1);
assertEquals(series1, series2);
assertEquals(series1, series1);
assertEquals(series1.hashCode(), series1.hashCode());
}
@Test(dataProvider = "tailSeries")
public void test_tailSeries(int count, int[] expected) {
LocalDateDoubleTimeSeries base =
LocalDateDoubleTimeSeries.builder().putAll(DATES_2010_14, VALUES_10_14).build();
LocalDateDoubleTimeSeries test = base.tailSeries(count);
assertEquals(test.size(), expected.length);
for (int i = 0; i < DATES_2010_14.size(); i++) {
if (Arrays.binarySearch(expected, i) >= 0) {
assertEquals(test.get(DATES_2010_14.get(i)), OptionalDouble.of(VALUES_10_14.get(i)));
} else {
assertEquals(test.get(DATES_2010_14.get(i)), OptionalDouble.empty());
}
}
}
public void test_filter_byDateAndValue() {
List<LocalDate> dates =
dates(DATE_2010_01_01, DATE_2011_06_01, DATE_2012_01_01, DATE_2013_06_01, DATE_2014_01_01);
LocalDateDoubleTimeSeries series =
LocalDateDoubleTimeSeries.builder().putAll(dates, VALUES_10_14).build();
LocalDateDoubleTimeSeries test = series.filter((ld, v) -> ld.getYear() >= 2012 && v % 2 == 0);
assertEquals(test.size(), 2);
assertEquals(test.get(DATE_2012_01_01), OptionalDouble.of(12d));
assertEquals(test.get(DATE_2014_01_01), OptionalDouble.of(14d));
}
public void test_of_singleton_nullDateDisallowed() {
assertThrowsIllegalArg(() -> LocalDateDoubleTimeSeries.of(null, 1d));
}
