Example #1
1
 @Override
 public HistoricalTimeSeries getHistoricalTimeSeries(
     ExternalIdBundle identifiers,
     String dataSource,
     String dataProvider,
     String dataField,
     LocalDate start,
     boolean includeStart,
     LocalDate end,
     boolean includeEnd,
     int maxPoints) {
   LocalDate resolvedStart = null;
   if (!includeStart && start != null) {
     resolvedStart = start.plusDays(1);
   } else {
     resolvedStart = start;
   }
   LocalDate resolvedEnd = null;
   if (!includeEnd && end != null) {
     resolvedEnd = end.minusDays(1);
   } else {
     resolvedEnd = end;
   }
   return doGetHistoricalTimeSeries(
       identifiers, dataSource, dataProvider, dataField, resolvedStart, resolvedEnd, maxPoints);
 }
Example #2
1
  public void testUpdateTimeSeriesAddNewLaterPointsOnly() {
    // Add the test series
    testAddTimeSeries();

    List<LocalDate> dates = ImmutableList.of(_today.plusDays(1));
    List<Double> values = ImmutableList.of(4d);
    ArrayLocalDateDoubleTimeSeries newTs = new ArrayLocalDateDoubleTimeSeries(dates, values);
    UniqueId id =
        _htsWriter.writeTimeSeries(
            DESCRIPTION,
            DATA_SOURCE,
            DATA_PROVIDER,
            DATA_FIELD,
            OBSERVATION_TIME,
            ExternalIdBundle.of(ID),
            newTs);

    ManageableHistoricalTimeSeries manageableTs = _htsMaster.getTimeSeries(id);
    LocalDateDoubleTimeSeries readTs = manageableTs.getTimeSeries();
    List<LocalDate> expectedDates =
        ImmutableList.of(_today.minusDays(2), _today.minusDays(1), _today, _today.plusDays(1));
    List<Double> expectedValues = ImmutableList.of(1d, 2d, 3d, 4d);
    ArrayLocalDateDoubleTimeSeries expectedTs =
        new ArrayLocalDateDoubleTimeSeries(expectedDates, expectedValues);
    assertEquals(expectedTs, readTs);
  }
 @Test
 public void test() {
   assertEquals(
       COUPON * DC.getDayCountFraction(D1, D2),
       DC.getAccruedInterest(D1, D2, D3, COUPON, PAYMENTS),
       0);
   assertEquals(DC.getConventionName(), "28/360");
   final LocalDate d1 = LocalDate.of(2012, 7, 2);
   final LocalDate d2 = LocalDate.of(2012, 7, 28);
   final LocalDate d3 = LocalDate.of(2012, 8, 2);
   final LocalDate d4 = LocalDate.of(2012, 8, 28);
   final LocalDate d5 = LocalDate.of(2013, 8, 2);
   final LocalDate d6 = LocalDate.of(2013, 8, 28);
   final LocalDate d7 = LocalDate.of(2012, 6, 29);
   final LocalDate d8 = LocalDate.of(2012, 7, 31);
   final LocalDate d9 = LocalDate.of(2012, 8, 31);
   final LocalDate d10 = LocalDate.of(2013, 8, 31);
   assertEquals(26. / 360, DC.getDayCountFraction(d1, d2), 0);
   assertEquals(28. / 360, DC.getDayCountFraction(d1, d3), 0);
   assertEquals(54. / 360, DC.getDayCountFraction(d1, d4), 0);
   assertEquals(1 + 28. / 360, DC.getDayCountFraction(d1, d5), 0);
   assertEquals(1 + 54. / 360, DC.getDayCountFraction(d1, d6), 0);
   assertEquals(28. / 360, DC.getDayCountFraction(d7, d2), 0);
   assertEquals(30. / 360, DC.getDayCountFraction(d7, d3), 0);
   assertEquals(56. / 360, DC.getDayCountFraction(d7, d4), 0);
   assertEquals(1 + 30. / 360, DC.getDayCountFraction(d7, d5), 0);
   assertEquals(1 + 56. / 360, DC.getDayCountFraction(d7, d6), 0);
   assertEquals(26. / 360, DC.getDayCountFraction(d1, d8), 0);
   assertEquals(28. / 360, DC.getDayCountFraction(d7, d8), 0);
   assertEquals(54. / 360, DC.getDayCountFraction(d1, d9), 0);
   assertEquals(56. / 360, DC.getDayCountFraction(d7, d9), 0);
   assertEquals(1 + 54. / 360, DC.getDayCountFraction(d1, d10), 0);
   assertEquals(1 + 56. / 360, DC.getDayCountFraction(d7, d10), 0);
 }
 @Override
 public Set<ComputedValue> execute(
     final FunctionExecutionContext executionContext,
     final FunctionInputs inputs,
     final ComputationTarget target,
     final Set<ValueRequirement> desiredValues) {
   final Object positionOrNode = getTarget(target);
   final ConventionBundleSource conventionSource =
       OpenGammaExecutionContext.getConventionBundleSource(executionContext);
   final ConventionBundle bundle =
       conventionSource.getConventionBundle(
           ExternalId.of(InMemoryConventionBundleMaster.SIMPLE_NAME_SCHEME, "USD_CAPM"));
   final Clock snapshotClock = executionContext.getValuationClock();
   final LocalDate now = snapshotClock.zonedDateTime().toLocalDate();
   final ValueRequirement desiredValue = desiredValues.iterator().next();
   final ValueProperties constraints = desiredValue.getConstraints();
   final Period samplingPeriod =
       getSamplingPeriod(constraints.getValues(ValuePropertyNames.SAMPLING_PERIOD));
   final LocalDate startDate = now.minus(samplingPeriod);
   final HistoricalTimeSeries riskFreeRateTSObject =
       (HistoricalTimeSeries) inputs.getValue(ValueRequirementNames.HISTORICAL_TIME_SERIES);
   final Object assetPnLObject =
       inputs.getValue(
           new ValueRequirement(
               ValueRequirementNames.PNL_SERIES,
               positionOrNode)); // TODO replace with return series when portfolio weights are in
   if (assetPnLObject == null) {
     throw new OpenGammaRuntimeException("Asset P&L was null");
   }
   final Object assetFairValueObject =
       inputs.getValue(new ValueRequirement(ValueRequirementNames.FAIR_VALUE, positionOrNode));
   if (assetFairValueObject == null) {
     throw new OpenGammaRuntimeException("Asset fair value was null");
   }
   final Object betaObject =
       inputs.getValue(new ValueRequirement(ValueRequirementNames.CAPM_BETA, positionOrNode));
   if (betaObject == null) {
     throw new OpenGammaRuntimeException("Beta was null");
   }
   final double beta = (Double) betaObject;
   final double fairValue = (Double) assetFairValueObject;
   DoubleTimeSeries<?> assetReturnTS = ((DoubleTimeSeries<?>) assetPnLObject).divide(fairValue);
   DoubleTimeSeries<?> riskFreeReturnTS =
       riskFreeRateTSObject.getTimeSeries().divide(100 * DAYS_PER_YEAR);
   DoubleTimeSeries<?>[] series = TimeSeriesIntersector.intersect(riskFreeReturnTS, assetReturnTS);
   riskFreeReturnTS = series[0];
   assetReturnTS = series[1];
   final TreynorRatioCalculator calculator =
       getCalculator(constraints.getValues(ValuePropertyNames.EXCESS_RETURN_CALCULATOR));
   final double ratio = calculator.evaluate(assetReturnTS, riskFreeReturnTS, beta);
   final ValueProperties resultProperties = getResultProperties(desiredValues.iterator().next());
   return Sets.newHashSet(
       new ComputedValue(
           new ValueSpecification(
               new ValueRequirement(
                   ValueRequirementNames.TREYNOR_RATIO, positionOrNode, resultProperties),
               getUniqueId()),
           ratio));
 }
 /**
  * Checks if the identifier is valid on the specified date.
  *
  * @param date the date to check for validity on, null returns true
  * @return true if valid on the specified date
  */
 public boolean isValidOn(LocalDate date) {
   if (date == null) {
     return true;
   }
   LocalDate from =
       Objects.firstNonNull(
           getValidFrom(), LocalDate.of(Year.MIN_YEAR, 1, 1)); // TODO: JSR-310 far past/future
   LocalDate to = Objects.firstNonNull(getValidTo(), LocalDate.of(Year.MAX_YEAR, 12, 31));
   return date.isBefore(from) == false && date.isAfter(to) == false;
 }
 /**
  * Returns the identifier in the form {@code <SCHEME>~<VALUE>~S~<VALID_FROM>~E~<VALID_TO>}.
  *
  * @return the identifier, not null
  */
 @Override
 public String toString() {
   StringBuilder buf = new StringBuilder(_identifier.toString());
   if (_validFrom != null) {
     buf.append("~S~").append(_validFrom.toString());
   }
   if (_validTo != null) {
     buf.append("~E~").append(_validTo.toString());
   }
   return buf.toString();
 }
 /**
  * Creates an instance.
  *
  * @param identifier the identifier, not null
  * @param validFrom the valid from date, may be null
  * @param validTo the valid to date, may be null
  */
 private ExternalIdWithDates(ExternalId identifier, LocalDate validFrom, LocalDate validTo) {
   ArgumentChecker.notNull(identifier, "identifier");
   if (validFrom != null && validTo != null) {
     ArgumentChecker.isTrue(
         validTo.isAfter(validFrom) || validTo.equals(validFrom),
         "ValidTo must be after or eqauls to ValidFrom");
   }
   _identifier = identifier;
   _validFrom = validFrom;
   _validTo = validTo;
 }
 @Test
 public void testStartAndEndSame1() {
   final LocalDate date = LocalDate.of(2001, 2, 13);
   final LocalDate[] dates = CALCULATOR.getSchedule(date, date, true, false);
   assertEquals(dates.length, 1);
   assertEquals(dates[0], date);
 }
