//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivity_fixing()
{
PointSensitivities computedNoFix = PRICER.presentValueSensitivity(RDEPOSIT, IMM_PROV_NOFIX);
CurrencyParameterSensitivities sensiComputedNoFix = IMM_PROV_NOFIX.parameterSensitivity(computedNoFix);
PointSensitivities computedFix = PRICER.presentValueSensitivity(RDEPOSIT, IMM_PROV_FIX);
CurrencyParameterSensitivities sensiComputedFix = IMM_PROV_NOFIX.parameterSensitivity(computedFix);
assertTrue(sensiComputedNoFix.equalWithTolerance(sensiComputedFix, TOLERANCE_PV_DELTA));
}
public virtual void present_value_sensitivity_premium_past()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRates(SWAPTION_PREPAST_LONG_REC, MULTI_USD, HW_PROVIDER);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRates(SWAPTION_LONG_REC, MULTI_USD, HW_PROVIDER);
CurrencyParameterSensitivities pvpsTrade = MULTI_USD.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = MULTI_USD.parameterSensitivity(pvcsProduct.build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, TOL * NOTIONAL));
}
public virtual void test_presentValueSensitivity()
{
PointSensitivities point = PRICER.presentValueSensitivity(FWD, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expectedUsd = CAL_FD.sensitivity(PROVIDER, (p) => PRICER.presentValue(FWD, (p)).getAmount(USD));
CurrencyParameterSensitivities expectedKrw = CAL_FD.sensitivity(PROVIDER, (p) => PRICER.presentValue(FWD, (p)).getAmount(KRW));
assertTrue(computed.equalWithTolerance(expectedUsd.combinedWith(expectedKrw), NOMINAL_USD * FX_RATE * EPS_FD));
}
public virtual void present_value_sensitivity_premium_past()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREPAST_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
CurrencyParameterSensitivities pvpsTrade = MULTI_USD.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = MULTI_USD.parameterSensitivity(pvcsProduct.build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, TOLERANCE_PV_DELTA));
}
public virtual void test_parSpreadSensitivity_started()
{
ResolvedFxSwap product = ResolvedFxSwap.ofForwardPoints(CurrencyAmount.of(USD, NOMINAL_USD), KRW, FX_RATE, FX_FWD_POINTS, PAYMENT_DATE_PAST, PAYMENT_DATE_NEAR);
PointSensitivities pts = PRICER.parSpreadSensitivity(product, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(pts);
CurrencyParameterSensitivities expected = CAL_FD.sensitivity(PROVIDER, (p) => CurrencyAmount.of(KRW, PRICER.parSpread(product, p)));
assertTrue(computed.equalWithTolerance(expected, TOLERANCE_SPREAD_DELTA));
}
public virtual void present_value_sensitivity_premium_past()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREPAST_LONG_REC, RATE_PROVIDER, VOLS);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS);
CurrencyParameterSensitivities pvpsTrade = RATE_PROVIDER.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = RATE_PROVIDER.parameterSensitivity(pvcsProduct.build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, NOTIONAL * TOL));
}
// Checks that the NDF present value sensitivity is coherent with the standard FX forward present value.
public virtual void test_presentValueCurveSensitivityVsForex()
{
PointSensitivities pvcsNDF = PRICER.presentValueSensitivity(NDF, PROVIDER).normalized();
CurrencyParameterSensitivities sensiNDF = PROVIDER.parameterSensitivity(pvcsNDF);
PointSensitivities pvcsFX = PRICER_FX.presentValueSensitivity(FOREX, PROVIDER).normalized();
CurrencyParameterSensitivities sensiFX = PROVIDER.parameterSensitivity(pvcsFX);
assertTrue(sensiNDF.equalWithTolerance(sensiFX.convertedTo(USD, PROVIDER), NOMINAL_USD * TOL));
}
public virtual void test_presentValueSensitivity_started()
{
ResolvedFxSwap product = ResolvedFxSwap.ofForwardPoints(CurrencyAmount.of(USD, NOMINAL_USD), KRW, FX_RATE, FX_FWD_POINTS, PAYMENT_DATE_PAST, PAYMENT_DATE_NEAR);
PointSensitivities point = PRICER.presentValueSensitivity(product, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expectedUsd = CAL_FD.sensitivity(PROVIDER, (p) => PRICER.presentValue(product, (p)).getAmount(USD));
CurrencyParameterSensitivities expectedKrw = CAL_FD.sensitivity(PROVIDER, (p) => PRICER.presentValue(product, (p)).getAmount(KRW));
assertTrue(computed.equalWithTolerance(expectedUsd.combinedWith(expectedKrw), NOMINAL_USD * FX_RATE * EPS_FD));
}
public virtual void test_presentValueSensitivity_position()
{
PointSensitivities point = PRICER.presentValueSensitivity(POSITION, RATES_PROVIDER, ISSUER_RATES_PROVIDER);
CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point).combinedWith(RATES_PROVIDER.parameterSensitivity(point));
CurrencyParameterSensitivities fdRates = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValue(POSITION, p, ISSUER_RATES_PROVIDER));
CurrencyParameterSensitivities fdPrice = FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p => PRICER.presentValue(POSITION, RATES_PROVIDER, p));
CurrencyParameterSensitivities expected = fdRates.combinedWith(fdPrice);
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS));
}
//-------------------------------------------------------------------------
public virtual void present_value_sensitivity_premium_forward()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyModel(SWAPTION_PREFWD_LONG_REC, RATE_PROVIDER, VOLS);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyModel(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 * NOTIONAL * TOL));
}
//-------------------------------------------------------------------------
public virtual void present_value_sensitivity_premium_forward()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREFWD_LONG_REC, MULTI_USD, BLACK_VOLS_USD);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, MULTI_USD, BLACK_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_singleDiscountCurveParameterSensitivity()
{
ZeroRateSensitivity zeroPt = ZeroRateSensitivity.of(USD, 10d, 5d);
CreditCurveZeroRateSensitivity creditPt = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY_ABC, JPY, 2d, 3d);
FxForwardSensitivity fxPt = FxForwardSensitivity.of(CurrencyPair.of(JPY, USD), USD, LocalDate.of(2017, 2, 14), 15d);
CreditRatesProvider test = ImmutableCreditRatesProvider.builder().creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD), Pair.of(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY), Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, CRD_DEF))).discountCurves(ImmutableMap.of(USD, DSC_USD, JPY, DSC_JPY)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, RR_ABC, LEGAL_ENTITY_DEF, RR_DEF)).valuationDate(VALUATION).build();
CurrencyParameterSensitivities computed = CurrencyParameterSensitivities.of(test.singleDiscountCurveParameterSensitivity(zeroPt.combinedWith(creditPt).combinedWith(fxPt).build(), USD));
CurrencyParameterSensitivities expected = DSC_USD.parameterSensitivity(zeroPt);
assertTrue(computed.equalWithTolerance(expected, 1.0e-14));
}
//-------------------------------------------------------------------------
public virtual void test_pvsensiZSpread_settle_before_val()
{
PointSensitivities pvsensiComputed = PRICER_TRADE.presentValueSensitivityWithZSpread(BILL_TRADE_SETTLE_BEFORE_VAL, PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0);
PointSensitivities pvsensiExpected = PRICER_PRODUCT.presentValueSensitivityWithZSpread(BILL_PRODUCT.resolve(REF_DATA), PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0).multipliedBy(QUANTITY);
assertTrue(pvsensiComputed.equalWithTolerance(pvsensiExpected, TOLERANCE_PVSENSI));
CurrencyParameterSensitivities paramSensiComputed = PROVIDER.parameterSensitivity(pvsensiComputed);
CurrencyParameterSensitivities paramSensiExpected = FD_CALC.sensitivity(PROVIDER, p => PRICER_TRADE.presentValueWithZSpread(BILL_TRADE_SETTLE_BEFORE_VAL, p, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0));
assertTrue(paramSensiComputed.equalWithTolerance(paramSensiExpected, EPS * NOTIONAL_AMOUNT * QUANTITY));
}
public virtual void test_pvsensiZSpread_settle_after_val()
{
PointSensitivities pvsensiComputed = PRICER_TRADE.presentValueSensitivityWithZSpread(BILL_TRADE_SETTLE_AFTER_VAL, PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0);
PointSensitivities pvsensiExpected = PRICER_PRODUCT.presentValueSensitivityWithZSpread(BILL_PRODUCT.resolve(REF_DATA), PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0).multipliedBy(QUANTITY).combinedWith(RepoCurveZeroRateSensitivity.of((ZeroRateSensitivity)PRICER_PAYMENT.presentValueSensitivity(BILL_TRADE_SETTLE_AFTER_VAL.Settlement.get(), PROVIDER.repoCurveDiscountFactors(BILL_PRODUCT.SecurityId, BILL_PRODUCT.LegalEntityId, BILL_PRODUCT.Currency).DiscountFactors), GROUP_REPO).build());
assertTrue(pvsensiComputed.equalWithTolerance(pvsensiExpected, TOLERANCE_PVSENSI));
CurrencyParameterSensitivities paramSensiComputed = PROVIDER.parameterSensitivity(pvsensiComputed);
CurrencyParameterSensitivities paramSensiExpected = FD_CALC.sensitivity(PROVIDER, p => PRICER_TRADE.presentValueWithZSpread(BILL_TRADE_SETTLE_AFTER_VAL, p, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0));
assertTrue(paramSensiComputed.equalWithTolerance(paramSensiExpected, EPS * NOTIONAL_AMOUNT * QUANTITY));
}
public virtual void test_curveParameterSensitivity()
{
ImmutableLegalEntityDiscountingProvider test = ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, GBP), DSC_FACTORS_ISSUER)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_ISSUER, GBP), DSC_FACTORS_REPO)).repoCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_REPO_ISSUER)).valuationDate(DATE).build();
LocalDate refDate = date(2018, 11, 24);
IssuerCurveZeroRateSensitivity sensi1 = test.issuerCurveDiscountFactors(ID_ISSUER, GBP).zeroRatePointSensitivity(refDate, GBP);
RepoCurveZeroRateSensitivity sensi2 = test.repoCurveDiscountFactors(ID_SECURITY, ID_ISSUER, GBP).zeroRatePointSensitivity(refDate, GBP);
PointSensitivities sensi = PointSensitivities.of(sensi1, sensi2);
CurrencyParameterSensitivities computed = test.parameterSensitivity(sensi);
CurrencyParameterSensitivities expected = DSC_FACTORS_ISSUER.parameterSensitivity(sensi1.createZeroRateSensitivity()).combinedWith(DSC_FACTORS_REPO.parameterSensitivity(sensi2.createZeroRateSensitivity()));
assertTrue(computed.equalWithTolerance(expected, 1.0e-12));
}
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 test_forecastValueSensitivity_afterFix()
{
PointSensitivityBuilder pointInterp = PRICER.forecastValueSensitivity(PERIOD_INTERP, IRP_AFTER_FIX);
CurrencyParameterSensitivities computedInterp = IRP_AFTER_FIX.parameterSensitivity(pointInterp.build());
PointSensitivityBuilder pointMonthly = PRICER.forecastValueSensitivity(PERIOD_MONTHLY, IRP_AFTER_FIX);
CurrencyParameterSensitivities computedMonthly = IRP_AFTER_FIX.parameterSensitivity(pointMonthly.build());
CurrencyParameterSensitivities expectedInterp = FD_CAL.sensitivity(IRP_AFTER_FIX, p => CurrencyAmount.of(USD, PRICER.forecastValue(PERIOD_INTERP, p)));
CurrencyParameterSensitivities expectedMonthly = FD_CAL.sensitivity(IRP_AFTER_FIX, p => CurrencyAmount.of(USD, PRICER.forecastValue(PERIOD_MONTHLY, p)));
assertTrue(computedInterp.equalWithTolerance(expectedInterp, NOTIONAL * FD_EPS));
assertTrue(computedMonthly.equalWithTolerance(expectedMonthly, NOTIONAL * FD_EPS));
}
public virtual void test_presentValueSensitivity_atExpiry()
{
// call
PointSensitivities pointCall = PRICER.presentValueSensitivityRatesStickyStrike(CALL_OTM, RATES_PROVIDER_EXPIRY, VOLS_EXPIRY);
CurrencyParameterSensitivities computedCall = RATES_PROVIDER_EXPIRY.parameterSensitivity(pointCall);
CurrencyParameterSensitivities expectedCall = FD_CAL.sensitivity(RATES_PROVIDER_EXPIRY, (p) => PRICER.presentValue(CALL_OTM, (p), VOLS_EXPIRY));
assertTrue(computedCall.equalWithTolerance(expectedCall, NOTIONAL * FD_EPS));
// put
PointSensitivities pointPut = PRICER.presentValueSensitivityRatesStickyStrike(PUT_OTM, RATES_PROVIDER_EXPIRY, VOLS_EXPIRY);
CurrencyParameterSensitivities computedPut = RATES_PROVIDER_EXPIRY.parameterSensitivity(pointPut);
CurrencyParameterSensitivities expectedPut = FD_CAL.sensitivity(RATES_PROVIDER_EXPIRY, (p) => PRICER.presentValue(PUT_OTM, (p), VOLS_EXPIRY));
assertTrue(computedPut.equalWithTolerance(expectedPut, NOTIONAL * FD_EPS));
}
public virtual void test_value_parameter_sensitivity_futfixing()
{
for (int i = 0; i < TEST_MONTHS.Length; i++)
{
YearMonth fixingMonth = TEST_OBS[i].FixingMonth;
if (!fixingMonth.isBefore(YearMonth.from(VAL_DATE_2)) && !USCPI_TS.containsDate(fixingMonth.atEndOfMonth()))
{
InflationRateSensitivity ptsExpected = (InflationRateSensitivity)InflationRateSensitivity.of(TEST_OBS[i], 1d);
CurrencyParameterSensitivities psComputed = INSTANCE_WITH_FUTFIXING.parameterSensitivity(ptsExpected);
double x = YearMonth.from(VAL_DATE_2).until(fixingMonth, MONTHS);
UnitParameterSensitivities sens1 = UnitParameterSensitivities.of(CURVE_INFL2.yValueParameterSensitivity(x));
CurrencyParameterSensitivities psExpected = sens1.multipliedBy(ptsExpected.Currency, ptsExpected.Sensitivity);
assertTrue(psComputed.equalWithTolerance(psExpected, TOLERANCE_DELTA), "test " + i);
}
}
}
//-------------------------------------------------------------------------
public virtual void test_parSpreadSensitivity_noFixing()
{
PointSensitivities computedNoFix = PRICER.parSpreadSensitivity(RDEPOSIT, IMM_PROV_NOFIX);
CurrencyParameterSensitivities sensiComputedNoFix = IMM_PROV_NOFIX.parameterSensitivity(computedNoFix);
CurrencyParameterSensitivities sensiExpected = CAL_FD.sensitivity(IMM_PROV_NOFIX, (p) => CurrencyAmount.of(EUR, PRICER.parSpread(RDEPOSIT, (p))));
assertTrue(sensiComputedNoFix.equalWithTolerance(sensiExpected, TOLERANCE_RATE_DELTA));
// Par rate and par spread sensitivities are equal
PointSensitivities computedParRateNoFix = PRICER.parRateSensitivity(RDEPOSIT, IMM_PROV_NOFIX);
CurrencyParameterSensitivities sensiComputedParRateNoFix = IMM_PROV_NOFIX.parameterSensitivity(computedParRateNoFix);
assertTrue(sensiComputedNoFix.equalWithTolerance(sensiComputedParRateNoFix, TOLERANCE_RATE_DELTA));
PointSensitivities computedFix = PRICER.parSpreadSensitivity(RDEPOSIT, IMM_PROV_FIX);
CurrencyParameterSensitivities sensiComputedFix = IMM_PROV_NOFIX.parameterSensitivity(computedFix);
assertTrue(sensiComputedFix.equalWithTolerance(sensiExpected, TOLERANCE_RATE_DELTA));
}
public virtual void test_presentValueSensitivityModelParamsVolatility_after()
{
PointSensitivityBuilder capComputed = PRICER.presentValueSensitivityModelParamsVolatility(CAP, RATES_AFTER, VOLS_AFTER);
PointSensitivityBuilder floorComputed = PRICER.presentValueSensitivityModelParamsVolatility(FLOOR, RATES_AFTER, VOLS_AFTER);
CurrencyParameterSensitivities capExpected = CurrencyParameterSensitivities.empty();
CurrencyParameterSensitivities floorExpected = CurrencyParameterSensitivities.empty();
int nPeriods = CAP.CapletFloorletPeriods.size();
for (int i = 3; i < nPeriods; ++i)
{
capExpected = capExpected.combinedWith(VOLS_AFTER.parameterSensitivity(PRICER_PERIOD.presentValueSensitivityModelParamsVolatility(CAP.CapletFloorletPeriods.get(i), RATES_AFTER, VOLS_AFTER).build()));
floorExpected = floorExpected.combinedWith(VOLS_AFTER.parameterSensitivity(PRICER_PERIOD.presentValueSensitivityModelParamsVolatility(FLOOR.CapletFloorletPeriods.get(i), RATES_AFTER, VOLS_AFTER).build()));
}
CurrencyParameterSensitivities capSensiComputed = VOLS_AFTER.parameterSensitivity(capComputed.build());
CurrencyParameterSensitivities floorSensiComputed = VOLS_AFTER.parameterSensitivity(floorComputed.build());
assertTrue(capSensiComputed.equalWithTolerance(capExpected, TOL * NOTIONAL_VALUE));
assertTrue(floorSensiComputed.equalWithTolerance(floorExpected, TOL * NOTIONAL_VALUE));
}
//-------------------------------------------------------------------------
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()
{
// call
PointSensitivities pointCall = PRICER.presentValueSensitivityRatesStickyStrike(CALL_OTM, RATES_PROVIDER, VOLS);
CurrencyParameterSensitivities computedCall = RATES_PROVIDER.parameterSensitivity(pointCall);
CurrencyParameterSensitivities expectedCall = FD_CAL.sensitivity(RATES_PROVIDER, (p) => PRICER.presentValue(CALL_OTM, (p), VOLS));
// contribution via implied volatility, to be subtracted.
CurrencyAmount pvVegaCall = PRICER.presentValueVega(CALL_OTM, RATES_PROVIDER, VOLS);
CurrencyParameterSensitivities impliedVolSenseCall = FD_CAL.sensitivity(RATES_PROVIDER, (p) => CurrencyAmount.of(USD, PRICER.impliedVolatility(CALL_OTM, (p), VOLS))).multipliedBy(-pvVegaCall.Amount);
assertTrue(computedCall.equalWithTolerance(expectedCall.combinedWith(impliedVolSenseCall), NOTIONAL * FD_EPS));
// put
PointSensitivities pointPut = PRICER.presentValueSensitivityRatesStickyStrike(PUT_OTM, RATES_PROVIDER, VOLS);
CurrencyParameterSensitivities computedPut = RATES_PROVIDER.parameterSensitivity(pointPut);
CurrencyParameterSensitivities expectedPut = FD_CAL.sensitivity(RATES_PROVIDER, (p) => PRICER.presentValue(PUT_OTM, (p), VOLS));
// contribution via implied volatility, to be subtracted.
CurrencyAmount pvVegaPut = PRICER.presentValueVega(PUT_OTM, RATES_PROVIDER, VOLS);
CurrencyParameterSensitivities impliedVolSensePut = FD_CAL.sensitivity(RATES_PROVIDER, (p) => CurrencyAmount.of(USD, PRICER.impliedVolatility(PUT_OTM, (p), VOLS))).multipliedBy(-pvVegaPut.Amount);
assertTrue(computedPut.equalWithTolerance(expectedPut.combinedWith(impliedVolSensePut), NOTIONAL * FD_EPS));
}
public virtual void test_presentValueSensitivity_after()
{
PointSensitivityBuilder capComputed = PRICER.presentValueSensitivityRates(CAP, RATES_AFTER, VOLS_AFTER);
PointSensitivityBuilder floorComputed = PRICER.presentValueSensitivityRates(FLOOR, RATES_AFTER, VOLS_AFTER);
PointSensitivityBuilder capExpected = PointSensitivityBuilder.none();
IborCapletFloorletPeriod period = FLOOR.CapletFloorletPeriods.get(1);
PointSensitivityBuilder floorExpected = RATES_AFTER.discountFactors(EUR).zeroRatePointSensitivity(period.PaymentDate).multipliedBy(-(STRIKE - OBS_INDEX_2) * NOTIONAL_VALUE * period.YearFraction);
int nPeriods = CAP.CapletFloorletPeriods.size();
for (int i = 2; i < nPeriods; ++i)
{
capExpected = capExpected.combinedWith(PRICER_PERIOD.presentValueSensitivityRates(CAP.CapletFloorletPeriods.get(i), RATES_AFTER, VOLS_AFTER));
floorExpected = floorExpected.combinedWith(PRICER_PERIOD.presentValueSensitivityRates(FLOOR.CapletFloorletPeriods.get(i), RATES_AFTER, VOLS_AFTER));
}
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()
{
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);
}
