@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; }
/** * Updates an existing time-series in the master. If the time series provided has overlaps with * the existing time series, the old versions of intersecting points will be corrected to the new * ones. After that, points later than the existing latest point of the time series will be * appended. * * @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 oId the unique identifier of the time-series to be updated, not null * @param timeSeries the time-series, not null * @return the unique identifier of the time-series */ public UniqueId writeTimeSeries( String description, String dataSource, String dataProvider, String dataField, String observationTime, ObjectId oId, LocalDateDoubleTimeSeries timeSeries) { UniqueId uId = oId.atLatestVersion(); ManageableHistoricalTimeSeries existingManageableTs = _htsMaster.getTimeSeries(uId); LocalDateDoubleTimeSeries existingTs = existingManageableTs.getTimeSeries(); if (existingTs.isEmpty()) { uId = _htsMaster.updateTimeSeriesDataPoints(oId, timeSeries); s_logger.debug( "Updating time series " + oId + "[" + dataField + "] with all as currently emtpy)"); } else { // There is a non-empty matching time-series already in the master so update it to reflect the // new time-series // 1: 'correct' any differences in the subseries already present LocalDateDoubleTimeSeries tsIntersection = timeSeries.subSeries( existingTs.getEarliestTime(), true, existingTs.getLatestTime(), true); if (!tsIntersection.equals(existingTs)) { s_logger.debug( "Correcting time series " + oId + "[" + dataField + "] from " + existingTs.getEarliestTime() + " to " + existingTs.getLatestTime()); uId = _htsMaster.correctTimeSeriesDataPoints(oId, tsIntersection); } // 2: 'update' the time-series to add any new, later points if (existingTs.getLatestTime().isBefore(timeSeries.getLatestTime())) { LocalDateDoubleTimeSeries newSeries = timeSeries.subSeries( existingTs.getLatestTime(), false, timeSeries.getLatestTime(), true); if (newSeries.size() > 0) { s_logger.debug( "Updating time series " + oId + "[" + dataField + "] from " + newSeries.getEarliestTime() + " to " + newSeries.getLatestTime()); uId = _htsMaster.updateTimeSeriesDataPoints(oId, newSeries); } } } return uId; }
/** * @param x An array of DoubleTimeSeries. If the array has only one element, then this is assumed * to be the price series and the result is the simple return. The dividend series is assumed * to be the second element. It does not have to be the same length as the price series (in * which case, dates without dividends are treated like the dividend was zero), and the * dividend data points do not have to correspond to any of the dates in the price series (in * which case, the result is the simple net return). * @throws IllegalArgumentException If the array is null * @throws TimeSeriesException Throws an exception if: the array is null; it has no elements; the * time series has less than two entries; if the calculation mode is strict and there are * zeroes in the price series. * @return A DoubleTimeSeries containing the return series. This will always be one element * shorter than the original price series. */ @Override public LocalDateDoubleTimeSeries evaluate(final LocalDateDoubleTimeSeries... x) { ArgumentChecker.notEmpty(x, "x"); ArgumentChecker.notNull(x[0], "first time series"); final LocalDateDoubleTimeSeries ts = x[0]; if (ts.size() < 2) { throw new TimeSeriesException("Need at least two data points to calculate return series"); } LocalDateDoubleTimeSeries d = null; if (x.length > 1) { if (x[1] != null) { d = x[1]; } } final int[] resultDates = new int[ts.size() - 1]; final double[] resultValues = new double[ts.size() - 1]; int resultIndex = 0; final LocalDateDoubleEntryIterator it = ts.iterator(); it.nextTimeFast(); double previousValue = it.currentValue(); double dividend; Double dividendTSData; while (it.hasNext()) { final int date = it.nextTimeFast(); final double value = it.currentValue(); if (isValueNonZero(previousValue) && isValueNonZero(value)) { resultDates[resultIndex] = date; if (d == null) { dividend = 0; } else { dividendTSData = d.getValue(date); dividend = dividendTSData == null ? 0 : dividendTSData; } resultValues[resultIndex++] = (value + dividend) / previousValue; } previousValue = value; } return getSeries(resultDates, resultValues, resultIndex); }
/** * Updates an existing time-series in the master. * * @param uniqueId the unique identifier of the time-series to be updated, not null * @param timeSeries the time-series, not null * @return the unique identifier of the time-series */ public UniqueId writeTimeSeries(UniqueId uniqueId, LocalDateDoubleTimeSeries timeSeries) { ManageableHistoricalTimeSeries existingManageableTs = _htsMaster.getTimeSeries(uniqueId); LocalDateDoubleTimeSeries existingTs = existingManageableTs.getTimeSeries(); if (existingTs.isEmpty()) { _htsMaster.updateTimeSeriesDataPoints(uniqueId, timeSeries); s_logger.debug("Updating time series " + uniqueId + " with all as currently emtpy)"); } else { // There is a matching time-series already in the master so update it to reflect the new // time-series // 1: 'correct' any differences in the subseries already present LocalDateDoubleTimeSeries tsIntersection = timeSeries.subSeries( existingTs.getEarliestTime(), true, existingTs.getLatestTime(), true); if (!tsIntersection.equals(existingTs)) { s_logger.debug( "Correcting time series " + uniqueId + " from " + existingTs.getEarliestTime() + " to " + existingTs.getLatestTime()); uniqueId = _htsMaster.correctTimeSeriesDataPoints(uniqueId.getObjectId(), tsIntersection); } // 2: 'update' the time-series to add any new, later points if (existingTs.getLatestTime().isBefore(timeSeries.getLatestTime())) { LocalDateDoubleTimeSeries newSeries = timeSeries.subSeries( existingTs.getLatestTime(), false, timeSeries.getLatestTime(), true); if (newSeries.size() > 0) { s_logger.debug( "Updating time series " + uniqueId + " from " + newSeries.getEarliestTime() + " to " + newSeries.getLatestTime()); uniqueId = _htsMaster.updateTimeSeriesDataPoints(uniqueId, newSeries); } } } return uniqueId; }
public void basicOperation() { NonVersionedRedisHistoricalTimeSeriesSource source = new NonVersionedRedisHistoricalTimeSeriesSource(getJedisPool(), getRedisPrefix()); UniqueId id1 = UniqueId.of("Test", "1"); UniqueId id2 = UniqueId.of("Test", "2"); UniqueId id3 = UniqueId.of("Test", "3"); source.setTimeSeriesPoint(id1, LocalDate.parse("2013-06-04"), 14.0); source.setTimeSeriesPoint(id1, LocalDate.parse("2013-06-05"), 15.0); source.setTimeSeriesPoint(id1, LocalDate.parse("2013-06-06"), 16.0); source.setTimeSeriesPoint(id1, LocalDate.parse("2013-06-07"), 17.0); source.setTimeSeriesPoint(id1, LocalDate.parse("2013-06-08"), 18.0); source.setTimeSeriesPoint(id2, LocalDate.parse("2013-06-04"), 24.0); source.setTimeSeriesPoint(id2, LocalDate.parse("2013-06-05"), 25.0); source.setTimeSeriesPoint(id2, LocalDate.parse("2013-06-06"), 26.0); source.setTimeSeriesPoint(id2, LocalDate.parse("2013-06-07"), 27.0); source.setTimeSeriesPoint(id2, LocalDate.parse("2013-06-08"), 28.0); source.setTimeSeriesPoint(id3, LocalDate.parse("2013-06-04"), 34.0); source.setTimeSeriesPoint(id3, LocalDate.parse("2013-06-05"), 35.0); source.setTimeSeriesPoint(id3, LocalDate.parse("2013-06-06"), 36.0); source.setTimeSeriesPoint(id3, LocalDate.parse("2013-06-07"), 37.0); source.setTimeSeriesPoint(id3, LocalDate.parse("2013-06-08"), 38.0); Pair<LocalDate, Double> pair = null; HistoricalTimeSeries hts = null; LocalDateDoubleTimeSeries ts = null; pair = source.getLatestDataPoint(id3); assertNotNull(pair); assertEquals(LocalDate.parse("2013-06-08"), pair.getFirst()); assertEquals(38.0, pair.getSecond(), 0.000001); assertNull(source.getHistoricalTimeSeries(UniqueId.of("Test", "5"))); hts = source.getHistoricalTimeSeries(id2); assertNotNull(hts); assertEquals(id2, hts.getUniqueId()); ts = hts.getTimeSeries(); assertNotNull(ts); assertEquals(5, ts.size()); assertEquals(24.0, ts.getValue(LocalDate.parse("2013-06-04")), 0.00001); assertEquals(25.0, ts.getValue(LocalDate.parse("2013-06-05")), 0.00001); assertEquals(26.0, ts.getValue(LocalDate.parse("2013-06-06")), 0.00001); assertEquals(27.0, ts.getValue(LocalDate.parse("2013-06-07")), 0.00001); assertEquals(28.0, ts.getValue(LocalDate.parse("2013-06-08")), 0.00001); hts = source.getHistoricalTimeSeries( ExternalIdBundle.of(ExternalId.of("Test", "1")), LocalDate.now(), "Data Source", "Data Provider", "Data Field"); assertNotNull(hts); assertEquals(id1, hts.getUniqueId()); ts = hts.getTimeSeries(); assertNotNull(ts); assertEquals(5, ts.size()); assertEquals(14.0, ts.getValue(LocalDate.parse("2013-06-04")), 0.00001); assertEquals(15.0, ts.getValue(LocalDate.parse("2013-06-05")), 0.00001); assertEquals(16.0, ts.getValue(LocalDate.parse("2013-06-06")), 0.00001); assertEquals(17.0, ts.getValue(LocalDate.parse("2013-06-07")), 0.00001); assertEquals(18.0, ts.getValue(LocalDate.parse("2013-06-08")), 0.00001); }