Example #9
0
 private void processFieldData(
     Element securityElem,
     String field,
     Map<String, ExternalIdBundle> bbgSecDomainMap,
     Map<ExternalIdBundle, HistoricalTimeSeries> result) {
   String secDes = securityElem.getElementAsString(BloombergConstants.SECURITY);
   ExternalIdBundle identifiers = bbgSecDomainMap.get(secDes);
   if (identifiers == null) {
     String message =
         "Found time series data for unrecognized security" + secDes + " " + bbgSecDomainMap;
     throw new OpenGammaRuntimeException(message);
   }
   HistoricalTimeSeries hts = result.get(identifiers);
   MapLocalDateDoubleTimeSeries timeSeries;
   if (hts == null) {
     timeSeries = new MapLocalDateDoubleTimeSeries();
     hts = new SimpleHistoricalTimeSeries(UID_SUPPLIER.get(), timeSeries);
     result.put(identifiers, hts);
   } else {
     timeSeries = (MapLocalDateDoubleTimeSeries) hts.getTimeSeries();
   }
   Element fieldDataArray = securityElem.getElement(FIELD_DATA);
   int numValues = fieldDataArray.numValues();
   for (int i = 0; i < numValues; i++) {
     Element fieldData = fieldDataArray.getValueAsElement(i);
     Datetime date = fieldData.getElementAsDate("date");
     double lastPrice = fieldData.getElementAsFloat64(field);
     int year = date.year();
     int month = date.month();
     int day = date.dayOfMonth();
     timeSeries.putDataPoint(LocalDate.of(year, month, day), lastPrice);
   }
 }
 @Test
 public void test1() {
   LocalDate startDate = LocalDate.of(2000, 1, 1);
   LocalDate endDate = LocalDate.of(2000, 12, 30);
   LocalDate[] forward = CALCULATOR.getSchedule(startDate, endDate, false, true);
   assertEquals(forward.length, 1);
   assertEquals(forward[0], startDate);
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, true));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, false, false));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, false));
   startDate = LocalDate.of(2000, 1, 2);
   endDate = LocalDate.of(2000, 12, 30);
   forward = CALCULATOR.getSchedule(startDate, endDate, false, true);
   assertEquals(forward.length, 0);
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, true));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, false, false));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, false));
   startDate = LocalDate.of(2002, 2, 2);
   endDate = LocalDate.of(2003, 2, 9);
   forward = CALCULATOR.getSchedule(startDate, endDate, false, true);
   assertEquals(forward.length, 1);
   assertEquals(forward[0], LocalDate.of(2003, 1, 1));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, true));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, false, false));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, false));
   startDate = LocalDate.of(2000, 1, 1);
   endDate = LocalDate.of(2010, 2, 9);
   final int months = 11;
   forward = CALCULATOR.getSchedule(startDate, endDate, false, true);
   assertEquals(forward.length, months);
   assertEquals(forward[0], startDate);
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, true));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, false, false));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, false));
   final LocalDate lastDate = LocalDate.of(2010, 1, 1);
   assertEquals(forward[months - 1], lastDate);
   for (int i = 1; i < months; i++) {
     if (forward[i].getYear() == forward[i - 1].getYear()) {
       assertEquals(forward[i].getYear() - forward[i - 1].getYear(), 1);
       assertEquals(forward[i].getMonthOfYear().getValue(), 1);
       assertEquals(forward[i].getDayOfMonth(), 1);
     }
   }
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, true));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, false, false));
   assertArrayEquals(forward, CALCULATOR.getSchedule(startDate, endDate, true, false));
 }
