/// <summary>
/// End-to-end test for curve calibration and round-tripping that uses the <seealso cref="MarketDataFactory"/>
/// to calibrate a curve and calculate PVs for the instruments at the curve nodes.
///
/// This tests the full pipeline of market data functions:
/// - Par rates
/// - Curve group (including calibration)
/// - Individual curves
/// - Discount factors
/// </summary>
public virtual void roundTripFraAndFixedFloatSwap()
{
// Configuration and market data for the curve ---------------------------------
string fra3x6 = "fra3x6";
string fra6x9 = "fra6x9";
string swap1y = "swap1y";
string swap2y = "swap2y";
string swap3y = "swap3y";
FraCurveNode fra3x6Node = fraNode(3, fra3x6);
FraCurveNode fra6x9Node = fraNode(6, fra6x9);
FixedIborSwapCurveNode swap1yNode = fixedIborSwapNode(Tenor.TENOR_1Y, swap1y);
FixedIborSwapCurveNode swap2yNode = fixedIborSwapNode(Tenor.TENOR_2Y, swap2y);
FixedIborSwapCurveNode swap3yNode = fixedIborSwapNode(Tenor.TENOR_3Y, swap3y);
IDictionary <ObservableId, double> parRateData = ImmutableMap.builder <ObservableId, double>().put(id(fra3x6), 0.0037).put(id(fra6x9), 0.0054).put(id(swap1y), 0.005).put(id(swap2y), 0.0087).put(id(swap3y), 0.012).build();
LocalDate valuationDate = date(2011, 3, 8);
// Build the trades from the node instruments
MarketData quotes = ImmutableMarketData.of(valuationDate, parRateData);
Trade fra3x6Trade = fra3x6Node.trade(1d, quotes, REF_DATA);
Trade fra6x9Trade = fra6x9Node.trade(1d, quotes, REF_DATA);
Trade swap1yTrade = swap1yNode.trade(1d, quotes, REF_DATA);
Trade swap2yTrade = swap2yNode.trade(1d, quotes, REF_DATA);
Trade swap3yTrade = swap3yNode.trade(1d, quotes, REF_DATA);
IList <Trade> trades = ImmutableList.of(fra3x6Trade, fra6x9Trade, swap1yTrade, swap2yTrade, swap3yTrade);
IList <CurveNode> nodes = ImmutableList.of(fra3x6Node, fra6x9Node, swap1yNode, swap2yNode, swap3yNode);
CurveGroupName groupName = CurveGroupName.of("Curve Group");
CurveName curveName = CurveName.of("FRA and Fixed-Float Swap Curve");
InterpolatedNodalCurveDefinition curveDefn = InterpolatedNodalCurveDefinition.builder().name(curveName).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(DayCounts.ACT_ACT_ISDA).nodes(nodes).interpolator(CurveInterpolators.DOUBLE_QUADRATIC).extrapolatorLeft(CurveExtrapolators.FLAT).extrapolatorRight(CurveExtrapolators.FLAT).build();
RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(groupName).addCurve(curveDefn, Currency.USD, IborIndices.USD_LIBOR_3M).build();
MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(groupName, groupDefn).build();
// Rules for market data and calculations ---------------------------------
RatesMarketDataLookup ratesLookup = RatesMarketDataLookup.of(groupDefn);
CalculationRules calculationRules = CalculationRules.of(functions(), Currency.USD, ratesLookup);
// Calculate the results and check the PVs for the node instruments are zero ----------------------
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
MarketData knownMarketData = MarketData.of(date(2011, 3, 8), parRateData);
// using the direct executor means there is no need to close/shutdown the runner
CalculationTasks tasks = CalculationTasks.of(calculationRules, trades, columns, REF_DATA);
MarketDataRequirements reqs = tasks.requirements(REF_DATA);
MarketData enhancedMarketData = marketDataFactory().create(reqs, marketDataConfig, knownMarketData, REF_DATA);
CalculationTaskRunner runner = CalculationTaskRunner.of(MoreExecutors.newDirectExecutorService());
Results results = runner.calculate(tasks, enhancedMarketData, REF_DATA);
results.Cells.ForEach(this.checkPvIsZero);
}
private void calibration_market_quote_sensitivity_check(System.Func <ImmutableMarketData, RatesProvider> calibrator, double shift)
{
double notional = 100_000_000.0;
double fx = 1.1111;
double fxPts = 0.0012;
ResolvedFxSwapTrade trade = EUR_USD.createTrade(VAL_DATE, Period.ofWeeks(6), Period.ofMonths(5), BuySell.BUY, notional, fx, fxPts, REF_DATA).resolve(REF_DATA);
RatesProvider result = CALIBRATOR.calibrate(CURVE_GROUP_CONFIG, ALL_QUOTES, REF_DATA);
PointSensitivities pts = FX_PRICER.presentValueSensitivity(trade.Product, result);
CurrencyParameterSensitivities ps = result.parameterSensitivity(pts);
CurrencyParameterSensitivities mqs = MQC.sensitivity(ps, result);
double pvUsd = FX_PRICER.presentValue(trade.Product, result).getAmount(USD).Amount;
double pvEur = FX_PRICER.presentValue(trade.Product, result).getAmount(EUR).Amount;
double[] mqsUsd1Computed = mqs.getSensitivity(USD_DSCON_CURVE_NAME, USD).Sensitivity.toArray();
for (int i = 0; i < USD_DSC_NB_NODES; i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> map = new java.util.HashMap<>(ALL_QUOTES.getValues());
IDictionary <MarketDataId <object>, object> map = new Dictionary <MarketDataId <object>, object>(ALL_QUOTES.Values);
map[QuoteId.of(StandardId.of(SCHEME, USD_DSC_ID_VALUE[i]))] = USD_DSC_MARKET_QUOTES[i] + shift;
ImmutableMarketData marketData = ImmutableMarketData.of(VAL_DATE, map);
RatesProvider rpShifted = calibrator(marketData);
double pvS = FX_PRICER.presentValue(trade.Product, rpShifted).getAmount(USD).Amount;
assertEquals(mqsUsd1Computed[i], (pvS - pvUsd) / shift, TOLERANCE_PV_DELTA);
}
double[] mqsUsd2Computed = mqs.getSensitivity(USD_DSCON_CURVE_NAME, EUR).Sensitivity.toArray();
for (int i = 0; i < USD_DSC_NB_NODES; i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> map = new java.util.HashMap<>(ALL_QUOTES.getValues());
IDictionary <MarketDataId <object>, object> map = new Dictionary <MarketDataId <object>, object>(ALL_QUOTES.Values);
map[QuoteId.of(StandardId.of(SCHEME, USD_DSC_ID_VALUE[i]))] = USD_DSC_MARKET_QUOTES[i] + shift;
ImmutableMarketData marketData = ImmutableMarketData.of(VAL_DATE, map);
RatesProvider rpShifted = calibrator(marketData);
double pvS = FX_PRICER.presentValue(trade.Product, rpShifted).getAmount(EUR).Amount;
assertEquals(mqsUsd2Computed[i], (pvS - pvEur) / shift, TOLERANCE_PV_DELTA);
}
double[] mqsEur1Computed = mqs.getSensitivity(EUR_DSC_CURVE_NAME, USD).Sensitivity.toArray();
for (int i = 0; i < EUR_DSC_NB_NODES; i++)
{
assertEquals(mqsEur1Computed[i], 0.0, TOLERANCE_PV_DELTA);
}
double[] mqsEur2Computed = mqs.getSensitivity(EUR_DSC_CURVE_NAME, EUR).Sensitivity.toArray();
for (int i = 0; i < EUR_DSC_NB_NODES; i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> map = new java.util.HashMap<>(ALL_QUOTES.getValues());
IDictionary <MarketDataId <object>, object> map = new Dictionary <MarketDataId <object>, object>(ALL_QUOTES.Values);
map[QuoteId.of(StandardId.of(SCHEME, EUR_DSC_ID_VALUE[i]))] = EUR_DSC_MARKET_QUOTES[i] + shift;
ImmutableMarketData marketData = ImmutableMarketData.of(VAL_DATE, map);
RatesProvider rpShifted = calibrator(marketData);
double pvS = FX_PRICER.presentValue(trade.Product, rpShifted).getAmount(EUR).Amount;
assertEquals(mqsEur2Computed[i], (pvS - pvEur) / shift, TOLERANCE_PV_DELTA, "Node " + i);
}
}
//-------------------------------------------------------------------------
public virtual 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.TotalParameterCount, 2);
assertEquals(test.resolvedTrades(marketData, REF_DATA), ImmutableList.of(trade1, trade2));
assertEquals(test.initialGuesses(marketData), ImmutableList.of(0.5d, 1.5d));
}
public virtual void test_fxProvider()
{
RatesMarketDataLookup test = RatesMarketDataLookup.of(ImmutableMap.of(), ImmutableMap.of());
LocalDate valDate = date(2015, 6, 30);
FxRateId gbpUsdId = FxRateId.of(GBP, USD);
FxRate gbpUsdRate = FxRate.of(GBP, USD, 1.6);
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(gbpUsdId, gbpUsdRate));
FxRateProvider fxProvider = test.fxRateProvider(md);
assertEquals(fxProvider.fxRate(GBP, USD), 1.6);
assertEquals(test.marketDataView(md).fxRateProvider().fxRate(GBP, USD), 1.6);
assertThrows(() => fxProvider.fxRate(EUR, USD), typeof(MarketDataNotFoundException));
}
private void calibration_market_quote_sensitivity_check(System.Func <MarketData, RatesProvider> calibrator, double shift)
{
double notional = 100_000_000.0;
double spread = 0.0050;
SwapTrade trade = IborIborSwapConventions.USD_LIBOR_3M_LIBOR_6M.createTrade(VAL_DATE, Period.ofMonths(8), Tenor.TENOR_7Y, BuySell.BUY, notional, spread, REF_DATA);
RatesProvider result = calibrator(ALL_QUOTES);
ResolvedSwap product = trade.Product.resolve(REF_DATA);
PointSensitivityBuilder pts = SWAP_PRICER.presentValueSensitivity(product, result);
CurrencyParameterSensitivities ps = result.parameterSensitivity(pts.build());
CurrencyParameterSensitivities mqs = MQC.sensitivity(ps, result);
double pv0 = SWAP_PRICER.presentValue(product, result).getAmount(USD).Amount;
double[] mqsDscComputed = mqs.getSensitivity(DSCON_CURVE_NAME, USD).Sensitivity.toArray();
for (int i = 0; i < DSC_NB_NODES; i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> map = new java.util.HashMap<>(ALL_QUOTES.getValues());
IDictionary <MarketDataId <object>, object> map = new Dictionary <MarketDataId <object>, object>(ALL_QUOTES.Values);
map[QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i]))] = DSC_MARKET_QUOTES[i] + shift;
ImmutableMarketData marketData = ImmutableMarketData.of(VAL_DATE, map);
RatesProvider rpShifted = calibrator(marketData);
double pvS = SWAP_PRICER.presentValue(product, rpShifted).getAmount(USD).Amount;
assertEquals(mqsDscComputed[i], (pvS - pv0) / shift, TOLERANCE_PV_DELTA, "DSC - node " + i);
}
double[] mqsFwd3Computed = mqs.getSensitivity(FWD3_CURVE_NAME, USD).Sensitivity.toArray();
for (int i = 0; i < FWD3_NB_NODES; i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> map = new java.util.HashMap<>(ALL_QUOTES.getValues());
IDictionary <MarketDataId <object>, object> map = new Dictionary <MarketDataId <object>, object>(ALL_QUOTES.Values);
map[QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[i]))] = FWD3_MARKET_QUOTES[i] + shift;
ImmutableMarketData marketData = ImmutableMarketData.of(VAL_DATE, map);
RatesProvider rpShifted = calibrator(marketData);
double pvS = SWAP_PRICER.presentValue(product, rpShifted).getAmount(USD).Amount;
assertEquals(mqsFwd3Computed[i], (pvS - pv0) / shift, TOLERANCE_PV_DELTA, "FWD3 - node " + i);
}
double[] mqsFwd6Computed = mqs.getSensitivity(FWD6_CURVE_NAME, USD).Sensitivity.toArray();
for (int i = 0; i < FWD6_NB_NODES; i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> map = new java.util.HashMap<>(ALL_QUOTES.getValues());
IDictionary <MarketDataId <object>, object> map = new Dictionary <MarketDataId <object>, object>(ALL_QUOTES.Values);
map[QuoteId.of(StandardId.of(SCHEME, FWD6_ID_VALUE[i]))] = FWD6_MARKET_QUOTES[i] + shift;
ImmutableMarketData marketData = ImmutableMarketData.of(VAL_DATE, map);
RatesProvider rpShifted = calibrator(marketData);
double pvS = SWAP_PRICER.presentValue(product, rpShifted).getAmount(USD).Amount;
assertEquals(mqsFwd6Computed[i], (pvS - pv0) / shift, TOLERANCE_PV_DELTA, "FWD6 - node " + i);
}
}
public virtual void test_bondDiscountingProvider()
{
LocalDate valDate = LocalDate.of(2015, 6, 30);
Curve ccAUsd = ConstantNodalCurve.of(Curves.zeroRates(CC_A_USD.CurveName, ACT_365F), 0.5d, 1.5d);
Curve ccBGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_B_GBP.CurveName, ACT_365F), 0.5d, 2d);
Curve ccAGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_A_GBP.CurveName, ACT_365F), 0.5d, 3d);
Curve dcGbp = ConstantNodalCurve.of(Curves.zeroRates(DC_GBP.CurveName, ACT_365F), 0.5d, 0.1d);
Curve dcUsd = ConstantNodalCurve.of(Curves.zeroRates(DC_USD.CurveName, ACT_365F), 0.5d, 0.05d);
Curve rcA = ConstantCurve.of(Curves.recoveryRates(RC_A.CurveName, ACT_365F), 0.5d);
Curve rcB = ConstantCurve.of(Curves.recoveryRates(RC_B.CurveName, ACT_365F), 0.4234d);
IDictionary <CurveId, Curve> curveMap = new Dictionary <CurveId, Curve>();
curveMap[CC_A_USD] = ccAUsd;
curveMap[CC_B_GBP] = ccBGbp;
curveMap[CC_A_GBP] = ccAGbp;
curveMap[DC_USD] = dcUsd;
curveMap[DC_GBP] = dcGbp;
curveMap[RC_A] = rcA;
curveMap[RC_B] = rcB;
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.copyOf(curveMap));
CreditRatesProvider provider = LOOKUP_WITH_SOURCE.creditRatesProvider(md);
assertEquals(provider.ValuationDate, valDate);
assertEquals(provider.findData(CC_A_USD.CurveName), ccAUsd);
assertEquals(provider.findData(DC_USD.CurveName), dcUsd);
assertEquals(provider.findData(RC_B.CurveName), rcB);
assertEquals(provider.findData(CurveName.of("Rubbish")), null);
// check credit curve
LegalEntitySurvivalProbabilities cc = provider.survivalProbabilities(ISSUER_A, GBP);
IsdaCreditDiscountFactors ccUnder = (IsdaCreditDiscountFactors)cc.SurvivalProbabilities;
assertEquals(ccUnder.Curve.Name, ccAGbp.Name);
assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_B, USD));
assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_C, USD));
// check discount curve
IsdaCreditDiscountFactors dc = (IsdaCreditDiscountFactors)provider.discountFactors(USD);
assertEquals(dc.Curve.Name, dcUsd.Name);
assertThrowsRuntime(() => provider.discountFactors(EUR));
// check recovery rate curve
ConstantRecoveryRates rc = (ConstantRecoveryRates)provider.recoveryRates(ISSUER_B);
assertEquals(rc.RecoveryRate, rcB.getParameter(0));
assertThrowsRuntime(() => provider.recoveryRates(ISSUER_C));
}
public virtual void test_ratesProvider()
{
ImmutableMap <Currency, CurveId> discounts = ImmutableMap.of(USD, CURVE_ID_DSC);
ImmutableMap <Index, CurveId> forwards = ImmutableMap.of(USD_FED_FUND, CURVE_ID_DSC, USD_LIBOR_3M, CURVE_ID_FWD, US_CPI_U, CURVE_ID_FWD);
RatesMarketDataLookup test = RatesMarketDataLookup.of(discounts, forwards);
LocalDate valDate = date(2015, 6, 30);
Curve dscCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_DSC.CurveName, ACT_360), 1d);
Curve fwdCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_FWD.CurveName, ACT_360), 2d);
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(CURVE_ID_DSC, dscCurve, CURVE_ID_FWD, fwdCurve));
RatesProvider ratesProvider = test.ratesProvider(md);
assertEquals(ratesProvider.ValuationDate, valDate);
assertEquals(ratesProvider.findData(CURVE_ID_DSC.CurveName), dscCurve);
assertEquals(ratesProvider.findData(CURVE_ID_FWD.CurveName), fwdCurve);
assertEquals(ratesProvider.findData(CurveName.of("Rubbish")), null);
assertEquals(ratesProvider.IborIndices, ImmutableSet.of(USD_LIBOR_3M));
assertEquals(ratesProvider.OvernightIndices, ImmutableSet.of(USD_FED_FUND));
assertEquals(ratesProvider.PriceIndices, ImmutableSet.of(US_CPI_U));
assertEquals(ratesProvider.TimeSeriesIndices, ImmutableSet.of());
// check discount factors
SimpleDiscountFactors df = (SimpleDiscountFactors)ratesProvider.discountFactors(USD);
assertEquals(df.Curve.Name, dscCurve.Name);
assertThrowsIllegalArg(() => ratesProvider.discountFactors(GBP));
// check Ibor
DiscountIborIndexRates ibor = (DiscountIborIndexRates)ratesProvider.iborIndexRates(USD_LIBOR_3M);
SimpleDiscountFactors iborDf = (SimpleDiscountFactors)ibor.DiscountFactors;
assertEquals(iborDf.Curve.Name, fwdCurve.Name);
assertThrowsIllegalArg(() => ratesProvider.iborIndexRates(GBP_LIBOR_3M));
// check Overnight
DiscountOvernightIndexRates on = (DiscountOvernightIndexRates)ratesProvider.overnightIndexRates(USD_FED_FUND);
SimpleDiscountFactors onDf = (SimpleDiscountFactors)on.DiscountFactors;
assertEquals(onDf.Curve.Name, dscCurve.Name);
assertThrowsIllegalArg(() => ratesProvider.overnightIndexRates(GBP_SONIA));
// check price curve must be interpolated
assertThrowsIllegalArg(() => ratesProvider.priceIndexValues(US_CPI_U));
// to immutable
ImmutableRatesProvider expectedImmutable = ImmutableRatesProvider.builder(valDate).fxRateProvider(MarketDataFxRateProvider.of(md)).discountCurve(USD, dscCurve).indexCurve(USD_FED_FUND, dscCurve).indexCurve(USD_LIBOR_3M, fwdCurve).indexCurve(US_CPI_U, fwdCurve).build();
assertEquals(ratesProvider.toImmutableRatesProvider(), expectedImmutable);
}
/// <summary>
/// Start from a generic zero-coupon curve. Compute the (inverse) Jacobian matrix using linear projection to a small
/// number of points and the Jacobian utility. Compare the direct Jacobian obtained by calibrating a curve
/// based on the trades with market quotes computed from the zero-coupon curve.
/// </summary>
public virtual void with_rebucketing_one_curve()
{
/* Create trades */
IList <ResolvedTrade> trades = new List <ResolvedTrade>();
IList <LocalDate> nodeDates = new List <LocalDate>();
double[] marketQuotes = new double[TENORS_STD_1.Length];
for (int looptenor = 0; looptenor < TENORS_STD_1.Length; looptenor++)
{
ResolvedSwapTrade t0 = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_1[looptenor], BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA);
marketQuotes[looptenor] = MARKET_QUOTE.value(t0, MULTICURVE_EUR_SINGLE_INPUT);
ResolvedSwapTrade t = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_1[looptenor], BuySell.BUY, 1.0, marketQuotes[looptenor], REF_DATA).resolve(REF_DATA);
nodeDates.Add(t.Product.EndDate);
trades.Add(t);
}
System.Func <ResolvedTrade, CurrencyParameterSensitivities> sensitivityFunction = (t) => CurveSensitivityUtils.linearRebucketing(MULTICURVE_EUR_SINGLE_INPUT.parameterSensitivity(PRICER_SWAP_PRODUCT.parRateSensitivity(((ResolvedSwapTrade)t).Product, MULTICURVE_EUR_SINGLE_INPUT).build()), nodeDates, VALUATION_DATE);
/* Market quotes for comparison */
IDictionary <QuoteId, double> mqCmp = new Dictionary <QuoteId, double>();
for (int looptenor = 0; looptenor < TENORS_STD_1.Length; looptenor++)
{
mqCmp[QuoteId.of(StandardId.of(OG_TICKER, TICKERS_STD_1[looptenor]))] = marketQuotes[looptenor];
}
ImmutableMarketData marketQuotesObject = ImmutableMarketData.of(VALUATION_DATE, mqCmp);
RatesProvider multicurveCmp = CALIBRATOR.calibrate(GROUPS_IN_1, marketQuotesObject, REF_DATA);
/* Comparison */
DoubleMatrix jiComputed = CurveSensitivityUtils.jacobianFromMarketQuoteSensitivities(LIST_CURVE_NAMES_1, trades, sensitivityFunction);
DoubleMatrix jiExpected = multicurveCmp.findData(EUR_SINGLE_NAME).get().Metadata.findInfo(CurveInfoType.JACOBIAN).get().JacobianMatrix;
assertEquals(jiComputed.rowCount(), jiExpected.rowCount());
assertEquals(jiComputed.columnCount(), jiExpected.columnCount());
for (int i = 0; i < jiComputed.rowCount(); i++)
{
for (int j = 0; j < jiComputed.columnCount(); j++)
{
assertEquals(jiComputed.get(i, j), jiExpected.get(i, j), TOLERANCE_JAC_APPROX);
// The comparison is not perfect due to the incoherences introduced by the re-bucketing
}
}
}
/// <summary>
/// Tests calibration a curve containing FRAs and pricing the curve instruments using the curve.
/// </summary>
public virtual void roundTripFra()
{
InterpolatedNodalCurveDefinition curveDefn = CurveTestUtils.fraCurveDefinition();
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <FraCurveNode> nodes = curveDefn.Nodes.Select(typeof(FraCurveNode).cast).collect(toImmutableList());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<com.opengamma.strata.data.MarketDataId<?>> keys = nodes.stream().map(CurveTestUtils::key).collect(toImmutableList());
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <MarketDataId <object> > keys = nodes.Select(CurveTestUtils.key).collect(toImmutableList());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, double> inputData = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, double>().put(keys.get(0), 0.003).put(keys.get(1), 0.0033).put(keys.get(2), 0.0037).put(keys.get(3), 0.0054).put(keys.get(4), 0.007).put(keys.get(5), 0.0091).put(keys.get(6), 0.0134).build();
IDictionary <MarketDataId <object>, double> inputData = ImmutableMap.builder <MarketDataId <object>, double>().put(keys[0], 0.003).put(keys[1], 0.0033).put(keys[2], 0.0037).put(keys[3], 0.0054).put(keys[4], 0.007).put(keys[5], 0.0091).put(keys[6], 0.0134).build();
CurveGroupName groupName = CurveGroupName.of("Curve Group");
CurveName curveName = CurveName.of("FRA Curve");
RatesCurveInputs curveInputs = RatesCurveInputs.of(inputData, DefaultCurveMetadata.of(curveName));
RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(groupName).addCurve(curveDefn, Currency.USD, IborIndices.USD_LIBOR_3M).build();
RatesCurveGroupMarketDataFunction function = new RatesCurveGroupMarketDataFunction();
LocalDate valuationDate = date(2011, 3, 8);
ScenarioMarketData inputMarketData = ImmutableScenarioMarketData.builder(valuationDate).addValue(RatesCurveInputsId.of(groupName, curveName, ObservableSource.NONE), curveInputs).build();
MarketDataBox <RatesCurveGroup> curveGroup = function.buildCurveGroup(groupDefn, CALIBRATOR, inputMarketData, REF_DATA, ObservableSource.NONE);
Curve curve = curveGroup.SingleValue.findDiscountCurve(Currency.USD).get();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, Object>().putAll(inputData).put(com.opengamma.strata.market.curve.CurveId.of(groupName, curveName), curve).build();
IDictionary <MarketDataId <object>, object> marketDataMap = ImmutableMap.builder <MarketDataId <object>, object>().putAll(inputData).put(CurveId.of(groupName, curveName), curve).build();
MarketData marketData = ImmutableMarketData.of(valuationDate, marketDataMap);
TestMarketDataMap scenarioMarketData = new TestMarketDataMap(valuationDate, marketDataMap, ImmutableMap.of());
RatesMarketDataLookup lookup = RatesMarketDataLookup.of(groupDefn);
RatesProvider ratesProvider = lookup.ratesProvider(scenarioMarketData.scenario(0));
// The PV should be zero for an instrument used to build the curve
nodes.ForEach(node => checkFraPvIsZero(node, ratesProvider, marketData));
}
// calculates the PV results for the instruments used in calibration from the config
private static Pair <IList <Trade>, Results> calculate(CalculationRunner runner)
{
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// load quotes
ImmutableMap <QuoteId, double> quotes = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE);
// create the market data
MarketData marketData = ImmutableMarketData.of(VAL_DATE, quotes);
// load the curve definition
IDictionary <CurveGroupName, RatesCurveGroupDefinition> defns = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE, SETTINGS_RESOURCE, CALIBRATION_RESOURCE);
RatesCurveGroupDefinition curveGroupDefinition = defns[CURVE_GROUP_NAME].filtered(VAL_DATE, refData);
// extract the trades used for calibration
IList <Trade> trades = curveGroupDefinition.CurveDefinitions.stream().flatMap(defn => defn.Nodes.stream()).filter(node => !(node is IborFixingDepositCurveNode)).map(node => node.trade(1d, marketData, refData)).collect(toImmutableList());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
// the configuration that defines how to create the curves when a curve group is requested
MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME, curveGroupDefinition).build();
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
RatesMarketDataLookup ratesLookup = RatesMarketDataLookup.of(curveGroupDefinition);
CalculationRules rules = CalculationRules.of(functions, ratesLookup);
// calibrate the curves and calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
MarketData calibratedMarketData = marketDataFactory().create(reqs, marketDataConfig, marketData, refData);
Results results = runner.calculate(rules, trades, columns, calibratedMarketData, refData);
return(Pair.of(trades, results));
}
public virtual void roundTripFraAndFixedFloatSwap()
{
CurveGroupName groupName = CurveGroupName.of("Curve Group");
InterpolatedNodalCurveDefinition curveDefn = CurveTestUtils.fraSwapCurveDefinition();
CurveName curveName = curveDefn.Name;
IList <CurveNode> nodes = curveDefn.Nodes;
RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(groupName).addCurve(curveDefn, Currency.USD, IborIndices.USD_LIBOR_3M).build();
RatesCurveGroupMarketDataFunction function = new RatesCurveGroupMarketDataFunction();
LocalDate valuationDate = date(2011, 3, 8);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, double> inputData = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, double>().put(CurveTestUtils.key(nodes.get(0)), 0.0037).put(CurveTestUtils.key(nodes.get(1)), 0.0054).put(CurveTestUtils.key(nodes.get(2)), 0.005).put(CurveTestUtils.key(nodes.get(3)), 0.0087).put(CurveTestUtils.key(nodes.get(4)), 0.012).build();
IDictionary <MarketDataId <object>, double> inputData = ImmutableMap.builder <MarketDataId <object>, double>().put(CurveTestUtils.key(nodes[0]), 0.0037).put(CurveTestUtils.key(nodes[1]), 0.0054).put(CurveTestUtils.key(nodes[2]), 0.005).put(CurveTestUtils.key(nodes[3]), 0.0087).put(CurveTestUtils.key(nodes[4]), 0.012).build();
RatesCurveInputs curveInputs = RatesCurveInputs.of(inputData, DefaultCurveMetadata.of(curveName));
ScenarioMarketData inputMarketData = ImmutableScenarioMarketData.builder(valuationDate).addValue(RatesCurveInputsId.of(groupName, curveName, ObservableSource.NONE), curveInputs).build();
MarketDataBox <RatesCurveGroup> curveGroup = function.buildCurveGroup(groupDefn, CALIBRATOR, inputMarketData, REF_DATA, ObservableSource.NONE);
Curve curve = curveGroup.SingleValue.findDiscountCurve(Currency.USD).get();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, Object>().putAll(inputData).put(com.opengamma.strata.market.curve.CurveId.of(groupName, curveName), curve).build();
IDictionary <MarketDataId <object>, object> marketDataMap = ImmutableMap.builder <MarketDataId <object>, object>().putAll(inputData).put(CurveId.of(groupName, curveName), curve).build();
MarketData marketData = ImmutableMarketData.of(valuationDate, marketDataMap);
TestMarketDataMap scenarioMarketData = new TestMarketDataMap(valuationDate, marketDataMap, ImmutableMap.of());
RatesMarketDataLookup lookup = RatesMarketDataLookup.of(groupDefn);
RatesProvider ratesProvider = lookup.ratesProvider(scenarioMarketData.scenario(0));
checkFraPvIsZero((FraCurveNode)nodes[0], ratesProvider, marketData);
checkFraPvIsZero((FraCurveNode)nodes[1], ratesProvider, marketData);
checkSwapPvIsZero((FixedIborSwapCurveNode)nodes[2], ratesProvider, marketData);
checkSwapPvIsZero((FixedIborSwapCurveNode)nodes[3], ratesProvider, marketData);
checkSwapPvIsZero((FixedIborSwapCurveNode)nodes[4], ratesProvider, marketData);
}
/// <summary>
/// Constructs the synthetic market data from an existing rates provider and the configuration of the new curves.
/// </summary>
/// <param name="group"> the curve group definition for the synthetic curves and instruments </param>
/// <param name="inputProvider"> the input rates provider </param>
/// <param name="refData"> the reference data, used to resolve the trades </param>
/// <returns> the market data </returns>
public ImmutableMarketData marketData(RatesCurveGroupDefinition group, RatesProvider inputProvider, ReferenceData refData)
{
// Retrieve the set of required indices and the list of required currencies
ISet <Index> indicesRequired = new HashSet <Index>();
IList <Currency> ccyRequired = new List <Currency>();
foreach (RatesCurveGroupEntry entry in group.Entries)
{
indicesRequired.addAll(entry.Indices);
((IList <Currency>)ccyRequired).AddRange(entry.DiscountCurrencies);
}
// Retrieve the required time series if present in the original provider
IDictionary <IndexQuoteId, LocalDateDoubleTimeSeries> ts = new Dictionary <IndexQuoteId, LocalDateDoubleTimeSeries>();
foreach (Index idx in Sets.intersection(inputProvider.TimeSeriesIndices, indicesRequired))
{
ts[IndexQuoteId.of(idx)] = inputProvider.timeSeries(idx);
}
LocalDate valuationDate = inputProvider.ValuationDate;
ImmutableList <CurveDefinition> curveGroups = group.CurveDefinitions;
// Create fake market quotes of 0, only to be able to generate trades
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, double> mapId0 = new java.util.HashMap<>();
IDictionary <MarketDataId <object>, double> mapId0 = new Dictionary <MarketDataId <object>, double>();
foreach (CurveDefinition entry in curveGroups)
{
ImmutableList <CurveNode> nodes = entry.Nodes;
for (int i = 0; i < nodes.size(); i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (com.opengamma.strata.data.MarketDataId<?> key : nodes.get(i).requirements())
foreach (MarketDataId <object> key in nodes.get(i).requirements())
{
mapId0[key] = 0.0d;
}
}
}
ImmutableMarketData marketQuotes0 = ImmutableMarketData.of(valuationDate, mapId0);
// Generate market quotes from the trades
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> mapIdSy = new java.util.HashMap<>();
IDictionary <MarketDataId <object>, object> mapIdSy = new Dictionary <MarketDataId <object>, object>();
foreach (CurveDefinition entry in curveGroups)
{
ImmutableList <CurveNode> nodes = entry.Nodes;
foreach (CurveNode node in nodes)
{
ResolvedTrade trade = node.resolvedTrade(1d, marketQuotes0, refData);
double mq = measures.value(trade, inputProvider);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> k = node.requirements().iterator().next();
MarketDataId <object> k = node.requirements().GetEnumerator().next();
mapIdSy[k] = mq;
}
}
// Generate quotes for FX pairs. The first currency is arbitrarily selected as starting point.
// The crosses are automatically generated by the MarketDataFxRateProvider used in calibration.
for (int loopccy = 1; loopccy < ccyRequired.Count; loopccy++)
{
CurrencyPair ccyPair = CurrencyPair.of(ccyRequired[0], ccyRequired[loopccy]);
FxRateId fxId = FxRateId.of(ccyPair);
mapIdSy[fxId] = FxRate.of(ccyPair, inputProvider.fxRate(ccyPair));
}
return(ImmutableMarketData.builder(valuationDate).addValueMap(mapIdSy).addTimeSeriesMap(ts).build());
}
