@Test
 public void testReturnsWithDividendsAtDifferentTimes() {
   final int n = 20;
   final LocalDate[] times = new LocalDate[n];
   final double[] data = new double[n];
   final double[] returns = new double[n - 1];
   double random;
   for (int i = 0; i < n; i++) {
     times[i] = LocalDate.ofEpochDay(i);
     random = RANDOM.nextDouble();
     data[i] = random;
     if (i > 0) {
       returns[i - 1] = Math.log(random / data[i - 1]);
     }
   }
   final LocalDateDoubleTimeSeries dividendTS =
       ImmutableLocalDateDoubleTimeSeries.of(
           new LocalDate[] {LocalDate.ofEpochDay(300)}, new double[] {3});
   final LocalDateDoubleTimeSeries priceTS = ImmutableLocalDateDoubleTimeSeries.of(times, data);
   final LocalDateDoubleTimeSeries returnTS =
       ImmutableLocalDateDoubleTimeSeries.of(Arrays.copyOfRange(times, 1, n), returns);
   assertTrue(
       CALCULATOR
           .evaluate(new LocalDateDoubleTimeSeries[] {priceTS, dividendTS})
           .equals(returnTS));
 }
 @Test
 public void testReturnsWithZeroesInSeries() {
   final int n = 20;
   final LocalDate[] times = new LocalDate[n];
   final double[] data = new double[n];
   final double[] returns = new double[n - 3];
   double random;
   for (int i = 0; i < n - 2; i++) {
     times[i] = LocalDate.ofEpochDay(i);
     random = RANDOM.nextDouble();
     data[i] = random;
     if (i > 0) {
       returns[i - 1] = Math.log(random / data[i - 1]);
     }
   }
   times[n - 2] = LocalDate.ofEpochDay(n - 2);
   data[n - 2] = 0;
   times[n - 1] = LocalDate.ofEpochDay(n - 1);
   data[n - 1] = RANDOM.nextDouble();
   final LocalDateDoubleTimeSeries priceTS = ImmutableLocalDateDoubleTimeSeries.of(times, data);
   final LocalDateDoubleTimeSeries returnTS =
       ImmutableLocalDateDoubleTimeSeries.of(Arrays.copyOfRange(times, 1, n - 2), returns);
   final TimeSeriesReturnCalculator strict =
       new ContinuouslyCompoundedTimeSeriesReturnCalculator(CalculationMode.STRICT);
   final LocalDateDoubleTimeSeries[] tsArray = new LocalDateDoubleTimeSeries[] {priceTS};
   try {
     strict.evaluate(tsArray);
     Assert.fail();
   } catch (final TimeSeriesException e) {
     // Expected
   }
   final TimeSeriesReturnCalculator lenient =
       new ContinuouslyCompoundedTimeSeriesReturnCalculator(CalculationMode.LENIENT);
   assertTrue(lenient.evaluate(tsArray).equals(returnTS));
 }
 @Test(expectedExceptions = TimeSeriesException.class)
 public void testWithBadInputs() {
   final LocalDateDoubleTimeSeries ts =
       ImmutableLocalDateDoubleTimeSeries.of(
           new LocalDate[] {LocalDate.ofEpochDay(1)}, new double[] {4});
   CALCULATOR.evaluate(new LocalDateDoubleTimeSeries[] {ts});
 }
 @BeforeMethod
 public void setUp() {
   dates = new LocalDate[] {LocalDate.of(2012, 6, 30), LocalDate.of(2012, 7, 1)};
   values = new double[] {1.1d, 2.2d};
   ts = ImmutableLocalDateDoubleTimeSeries.of(dates, values);
   empty = ImmutableLocalDateDoubleTimeSeries.EMPTY_SERIES;
 }
 @Override
 protected LocalDateDoubleTimeSeries getReturnSeries(
     LocalDateDoubleTimeSeries ts, ValueRequirement desiredValue) {
   LocalDateDoubleTimeSeries differenceSeries = super.getReturnSeries(ts, desiredValue);
   double lambda =
       Double.parseDouble(
           desiredValue.getConstraint(
               VolatilityWeightingFunctionUtils.VOLATILITY_WEIGHTING_LAMBDA_PROPERTY));
   TimeSeriesWeightedVolatilityOperator weightedVol =
       new TimeSeriesWeightedVolatilityOperator(lambda);
   LocalDateDoubleTimeSeries weightedVolSeries =
       (LocalDateDoubleTimeSeries) weightedVol.evaluate(ts);
   int n = weightedVolSeries.size();
   double endDateWeightedVol = weightedVolSeries.getLatestValueFast();
   double[] volWeightedDifferences = new double[n];
   for (int i = 0; i < n; i++) {
     System.out.println(
         differenceSeries.getTimeAtIndex(i)
             + ","
             + differenceSeries.getValueAtIndexFast(i)
             + ","
             + weightedVolSeries.getValueAtIndexFast(i));
     volWeightedDifferences[i] =
         differenceSeries.getValueAtIndexFast(i)
             * endDateWeightedVol
             / weightedVolSeries.getValueAtIndexFast(i);
   }
   LocalDateDoubleTimeSeries volWeightedDifferenceSeries =
       ImmutableLocalDateDoubleTimeSeries.of(
           weightedVolSeries.timesArrayFast(), volWeightedDifferences);
   return volWeightedDifferenceSeries;
 }
 private static MarketDataEnvironment createSuppliedData() {
   LocalDateDoubleTimeSeries optionPrice =
       ImmutableLocalDateDoubleTimeSeries.of(VALUATION_TIME.toLocalDate(), 0.975);
   RawId<Double> optionRawId =
       RawId.of(ExternalSchemes.syntheticSecurityId("Test future option").toBundle());
   MarketDataEnvironmentBuilder builder = new MarketDataEnvironmentBuilder();
   builder.add(optionRawId, optionPrice);
   builder.add(VolatilitySurfaceId.of("TestExchange"), new VolatilitySurface(TEST_SURFACE));
   builder.valuationTime(VALUATION_TIME);
   return builder.build();
 }
 /**
  * Adds or updates a time-series in the master. Will not "erase" any existing point, just used to
  * add a new point.
  *
  * @param description a description of the time-series for display purposes, not null
  * @param dataSource the data source, not null
  * @param dataProvider the data provider, not null
  * @param dataField the data field, not null
  * @param observationTime the descriptive observation time key, e.g. LONDON_CLOSE, not null
  * @param externalIdBundle the external identifiers with which the time-series is associated, not
  *     null
  * @param date the date, not null
  * @param value the value, not null
  * @return the unique identifier of the time-series
  */
 public UniqueId writeTimeSeriesPoint(
     String description,
     String dataSource,
     String dataProvider,
     String dataField,
     String observationTime,
     ExternalIdBundle externalIdBundle,
     LocalDate date,
     double value) {
   LocalDateDoubleTimeSeries ts = ImmutableLocalDateDoubleTimeSeries.of(date, value);
   return writeTimeSeries(
       description, dataSource, dataProvider, dataField, observationTime, externalIdBundle, ts);
 }