public class BloombergEquityFutureOptionVolatilitySurfaceInstrumentProviderTest {
  private static final String PREFIX = "DJX";
  private static final String POSTFIX = "Index";
  private static final LocalDate DATE = LocalDate.of(2012, 5, 23);
  private static final Short[] EXPIRY_OFFSETS = new Short[] {1, 2, 8};
  private static final Double[] STRIKES = new Double[] {90.0, 145.0, 205.0};

  private static final String DATA_FIELD_NAME = "OPT_IMPLIED_VOLATILITY_MID";

  private static final String[][] RESULTS =
      new String[][] {
        new String[] {
          "DJX 06/16/12 P90.0 Index", "DJX 06/16/12 P145.0 Index", "DJX 06/16/12 C205.0 Index"
        },
        new String[] {
          "DJX 07/21/12 P90.0 Index", "DJX 07/21/12 P145.0 Index", "DJX 07/21/12 C205.0 Index"
        },
        new String[] {
          "DJX 03/16/13 P90.0 Index", "DJX 03/16/13 P145.0 Index", "DJX 03/16/13 C205.0 Index"
        }
      }; // TODO Fix date on this last one

  private static final FutureOptionExpiries UTILS =
      FutureOptionExpiries.of(new NextExpiryAdjuster(3, DayOfWeek.FRIDAY, 1));
  private static LocalDate[] EXPIRY_DATES = new LocalDate[3];
  private static final String EXCHANGE = "OSE";

  static {
    for (int i = 0; i < EXPIRY_OFFSETS.length; i++) {
      EXPIRY_DATES[i] = FutureOptionExpiries.EQUITY.getFutureOptionExpiry(EXPIRY_OFFSETS[i], DATE);
    }
  }

  private static final BloombergEquityFutureOptionVolatilitySurfaceInstrumentProvider PROVIDER =
      new BloombergEquityFutureOptionVolatilitySurfaceInstrumentProvider(
          PREFIX, POSTFIX, DATA_FIELD_NAME, 150.25, EXCHANGE);

  @Test
  public void test() {
    for (int i = 0; i < EXPIRY_OFFSETS.length; i++) {
      for (int j = 0; j < STRIKES.length; j++) {
        final String expected = RESULTS[i][j];
        final ExternalId actual = PROVIDER.getInstrument(EXPIRY_OFFSETS[i], STRIKES[j], DATE);
        assertEquals(ExternalSchemes.BLOOMBERG_TICKER_WEAK, actual.getScheme());
        assertEquals(expected, actual.getValue());
      }
    }
  }

  @Test
  public void testUtils() {
    assertEquals(EXPIRY_DATES[0], FutureOptionExpiries.EQUITY.getMonthlyExpiry(1, DATE));
    assertEquals(EXPIRY_DATES[1], FutureOptionExpiries.EQUITY.getMonthlyExpiry(2, DATE));
    assertEquals(
        EXPIRY_DATES[2],
        FutureOptionExpiries.EQUITY.getQuarterlyExpiry(
            EXPIRY_OFFSETS[2] - 6, UTILS.getMonthlyExpiry(6, DATE)));
  }
}
Example #12
0
  public void testAddTimeSeries() {
    List<LocalDate> dates = ImmutableList.of(_today.minusDays(2), _today.minusDays(1), _today);
    List<Double> values = ImmutableList.of(1d, 2d, 3d);
    ArrayLocalDateDoubleTimeSeries origTs = new ArrayLocalDateDoubleTimeSeries(dates, values);
    UniqueId id =
        _htsWriter.writeTimeSeries(
            DESCRIPTION,
            DATA_SOURCE,
            DATA_PROVIDER,
            DATA_FIELD,
            OBSERVATION_TIME,
            ExternalIdBundle.of(ID),
            origTs);

    ManageableHistoricalTimeSeries manageableTs = _htsMaster.getTimeSeries(id);
    LocalDateDoubleTimeSeries readTs = manageableTs.getTimeSeries();
    assertEquals(origTs, readTs);
  }
 public void test() {
   ManageableTrade obj = new ManageableTrade();
   obj.setUniqueId(UniqueId.of("U", "1"));
   obj.setQuantity(BigDecimal.ONE);
   obj.setSecurityLink(new ManageableSecurityLink(ExternalId.of("A", "B")));
   obj.getSecurityLink().setObjectId(ObjectId.of("O", "1"));
   obj.setTradeDate(LocalDate.of(2011, 6, 1));
   obj.setCounterpartyExternalId(ExternalId.of("C", "D"));
   testFudgeMessage(obj);
 }
 @Override
 public int hashCode() {
   final int prime = 31;
   int result = 1;
   result = prime * result + _convention.hashCode();
   result = prime * result + Arrays.hashCode(_conversionFactors);
   result = prime * result + Arrays.hashCode(_deliverableBonds);
   result = prime * result + _deliveryDate.hashCode();
   return result;
 }
 private HistoricalTimeSeries getAllowedRecentPoints(
     HistoricalTimeSeriesInfoDocument timeSeriesInfo) {
   LocalDate from = oldestTimeSeriesAllowed();
   HistoricalTimeSeries timeSeries =
       getToolContext()
           .getHistoricalTimeSeriesSource()
           .getHistoricalTimeSeries(
               timeSeriesInfo.getUniqueId().toLatest(), from, true, LocalDate.now(), true);
   return timeSeries;
 }
