// -------------------------------------------------------------------------
public void test_priceSensitivity() {
PointSensitivities point =
OPTION_PRICER.priceSensitivityStickyStrike(
FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER);
CurveCurrencyParameterSensitivities computed = RATE_PROVIDER.curveParameterSensitivity(point);
CurveCurrencyParameterSensitivities expected =
FD_CAL.sensitivity(
RATE_PROVIDER,
(p) ->
CurrencyAmount.of(
EUR, OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, (p), VOL_PROVIDER)));
double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER);
double strike = FUTURE_OPTION_PRODUCT.getStrikePrice();
double expiryTime =
ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate());
double logMoneyness = Math.log(strike / futurePrice);
double logMoneynessUp = Math.log(strike / (futurePrice + EPS));
double logMoneynessDw = Math.log(strike / (futurePrice - EPS));
double vol = SURFACE.zValue(expiryTime, logMoneyness);
double volUp = SURFACE.zValue(expiryTime, logMoneynessUp);
double volDw = SURFACE.zValue(expiryTime, logMoneynessDw);
double volSensi = 0.5 * (volUp - volDw) / EPS;
double vega = BlackFormulaRepository.vega(futurePrice, strike, expiryTime, vol);
CurveCurrencyParameterSensitivities sensiVol =
RATE_PROVIDER
.curveParameterSensitivity(
FUTURE_PRICER.priceSensitivity(
FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER))
.multipliedBy(-vega * volSensi);
expected = expected.combinedWith(sensiVol);
assertTrue(computed.equalWithTolerance(expected, 30d * EPS));
}
// -------------------------------------------------------------------------
public void test_priceSensitivity() {
PointSensitivities point = FUTURE_PRICER.priceSensitivity(FUTURE_PRODUCT, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected =
FD_CAL.sensitivity(
PROVIDER, (p) -> CurrencyAmount.of(USD, FUTURE_PRICER.price(FUTURE_PRODUCT, (p))));
assertTrue(computed.equalWithTolerance(expected, EPS * 10.0));
}
public void test_presentValueProductSensitivity_noExcoupon() {
PointSensitivityBuilder point = PRICER.presentValueSensitivity(PRODUCT_NO_EXCOUPON, PROVIDER);
CurveCurrencyParameterSensitivities computed =
PROVIDER.curveParameterSensitivity(point.build());
CurveCurrencyParameterSensitivities expected =
FD_CAL.sensitivity(PROVIDER, (p) -> PRICER.presentValue(PRODUCT_NO_EXCOUPON, (p)));
assertTrue(computed.equalWithTolerance(expected, 30d * NOTIONAL * EPS));
}
/** Test par spread sensitivity for ISDA FRA Discounting method. */
public void test_parSpreadSensitivity_ISDA() {
PointSensitivities sensi = DEFAULT_PRICER.parSpreadSensitivity(FRA, IMM_PROV);
CurveCurrencyParameterSensitivities sensiComputed = IMM_PROV.curveParameterSensitivity(sensi);
CurveCurrencyParameterSensitivities sensiExpected =
CAL_FD.sensitivity(
IMM_PROV,
(p) -> CurrencyAmount.of(FRA.getCurrency(), DEFAULT_PRICER.parSpread(FRA, (p))));
assertTrue(sensiComputed.equalWithTolerance(sensiExpected, EPS_FD));
}
public void test_dirtyPriceSensitivity() {
PointSensitivityBuilder point = PRICER.dirtyPriceSensitivity(BOND_SECURITY, PROVIDER);
CurveCurrencyParameterSensitivities computed =
PROVIDER.curveParameterSensitivity(point.build());
CurveCurrencyParameterSensitivities expected =
FD_CAL.sensitivity(
PROVIDER,
(p) -> CurrencyAmount.of(EUR, PRICER.dirtyPriceFromCurves(BOND_SECURITY, (p))));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * EPS));
}
public void test_presentValueSensitivityWithZSpread_continuous() {
PointSensitivityBuilder point =
PRICER.presentValueSensitivityWithZSpread(PRODUCT, PROVIDER, Z_SPREAD, CONTINUOUS, 0);
CurveCurrencyParameterSensitivities computed =
PROVIDER.curveParameterSensitivity(point.build());
CurveCurrencyParameterSensitivities expected =
FD_CAL.sensitivity(
PROVIDER, (p) -> PRICER.presentValueWithZSpread(PRODUCT, (p), Z_SPREAD, CONTINUOUS, 0));
assertTrue(computed.equalWithTolerance(expected, 20d * NOTIONAL * EPS));
}
// -------------------------------------------------------------------------
public void test_cashFlowEquivalentAndSensitivity() {
Swap swap = Swap.builder().legs(IBOR_LEG, FIXED_LEG).build();
ImmutableMap<NotionalExchange, PointSensitivityBuilder> computedFull =
CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivitySwap(swap.expand(), PROVIDER);
ImmutableList<NotionalExchange> keyComputedFull = computedFull.keySet().asList();
ImmutableList<PointSensitivityBuilder> valueComputedFull = computedFull.values().asList();
ImmutableMap<NotionalExchange, PointSensitivityBuilder> computedIborLeg =
CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityIborLeg(
IBOR_LEG.expand(), PROVIDER);
ImmutableMap<NotionalExchange, PointSensitivityBuilder> computedFixedLeg =
CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityFixedLeg(
FIXED_LEG.expand(), PROVIDER);
assertEquals(computedFixedLeg.keySet().asList(), keyComputedFull.subList(0, 2));
assertEquals(computedIborLeg.keySet().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) {
final int index = i;
CurveCurrencyParameterSensitivities expected =
calc.sensitivity(
PROVIDER,
p ->
((NotionalExchange)
CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap.expand(), p)
.getPaymentEvents()
.get(index))
.getPaymentAmount());
PointSensitivityBuilder point =
computedFull.get(
CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap.expand(), PROVIDER)
.getPaymentEvents()
.get(index));
CurveCurrencyParameterSensitivities computed =
PROVIDER.curveParameterSensitivity(point.build());
assertTrue(computed.equalWithTolerance(expected, eps * NOTIONAL));
}
}
public void test_priceSensitivityWithZSpread_continuous() {
PointSensitivities point =
FUTURE_PRICER.priceSensitivityWithZSpread(
FUTURE_PRODUCT, PROVIDER, Z_SPREAD, CONTINUOUS, 0);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected =
FD_CAL.sensitivity(
PROVIDER,
(p) ->
CurrencyAmount.of(
USD,
FUTURE_PRICER.priceWithZSpread(FUTURE_PRODUCT, (p), Z_SPREAD, CONTINUOUS, 0)));
assertTrue(computed.equalWithTolerance(expected, EPS * 10.0));
}
public void test_presentValueSensitivityWithZSpread_periodic_noExcoupon() {
PointSensitivityBuilder point =
PRICER.presentValueSensitivityWithZSpread(
PRODUCT_NO_EXCOUPON, PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
CurveCurrencyParameterSensitivities computed =
PROVIDER.curveParameterSensitivity(point.build());
CurveCurrencyParameterSensitivities expected =
FD_CAL.sensitivity(
PROVIDER,
(p) ->
PRICER.presentValueWithZSpread(
PRODUCT_NO_EXCOUPON, (p), Z_SPREAD, PERIODIC, PERIOD_PER_YEAR));
assertTrue(computed.equalWithTolerance(expected, 20d * NOTIONAL * EPS));
}
public void test_dirtyPriceSensitivityWithZspread_continuous() {
PointSensitivityBuilder point =
PRICER.dirtyPriceSensitivityWithZspread(BOND_SECURITY, PROVIDER, Z_SPREAD, CONTINUOUS, 0);
CurveCurrencyParameterSensitivities computed =
PROVIDER.curveParameterSensitivity(point.build());
CurveCurrencyParameterSensitivities expected =
FD_CAL.sensitivity(
PROVIDER,
(p) ->
CurrencyAmount.of(
EUR,
PRICER.dirtyPriceFromCurvesWithZSpread(
BOND_SECURITY, (p), Z_SPREAD, CONTINUOUS, 0)));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * EPS));
}
/** Test parameter sensitivity with finite difference sensitivity calculator. No cutoff period. */
public void rateChfNoCutOffParameterSensitivity() {
LocalDate[] valuationDate = {date(2015, 1, 1), date(2015, 1, 8)};
double[] time = new double[] {0.0, 0.5, 1.0, 2.0, 5.0, 10.0};
double[] rate = new double[] {0.0100, 0.0110, 0.0115, 0.0130, 0.0135, 0.0135};
for (int loopvaldate = 0; loopvaldate < 2; loopvaldate++) {
Curve onCurve =
InterpolatedNodalCurve.of(Curves.zeroRates("ON", ACT_ACT_ISDA), time, rate, INTERPOLATOR);
ImmutableRatesProvider prov =
ImmutableRatesProvider.builder()
.valuationDate(valuationDate[loopvaldate])
.indexCurves(ImmutableMap.of(CHF_TOIS, onCurve))
.timeSeries(ImmutableMap.of(CHF_TOIS, TIME_SERIES_BUILDER.build()))
.build();
OvernightAveragedRateObservation ro =
OvernightAveragedRateObservation.of(CHF_TOIS, FIXING_START_DATE, FIXING_END_DATE, 0);
ForwardOvernightAveragedRateObservationFn obsFn =
ForwardOvernightAveragedRateObservationFn.DEFAULT;
PointSensitivityBuilder sensitivityBuilderComputed =
obsFn.rateSensitivity(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, prov);
CurveCurrencyParameterSensitivities parameterSensitivityComputed =
prov.curveParameterSensitivity(sensitivityBuilderComputed.build());
CurveCurrencyParameterSensitivities parameterSensitivityExpected =
CAL_FD.sensitivity(
prov,
(p) ->
CurrencyAmount.of(
CHF_TOIS.getCurrency(),
obsFn.rate(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, (p))));
assertTrue(
parameterSensitivityComputed.equalWithTolerance(
parameterSensitivityExpected, EPS_FD * 10.0));
}
}
