private RatesCurveGroupDefinitionBuilder merge(RatesCurveGroupEntry newEntry, CurveDefinition curveDefinition) { curveDefinitions.put(curveDefinition.getName(), curveDefinition); return mergeEntry(newEntry); }
/** * Creates a list of trades representing the instrument at each node. * <p> * This uses the observed market data to build the trade that each node represents. * The result combines the list of trades from each curve in order. * Each trade is created with a quantity of 1. * The valuation date is defined by the market data. * * @param marketData the market data required to build a trade for the instrument, including the valuation date * @param refData the reference data, used to resolve the trades * @return the list of all trades */ public ImmutableList<ResolvedTrade> resolvedTrades(MarketData marketData, ReferenceData refData) { return curveDefinitionsByName.values().stream() .flatMap(curveDef -> curveDef.getNodes().stream()) .map(node -> node.resolvedTrade(1d, marketData, refData)) .collect(toImmutableList()); }
/** * Converts this definition to the summary form. * <p> * The {@link CurveParameterSize} class provides a summary of this definition * consisting of the name and parameter size. * * @return the summary form */ public default CurveParameterSize toCurveParameterSize() { return CurveParameterSize.of(getName(), getParameterCount()); }
ImmutableList.Builder<CurveParameterSize> builder = ImmutableList.builder(); for (CurveDefinition entry : curveGroups) { ImmutableList<CurveNode> nodes = entry.getNodes(); List<Trade> tradesCurve = new ArrayList<>(); List<ResolvedTrade> resolvedTradesCurve = new ArrayList<>(); resolvedTradesCurve.add(node.resolvedTrade(1d, MARKET_QUOTES, REF_DATA)); trades.put(entry.getName(), tradesCurve); resolvedTrades.put(entry.getName(), resolvedTradesCurve); builder.add(entry.toCurveParameterSize());
CurveDefinition curveDefn = curveDefinitions.get(i); CurveMetadata metadata = curveMetadata.get(i); CurveName name = curveDefn.getName(); int paramCount = curveDefn.getParameterCount(); DoubleArray curveParams = parameters.subArray(startIndex, startIndex + paramCount); startIndex += paramCount; Curve curve = curveDefn.curve(knownProvider.getValuationDate(), childMetadata, curveParams);
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); }
/** * 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); }
/** * Gets the total number of parameters in the group. * <p> * This returns the total number of parameters in the group, which equals the number of nodes. * The result of {@link #resolvedTrades(MarketData, ReferenceData)}, and * {@link #initialGuesses(MarketData)} will be of this size. * * @return the number of parameters */ public int getTotalParameterCount() { return curveDefinitionsByName.entrySet().stream().mapToInt(entry -> entry.getValue().getParameterCount()).sum(); }
/** * Creates the curve metadata for each definition. * <p> * This method returns a list of metadata, one for each curve definition. * * @param valuationDate the valuation date * @param refData the reference data * @return the metadata */ public ImmutableList<CurveMetadata> metadata(LocalDate valuationDate, ReferenceData refData) { return curveDefinitionsByName.values().stream() .map(curveDef -> curveDef.metadata(valuationDate, refData)) .collect(toImmutableList()); }
private static ImmutableList<CurveParameterSize> toOrder(RatesCurveGroupDefinition groupDefn) { return groupDefn.getCurveDefinitions().stream().map(def -> def.toCurveParameterSize()).collect(toImmutableList()); }
/** * Returns a filtered version of this definition with no invalid nodes. * <p> * A curve is formed of a number of nodes, each of which has an associated date. * To be valid, the curve node dates must be in order from earliest to latest. * This method applies rules to remove invalid nodes. * * @param valuationDate the valuation date * @param refData the reference data * @return the resolved definition, that should be used in preference to this one * @throws IllegalArgumentException if the curve nodes are invalid */ public RatesCurveGroupDefinition filtered(LocalDate valuationDate, ReferenceData refData) { List<CurveDefinition> filtered = curveDefinitions.stream() .map(ncd -> ncd.filtered(valuationDate, refData)) .collect(toImmutableList()); return new RatesCurveGroupDefinition( name, entries, filtered, seasonalityDefinitions, computeJacobian, computePvSensitivityToMarketQuote); }
private CurveMetadata childMetadata( CurveMetadata metadata, CurveDefinition curveDefn, Map<CurveName, JacobianCalibrationMatrix> jacobians, Map<CurveName, DoubleArray> sensitivitiesMarketQuote) { JacobianCalibrationMatrix jacobian = jacobians.get(curveDefn.getName()); CurveMetadata metadataResult = metadata; if (jacobian != null) { metadataResult = metadata.withInfo(CurveInfoType.JACOBIAN, jacobian); } DoubleArray sensitivity = sensitivitiesMarketQuote.get(curveDefn.getName()); if (sensitivity != null) { metadataResult = metadataResult.withInfo(CurveInfoType.PV_SENSITIVITY_TO_MARKET_QUOTE, sensitivity); } return metadataResult; }
ImmutableList<CurveNode> nodes = entry.getNodes(); for (int i = 0; i < nodes.size(); i++) { for (MarketDataId<?> key : nodes.get(i).requirements()) { ImmutableList<CurveNode> nodes = entry.getNodes(); for (CurveNode node : nodes) { ResolvedTrade trade = node.resolvedTrade(1d, marketQuotes0, refData);
/** * Returns a copy of this object containing the specified curve definitions. * <p> * Curves are ignored if there is no entry in this definition with the same curve name. * * @param curveDefinitions curve definitions * @return a copy of this object containing the specified curve definitions */ public RatesCurveGroupDefinition withCurveDefinitions(List<CurveDefinition> curveDefinitions) { Set<CurveName> curveNames = entries.stream().map(entry -> entry.getCurveName()).collect(toSet()); List<CurveDefinition> filteredDefinitions = curveDefinitions.stream().filter(def -> curveNames.contains(def.getName())).collect(toImmutableList()); return new RatesCurveGroupDefinition( name, entries, filteredDefinitions, seasonalityDefinitions, computeJacobian, computePvSensitivityToMarketQuote); }
public void check_pv_with_measures() { ImmutableRatesProvider multicurve = CALIBRATOR.calibrate(GROUP_DEFINITION, MARKET_QUOTES, REF_DATA); // the trades used for calibration List<ResolvedTrade> trades = new ArrayList<>(); ImmutableList<CurveDefinition> curveGroups = GROUP_DEFINITION.getCurveDefinitions(); for (CurveDefinition entry : curveGroups) { ImmutableList<CurveNode> nodes = entry.getNodes(); for (CurveNode node : nodes) { trades.add(node.resolvedTrade(1d, MARKET_QUOTES, REF_DATA)); } } // Check PV = 0 for (ResolvedTrade trade : trades) { double pv = PV_MEASURES.value(trade, multicurve); assertEquals(pv, 0.0, TOLERANCE_PV); } }
ImmutableList<CurveNode> dscNodes = definitions.get(0).getNodes(); List<ResolvedTrade> dscTrades = new ArrayList<>(); for (int i = 0; i < dscNodes.size(); i++) { ImmutableList<CurveNode> fwd3Nodes = definitions.get(1).getNodes(); List<ResolvedTrade> fwd3Trades = new ArrayList<>(); for (int i = 0; i < fwd3Nodes.size(); i++) { ImmutableList<CurveNode> fwd6Nodes = definitions.get(2).getNodes(); List<ResolvedTrade> fwd6Trades = new ArrayList<>(); for (int i = 0; i < fwd6Nodes.size(); i++) {
/** * Package-private constructor used by the builder. * * @param name the name of the curve group * @param entries details of the curves in the group * @param curveDefinitions definitions which specify how the curves are calibrated */ @ImmutableConstructor RatesCurveGroupDefinition( CurveGroupName name, Collection<RatesCurveGroupEntry> entries, Collection<? extends CurveDefinition> curveDefinitions, Map<CurveName, SeasonalityDefinition> seasonalityDefinitions, boolean computeJacobian, boolean computePvSensitivityToMarketQuote) { this.name = ArgChecker.notNull(name, "name"); this.entries = ImmutableList.copyOf(entries); this.curveDefinitions = ImmutableList.copyOf(curveDefinitions); this.entriesByName = entries.stream().collect(toImmutableMap(entry -> entry.getCurveName(), entry -> entry)); this.curveDefinitionsByName = curveDefinitions.stream().collect(toImmutableMap(def -> def.getName(), def -> def)); this.computeJacobian = computeJacobian; this.computePvSensitivityToMarketQuote = computePvSensitivityToMarketQuote; this.seasonalityDefinitions = ImmutableMap.copyOf(seasonalityDefinitions); validate(); }
public void calibrate_ts_empty() { MarketData mad = CALIBRATOR_SYNTHETIC.marketData(GROUPS_SYN_EUR, MULTICURVE_INPUT_EUR_TSEMPTY, REF_DATA); RatesProvider multicurveSyn = CALIBRATOR_SYNTHETIC.calibrate(GROUPS_SYN_EUR, MULTICURVE_INPUT_EUR_TSEMPTY, REF_DATA); for (CurveDefinition entry : GROUPS_SYN_EUR.getCurveDefinitions()) { ImmutableList<CurveNode> nodes = entry.getNodes(); for (CurveNode node : nodes) { ResolvedTrade trade = node.resolvedTrade(1d, mad, REF_DATA); double mqIn = MQ_MEASURES.value(trade, MULTICURVE_INPUT_EUR_TSEMPTY); double mqSy = MQ_MEASURES.value(trade, multicurveSyn); assertEquals(mqIn, mqSy, TOLERANCE_MQ); } } assertEquals(mad.getTimeSeriesIds(), ImmutableSet.of()); }
/** * Adds the definition of a discount curve to the curve group definition. * * @param curveDefinition the discount curve configuration * @param otherCurrencies additional currencies for which the curve can provide discount factors * @param currency the currency for which the curve provides discount rates * @return this builder */ public RatesCurveGroupDefinitionBuilder addDiscountCurve( CurveDefinition curveDefinition, Currency currency, Currency... otherCurrencies) { ArgChecker.notNull(curveDefinition, "curveDefinition"); ArgChecker.notNull(currency, "currency"); RatesCurveGroupEntry entry = RatesCurveGroupEntry.builder() .curveName(curveDefinition.getName()) .discountCurrencies(ImmutableSet.copyOf(Lists.asList(currency, otherCurrencies))) .build(); return merge(entry, curveDefinition); }