Example #16
0
 @Override
 public void convertValue(
     final ValueConversionContext conversionContext,
     final Object value,
     final JavaTypeInfo<?> type) {
   if ((value == null) && type.isAllowNull()) {
     conversionContext.setResult(null);
     return;
   }
   final Class<?> clazz = type.getRawClass();
   if (clazz == Value.class) {
     if (value instanceof LocalDate) {
       conversionContext.setResult(ValueUtils.of(((LocalDate) value).toString()));
     } else if (value instanceof InstantProvider) {
       conversionContext.setResult(
           ValueUtils.of((double) ((InstantProvider) value).toInstant().getEpochSeconds()));
     } else {
       conversionContext.setFail();
     }
   } else if (clazz == LocalDate.class) {
     final String str = ((Value) value).getStringValue();
     if (str != null) {
       try {
         conversionContext.setResult(LocalDate.parse(str));
       } catch (CalendricalException e) {
         conversionContext.setFail();
       }
     } else {
       conversionContext.setFail();
     }
   } else if (clazz == Instant.class) {
     final Double epochSeconds = ((Value) value).getDoubleValue();
     if (epochSeconds != null) {
       conversionContext.setResult(Instant.ofEpochSeconds(epochSeconds.longValue()));
     } else {
       conversionContext.setFail();
     }
   } else if (clazz == ZonedDateTime.class) {
     final ZonedDateTime zdt = valueToZonedDateTime((Value) value);
     if (zdt != null) {
       conversionContext.setResult(zdt);
     } else {
       conversionContext.setFail();
     }
   } else if (clazz == Expiry.class) {
     final ZonedDateTime zdt = valueToZonedDateTime((Value) value);
     if (zdt != null) {
       conversionContext.setResult(new Expiry(zdt));
     } else {
       conversionContext.setFail();
     }
   } else {
     conversionContext.setFail();
   }
 }
 @Test
 public void testRecursive1() {
   LocalDate startDate = LocalDate.of(2000, 1, 1);
   LocalDate endDate = LocalDate.of(2000, 1, 30);
   LocalDate[] forward = CALCULATOR.getSchedule(startDate, endDate, false, true);
   LocalDate[] backward = CALCULATOR.getSchedule(startDate, endDate, true, true);
   assertEquals(forward.length, 1);
   assertEquals(backward.length, 1);
   assertEquals(forward[0], startDate);
   assertEquals(backward[0], endDate);
   startDate = LocalDate.of(2002, 2, 1);
   endDate = LocalDate.of(2002, 2, 9);
   forward = CALCULATOR.getSchedule(startDate, endDate, false, true);
   backward = CALCULATOR.getSchedule(startDate, endDate, true, true);
   assertEquals(forward.length, 1);
   assertEquals(backward.length, 1);
   assertEquals(forward[0], startDate);
   assertEquals(backward[0], endDate);
   startDate = LocalDate.of(2000, 1, 1);
   endDate = LocalDate.of(2002, 2, 9);
   final int months = 26;
   forward = CALCULATOR.getSchedule(startDate, endDate, false, true);
   backward = CALCULATOR.getSchedule(startDate, endDate, true, true);
   assertEquals(forward.length, months);
   assertEquals(backward.length, months);
   assertEquals(forward[0], startDate);
   assertEquals(backward[0], LocalDate.of(2000, 1, 9));
   assertEquals(forward[months - 1], LocalDate.of(2002, 2, 1));
   assertEquals(backward[months - 1], endDate);
   for (int i = 1; i < months; i++) {
     if (forward[i].getYear() == forward[i - 1].getYear()) {
       assertEquals(
           forward[i].getMonthOfYear().getValue() - forward[i - 1].getMonthOfYear().getValue(), 1);
       assertEquals(
           backward[i].getMonthOfYear().getValue() - backward[i - 1].getMonthOfYear().getValue(),
           1);
     } else {
       assertEquals(
           forward[i].getMonthOfYear().getValue() - forward[i - 1].getMonthOfYear().getValue(),
           -11);
       assertEquals(
           backward[i].getMonthOfYear().getValue() - backward[i - 1].getMonthOfYear().getValue(),
           -11);
     }
     assertEquals(forward[i].getDayOfMonth(), 1);
     assertEquals(backward[i].getDayOfMonth(), 9);
   }
 }
 /**
  * Parses an {@code ExternalIdWithDates} from a formatted scheme and value.
  *
  * <p>This parses the identifier from the form produced by {@code toString()} which is {@code
  * <SCHEME>~<VALUE>~S~<VALID_FROM>~E~<VALID_TO>}.
  *
  * @param str the identifier to parse, not null
  * @return the identifier, not null
  * @throws IllegalArgumentException if the identifier cannot be parsed
  */
 public static ExternalIdWithDates parse(String str) {
   ArgumentChecker.notNull(str, "parse string");
   ExternalId identifier = null;
   LocalDate validFrom = null;
   LocalDate validTo = null;
   int startPos = str.indexOf("~S~");
   int endPos = str.indexOf("~E~");
   if (startPos > 0) {
     identifier = ExternalId.parse(str.substring(0, startPos));
     if (endPos > 0) {
       validFrom = LocalDate.parse(str.substring(startPos + 3, endPos));
       validTo = LocalDate.parse(str.substring(endPos + 3));
     } else {
       validFrom = LocalDate.parse(str.substring(startPos + 3));
     }
   } else if (endPos > 0) {
     identifier = ExternalId.parse(str.substring(0, endPos));
     validTo = LocalDate.parse(str.substring(endPos + 3));
   } else {
     identifier = ExternalId.parse(str);
   }
   return new ExternalIdWithDates(identifier, validFrom, validTo);
 }
