//-------------------------------------------------------------------------
public virtual void coverage()
{
BlackSwaptionExpiryTenorVolatilities test1 = BlackSwaptionExpiryTenorVolatilities.of(CONVENTION, VAL_DATE_TIME, SURFACE);
coverImmutableBean(test1);
BlackSwaptionExpiryTenorVolatilities test2 = BlackSwaptionExpiryTenorVolatilities.of(CONVENTION, VAL_DATE.atStartOfDay(ZoneOffset.UTC), SURFACE);
coverBeanEquals(test1, test2);
}
public virtual void test_volatility_sensitivity()
{
double eps = 1.0e-6;
int nData = TIME.size();
for (int i = 0; i < NB_TEST; i++)
{
double expiryTime = VOLS.relativeTime(TEST_OPTION_EXPIRY[i]);
SwaptionSensitivity point = SwaptionSensitivity.of(VOLS.Name, expiryTime, TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD, GBP, TEST_SENSITIVITY[i]);
CurrencyParameterSensitivities sensActual = VOLS.parameterSensitivity(point);
DoubleArray computed = sensActual.getSensitivity(SURFACE.Name, GBP).Sensitivity;
for (int j = 0; j < nData; j++)
{
DoubleArray volDataUp = VOL.with(j, VOL.get(j) + eps);
DoubleArray volDataDw = VOL.with(j, VOL.get(j) - eps);
InterpolatedNodalSurface paramUp = InterpolatedNodalSurface.of(METADATA, TIME, TENOR, volDataUp, INTERPOLATOR_2D);
InterpolatedNodalSurface paramDw = InterpolatedNodalSurface.of(METADATA, TIME, TENOR, volDataDw, INTERPOLATOR_2D);
BlackSwaptionExpiryTenorVolatilities provUp = BlackSwaptionExpiryTenorVolatilities.of(CONVENTION, VAL_DATE_TIME, paramUp);
BlackSwaptionExpiryTenorVolatilities provDw = BlackSwaptionExpiryTenorVolatilities.of(CONVENTION, VAL_DATE_TIME, paramDw);
double volUp = provUp.volatility(TEST_OPTION_EXPIRY[i], TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD);
double volDw = provDw.volatility(TEST_OPTION_EXPIRY[i], TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD);
double fd = 0.5 * (volUp - volDw) / eps;
assertEquals(computed.get(j), fd * TEST_SENSITIVITY[i], eps);
}
}
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
BlackSwaptionExpiryTenorVolatilities other = (BlackSwaptionExpiryTenorVolatilities)obj;
return(JodaBeanUtils.equal(convention, other.convention) && JodaBeanUtils.equal(valuationDateTime, other.valuationDateTime) && JodaBeanUtils.equal(surface, other.surface));
}
return(false);
}
public virtual void test_presentValueSensitivityRatesStickyModel_stickyStrike()
{
SwaptionVolatilities volSabr = SwaptionSabrRateVolatilityDataSet.getVolatilitiesUsd(VAL_DATE, false);
double impliedVol = SWAPTION_PRICER.impliedVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, volSabr);
SurfaceMetadata blackMeta = Surfaces.blackVolatilityByExpiryTenor("CST", VOLS.DayCount);
SwaptionVolatilities volCst = BlackSwaptionExpiryTenorVolatilities.of(VOLS.Convention, VOLS.ValuationDateTime, ConstantSurface.of(blackMeta, impliedVol));
// To obtain a constant volatility surface which create a sticky strike sensitivity
PointSensitivityBuilder pointRec = SWAPTION_PRICER.presentValueSensitivityRatesStickyStrike(SWAPTION_REC_LONG, RATE_PROVIDER, volSabr);
CurrencyParameterSensitivities computedRec = RATE_PROVIDER.parameterSensitivity(pointRec.build());
CurrencyParameterSensitivities expectedRec = FD_CAL.sensitivity(RATE_PROVIDER, (p) => SWAPTION_PRICER.presentValue(SWAPTION_REC_LONG, (p), volCst));
assertTrue(computedRec.equalWithTolerance(expectedRec, NOTIONAL * FD_EPS * 100d));
PointSensitivityBuilder pointPay = SWAPTION_PRICER.presentValueSensitivityRatesStickyStrike(SWAPTION_PAY_SHORT, RATE_PROVIDER, volSabr);
CurrencyParameterSensitivities computedPay = RATE_PROVIDER.parameterSensitivity(pointPay.build());
CurrencyParameterSensitivities expectedPay = FD_CAL.sensitivity(RATE_PROVIDER, (p) => SWAPTION_PRICER.presentValue(SWAPTION_PAY_SHORT, (p), volCst));
assertTrue(computedPay.equalWithTolerance(expectedPay, NOTIONAL * FD_EPS * 100d));
}
//-------------------------------------------------------------------------
public virtual void present_value_sensitivityBlackVolatility_FD()
{
double shiftVol = 1.0E-4;
Surface surfaceUp = ConstantSurface.of(SwaptionBlackVolatilityDataSets.META_DATA, SwaptionBlackVolatilityDataSets.VOLATILITY + shiftVol);
Surface surfaceDw = ConstantSurface.of(SwaptionBlackVolatilityDataSets.META_DATA, SwaptionBlackVolatilityDataSets.VOLATILITY - shiftVol);
CurrencyAmount pvP = PRICER_SWAPTION_BLACK.presentValue(SWAPTION_LONG_PAY, MULTI_USD, BlackSwaptionExpiryTenorVolatilities.of(BLACK_VOLS_CST_USD.Convention, VAL_DATE.atStartOfDay(ZoneOffset.UTC), surfaceUp));
CurrencyAmount pvM = PRICER_SWAPTION_BLACK.presentValue(SWAPTION_LONG_PAY, MULTI_USD, BlackSwaptionExpiryTenorVolatilities.of(BLACK_VOLS_CST_USD.Convention, VAL_DATE.atStartOfDay(ZoneOffset.UTC), surfaceDw));
double pvnvsFd = (pvP.Amount - pvM.Amount) / (2 * shiftVol);
SwaptionSensitivity pvnvsAd = PRICER_SWAPTION_BLACK.presentValueSensitivityModelParamsVolatility(SWAPTION_LONG_PAY, MULTI_USD, BLACK_VOLS_CST_USD);
assertEquals(pvnvsAd.Currency, USD);
assertEquals(pvnvsAd.Sensitivity, pvnvsFd, TOLERANCE_PV_VEGA);
assertEquals(pvnvsAd.VolatilitiesName, BLACK_VOLS_CST_USD.Name);
assertEquals(pvnvsAd.Expiry, BLACK_VOLS_CST_USD.relativeTime(SWAPTION_LONG_PAY.Expiry));
assertEquals(pvnvsAd.Tenor, SWAP_TENOR_YEAR, TOLERANCE_RATE);
assertEquals(pvnvsAd.Strike, STRIKE, TOLERANCE_RATE);
double forward = PRICER_SWAP.parRate(RSWAP_REC, MULTI_USD);
assertEquals(pvnvsAd.Forward, forward, TOLERANCE_RATE);
}
