public CurrencyParameterSensitivities sensitivities(T trade, RatesProvider provider)
{
PointSensitivities pts = sensitivityFn.apply(trade, provider);
CurrencyParameterSensitivities ps = provider.parameterSensitivity(pts);
return(MQC.sensitivity(ps, provider));
}
// market quote bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01MarketQuoteBucketed(ResolvedFraTrade trade, RatesProvider ratesProvider)
{
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider);
CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity);
return(MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider).multipliedBy(ONE_BASIS_POINT));
}
// market quote sum PV01 for one scenario
internal MultiCurrencyAmount pv01MarketQuoteSum(ResolvedSwapTrade trade, RatesProvider ratesProvider)
{
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider);
CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity);
return(MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider).total().multipliedBy(ONE_BASIS_POINT));
}
// calculates the sensitivity
private CurrencyParameterSensitivity calculateCurveSensitivity(ResolvedFraTrade trade, RatesMarketData marketData, CurveId curveId, Curve bumpedCurve)
{
MarketData bumpedMarketData = marketData.MarketData.withValue(curveId, bumpedCurve);
RatesProvider bumpedRatesProvider = marketData.withMarketData(bumpedMarketData).ratesProvider();
PointSensitivities pointSensitivities = tradePricer.presentValueSensitivity(trade, bumpedRatesProvider);
CurrencyParameterSensitivities paramSensitivities = bumpedRatesProvider.parameterSensitivity(pointSensitivities);
return(Iterables.getOnlyElement(paramSensitivities.Sensitivities));
}
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);
}
}
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_pv01()
{
FxVanillaOptionTradeCalculationFunction function = new FxVanillaOptionTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
BlackFxVanillaOptionTradePricer pricer = BlackFxVanillaOptionTradePricer.DEFAULT;
PointSensitivities pvPointSens = pricer.presentValueSensitivityRatesStickyStrike(RTRADE, provider, VOLS);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01 = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedBucketedPv01 = pvParamSens.multipliedBy(1e-4);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedBucketedPv01))));
}
public virtual void test_pv01()
{
TermDepositTradeCalculationFunction function = new TermDepositTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
DiscountingTermDepositProductPricer pricer = DiscountingTermDepositProductPricer.DEFAULT;
ResolvedTermDeposit resolved = TRADE.Product.resolve(REF_DATA);
PointSensitivities pvPointSens = pricer.presentValueSensitivity(resolved, provider);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01 = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedBucketedPv01 = pvParamSens.multipliedBy(1e-4);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedBucketedPv01))));
}
/// <summary>
/// Calibrate a single curve to 4 points. Use the resulting calibrated curves as starting point of the computation
/// of a Jacobian. Compare the direct Jacobian and the one reconstructed from trades.
/// </summary>
public virtual void direct_two_curves()
{
JacobianCalibrationMatrix jiObject = MULTICURVE_EUR_2_CALIBRATED.findData(EUR_DSCON_OIS).get().Metadata.findInfo(CurveInfoType.JACOBIAN).get();
ImmutableList <CurveParameterSize> order = jiObject.Order; // To obtain the order of the curves in the jacobian
/* Create trades */
IList <ResolvedTrade> tradesDsc = new List <ResolvedTrade>();
for (int looptenor = 0; looptenor < TENORS_STD_2_OIS.Length; looptenor++)
{
ResolvedSwapTrade t0 = EUR_FIXED_1Y_EONIA_OIS.createTrade(VALUATION_DATE, TENORS_STD_2_OIS[looptenor], BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA);
double rate = MARKET_QUOTE.value(t0, MULTICURVE_EUR_2_CALIBRATED);
ResolvedSwapTrade t = EUR_FIXED_1Y_EONIA_OIS.createTrade(VALUATION_DATE, TENORS_STD_2_OIS[looptenor], BuySell.BUY, 1.0, rate, REF_DATA).resolve(REF_DATA);
tradesDsc.Add(t);
}
IList <ResolvedTrade> tradesE3 = new List <ResolvedTrade>();
// Fixing
IborFixingDepositConvention c = IborFixingDepositConvention.of(EUR_EURIBOR_6M);
ResolvedIborFixingDepositTrade fix0 = c.createTrade(VALUATION_DATE, EUR_EURIBOR_6M.Tenor.Period, BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA);
double rateFixing = MARKET_QUOTE.value(fix0, MULTICURVE_EUR_2_CALIBRATED);
ResolvedIborFixingDepositTrade fix = c.createTrade(VALUATION_DATE, EUR_EURIBOR_6M.Tenor.Period, BuySell.BUY, 1.0, rateFixing, REF_DATA).resolve(REF_DATA);
tradesE3.Add(fix);
// IRS
for (int looptenor = 0; looptenor < TENORS_STD_2_IRS.Length; looptenor++)
{
ResolvedSwapTrade t0 = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_2_IRS[looptenor], BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA);
double rate = MARKET_QUOTE.value(t0, MULTICURVE_EUR_2_CALIBRATED);
ResolvedSwapTrade t = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_2_IRS[looptenor], BuySell.BUY, 1.0, rate, REF_DATA).resolve(REF_DATA);
tradesE3.Add(t);
}
IList <ResolvedTrade> trades = new List <ResolvedTrade>();
if (order.get(0).Name.Equals(EUR_DSCON_OIS))
{
((IList <ResolvedTrade>)trades).AddRange(tradesDsc);
((IList <ResolvedTrade>)trades).AddRange(tradesE3);
}
else
{
((IList <ResolvedTrade>)trades).AddRange(tradesE3);
((IList <ResolvedTrade>)trades).AddRange(tradesDsc);
}
/* Par rate sensitivity */
System.Func <ResolvedTrade, CurrencyParameterSensitivities> sensitivityFunction = (t) => MULTICURVE_EUR_2_CALIBRATED.parameterSensitivity((t is ResolvedSwapTrade) ? PRICER_SWAP_PRODUCT.parRateSensitivity(((ResolvedSwapTrade)t).Product, MULTICURVE_EUR_2_CALIBRATED).build() : PRICER_IBORFIX_PRODUCT.parRateSensitivity(((ResolvedIborFixingDepositTrade)t).Product, MULTICURVE_EUR_2_CALIBRATED));
DoubleMatrix jiComputed = CurveSensitivityUtils.jacobianFromMarketQuoteSensitivities(order, trades, sensitivityFunction);
DoubleMatrix jiExpectedDsc = MULTICURVE_EUR_2_CALIBRATED.findData(EUR_DSCON_OIS).get().Metadata.getInfo(CurveInfoType.JACOBIAN).JacobianMatrix;
DoubleMatrix jiExpectedE3 = MULTICURVE_EUR_2_CALIBRATED.findData(EUR_EURIBOR6M_IRS).get().Metadata.getInfo(CurveInfoType.JACOBIAN).JacobianMatrix;
/* Comparison */
assertEquals(jiComputed.rowCount(), jiExpectedDsc.rowCount() + jiExpectedE3.rowCount());
assertEquals(jiComputed.columnCount(), jiExpectedDsc.columnCount());
assertEquals(jiComputed.columnCount(), jiExpectedE3.columnCount());
int shiftDsc = order.get(0).Name.Equals(EUR_DSCON_OIS) ? 0 : jiExpectedE3.rowCount();
for (int i = 0; i < jiExpectedDsc.rowCount(); i++)
{
for (int j = 0; j < jiExpectedDsc.columnCount(); j++)
{
assertEquals(jiComputed.get(i + shiftDsc, j), jiExpectedDsc.get(i, j), TOLERANCE_JAC);
}
}
int shiftE3 = order.get(0).Name.Equals(EUR_DSCON_OIS) ? jiExpectedDsc.rowCount() : 0;
for (int i = 0; i < jiExpectedE3.rowCount(); i++)
{
for (int j = 0; j < jiExpectedDsc.columnCount(); j++)
{
assertEquals(jiComputed.get(i + shiftE3, j), jiExpectedE3.get(i, j), TOLERANCE_JAC);
}
}
}
/// <summary>
/// Calibrate a single curve to 4 points. Use the resulting calibrated curves as starting point of the computation
/// of a Jacobian. Compare the direct Jacobian and the one reconstructed from trades.
/// </summary>
public virtual void direct_one_curve()
{
/* Create trades */
IList <ResolvedTrade> trades = new List <ResolvedTrade>();
IList <LocalDate> nodeDates = new List <LocalDate>();
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);
double rate = MARKET_QUOTE.value(t0, MULTICURVE_EUR_SINGLE_CALIBRATED);
ResolvedSwapTrade t = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_1[looptenor], BuySell.BUY, 1.0, rate, REF_DATA).resolve(REF_DATA);
nodeDates.Add(t.Product.EndDate);
trades.Add(t);
}
/* Par rate sensitivity */
System.Func <ResolvedTrade, CurrencyParameterSensitivities> sensitivityFunction = (t) => MULTICURVE_EUR_SINGLE_CALIBRATED.parameterSensitivity(PRICER_SWAP_PRODUCT.parRateSensitivity(((ResolvedSwapTrade)t).Product, MULTICURVE_EUR_SINGLE_CALIBRATED).build());
DoubleMatrix jiComputed = CurveSensitivityUtils.jacobianFromMarketQuoteSensitivities(LIST_CURVE_NAMES_1, trades, sensitivityFunction);
DoubleMatrix jiExpected = MULTICURVE_EUR_SINGLE_CALIBRATED.findData(EUR_SINGLE_NAME).get().Metadata.findInfo(CurveInfoType.JACOBIAN).get().JacobianMatrix;
/* Comparison */
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);
}
}
}
// calibrated bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01CalibratedBucketed(ResolvedFraTrade trade, RatesProvider ratesProvider)
{
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider);
return(ratesProvider.parameterSensitivity(pointSensitivity).multipliedBy(ONE_BASIS_POINT));
}
//-------------------------------------------------------------------------
public virtual void calibration_transition_coherence_par_rate()
{
RatesProvider provider = CalibrationEurStandard.calibrateEurStandard(VAL_DATE, DSC_MARKET_QUOTES, DSC_OIS_TENORS, FWD3_FIXING_QUOTE, FWD3_FRA_QUOTES, FWD3_IRS_QUOTES, FWD3_FRA_TENORS, FWD3_IRS_TENORS, FWD6_FIXING_QUOTE, FWD6_FRA_QUOTES, FWD6_IRS_QUOTES, FWD6_FRA_TENORS, FWD6_IRS_TENORS);
/* Curve Discounting/EUR-EONIA */
string[] dscIdValues = CalibrationEurStandard.dscIdValues(DSC_OIS_TENORS);
/* Curve EUR-EURIBOR-3M */
double[] fwd3MarketQuotes = CalibrationEurStandard.fwdMarketQuotes(FWD3_FIXING_QUOTE, FWD3_FRA_QUOTES, FWD3_IRS_QUOTES);
string[] fwd3IdValue = CalibrationEurStandard.fwdIdValue(3, FWD3_FIXING_QUOTE, FWD3_FRA_QUOTES, FWD3_IRS_QUOTES, FWD3_FRA_TENORS, FWD3_IRS_TENORS);
/* Curve EUR-EURIBOR-6M */
double[] fwd6MarketQuotes = CalibrationEurStandard.fwdMarketQuotes(FWD6_FIXING_QUOTE, FWD6_FRA_QUOTES, FWD6_IRS_QUOTES);
string[] fwd6IdValue = CalibrationEurStandard.fwdIdValue(6, FWD6_FIXING_QUOTE, FWD6_FRA_QUOTES, FWD6_IRS_QUOTES, FWD6_FRA_TENORS, FWD6_IRS_TENORS);
/* All quotes for the curve calibration */
MarketData allQuotes = CalibrationEurStandard.allQuotes(VAL_DATE, DSC_MARKET_QUOTES, dscIdValues, fwd3MarketQuotes, fwd3IdValue, fwd6MarketQuotes, fwd6IdValue);
/* All nodes by groups. */
RatesCurveGroupDefinition config = CalibrationEurStandard.config(DSC_OIS_TENORS, dscIdValues, FWD3_FRA_TENORS, FWD3_IRS_TENORS, fwd3IdValue, FWD6_FRA_TENORS, FWD6_IRS_TENORS, fwd6IdValue);
ImmutableList <CurveDefinition> definitions = config.CurveDefinitions;
// Test PV Dsc
ImmutableList <CurveNode> dscNodes = definitions.get(0).Nodes;
IList <ResolvedTrade> dscTrades = new List <ResolvedTrade>();
for (int i = 0; i < dscNodes.size(); i++)
{
dscTrades.Add(dscNodes.get(i).resolvedTrade(1d, allQuotes, REF_DATA));
}
// OIS
for (int loopnode = 0; loopnode < DSC_MARKET_QUOTES.Length; loopnode++)
{
PointSensitivities pts = SWAP_PRICER.parRateSensitivity(((ResolvedSwapTrade)dscTrades[loopnode]).Product, provider).build();
CurrencyParameterSensitivities ps = provider.parameterSensitivity(pts);
CurrencyParameterSensitivities mqs = MQC.sensitivity(ps, provider);
assertEquals(mqs.size(), 3); // Calibration of all curves simultaneously
CurrencyParameterSensitivity mqsDsc = mqs.getSensitivity(CalibrationEurStandard.DSCON_CURVE_NAME, EUR);
assertTrue(mqsDsc.MarketDataName.Equals(CalibrationEurStandard.DSCON_CURVE_NAME));
assertTrue(mqsDsc.Currency.Equals(EUR));
DoubleArray mqsData = mqsDsc.Sensitivity;
assertEquals(mqsData.size(), DSC_MARKET_QUOTES.Length);
for (int i = 0; i < mqsData.size(); i++)
{
assertEquals(mqsData.get(i), (i == loopnode) ? 1.0 : 0.0, TOLERANCE_DELTA);
}
}
// Test PV Fwd3
ImmutableList <CurveNode> fwd3Nodes = definitions.get(1).Nodes;
IList <ResolvedTrade> fwd3Trades = new List <ResolvedTrade>();
for (int i = 0; i < fwd3Nodes.size(); i++)
{
fwd3Trades.Add(fwd3Nodes.get(i).resolvedTrade(1d, allQuotes, REF_DATA));
}
for (int loopnode = 0; loopnode < fwd3MarketQuotes.Length; loopnode++)
{
PointSensitivities pts = null;
if (fwd3Trades[loopnode] is ResolvedIborFixingDepositTrade)
{
pts = PRICER_FIXING.parSpreadSensitivity(((ResolvedIborFixingDepositTrade)fwd3Trades[loopnode]).Product, provider);
}
if (fwd3Trades[loopnode] is ResolvedFraTrade)
{
pts = PRICER_FRA.parSpreadSensitivity(((ResolvedFraTrade)fwd3Trades[loopnode]).Product, provider);
}
if (fwd3Trades[loopnode] is ResolvedSwapTrade)
{
pts = SWAP_PRICER.parSpreadSensitivity(((ResolvedSwapTrade)fwd3Trades[loopnode]).Product, provider).build();
}
CurrencyParameterSensitivities ps = provider.parameterSensitivity(pts);
CurrencyParameterSensitivities mqs = MQC.sensitivity(ps, provider);
assertEquals(mqs.size(), 3); // Calibration of all curves simultaneously
CurrencyParameterSensitivity mqsDsc = mqs.getSensitivity(CalibrationEurStandard.DSCON_CURVE_NAME, EUR);
CurrencyParameterSensitivity mqsFwd3 = mqs.getSensitivity(CalibrationEurStandard.FWD3_CURVE_NAME, EUR);
DoubleArray mqsDscData = mqsDsc.Sensitivity;
assertEquals(mqsDscData.size(), DSC_MARKET_QUOTES.Length);
for (int i = 0; i < mqsDscData.size(); i++)
{
assertEquals(mqsDscData.get(i), 0.0, TOLERANCE_DELTA);
}
DoubleArray mqsFwd3Data = mqsFwd3.Sensitivity;
assertEquals(mqsFwd3Data.size(), fwd3MarketQuotes.Length);
for (int i = 0; i < mqsFwd3Data.size(); i++)
{
assertEquals(mqsFwd3Data.get(i), (i == loopnode) ? 1.0 : 0.0, TOLERANCE_DELTA);
}
}
// Test PV Fwd6
ImmutableList <CurveNode> fwd6Nodes = definitions.get(2).Nodes;
IList <ResolvedTrade> fwd6Trades = new List <ResolvedTrade>();
for (int i = 0; i < fwd6Nodes.size(); i++)
{
fwd6Trades.Add(fwd6Nodes.get(i).resolvedTrade(1d, allQuotes, REF_DATA));
}
for (int loopnode = 0; loopnode < fwd6MarketQuotes.Length; loopnode++)
{
PointSensitivities pts = null;
if (fwd6Trades[loopnode] is ResolvedIborFixingDepositTrade)
{
pts = PRICER_FIXING.parSpreadSensitivity(((ResolvedIborFixingDepositTrade)fwd6Trades[loopnode]).Product, provider);
}
if (fwd6Trades[loopnode] is ResolvedFraTrade)
{
pts = PRICER_FRA.parSpreadSensitivity(((ResolvedFraTrade)fwd6Trades[loopnode]).Product, provider);
}
if (fwd6Trades[loopnode] is ResolvedSwapTrade)
{
pts = SWAP_PRICER.parSpreadSensitivity(((ResolvedSwapTrade)fwd6Trades[loopnode]).Product, provider).build();
}
CurrencyParameterSensitivities ps = provider.parameterSensitivity(pts);
CurrencyParameterSensitivities mqs = MQC.sensitivity(ps, provider);
assertEquals(mqs.size(), 3);
CurrencyParameterSensitivity mqsDsc = mqs.getSensitivity(CalibrationEurStandard.DSCON_CURVE_NAME, EUR);
CurrencyParameterSensitivity mqsFwd3 = mqs.getSensitivity(CalibrationEurStandard.FWD3_CURVE_NAME, EUR);
CurrencyParameterSensitivity mqsFwd6 = mqs.getSensitivity(CalibrationEurStandard.FWD6_CURVE_NAME, EUR);
DoubleArray mqsDscData = mqsDsc.Sensitivity;
assertEquals(mqsDscData.size(), DSC_MARKET_QUOTES.Length);
for (int i = 0; i < mqsDscData.size(); i++)
{
assertEquals(mqsDscData.get(i), 0.0, TOLERANCE_DELTA);
}
DoubleArray mqsFwd3Data = mqsFwd3.Sensitivity;
assertEquals(mqsFwd3Data.size(), fwd3MarketQuotes.Length);
for (int i = 0; i < mqsFwd3Data.size(); i++)
{
assertEquals(mqsFwd3Data.get(i), 0.0, TOLERANCE_DELTA);
}
DoubleArray mqsFwd6Data = mqsFwd6.Sensitivity;
assertEquals(mqsFwd6Data.size(), fwd6MarketQuotes.Length);
for (int i = 0; i < mqsFwd6Data.size(); i++)
{
assertEquals(mqsFwd6Data.get(i), (i == loopnode) ? 1.0 : 0.0, TOLERANCE_DELTA);
}
}
}
//-------------------------------------------------------------------------
/// <summary>
/// Runs the calibration of SABR on swaptions and print on the console the present value, bucketed PV01 and
/// the bucketed Vega of a 18M x 4Y swaption.
/// </summary>
/// <param name="args"> -s to use the spares data </param>
public static void Main(string[] args)
{
long start, end;
// Swaption description
BuySell payer = BuySell.BUY;
Period expiry = Period.ofMonths(18);
double notional = 1_000_000;
double strike = 0.0100;
Tenor tenor = Tenor.TENOR_4Y;
LocalDate expiryDate = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(expiry), REF_DATA);
SwapTrade underlying = EUR_FIXED_1Y_EURIBOR_6M.createTrade(expiryDate, tenor, payer, notional, strike, REF_DATA);
Swaption swaption = Swaption.builder().expiryDate(AdjustableDate.of(expiryDate)).expiryTime(LocalTime.of(11, 0x0)).expiryZone(ZoneId.of("Europe/Berlin")).underlying(underlying.Product).longShort(LongShort.LONG).swaptionSettlement(PhysicalSwaptionSettlement.DEFAULT).build();
ResolvedSwaption resolvedSwaption = swaption.resolve(REF_DATA);
// select data
TenorRawOptionData data = DATA_FULL;
if (args.Length > 0)
{
if (args[0].Equals("-s"))
{
data = DATA_SPARSE;
}
}
start = DateTimeHelper.CurrentUnixTimeMillis();
// Curve calibration
RatesProvider multicurve = CALIBRATOR.calibrate(CONFIGS, MARKET_QUOTES, REF_DATA);
end = DateTimeHelper.CurrentUnixTimeMillis();
Console.WriteLine("Curve calibration time: " + (end - start) + " ms.");
// SABR calibration
start = DateTimeHelper.CurrentUnixTimeMillis();
double beta = 0.50;
SurfaceMetadata betaMetadata = DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build();
Surface betaSurface = ConstantSurface.of(betaMetadata, beta);
double shift = 0.0300;
Surface shiftSurface = ConstantSurface.of("SABR-Shift", shift);
SabrParametersSwaptionVolatilities sabr = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, data, multicurve, betaSurface, shiftSurface);
end = DateTimeHelper.CurrentUnixTimeMillis();
Console.WriteLine("SABR calibration time: " + (end - start) + " ms.");
// Price and risk
Console.WriteLine("Risk measures: ");
start = DateTimeHelper.CurrentUnixTimeMillis();
CurrencyAmount pv = SWAPTION_PRICER.presentValue(resolvedSwaption, multicurve, sabr);
Console.WriteLine(" |-> PV: " + pv.ToString());
PointSensitivities deltaPts = SWAPTION_PRICER.presentValueSensitivityRatesStickyModel(resolvedSwaption, multicurve, sabr).build();
CurrencyParameterSensitivities deltaBucketed = multicurve.parameterSensitivity(deltaPts);
Console.WriteLine(" |-> Delta bucketed: " + deltaBucketed.ToString());
PointSensitivities vegaPts = SWAPTION_PRICER.presentValueSensitivityModelParamsSabr(resolvedSwaption, multicurve, sabr).build();
Console.WriteLine(" |-> Vega point: " + vegaPts.ToString());
CurrencyParameterSensitivities vegaBucketed = sabr.parameterSensitivity(vegaPts);
for (int i = 0; i < vegaBucketed.size(); i++)
{
Console.WriteLine(" |-> Vega bucketed: " + vegaBucketed.Sensitivities.get(i));
}
end = DateTimeHelper.CurrentUnixTimeMillis();
Console.WriteLine("PV and risk time: " + (end - start) + " ms.");
}
// calibrated sum PV01 for one scenario
internal MultiCurrencyAmount pv01CalibratedSum(ResolvedSwapTrade trade, RatesProvider ratesProvider)
{
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider);
return(ratesProvider.parameterSensitivity(pointSensitivity).total().multipliedBy(ONE_BASIS_POINT));
}