Example #19
0
 protected void processFieldData(
     final Element fieldDataArray,
     String field,
     final List<LocalDate> dates,
     final List<Double> values) {
   int numValues = fieldDataArray.numValues();
   for (int i = 0; i < numValues; i++) {
     Element fieldData = fieldDataArray.getValueAsElement(i);
     Datetime date = fieldData.getElementAsDate("date");
     double fieldValue = fieldData.getElementAsFloat64(field);
     dates.add(LocalDate.of(date.year(), date.month(), date.dayOfMonth()));
     values.add(fieldValue);
   }
 }
 private HistoricalTimeSeriesInfoDocument loadTimeSeries(ExternalIdBundle idBundle) {
   ReferenceDataProvider referenceDataProvider =
       ((BloombergToolContext) getToolContext()).getBloombergReferenceDataProvider();
   if (idBundle.getExternalId(ExternalSchemes.BLOOMBERG_BUID) == null
       && idBundle.getExternalId(ExternalSchemes.BLOOMBERG_TICKER) != null) {
     // For some reason loading some series by TICKER fails, but BUID works
     BiMap<String, ExternalIdBundle> map =
         BloombergDataUtils.convertToBloombergBuidKeys(
             Collections.singleton(idBundle), referenceDataProvider);
     if (map.size() != 1) {
       throw new OpenGammaRuntimeException("Failed to get buid");
     }
     for (String key : map.keySet()) {
       ReferenceDataResult buidResult =
           referenceDataProvider.getFields(
               Collections.singleton(key),
               Collections.singleton(BloombergConstants.FIELD_ID_BBG_UNIQUE));
       String buid =
           buidResult
               .getResult(key)
               .getFieldData()
               .getString(BloombergConstants.FIELD_ID_BBG_UNIQUE);
       idBundle = idBundle.withExternalId(ExternalSchemes.bloombergTickerSecurityId(buid));
     }
   }
   ExternalIdBundle searchBundle =
       idBundle.withoutScheme(
           ExternalSchemes
               .ISIN); // For things which move country, e.g. ISIN(VALE5 BZ Equity) == ISIN(RIODF
   // US Equity)
   Map<ExternalId, UniqueId> timeSeries =
       getToolContext()
           .getHistoricalTimeSeriesLoader()
           .addTimeSeries(
               searchBundle.getExternalIds(),
               "CMPL",
               "PX_LAST",
               LocalDate.now().minusYears(1),
               null);
   if (timeSeries.size() != 1) {
     throw new OpenGammaRuntimeException(
         "Failed to load time series " + idBundle + " " + timeSeries);
   }
   for (UniqueId uid : timeSeries.values()) {
     return getToolContext().getHistoricalTimeSeriesMaster().get(uid);
   }
   throw new OpenGammaRuntimeException("Unexpected state");
 }
Example #21
0
 private static ZonedDateTime valueToZonedDateTime(final Value v) {
   final Double epochSeconds = v.getDoubleValue();
   if (epochSeconds != null) {
     return ZonedDateTime.ofEpochSeconds(epochSeconds.longValue(), TimeZone.UTC);
   } else {
     final String dateTime = v.getStringValue();
     if (dateTime != null) {
       try {
         return ZonedDateTime.parse(dateTime);
       } catch (CalendricalException e) {
         // Ignore
       }
       try {
         return ZonedDateTime.of(LocalDate.parse(dateTime), LocalTime.MIDDAY, TimeZone.UTC);
       } catch (CalendricalException e) {
         // Ignore
       }
     }
   }
   return null;
 }
Example #22
0
  @Test(enabled = false) // Current implementation does not support removing points
  public void testUpdateTimeSeriesRemoveExistingPoints() {
    // Add the test series
    testAddTimeSeries();

    List<LocalDate> dates = ImmutableList.of(_today.minusDays(2), _today);
    List<Double> values = ImmutableList.of(6d, 7d);
    ArrayLocalDateDoubleTimeSeries updatedTs = new ArrayLocalDateDoubleTimeSeries(dates, values);
    UniqueId id =
        _htsWriter.writeTimeSeries(
            DESCRIPTION,
            DATA_SOURCE,
            DATA_PROVIDER,
            DATA_FIELD,
            OBSERVATION_TIME,
            ExternalIdBundle.of(ID),
            updatedTs);

    ManageableHistoricalTimeSeries manageableTs = _htsMaster.getTimeSeries(id);
    LocalDateDoubleTimeSeries readTs = manageableTs.getTimeSeries();
    assertEquals(updatedTs, readTs);
  }
Example #23
0
  private HistoricalTimeSeries doGetHistoricalTimeSeries(
      ExternalIdBundle identifiers,
      String dataSource,
      String dataProvider,
      String field,
      LocalDate startDate,
      LocalDate endDate,
      Integer maxPoints) {
    ArgumentChecker.notNull(identifiers, "identifiers");
    ArgumentChecker.notNull(field, "field");
    ArgumentChecker.notNull(startDate, "startDate");
    ArgumentChecker.notNull(endDate, "endDate");
    Validate.isTrue(
        ObjectUtils.equals(dataSource, BLOOMBERG_DATA_SOURCE_NAME),
        getClass().getName() + "cannot support " + dataSource);

    if (maxPoints != null && maxPoints > 0) {
      throw new UnsupportedOperationException(
          "Fetching a bounded number of points from the start of a Bloomberg time-series is unsupported");
    }

    s_logger.info("Getting HistoricalTimeSeries for security {}", identifiers);

    ensureStarted();

    if (endDate.isBefore(startDate)) {
      throw new IllegalArgumentException("endDate must be after startDate");
    }
    ExternalId dsid = BloombergDomainIdentifierResolver.resolvePreferredIdentifier(identifiers);
    String bbgKey =
        BloombergDomainIdentifierResolver.toBloombergKeyWithDataProvider(dsid, dataProvider);
    Request request =
        composeRequest(bbgKey, dataSource, dataProvider, field, startDate, endDate, maxPoints);
    _statistics.gotFields(Collections.singleton(bbgKey), Collections.singleton(field));
    LocalDateDoubleTimeSeries timeSeries = processRequest(bbgKey, request, field);
    return new SimpleHistoricalTimeSeries(UID_SUPPLIER.get(), timeSeries);
  }
