public void test_builder4() { RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addCurve(CURVE_NAME1, GBP, GBP_LIBOR_1M, GBP_LIBOR_3M) .build(); assertEquals(test.getName(), CurveGroupName.of("Test")); assertEquals(test.getEntries(), ImmutableList.of(ENTRY3)); assertEquals(test.findEntry(CurveName.of("Test")), Optional.of(ENTRY3)); assertEquals(test.findEntry(CurveName.of("Test2")), Optional.empty()); assertEquals(test.findEntry(CurveName.of("Rubbish")), Optional.empty()); }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 3373707: // name return ((RatesCurveGroupDefinition) bean).getName(); case -1591573360: // entries return ((RatesCurveGroupDefinition) bean).getEntries(); case -336166639: // curveDefinitions return ((RatesCurveGroupDefinition) bean).getCurveDefinitions(); case 1051792832: // seasonalityDefinitions return ((RatesCurveGroupDefinition) bean).getSeasonalityDefinitions(); case -1730091410: // computeJacobian return ((RatesCurveGroupDefinition) bean).isComputeJacobian(); case -2061625469: // computePvSensitivityToMarketQuote return ((RatesCurveGroupDefinition) bean).isComputePvSensitivityToMarketQuote(); } return super.propertyGet(bean, propertyName, quiet); }
/** * Builds a list of curve group definitions from the map of curves and their keys. * <p> * The keys specify which curve groups each curve belongs to and how it is used in the group, for example * as a discount curve for a particular currency or as a forward curve for an index. * * @param garMap the map of name to keys * @return a map of curve group name to curve group definition built from the curves */ private static ImmutableList<RatesCurveGroupDefinition> buildCurveGroups( Map<CurveName, Set<GroupAndReference>> garMap) { Multimap<CurveGroupName, RatesCurveGroupEntry> groups = LinkedHashMultimap.create(); for (Map.Entry<CurveName, Set<GroupAndReference>> entry : garMap.entrySet()) { CurveName curveName = entry.getKey(); Set<GroupAndReference> curveIds = entry.getValue(); Map<CurveGroupName, List<GroupAndReference>> idsByGroup = curveIds.stream().collect(groupingBy(p -> p.groupName)); for (Map.Entry<CurveGroupName, List<GroupAndReference>> groupEntry : idsByGroup.entrySet()) { CurveGroupName groupName = groupEntry.getKey(); List<GroupAndReference> gars = groupEntry.getValue(); groups.put(groupName, curveGroupEntry(curveName, gars)); } } return MapStream.of(groups.asMap()) .map((name, entry) -> RatesCurveGroupDefinition.of(name, entry, ImmutableList.of())) .collect(toImmutableList()); }
private static ImmutableMap<CurveGroupName, RatesCurveGroupDefinition> parse0( CharSource groupsCharSource, CharSource settingsCharSource, Map<CurveName, SeasonalityDefinition> seasonality, Collection<CharSource> curveNodeCharSources) { // load curve groups and settings List<RatesCurveGroupDefinition> curveGroups = RatesCurveGroupDefinitionCsvLoader.parseCurveGroupDefinitions(groupsCharSource); Map<CurveName, LoadedCurveSettings> settingsMap = RatesCurvesCsvLoader.parseCurveSettings(settingsCharSource); // load curve definitions List<CurveDefinition> curveDefinitions = curveNodeCharSources.stream() .flatMap(res -> parseSingle(res, settingsMap).stream()) .collect(toImmutableList()); // Add the curve definitions to the curve group definitions return curveGroups.stream() .map(groupDefinition -> groupDefinition.withCurveDefinitions(curveDefinitions).withSeasonalityDefinitions(seasonality)) .collect(toImmutableMap(groupDefinition -> groupDefinition.getName())); }
.collect(toMap(curve -> curve.getMetadata().getCurveName(), curve -> curve, (curve1, curve2) -> curve1)); for (RatesCurveGroupEntry entry : curveGroupDefinition.getEntries()) { CurveName curveName = entry.getCurveName(); Curve curve = curveMap.get(curveName); log.debug("No curve found named '{}' when building curve group '{}'", curveName, curveGroupDefinition.getName()); continue; return RatesCurveGroup.of(curveGroupDefinition.getName(), discountCurves, forwardCurves);
public void test_builder1() { RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addDiscountCurve(CURVE_DEFN1, GBP) .addForwardCurve(CURVE_DEFN1, GBP_SONIA) .addForwardCurve(CURVE_DEFN1, GBP_LIBOR_1W) .addForwardCurve(CURVE_DEFN2, GBP_LIBOR_1M, GBP_LIBOR_3M) .build(); assertEquals(test.getName(), CurveGroupName.of("Test")); assertEquals(test.getEntries(), ImmutableList.of(ENTRY1, ENTRY2)); assertEquals(test.findDiscountCurveName(GBP), Optional.of(CURVE_NAME1)); assertEquals(test.findDiscountCurveName(USD), Optional.empty()); assertEquals(test.findForwardCurveName(GBP_LIBOR_1W), Optional.of(CURVE_NAME1)); assertEquals(test.findForwardCurveName(GBP_LIBOR_1M), Optional.of(CURVE_NAME2)); assertEquals(test.findForwardCurveName(GBP_LIBOR_6M), Optional.empty()); assertEquals(test.findForwardCurveNames(GBP_LIBOR), ImmutableSet.of(CURVE_NAME1, CURVE_NAME2)); assertEquals(test.findEntry(CurveName.of("Test")), Optional.of(ENTRY1)); assertEquals(test.findEntry(CurveName.of("Test2")), Optional.of(ENTRY2)); assertEquals(test.findEntry(CurveName.of("Rubbish")), Optional.empty()); assertEquals(test.findCurveDefinition(CurveName.of("Test")), Optional.of(CURVE_DEFN1)); assertEquals(test.findCurveDefinition(CurveName.of("Test2")), Optional.of(CURVE_DEFN2)); assertEquals(test.findCurveDefinition(CurveName.of("Rubbish")), Optional.empty()); }
ImmutableMap<CurveName, JacobianCalibrationMatrix> jacobians = ImmutableMap.of(); for (RatesCurveGroupDefinition groupDefn : allGroupsDefn) { if (groupDefn.getEntries().isEmpty()) { continue; groupDefn.bindTimeSeries(knownData.getValuationDate(), knownData.getTimeSeries()); ImmutableList<ResolvedTrade> trades = groupDefnBound.resolvedTrades(marketData, refData); ImmutableList<Double> initialGuesses = groupDefnBound.initialGuesses(marketData); ImmutableList<CurveParameterSize> orderGroup = toOrder(groupDefnBound); ImmutableList<CurveParameterSize> orderPrevAndGroup = ImmutableList.<CurveParameterSize>builder() if (groupDefnBound.isComputeJacobian()) { jacobians = updateJacobiansForGroup( calibratedProvider, trades, orderGroup, orderPrev, orderPrevAndGroup, jacobians); if (groupDefnBound.isComputePvSensitivityToMarketQuote()) { ImmutableRatesProvider providerWithJacobian = providerGenerator.generate(calibratedGroupParams, jacobians); sensitivityToMarketQuote = sensitivityToMarketQuoteForGroup(providerWithJacobian, trades, orderGroup);
private void assertDefinition(RatesCurveGroupDefinition defn) { assertEquals(defn.getName(), CurveGroupName.of("Default")); assertEquals(defn.getEntries().size(), 3); assertEquals(defn.getSeasonalityDefinitions().size(), 1); assertEquals(defn.getSeasonalityDefinitions().get(CurveName.of("USD-CPI")).getAdjustmentType(), ShiftType.SCALED); RatesCurveGroupEntry entry0 = findEntry(defn, "USD-Disc"); RatesCurveGroupEntry entry1 = findEntry(defn, "USD-3ML"); RatesCurveGroupEntry entry2 = findEntry(defn, "USD-CPI"); CurveDefinition defn0 = defn.findCurveDefinition(entry0.getCurveName()).get(); CurveDefinition defn1 = defn.findCurveDefinition(entry1.getCurveName()).get(); CurveDefinition defn2 = defn.findCurveDefinition(entry2.getCurveName()).get(); assertEquals(entry0.getDiscountCurrencies(), ImmutableSet.of(Currency.USD)); assertEquals(entry0.getIndices(), ImmutableSet.of()); assertEquals(defn0.getName(), CurveName.of("USD-Disc")); assertEquals(defn0.getYValueType(), ValueType.ZERO_RATE); assertEquals(defn0.getParameterCount(), 17); assertEquals(entry1.getDiscountCurrencies(), ImmutableSet.of()); assertEquals(entry1.getIndices(), ImmutableSet.of(IborIndices.USD_LIBOR_3M)); assertEquals(defn1.getName(), CurveName.of("USD-3ML")); assertEquals(defn1.getYValueType(), ValueType.ZERO_RATE); assertEquals(defn1.getParameterCount(), 27); assertEquals(entry2.getDiscountCurrencies(), ImmutableSet.of()); assertEquals(entry2.getIndices(), ImmutableSet.of(PriceIndices.US_CPI_U)); assertEquals(defn2.getName(), CurveName.of("USD-CPI")); assertEquals(defn2.getYValueType(), ValueType.PRICE_INDEX); assertEquals(defn2.getParameterCount(), 2); }
public void test_bind() { RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addCurve(CURVE_DEFN1, GBP, GBP_LIBOR_1M, GBP_LIBOR_3M) .addForwardCurve(CURVE_DEFN_I, GB_RPI) .addSeasonality(CURVE_NAME_I, SEASONALITY_ADDITIVE_DEF) .build(); LocalDate valuationDate = LocalDate.of(2015, 11, 10); LocalDate lastFixingDate = LocalDate.of(2015, 10, 31); LocalDate otherFixingDate = LocalDate.of(2015, 9, 30); double lastFixingValue = 234.56; Map<Index, LocalDateDoubleTimeSeries> map = ImmutableMap.of(GB_RPI, LocalDateDoubleTimeSeries.builder() .put(lastFixingDate, 234.56).put(otherFixingDate, lastFixingValue - 1).build()); RatesCurveGroupDefinition testBound = test.bindTimeSeries(valuationDate, map); List<CurveDefinition> list = testBound.getCurveDefinitions(); assertEquals(list.size(), 2); assertTrue(list.get(0) instanceof InterpolatedNodalCurveDefinition); assertTrue(list.get(1) instanceof InflationNodalCurveDefinition); InflationNodalCurveDefinition seasonDef = (InflationNodalCurveDefinition) list.get(1); assertEquals(seasonDef.getCurveWithoutFixingDefinition(), CURVE_DEFN_I); assertEquals(seasonDef.getLastFixingMonth(), YearMonth.from(lastFixingDate)); assertEquals(seasonDef.getLastFixingValue(), lastFixingValue); assertEquals(seasonDef.getName(), CURVE_NAME_I); assertEquals(seasonDef.getSeasonalityDefinition(), SEASONALITY_ADDITIVE_DEF); assertEquals(seasonDef.getYValueType(), ValueType.PRICE_INDEX); }
private static ImmutableList<CurveParameterSize> toOrder(RatesCurveGroupDefinition groupDefn) { return groupDefn.getCurveDefinitions().stream().map(def -> def.toCurveParameterSize()).collect(toImmutableList()); }
for (RatesCurveGroupEntry entry : group.getEntries()) { indicesRequired.addAll(entry.getIndices()); ccyRequired.addAll(entry.getDiscountCurrencies()); ImmutableList<CurveDefinition> curveGroups = group.getCurveDefinitions();
public void test_tradesInitialGuesses() { RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addCurve(CURVE_DEFN1, GBP, GBP_LIBOR_1M, GBP_LIBOR_3M) .build(); MarketData marketData = ImmutableMarketData.of( date(2015, 6, 30), ImmutableMap.of(GBP_LIBOR_1M_ID, 0.5d, GBP_LIBOR_3M_ID, 1.5d)); Trade trade1 = NODE1.trade(1d, marketData, REF_DATA); Trade trade2 = NODE2.trade(1d, marketData, REF_DATA); assertEquals(test.getTotalParameterCount(), 2); assertEquals(test.resolvedTrades(marketData, REF_DATA), ImmutableList.of(trade1, trade2)); assertEquals(test.initialGuesses(marketData), ImmutableList.of(0.5d, 1.5d)); }
private RatesCurveGroupEntry findEntry(RatesCurveGroupDefinition defn, String curveName) { return defn.getEntries().stream().filter(d -> d.getCurveName().getName().equals(curveName)).findFirst().get(); }
/** * Obtains a generator from an existing provider and definition. * * @param knownProvider the underlying known provider * @param groupDefn the curve group definition * @param refData the reference data to use * @return the generator */ public static ImmutableRatesProviderGenerator of( ImmutableRatesProvider knownProvider, RatesCurveGroupDefinition groupDefn, ReferenceData refData) { List<CurveDefinition> curveDefns = new ArrayList<>(); List<CurveMetadata> curveMetadata = new ArrayList<>(); SetMultimap<CurveName, Currency> discountNames = HashMultimap.create(); SetMultimap<CurveName, Index> indexNames = HashMultimap.create(); for (CurveDefinition curveDefn : groupDefn.getCurveDefinitions()) { curveDefns.add(curveDefn); curveMetadata.add(curveDefn.metadata(knownProvider.getValuationDate(), refData)); CurveName curveName = curveDefn.getName(); // A curve group is guaranteed to include an entry for every definition RatesCurveGroupEntry entry = groupDefn.findEntry(curveName).get(); Set<Currency> ccy = entry.getDiscountCurrencies(); discountNames.putAll(curveName, ccy); indexNames.putAll(curveName, entry.getIndices()); } return new ImmutableRatesProviderGenerator( knownProvider, curveDefns, curveMetadata, discountNames, indexNames); }
public void coverage() { RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addDiscountCurve(CURVE_DEFN1, GBP) .build(); coverImmutableBean(test); RatesCurveGroupDefinition test2 = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test2")) .addForwardCurve(CURVE_DEFN2, GBP_LIBOR_1M) .build(); coverBeanEquals(test, test2); }
public void test_combinedWith_sameCurveNamesClash() { RatesCurveGroupDefinition base1 = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addCurve(CURVE_DEFN1, GBP, GBP_LIBOR_1M, GBP_LIBOR_3M) .addForwardCurve(CURVE_DEFN_I, GB_RPI) .build(); RatesCurveGroupDefinition base2 = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("TestX")) .addCurve(CURVE_DEFN1B, GBP, GBP_LIBOR_6M) .build(); assertThrowsIllegalArg(() -> base1.combinedWith(base2)); }
public void test_metadata() { RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addCurve(CURVE_DEFN1, GBP, GBP_LIBOR_1M, GBP_LIBOR_3M) .build(); LocalDate valuationDate = date(2015, 6, 30); CurveMetadata meta = CURVE_DEFN1.metadata(valuationDate, REF_DATA); assertEquals(test.metadata(valuationDate, REF_DATA), ImmutableList.of(meta)); }
public void test_withName() { RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addDiscountCurve(CURVE_DEFN1, GBP) .build(); RatesCurveGroupDefinition expected = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("NewName")) .addDiscountCurve(CURVE_DEFN1, GBP) .build(); RatesCurveGroupDefinition withNewName = test.withName(CurveGroupName.of("NewName")); assertEquals(withNewName, expected); } }
public void calibration_transition_coherence_par_rate() { RatesProvider provider = CALIBRATOR.calibrate(CURVE_GROUP_DEFN, ALL_QUOTES, REF_DATA); ImmutableList<ResolvedTrade> dscTrades = CURVE_GROUP_DEFN.resolvedTrades(ALL_QUOTES, REF_DATA); for (int loopnode = 0; loopnode < dscTrades.size(); loopnode++) { PointSensitivities pts = SWAP_PRICER.parRateSensitivity( ((ResolvedSwapTrade) dscTrades.get(loopnode)).getProduct(), provider).build(); CurrencyParameterSensitivities ps = provider.parameterSensitivity(pts); CurrencyParameterSensitivities mqs = MQC.sensitivity(ps, provider); assertEquals(mqs.size(), 1); CurrencyParameterSensitivity mqsDsc = mqs.getSensitivity(ALL_CURVE_NAME, BRL); assertTrue(mqsDsc.getMarketDataName().equals(ALL_CURVE_NAME)); assertTrue(mqsDsc.getCurrency().equals(BRL)); DoubleArray mqsData = mqsDsc.getSensitivity(); assertEquals(mqsData.size(), dscTrades.size()); for (int i = 0; i < mqsData.size(); i++) { assertEquals(mqsData.get(i), (i == loopnode) ? 1.0 : 0.0, TOLERANCE_DELTA); } } }
public void test_filtered() { DummyFraCurveNode node1 = DummyFraCurveNode.of(Period.ofDays(5), GBP_LIBOR_1M, GBP_LIBOR_1M_ID); DummyFraCurveNode node2 = DummyFraCurveNode.of(Period.ofDays(10), GBP_LIBOR_1M, GBP_LIBOR_1M_ID); DummyFraCurveNode node3 = DummyFraCurveNode.of(Period.ofDays(11), GBP_LIBOR_1M, GBP_LIBOR_1M_ID, DROP_THIS_2D); ImmutableList<DummyFraCurveNode> nodes = ImmutableList.of(node1, node2, node3); LocalDate valuationDate = date(2015, 6, 30); InterpolatedNodalCurveDefinition curveDefn = InterpolatedNodalCurveDefinition.builder() .name(CURVE_NAME1) .xValueType(ValueType.YEAR_FRACTION) .yValueType(ValueType.ZERO_RATE) .dayCount(ACT_365F) .nodes(nodes) .interpolator(CurveInterpolators.LINEAR) .extrapolatorLeft(CurveExtrapolators.FLAT) .extrapolatorRight(CurveExtrapolators.FLAT) .build(); RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addCurve(curveDefn, GBP, GBP_LIBOR_1M, GBP_LIBOR_3M) .build(); RatesCurveGroupDefinition expected = RatesCurveGroupDefinition.builder() .name(CurveGroupName.of("Test")) .addCurve(curveDefn.filtered(valuationDate, REF_DATA), GBP, GBP_LIBOR_1M, GBP_LIBOR_3M) .build(); assertEquals(test.filtered(valuationDate, REF_DATA), expected); }