//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivity()
{
for (int i = 0; i < NB_STRIKES; ++i)
{
ResolvedFxVanillaOption option = CALLS[i];
PointSensitivityBuilder point = PRICER.presentValueSensitivityRatesStickyStrike(option, RATES_PROVIDER, VOLS);
CurrencyParameterSensitivities sensiComputed = RATES_PROVIDER.parameterSensitivity(point.build());
double timeToExpiry = VOLS.relativeTime(EXPIRY);
double forwardRate = FX_PRICER.forwardFxRate(UNDERLYING[i], RATES_PROVIDER).fxRate(CURRENCY_PAIR);
double strikeRate = option.Strike;
SmileDeltaParameters smileAtTime = VOLS.Smile.smileForExpiry(timeToExpiry);
double[] vols = smileAtTime.Volatility.toArray();
double df = RATES_PROVIDER.discountFactor(USD, PAY);
CurrencyParameterSensitivities sensiExpected = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValue(option, p, VOLS));
CurrencyParameterSensitivities sensiRes = FD_CAL.sensitivity(RATES_PROVIDER, (ImmutableRatesProvider p) =>
{
double fwd = FX_PRICER.forwardFxRate(option.Underlying, p).fxRate(CURRENCY_PAIR);
double[] strs = smileAtTime.strike(fwd).toArray();
double[] wghts = weights(fwd, strikeRate, strs, timeToExpiry, vols[1]);
double res = 0d;
for (int j = 0; j < 3; ++j)
{
res += wghts[j] * (BlackFormulaRepository.price(forwardRate, strs[j], timeToExpiry, vols[j], true) - BlackFormulaRepository.price(forwardRate, strs[j], timeToExpiry, vols[1], true));
}
return(CurrencyAmount.of(USD, -res * df * NOTIONAL));
});
assertTrue(sensiComputed.equalWithTolerance(sensiExpected.combinedWith(sensiRes), FD_EPS * NOTIONAL * 10d));
}
}
public virtual void test_priceSensitivity()
{
PointSensitivities point = PRICER.priceSensitivityRates(FUTURE, RATE_PROVIDER, HW_PROVIDER);
CurrencyParameterSensitivities computed = RATE_PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATE_PROVIDER, (p) => CurrencyAmount.of(EUR, PRICER.price(FUTURE, (p), HW_PROVIDER)));
assertTrue(computed.equalWithTolerance(expected, TOL_FD));
}
public virtual void test_presentValueSensitivity()
{
PointSensitivities computed = PRICER.presentValueSensitivity(RTERM_DEPOSIT, IMM_PROV);
CurrencyParameterSensitivities sensiComputed = IMM_PROV.parameterSensitivity(computed);
CurrencyParameterSensitivities sensiExpected = CAL_FD.sensitivity(IMM_PROV, (p) => PRICER.presentValue(RTERM_DEPOSIT, (p)));
assertTrue(sensiComputed.equalWithTolerance(sensiExpected, NOTIONAL * EPS_FD));
}
public virtual void test_presentValueSensitivity()
{
PointSensitivities point = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, (p) => TRADE_PRICER.presentValue(FUTURE_TRADE, (p), LASTMARG_PRICE));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS * 10d));
}
public virtual void test_presentValueSensitivity()
{
PointSensitivities point = PRICER.presentValueSensitivityRates(FUTURE_TRADE, RATE_PROVIDER, HW_PROVIDER);
CurrencyParameterSensitivities computed = RATE_PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATE_PROVIDER, p => PRICER.presentValue(FUTURE_TRADE, p, HW_PROVIDER, LAST_PRICE));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * TOL_FD));
}
public virtual void test_presentValueSensitivity_afterFix()
{
PointSensitivityBuilder pointCaplet = PRICER.presentValueSensitivityRates(CAPLET_LONG, RATES_AFTER_FIX, VOLS_AFTER_FIX);
CurrencyParameterSensitivities computedCaplet = RATES_AFTER_FIX.parameterSensitivity(pointCaplet.build());
PointSensitivityBuilder pointFloorlet = PRICER.presentValueSensitivityRates(FLOORLET_SHORT, RATES_AFTER_FIX, VOLS_AFTER_FIX);
CurrencyParameterSensitivities computedFloorlet = RATES_AFTER_FIX.parameterSensitivity(pointFloorlet.build());
CurrencyParameterSensitivities expectedCaplet = FD_CAL.sensitivity(RATES_AFTER_FIX, p => PRICER_BASE.presentValue(CAPLET_LONG, p, VOLS_AFTER_FIX));
CurrencyParameterSensitivities expectedFloorlet = FD_CAL.sensitivity(RATES_AFTER_FIX, p => PRICER_BASE.presentValue(FLOORLET_SHORT, p, VOLS_AFTER_FIX));
assertTrue(computedCaplet.equalWithTolerance(expectedCaplet, EPS_FD * NOTIONAL));
assertTrue(computedFloorlet.equalWithTolerance(expectedFloorlet, EPS_FD * NOTIONAL));
}
public virtual void presentValueSensitivity_onPayment()
{
PointSensitivities ptsCpn = PRICER_CMS.presentValueSensitivity(COUPON, RATES_PROVIDER_ON_PAY).build();
PointSensitivities ptsCapletOtm = PRICER_CMS.presentValueSensitivity(CAPLET, RATES_PROVIDER_ON_PAY).build();
PointSensitivities ptsCapletItm = PRICER_CMS.presentValueSensitivity(CAPLET_NEGATIVE, RATES_PROVIDER_ON_PAY).build();
PointSensitivities ptsFloorletItm = PRICER_CMS.presentValueSensitivity(FLOORLET, RATES_PROVIDER_ON_PAY).build();
PointSensitivities ptsFloorletOtm = PRICER_CMS.presentValueSensitivity(FLOORLET_NEGATIVE, RATES_PROVIDER_ON_PAY).build();
assertTrue(RATES_PROVIDER_ON_PAY.parameterSensitivity(ptsCpn).equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_DELTA));
assertTrue(RATES_PROVIDER_ON_PAY.parameterSensitivity(ptsCapletOtm).equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_DELTA));
assertTrue(RATES_PROVIDER_ON_PAY.parameterSensitivity(ptsCapletItm).equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_DELTA));
assertTrue(RATES_PROVIDER_ON_PAY.parameterSensitivity(ptsFloorletItm).equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_DELTA));
assertTrue(RATES_PROVIDER_ON_PAY.parameterSensitivity(ptsFloorletOtm).equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_DELTA));
}
//-------------------------------------------------------------------------
public virtual void test_cashFlowEquivalentAndSensitivity()
{
ResolvedSwap swap = ResolvedSwap.of(IBOR_LEG, FIXED_LEG);
ImmutableMap <Payment, PointSensitivityBuilder> computedFull = CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivitySwap(swap, PROVIDER);
ImmutableList <Payment> keyComputedFull = computedFull.Keys.asList();
ImmutableList <PointSensitivityBuilder> valueComputedFull = computedFull.values().asList();
ImmutableMap <Payment, PointSensitivityBuilder> computedIborLeg = CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityIborLeg(IBOR_LEG, PROVIDER);
ImmutableMap <Payment, PointSensitivityBuilder> computedFixedLeg = CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityFixedLeg(FIXED_LEG, PROVIDER);
assertEquals(computedFixedLeg.Keys.asList(), keyComputedFull.subList(0, 2));
assertEquals(computedIborLeg.Keys.asList(), keyComputedFull.subList(2, 6));
assertEquals(computedFixedLeg.values().asList(), valueComputedFull.subList(0, 2));
assertEquals(computedIborLeg.values().asList(), valueComputedFull.subList(2, 6));
double eps = 1.0e-7;
RatesFiniteDifferenceSensitivityCalculator calc = new RatesFiniteDifferenceSensitivityCalculator(eps);
int size = keyComputedFull.size();
for (int i = 0; i < size; ++i)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int index = i;
int index = i;
CurrencyParameterSensitivities expected = calc.sensitivity(PROVIDER, p => ((NotionalExchange)CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap, p).PaymentEvents.get(index)).PaymentAmount);
SwapPaymentEvent @event = CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap, PROVIDER).PaymentEvents.get(index);
PointSensitivityBuilder point = computedFull.get(((NotionalExchange)@event).Payment);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point.build());
assertTrue(computed.equalWithTolerance(expected, eps * NOTIONAL));
}
}
public virtual void presentValueSensitivity_buySell()
{
PointSensitivityBuilder pvBuy = PRICER_CMS.presentValueSensitivity(COUPON, RATES_PROVIDER);
PointSensitivityBuilder pvSell = PRICER_CMS.presentValueSensitivity(COUPON_SELL, RATES_PROVIDER);
CurrencyParameterSensitivities ps = RATES_PROVIDER.parameterSensitivity(pvBuy.combinedWith(pvSell).build());
assertTrue(ps.equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_DELTA));
}
//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivity()
{
PointSensitivityBuilder pointCaplet = PRICER.presentValueSensitivityRatesStickyModel(CAPLET_LONG, RATES, VOLS);
CurrencyParameterSensitivities computedCaplet = RATES.parameterSensitivity(pointCaplet.build());
PointSensitivityBuilder pointFloorlet = PRICER.presentValueSensitivityRatesStickyModel(FLOORLET_SHORT, RATES, VOLS);
CurrencyParameterSensitivities computedFloorlet = RATES.parameterSensitivity(pointFloorlet.build());
CurrencyParameterSensitivities expectedCaplet = FD_CAL.sensitivity(RATES, p => PRICER_BASE.presentValue(CAPLET_LONG, p, VOLS));
CurrencyParameterSensitivities expectedFloorlet = FD_CAL.sensitivity(RATES, p => PRICER_BASE.presentValue(FLOORLET_SHORT, p, VOLS));
assertTrue(computedCaplet.equalWithTolerance(expectedCaplet, EPS_FD * NOTIONAL * 50d));
assertTrue(computedFloorlet.equalWithTolerance(expectedFloorlet, EPS_FD * NOTIONAL * 50d));
// consistency with shifted Black
PointSensitivityBuilder pointCapletBase = PRICER.presentValueSensitivityRates(CAPLET_LONG, RATES, VOLS);
PointSensitivityBuilder pointFloorletBase = PRICER.presentValueSensitivityRates(FLOORLET_SHORT, RATES, VOLS);
double forward = RATES.iborIndexRates(EUR_EURIBOR_3M).rate(RATE_COMP.Observation);
double expiry = VOLS.relativeTime(CAPLET_LONG.FixingDateTime);
double volatility = VOLS.volatility(expiry, STRIKE, forward);
ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities vols = ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities.of(EUR_EURIBOR_3M, VALUATION, ConstantSurface.of("constVol", volatility).withMetadata(Surfaces.blackVolatilityByExpiryStrike("costVol", DayCounts.ACT_ACT_ISDA)), IborCapletFloorletSabrRateVolatilityDataSet.CURVE_CONST_SHIFT);
PointSensitivityBuilder pointCapletExp = PRICER_BASE.presentValueSensitivityRates(CAPLET_LONG, RATES, vols);
PointSensitivityBuilder pointFloorletExp = PRICER_BASE.presentValueSensitivityRates(FLOORLET_SHORT, RATES, vols);
assertEquals(pointCapletBase, pointCapletExp);
assertEquals(pointFloorletBase, pointFloorletExp);
}
//-------------------------------------------------------------------------
public virtual void present_value_sensitivity_premium_forward()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREFWD_LONG_REC, RATE_PROVIDER, VOLS);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS);
PointSensitivityBuilder pvcsPremium = PRICER_PAYMENT.presentValueSensitivity(PREMIUM_FWD_PAY, RATE_PROVIDER);
CurrencyParameterSensitivities pvpsTrade = RATE_PROVIDER.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = RATE_PROVIDER.parameterSensitivity(pvcsProduct.combinedWith(pvcsPremium).build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, NOTIONAL * TOL));
}
//-------------------------------------------------------------------------
public virtual void present_value_sensitivity_premium_forward()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREFWD_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
PointSensitivityBuilder pvcsPremium = PRICER_PAYMENT.presentValueSensitivity(PREMIUM_FWD_PAY, MULTI_USD);
CurrencyParameterSensitivities pvpsTrade = MULTI_USD.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = MULTI_USD.parameterSensitivity(pvcsProduct.combinedWith(pvcsPremium).build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, TOLERANCE_PV_DELTA));
}
//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivity()
{
PointSensitivityBuilder capComputed = PRICER.presentValueSensitivityRates(CAP, RATES, VOLS);
PointSensitivityBuilder floorComputed = PRICER.presentValueSensitivityRates(FLOOR, RATES, VOLS);
PointSensitivityBuilder capExpected = PointSensitivityBuilder.none();
PointSensitivityBuilder floorExpected = PointSensitivityBuilder.none();
int nPeriods = CAP.CapletFloorletPeriods.size();
for (int i = 0; i < nPeriods; ++i)
{
capExpected = capExpected.combinedWith(PRICER_PERIOD.presentValueSensitivityRates(CAP.CapletFloorletPeriods.get(i), RATES, VOLS));
floorExpected = floorExpected.combinedWith(PRICER_PERIOD.presentValueSensitivityRates(FLOOR.CapletFloorletPeriods.get(i), RATES, VOLS));
}
CurrencyParameterSensitivities capSensiComputed = RATES_AFTER.parameterSensitivity(capComputed.build());
CurrencyParameterSensitivities floorSensiComputed = RATES_AFTER.parameterSensitivity(floorComputed.build());
CurrencyParameterSensitivities capSensiExpected = RATES_AFTER.parameterSensitivity(capExpected.build());
CurrencyParameterSensitivities floorSensiExpected = RATES_AFTER.parameterSensitivity(floorExpected.build());
assertTrue(capSensiComputed.equalWithTolerance(capSensiExpected, NOTIONAL_VALUE * TOL));
assertTrue(floorSensiComputed.equalWithTolerance(floorSensiExpected, NOTIONAL_VALUE * TOL));
}
public virtual void test_presentValueSensitivity_afterFix()
{
PointSensitivityBuilder pointInterp = PRICER.presentValueSensitivity(PERIOD_INTERP, IRP_AFTER_FIX, ICDF_AFTER_FIX);
CurrencyParameterSensitivities computedInterp1 = LEDP_AFTER_FIX.parameterSensitivity(pointInterp.build());
CurrencyParameterSensitivities computedInterp2 = IRP_AFTER_FIX.parameterSensitivity(pointInterp.build());
PointSensitivityBuilder pointMonthly = PRICER.presentValueSensitivity(PERIOD_MONTHLY, IRP_AFTER_FIX, ICDF_AFTER_FIX);
CurrencyParameterSensitivities computedMonthly1 = LEDP_AFTER_FIX.parameterSensitivity(pointMonthly.build());
CurrencyParameterSensitivities computedMonthly2 = IRP_AFTER_FIX.parameterSensitivity(pointMonthly.build());
CurrencyParameterSensitivities expectedInterp = fdSensitivity(PERIOD_INTERP, IRP_AFTER_FIX, LEDP_AFTER_FIX);
CurrencyParameterSensitivities expectedMonthly = fdSensitivity(PERIOD_MONTHLY, IRP_AFTER_FIX, LEDP_AFTER_FIX);
assertTrue(computedInterp1.combinedWith(computedInterp2).equalWithTolerance(expectedInterp, NOTIONAL * FD_EPS));
assertTrue(computedMonthly1.combinedWith(computedMonthly2).equalWithTolerance(expectedMonthly, NOTIONAL * FD_EPS));
}
public virtual void priceSensitivity()
{
// March 2016
PointSensitivities pointMar = PRODUCT_PRICER.priceSensitivity(FUTURE_PRODUCT_MAR, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiMar = RATES_PROVIDER.parameterSensitivity(pointMar);
double[] sensiFwdMar = new double[] { 0.003743310260261194, -0.01313010637003998, -4.527622886220682E-4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiMar.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdMar, TOL));
// June 2016
PointSensitivities pointJun = PRODUCT_PRICER.priceSensitivity(FUTURE_PRODUCT_JUN, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiJun = RATES_PROVIDER.parameterSensitivity(pointJun);
double[] sensiFwdJun = new double[] { 0.0, 0.01347165823324645, 0.0, 0.0, -0.023308107101966076, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiJun.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdJun, TOL));
// September 2016
PointSensitivities pointSep = PRODUCT_PRICER.priceSensitivity(FUTURE_PRODUCT_SEP, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiSep = RATES_PROVIDER.parameterSensitivity(pointSep);
double[] sensiFwdSep = new double[] { 0.0, 0.0, 0.0, 0.0, 0.01936692513656471, 0.0048417312841411864, 0.0, -0.027462515988551, -0.006580907103066675, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiSep.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdSep, TOL));
// June 2017
PointSensitivities pointJunMid = PRODUCT_PRICER.priceSensitivity(FUTURE_PRODUCT_JUN_MID, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiJunMid = RATES_PROVIDER.parameterSensitivity(pointJunMid);
double[] sensiFwdJunMid = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016154080854008976, -0.013340017892182532, -0.012672512226590141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiJunMid.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdJunMid, TOL));
// March 2020
PointSensitivities pointMarLong = PRODUCT_PRICER.priceSensitivity(FUTURE_PRODUCT_MAR_LONG, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiMarLong = RATES_PROVIDER.parameterSensitivity(pointMarLong);
double[] sensiFwdMarLong = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03382389130551987, -0.043661005746776824, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiMarLong.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdMarLong, TOL));
}
//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivityFromCleanPrice_standard()
{
PointSensitivities point = PRICER.presentValueSensitivityFromCleanPrice(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE);
CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point).combinedWith(RATES_PROVIDER.parameterSensitivity(point));
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValueFromCleanPrice(TRADE_STANDARD, p, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE)).combinedWith(FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p => PRICER.presentValueFromCleanPrice(TRADE_STANDARD, RATES_PROVIDER, p, REF_DATA, TRADE_PRICE)));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS));
}