Example #24
0
 @BeforeMethod
 public void setup() {
   _htsMaster = new InMemoryHistoricalTimeSeriesMaster();
   _htsWriter = new HistoricalTimeSeriesMasterUtils(_htsMaster);
   _today = LocalDate.now();
 }
 private LocalDate oldestTimeSeriesAllowed() {
   return LocalDate.now().minusWeeks(1);
 }
 private LocalDate getRandomTradeDate(ExternalId ticker) {
   int tradeAge = (int) (3 + (Math.random() * 30));
   LocalDate tradeDate = LocalDate.now().minusDays(tradeAge);
   // TODO: pick a date for which PX_LAST is known
   return tradeDate;
 }
  private void spreadOptions(
      ManageablePortfolioNode bucketNode,
      Collection<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>> options,
      OptionType type,
      int scale,
      Set<ExternalId> tickersToLoad,
      BigDecimal underlyingAmount,
      boolean includeUnderlying,
      int targetNumber) {

    if (targetNumber == 0) {
      return;
    }

    Collection<BloombergTickerParserEQOption> chosen =
        new ArrayList<BloombergTickerParserEQOption>();

    int remaining = targetNumber;
    for (Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption> pair : options) {
      BloombergTickerParserEQOption option;
      if (type == OptionType.PUT) {
        option = pair.getSecond();
      } else {
        option = pair.getFirst();
      }

      // TODO [LAPANA-29] Should be able to do this for index options too
      if (includeUnderlying) {
        try {
          HistoricalTimeSeriesInfoDocument loadedTs = getOrLoadTimeSeries(option.getIdentifier());
          HistoricalTimeSeries ts =
              getToolContext()
                  .getHistoricalTimeSeriesSource()
                  .getHistoricalTimeSeries(
                      loadedTs.getUniqueId(),
                      LocalDate.now().minusWeeks(1),
                      true,
                      LocalDate.now(),
                      true);
          if (ts.getTimeSeries().isEmpty()) {
            s_logger.info("No recent time series points for " + option.getIdentifier());
            //   leave in for now
            //          continue; //This option is not liquid enough for us
          }
        } catch (Exception ex) {
          s_logger.warn("Failed to get time series for " + option.getIdentifier(), ex);
          // TODO: stop refetching this series each time
          continue; // This option is not liquid enough for us
        }
      }
      chosen.add(option);
      remaining--;
      if (remaining == 0) {
        break;
      }
    }

    if (chosen.size() == 0) {
      s_logger.warn("Couldn't find any liquid " + type + " options from " + options);
      return; // TODO: should we try another expiry?
    }
    for (BloombergTickerParserEQOption option : chosen) {
      tickersToLoad.add(option.getIdentifier());
      addPosition(
          bucketNode, BigDecimal.valueOf(scale).multiply(_numContracts), option.getIdentifier());
    }
  }
  private void addNodes(
      ManageablePortfolioNode rootNode,
      String underlying,
      boolean includeUnderlying,
      Period[] expiries) {
    ExternalId ticker = ExternalSchemes.bloombergTickerSecurityId(underlying);
    ManageableSecurity underlyingSecurity = null;
    if (includeUnderlying) {
      underlyingSecurity = getOrLoadEquity(ticker);
    }

    ExternalIdBundle bundle =
        underlyingSecurity == null
            ? ExternalIdBundle.of(ticker)
            : underlyingSecurity.getExternalIdBundle();
    HistoricalTimeSeriesInfoDocument timeSeriesInfo = getOrLoadTimeSeries(ticker, bundle);
    double estimatedCurrentStrike = getOrLoadMostRecentPoint(timeSeriesInfo);
    Set<ExternalId> optionChain = getOptionChain(ticker);

    // TODO: reuse positions/nodes?
    String longName = underlyingSecurity == null ? "" : underlyingSecurity.getName();
    String formattedName = MessageFormatter.format("[{}] {}", underlying, longName);
    ManageablePortfolioNode equityNode = new ManageablePortfolioNode(formattedName);

    BigDecimal underlyingAmount =
        VALUE_OF_UNDERLYING.divide(
            BigDecimal.valueOf(estimatedCurrentStrike), BigDecimal.ROUND_HALF_EVEN);

    if (includeUnderlying) {
      addPosition(equityNode, underlyingAmount, ticker);
    }

    TreeMap<LocalDate, Set<BloombergTickerParserEQOption>> optionsByExpiry =
        new TreeMap<LocalDate, Set<BloombergTickerParserEQOption>>();
    for (ExternalId optionTicker : optionChain) {
      s_logger.debug("Got option {}", optionTicker);

      BloombergTickerParserEQOption optionInfo =
          BloombergTickerParserEQOption.getOptionParser(optionTicker);
      s_logger.debug("Got option info {}", optionInfo);

      LocalDate key = optionInfo.getExpiry();
      Set<BloombergTickerParserEQOption> set = optionsByExpiry.get(key);
      if (set == null) {
        set = new HashSet<BloombergTickerParserEQOption>();
        optionsByExpiry.put(key, set);
      }
      set.add(optionInfo);
    }
    Set<ExternalId> tickersToLoad = new HashSet<ExternalId>();

    BigDecimal expiryCount = BigDecimal.valueOf(expiries.length);
    BigDecimal defaultAmountAtExpiry = underlyingAmount.divide(expiryCount, BigDecimal.ROUND_DOWN);
    BigDecimal spareAmountAtExpiry = defaultAmountAtExpiry.add(BigDecimal.ONE);
    int spareCount =
        underlyingAmount.subtract(defaultAmountAtExpiry.multiply(expiryCount)).intValue();

    for (int i = 0; i < expiries.length; i++) {
      Period bucketPeriod = expiries[i];

      ManageablePortfolioNode bucketNode =
          new ManageablePortfolioNode(bucketPeriod.toString().substring(1));

      LocalDate nowish =
          LocalDate.now()
              .withDayOfMonth(
                  20); // This avoids us picking different options every time this script is run
      LocalDate targetExpiry = nowish.plus(bucketPeriod);
      LocalDate chosenExpiry = optionsByExpiry.floorKey(targetExpiry);
      if (chosenExpiry == null) {
        s_logger.warn("No options for {} on {}", targetExpiry, underlying);
        continue;
      }
      s_logger.info(
          "Using time {} for bucket {} ({})",
          new Object[] {chosenExpiry, bucketPeriod, targetExpiry});

      Set<BloombergTickerParserEQOption> optionsAtExpiry = optionsByExpiry.get(chosenExpiry);
      TreeMap<Double, Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>>
          optionsByStrike =
              new TreeMap<
                  Double, Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>>();
      for (BloombergTickerParserEQOption option : optionsAtExpiry) {
        //        s_logger.info("option {}", option);
        double key = option.getStrike();
        Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption> pair =
            optionsByStrike.get(key);
        if (pair == null) {
          pair = Pair.of(null, null);
        }
        if (option.getOptionType() == OptionType.CALL) {
          pair = Pair.of(option, pair.getSecond());
        } else {
          pair = Pair.of(pair.getFirst(), option);
        }
        optionsByStrike.put(key, pair);
      }

      // cascading collar?
      BigDecimal amountAtExpiry = spareCount-- > 0 ? spareAmountAtExpiry : defaultAmountAtExpiry;

      s_logger.info(" est strike {}", estimatedCurrentStrike);
      Double[] strikes = optionsByStrike.keySet().toArray(new Double[0]);

      int strikeIndex = Arrays.binarySearch(strikes, estimatedCurrentStrike);
      if (strikeIndex < 0) {
        strikeIndex = -(1 + strikeIndex);
      }
      s_logger.info(
          "strikes length {} index {} strike of index {}",
          new Object[] {
            Integer.valueOf(strikes.length),
            Integer.valueOf(strikeIndex),
            Double.valueOf(strikes[strikeIndex])
          });

      int minIndex = strikeIndex - _numOptions;
      minIndex = Math.max(0, minIndex);
      int maxIndex = strikeIndex + _numOptions;
      maxIndex = Math.min(strikes.length - 1, maxIndex);

      s_logger.info("min {} max {}", Integer.valueOf(minIndex), Integer.valueOf(maxIndex));
      StringBuffer sb = new StringBuffer("strikes: [");
      for (int j = minIndex; j <= maxIndex; j++) {
        sb.append(" ");
        sb.append(strikes[j]);
      }
      sb.append(" ]");
      s_logger.info(sb.toString());

      // Short Calls
      ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>> calls =
          new ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>>();
      for (int j = minIndex; j < strikeIndex; j++) {
        Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption> pair =
            optionsByStrike.get(strikes[j]);
        if (pair == null) {
          throw new OpenGammaRuntimeException("no pair for strike" + strikes[j]);
        }
        calls.add(pair);
      }
      spreadOptions(
          bucketNode,
          calls,
          OptionType.CALL,
          -1,
          tickersToLoad,
          amountAtExpiry,
          includeUnderlying,
          calls.size());

      // Long Puts
      ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>> puts =
          new ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>>();
      for (int j = strikeIndex + 1; j <= maxIndex; j++) {
        Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption> pair =
            optionsByStrike.get(strikes[j]);
        if (pair == null) {
          throw new OpenGammaRuntimeException("no pair for strike" + strikes[j]);
        }
        puts.add(pair);
      }
      spreadOptions(
          bucketNode,
          puts,
          OptionType.PUT,
          1,
          tickersToLoad,
          amountAtExpiry,
          includeUnderlying,
          puts.size());

      if (bucketNode.getChildNodes().size() + bucketNode.getPositionIds().size() > 0) {
        equityNode.addChildNode(bucketNode); // Avoid generating empty nodes
      }
    }

    for (ExternalId optionTicker : tickersToLoad) {
      ManageableSecurity loaded = getOrLoadSecurity(optionTicker);
      if (loaded == null) {
        throw new OpenGammaRuntimeException("Unexpected option type " + loaded);
      }

      // TODO [LAPANA-29] Should be able to do this for index options too
      if (includeUnderlying) {
        try {
          HistoricalTimeSeriesInfoDocument loadedTs =
              getOrLoadTimeSeries(optionTicker, loaded.getExternalIdBundle());
          if (loadedTs == null) {
            throw new OpenGammaRuntimeException("Failed to get time series for " + loaded);
          }
        } catch (Exception ex) {
          s_logger.error("Failed to get time series for " + loaded, ex);
        }
      }
    }

    if (equityNode.getPositionIds().size() + equityNode.getChildNodes().size() > 0) {
      rootNode.addChildNode(equityNode);
    }
  }
/** Tests related to the construction of interest rate future security. */
public class InterestRateFutureSecurityTest {
  // EURIBOR 3M Index
  private static final Period TENOR = Period.ofMonths(3);
  private static final int SETTLEMENT_DAYS = 2;
  private static final Calendar CALENDAR = new MondayToFridayCalendar("A");
  private static final DayCount DAY_COUNT_INDEX =
      DayCountFactory.INSTANCE.getDayCount("Actual/360");
  private static final BusinessDayConvention BUSINESS_DAY =
      BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention("Modified Following");
  private static final boolean IS_EOM = true;
  private static final Currency CUR = Currency.EUR;
  private static final IborIndex IBOR_INDEX =
      new IborIndex(CUR, TENOR, SETTLEMENT_DAYS, CALENDAR, DAY_COUNT_INDEX, BUSINESS_DAY, IS_EOM);
  // Future
  private static final ZonedDateTime SPOT_LAST_TRADING_DATE = DateUtil.getUTCDate(2012, 9, 19);
  private static final ZonedDateTime LAST_TRADING_DATE =
      ScheduleCalculator.getAdjustedDate(SPOT_LAST_TRADING_DATE, CALENDAR, -SETTLEMENT_DAYS);
  private static final ZonedDateTime FIXING_END_DATE =
      ScheduleCalculator.getAdjustedDate(
          SPOT_LAST_TRADING_DATE, BUSINESS_DAY, CALENDAR, IS_EOM, TENOR);
  private static final double NOTIONAL = 1000000.0; // 1m
  private static final double FUTURE_FACTOR = 0.25;
  private static final String NAME = "ERU2";
  //  private static final InterestRateFutureSecurityDefinition ERU2 = new
  // InterestRateFutureSecurityDefinition(LAST_TRADING_DATE, IBOR_INDEX, NOTIONAL, FUTURE_FACTOR,
  // NAME);

  private static final LocalDate REFERENCE_DATE = LocalDate.of(2010, 8, 18);
  private static final DayCount ACT_ACT =
      DayCountFactory.INSTANCE.getDayCount("Actual/Actual ISDA");
  private static final ZonedDateTime REFERENCE_DATE_ZONED =
      ZonedDateTime.of(LocalDateTime.ofMidnight(REFERENCE_DATE), TimeZone.UTC);
  private static final double LAST_TRADING_TIME =
      ACT_ACT.getDayCountFraction(REFERENCE_DATE_ZONED, LAST_TRADING_DATE);
  private static final double FIXING_START_TIME =
      ACT_ACT.getDayCountFraction(REFERENCE_DATE_ZONED, SPOT_LAST_TRADING_DATE);
  private static final double FIXING_END_TIME =
      ACT_ACT.getDayCountFraction(REFERENCE_DATE_ZONED, FIXING_END_DATE);
  private static final double FIXING_ACCRUAL =
      DAY_COUNT_INDEX.getDayCountFraction(SPOT_LAST_TRADING_DATE, FIXING_END_DATE);
  private static final String DISCOUNTING_CURVE_NAME = "Funding";
  private static final String FORWARD_CURVE_NAME = "Forward";
  private static final InterestRateFutureSecurity ERU2 =
      new InterestRateFutureSecurity(
          LAST_TRADING_TIME,
          IBOR_INDEX,
          FIXING_START_TIME,
          FIXING_END_TIME,
          FIXING_ACCRUAL,
          NOTIONAL,
          FUTURE_FACTOR,
          NAME,
          DISCOUNTING_CURVE_NAME,
          FORWARD_CURVE_NAME);

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testNullIndex() {
    new InterestRateFutureSecurity(
        LAST_TRADING_TIME,
        null,
        FIXING_START_TIME,
        FIXING_END_TIME,
        FIXING_ACCRUAL,
        NOTIONAL,
        FUTURE_FACTOR,
        NAME,
        DISCOUNTING_CURVE_NAME,
        FORWARD_CURVE_NAME);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testNullName() {
    new InterestRateFutureSecurity(
        LAST_TRADING_TIME,
        IBOR_INDEX,
        FIXING_START_TIME,
        FIXING_END_TIME,
        FIXING_ACCRUAL,
        NOTIONAL,
        FUTURE_FACTOR,
        null,
        DISCOUNTING_CURVE_NAME,
        FORWARD_CURVE_NAME);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testNullDscCurve() {
    new InterestRateFutureSecurity(
        LAST_TRADING_TIME,
        IBOR_INDEX,
        FIXING_START_TIME,
        FIXING_END_TIME,
        FIXING_ACCRUAL,
        NOTIONAL,
        FUTURE_FACTOR,
        NAME,
        null,
        FORWARD_CURVE_NAME);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testNullForwardCurve() {
    new InterestRateFutureSecurity(
        LAST_TRADING_TIME,
        IBOR_INDEX,
        FIXING_START_TIME,
        FIXING_END_TIME,
        FIXING_ACCRUAL,
        NOTIONAL,
        FUTURE_FACTOR,
        NAME,
        DISCOUNTING_CURVE_NAME,
        null);
  }

  @Test
  public void getter() {
    assertEquals(LAST_TRADING_TIME, ERU2.getLastTradingTime());
    assertEquals(IBOR_INDEX, ERU2.getIborIndex());
    assertEquals(NOTIONAL, ERU2.getNotional());
    assertEquals(FUTURE_FACTOR, ERU2.getPaymentAccrualFactor());
    assertEquals(DISCOUNTING_CURVE_NAME, ERU2.getDiscountingCurveName());
    assertEquals(FORWARD_CURVE_NAME, ERU2.getForwardCurveName());
    assertEquals(NAME, ERU2.getName());
    assertEquals(FIXING_START_TIME, ERU2.getFixingPeriodStartTime());
    assertEquals(FIXING_END_TIME, ERU2.getFixingPeriodEndTime());
    assertEquals(FIXING_ACCRUAL, ERU2.getFixingPeriodAccrualFactor());
  }

  @Test
  public void equalHash() {
    assertTrue(ERU2.equals(ERU2));
    InterestRateFutureSecurity other =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertTrue(ERU2.equals(other));
    assertTrue(ERU2.hashCode() == other.hashCode());
    assertEquals(ERU2.toString(), other.toString());
    InterestRateFutureSecurity modifiedFuture;
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME - 0.01,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME + 0.01,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME + 0.01,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL + 0.01,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL + 1.0,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR + 0.25,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME + "NO",
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME + "NO");
    assertFalse(ERU2.equals(modifiedFuture));
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            IBOR_INDEX,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME + NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    IborIndex otherIndex =
        new IborIndex(
            CUR, TENOR, SETTLEMENT_DAYS, CALENDAR, DAY_COUNT_INDEX, BUSINESS_DAY, !IS_EOM);
    modifiedFuture =
        new InterestRateFutureSecurity(
            LAST_TRADING_TIME,
            otherIndex,
            FIXING_START_TIME,
            FIXING_END_TIME,
            FIXING_ACCRUAL,
            NOTIONAL,
            FUTURE_FACTOR,
            NAME,
            DISCOUNTING_CURVE_NAME,
            FORWARD_CURVE_NAME);
    assertFalse(ERU2.equals(modifiedFuture));
    assertFalse(ERU2.equals(LAST_TRADING_DATE));
    assertFalse(ERU2.equals(null));
  }
}
 private HistoricalTimeSeriesInfoDocument loadTimeSeries(
     HistoricalTimeSeriesInfoDocument timeSeriesInfo) {
   ExternalIdBundle idBundle =
       timeSeriesInfo.getInfo().getExternalIdBundle().toBundle(LocalDate.now());
   return loadTimeSeries(idBundle);
 }