//-------------------------------------------------------------------------
public virtual void test_cloned()
{
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
SwaptionSensitivity test = @base.cloned();
assertSame(test, @base);
}
//-------------------------------------------------------------------------
public virtual void present_value_normal_vol_sensitivity_premium_forward()
{
PointSensitivities vegaTrade = PRICER_TRADE.presentValueSensitivityModelParamsVolatility(SWAPTION_PREFWD_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
SwaptionSensitivity vegaProduct = PRICER_PRODUCT.presentValueSensitivityModelParamsVolatility(SWAPTION_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
assertEquals(vegaTrade.Sensitivities.get(0).Sensitivity, vegaProduct.Sensitivity, TOLERANCE_PV_VEGA);
}
//-------------------------------------------------------------------------
public virtual void test_build()
{
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
PointSensitivities test = @base.build();
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivityBlackVolatility()
{
SwaptionSensitivity sensiRec = PRICER.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS);
SwaptionSensitivity sensiPay = PRICER.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS);
double forward = SWAP_PRICER.parRate(RSWAP_REC, RATE_PROVIDER);
double annuityCash = SWAP_PRICER.LegPricer.annuityCash(RFIXED_LEG_REC, forward);
double expiry = VOLS.relativeTime(SWAPTION_REC_LONG.Expiry);
double tenor = VOLS.tenor(SETTLE, END);
double volatility = SURFACE.zValue(expiry, tenor);
double settle = ACT_ACT_ISDA.relativeYearFraction(VAL_DATE, SETTLE);
double df = Math.Exp(-DSC_CURVE.yValue(settle) * settle);
double expectedRec = df * annuityCash * BlackFormulaRepository.vega(forward, RATE, expiry, volatility);
double expectedPay = -df *annuityCash *BlackFormulaRepository.vega(forward, RATE, expiry, volatility);
assertEquals(sensiRec.Currency, EUR);
assertEquals(sensiRec.Sensitivity, expectedRec, NOTIONAL * TOL);
assertEquals(sensiRec.VolatilitiesName, VOLS.Name);
assertEquals(sensiRec.Expiry, expiry);
assertEquals(sensiRec.Tenor, 5.0);
assertEquals(sensiRec.Strike, RATE);
assertEquals(sensiRec.Forward, forward, TOL);
assertEquals(sensiPay.Currency, EUR);
assertEquals(sensiPay.Sensitivity, expectedPay, NOTIONAL * TOL);
assertEquals(sensiRec.VolatilitiesName, VOLS.Name);
assertEquals(sensiPay.Expiry, expiry);
assertEquals(sensiPay.Tenor, 5.0);
assertEquals(sensiPay.Strike, RATE);
assertEquals(sensiPay.Forward, forward, TOL);
}
//-------------------------------------------------------------------------
public virtual void present_value_black_vol_sensitivity_premium_forward()
{
PointSensitivities vegaTrade = PRICER_TRADE.presentValueSensitivityModelParamsVolatility(SWAPTION_PREFWD_LONG_REC, RATE_PROVIDER, VOLS);
SwaptionSensitivity vegaProduct = PRICER_PRODUCT.presentValueSensitivityModelParamsVolatility(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS);
assertEquals(vegaTrade.Sensitivities.get(0).Sensitivity, vegaProduct.Sensitivity, NOTIONAL * TOL);
}
public virtual void present_value_sensitivityBlackVolatility_payer_receiver_parity()
{
SwaptionSensitivity pvptLongPay = PRICER_SWAPTION_BLACK.presentValueSensitivityModelParamsVolatility(SWAPTION_LONG_PAY, MULTI_USD, BLACK_VOLS_USD_STD);
SwaptionSensitivity pvptShortRec = PRICER_SWAPTION_BLACK.presentValueSensitivityModelParamsVolatility(SWAPTION_SHORT_REC, MULTI_USD, BLACK_VOLS_USD_STD);
assertEquals(pvptLongPay.Sensitivity + pvptShortRec.Sensitivity, 0, TOLERANCE_PV_VEGA);
}
//-------------------------------------------------------------------------
public virtual void test_presentValueVega_parity()
{
SwaptionSensitivity vegaRec = SWAPTION_PRICER.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS);
SwaptionSensitivity vegaPay = SWAPTION_PRICER.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS);
assertEquals(vegaRec.Sensitivity, -vegaPay.Sensitivity, TOLERANCE_DELTA);
}
public virtual void present_value_sensitivityNormalVolatility_long_short_parity()
{
SwaptionSensitivity pvptLongPay = PRICER_SWAPTION_NORMAL.presentValueSensitivityModelParamsVolatility(SWAPTION_LONG_REC, MULTI_USD, NORMAL_VOLS_USD_STD);
SwaptionSensitivity pvptShortRec = PRICER_SWAPTION_NORMAL.presentValueSensitivityModelParamsVolatility(SWAPTION_SHORT_REC, MULTI_USD, NORMAL_VOLS_USD_STD);
assertEquals(pvptLongPay.Sensitivity, -pvptShortRec.Sensitivity, TOLERANCE_PV_VEGA);
}
//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivityNormalVolatility()
{
SwaptionSensitivity computedRec = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS);
CurrencyAmount pvRecUp = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(FD_EPS));
CurrencyAmount pvRecDw = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(-FD_EPS));
double expectedRec = 0.5 * (pvRecUp.Amount - pvRecDw.Amount) / FD_EPS;
assertEquals(computedRec.Currency, USD);
assertEquals(computedRec.Sensitivity, expectedRec, FD_EPS * NOTIONAL);
assertEquals(computedRec.VolatilitiesName, VOLS.Name);
assertEquals(computedRec.Expiry, VOLS.relativeTime(SWAPTION_REC_LONG.Expiry));
assertEquals(computedRec.Tenor, SWAP_TENOR_YEAR, TOL);
assertEquals(computedRec.Strike, STRIKE, TOL);
assertEquals(computedRec.Forward, PRICER_SWAP.parRate(RSWAP_REC, RATE_PROVIDER), TOL);
SwaptionSensitivity computedPay = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS);
CurrencyAmount pvUpPay = PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(FD_EPS));
CurrencyAmount pvDwPay = PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(-FD_EPS));
double expectedPay = 0.5 * (pvUpPay.Amount - pvDwPay.Amount) / FD_EPS;
assertEquals(computedPay.Currency, USD);
assertEquals(computedPay.Sensitivity, expectedPay, FD_EPS * NOTIONAL);
assertEquals(computedPay.VolatilitiesName, VOLS.Name);
assertEquals(computedPay.Expiry, VOLS.relativeTime(SWAPTION_PAY_SHORT.Expiry));
assertEquals(computedPay.Tenor, SWAP_TENOR_YEAR, TOL);
assertEquals(computedPay.Strike, STRIKE, TOL);
assertEquals(computedPay.Forward, PRICER_SWAP.parRate(RSWAP_PAY, RATE_PROVIDER), TOL);
}
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);
}
}
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity to the implied volatility of the swaption trade.
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the point sensitivity to the implied volatility </returns>
public virtual PointSensitivities presentValueSensitivityModelParamsVolatility(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SabrSwaptionVolatilities swaptionVolatilities)
{
ResolvedSwaption product = trade.Product;
SwaptionSensitivity pointSens = isCash(product) ? cashParYieldPricer.presentValueSensitivityModelParamsVolatility(product, ratesProvider, swaptionVolatilities) : physicalPricer.presentValueSensitivityModelParamsVolatility(product, ratesProvider, swaptionVolatilities);
return(PointSensitivities.of(pointSens));
}
//-------------------------------------------------------------------------
public virtual void test_multipliedBy()
{
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
SwaptionSensitivity expected = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d * 3.5d);
SwaptionSensitivity test = @base.multipliedBy(3.5d);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_withSensitivity()
{
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
SwaptionSensitivity expected = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 20d);
SwaptionSensitivity test = @base.withSensitivity(20d);
assertEquals(test, expected);
}
private CurrencyParameterSensitivity parameterSensitivity(SwaptionSensitivity point)
{
double expiry = point.Expiry;
double strike = point.Strike;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(expiry, strike);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
private CurrencyParameterSensitivity parameterSensitivity(SwaptionSensitivity point)
{
double expiry = point.Expiry;
double moneyness = point.Strike - point.Forward;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(expiry, moneyness);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
public virtual void test_presentValueSensitivityNormalVolatility_after_expiry()
{
SwaptionSensitivity sensiRec = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG_PAST, RATE_PROVIDER, VOLS);
SwaptionSensitivity sensiPay = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT_PAST, RATE_PROVIDER, VOLS);
assertEquals(sensiRec.Sensitivity, 0.0d, NOTIONAL * TOL);
assertEquals(sensiPay.Sensitivity, 0.0d, NOTIONAL * TOL);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
FxRate rate = FxRate.of(GBP, USD, 1.5d);
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
SwaptionSensitivity expected = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, USD, 32d * 1.5d);
assertEquals(@base.convertedTo(USD, rate), expected);
assertEquals(@base.convertedTo(GBP, rate), @base);
}
public virtual void present_value_sensitivityBlackVolatility_at_expiry()
{
SwaptionSensitivity sensiRec = PRICER_SWAPTION_BLACK.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_AT_EXPIRY, MULTI_USD, BLACK_VOLS_USD_STD);
assertEquals(sensiRec.Sensitivity, 0d, TOLERANCE_PV);
SwaptionSensitivity sensiPay = PRICER_SWAPTION_BLACK.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_AT_EXPIRY, MULTI_USD, BLACK_VOLS_USD_STD);
assertEquals(sensiPay.Sensitivity, 0d, TOLERANCE_PV);
}
public int compareKey(PointSensitivity other)
{
if (other is SwaptionSensitivity)
{
SwaptionSensitivity otherSwpt = (SwaptionSensitivity)other;
return(ComparisonChain.start().compare(volatilitiesName, otherSwpt.volatilitiesName).compare(currency, otherSwpt.currency).compare(expiry, otherSwpt.expiry).compare(tenor, otherSwpt.tenor).compare(strike, otherSwpt.strike).compare(forward, otherSwpt.forward).result());
}
return(this.GetType().Name.CompareTo(other.GetType().Name));
}
public virtual void test_presentValueSensitivityBlackVolatility_afterMaturity()
{
SwaptionSensitivity sensiRec = PRICER.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG, RATES_PROVIDER_AFTER_MATURITY, VOLS_AFTER_MATURITY);
assertEquals(sensiRec.Sensitivity, 0d, NOTIONAL * TOL);
SwaptionSensitivity sensiPay = PRICER.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT, RATES_PROVIDER_AFTER_MATURITY, VOLS_AFTER_MATURITY);
assertEquals(sensiPay.Sensitivity, 0d, NOTIONAL * TOL);
}
//-------------------------------------------------------------------------
public virtual void test_buildInto()
{
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
MutablePointSensitivities combo = new MutablePointSensitivities();
MutablePointSensitivities test = @base.buildInto(combo);
assertSame(test, combo);
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
public virtual void test_combinedWith_mutable()
{
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(@base);
PointSensitivityBuilder test = @base.combinedWith(new MutablePointSensitivities());
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_withCurrency()
{
SwaptionSensitivity @base = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
assertSame(@base.withCurrency(GBP), @base);
SwaptionSensitivity expected = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, USD, 32d);
SwaptionSensitivity test = @base.withCurrency(USD);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_combinedWith()
{
SwaptionSensitivity base1 = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
SwaptionSensitivity base2 = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 22d);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(base1).add(base2);
PointSensitivityBuilder test = base1.combinedWith(base2);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_of()
{
SwaptionSensitivity test = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
assertEquals(test.VolatilitiesName, NAME);
assertEquals(test.Expiry, EXPIRY);
assertEquals(test.Tenor, TENOR);
assertEquals(test.Strike, STRIKE);
assertEquals(test.Forward, FORWARD);
assertEquals(test.Currency, GBP);
assertEquals(test.Sensitivity, 32d);
}
public virtual void test_presentValueSensitivityNormalVolatility_parity()
{
SwaptionSensitivity pvSensiRecLong = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS);
SwaptionSensitivity pvSensiRecShort = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_SHORT, RATE_PROVIDER, VOLS);
SwaptionSensitivity pvSensiPayLong = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_LONG, RATE_PROVIDER, VOLS);
SwaptionSensitivity pvSensiPayShort = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS);
assertEquals(pvSensiRecLong.Sensitivity, -pvSensiRecShort.Sensitivity, NOTIONAL * TOL);
assertEquals(pvSensiPayLong.Sensitivity, -pvSensiPayShort.Sensitivity, NOTIONAL * TOL);
assertEquals(pvSensiRecLong.Sensitivity, pvSensiPayLong.Sensitivity, NOTIONAL * TOL);
assertEquals(pvSensiPayShort.Sensitivity, pvSensiPayShort.Sensitivity, NOTIONAL * TOL);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
SwaptionSensitivity test = SwaptionSensitivity.of(NAME, EXPIRY, TENOR, STRIKE, FORWARD, GBP, 32d);
coverImmutableBean(test);
SwaptionSensitivity test2 = SwaptionSensitivity.of(NAME2, EXPIRY + 1, TENOR + 1, STRIKE + 1, FORWARD + 1, USD, 32d);
coverBeanEquals(test, test2);
ZeroRateSensitivity test3 = ZeroRateSensitivity.of(USD, 0.5d, 2d);
coverBeanEquals(test, test3);
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
SwaptionSensitivity other = (SwaptionSensitivity)obj;
return(JodaBeanUtils.equal(volatilitiesName, other.volatilitiesName) && JodaBeanUtils.equal(expiry, other.expiry) && JodaBeanUtils.equal(tenor, other.tenor) && JodaBeanUtils.equal(strike, other.strike) && JodaBeanUtils.equal(forward, other.forward) && JodaBeanUtils.equal(currency, other.currency) && JodaBeanUtils.equal(sensitivity, other.sensitivity));
}
return(false);
}
public CurrencyParameterSensitivities parameterSensitivity(PointSensitivities pointSensitivities)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is SwaptionSensitivity)
{
SwaptionSensitivity pt = (SwaptionSensitivity)point;
if (pt.VolatilitiesName.Equals(Name))
{
sens = sens.combinedWith(parameterSensitivity(pt));
}
}
}
return(sens);
}
//-------------------------------------------------------------------------
public virtual void present_value_sensitivityNormalVolatility_FD()
{
double shiftVol = 1.0E-4;
CurrencyAmount pvP = PRICER_SWAPTION_NORMAL.presentValue(SWAPTION_LONG_PAY, MULTI_USD, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(shiftVol));
CurrencyAmount pvM = PRICER_SWAPTION_NORMAL.presentValue(SWAPTION_LONG_PAY, MULTI_USD, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(-shiftVol));
double pvnvsFd = (pvP.Amount - pvM.Amount) / (2 * shiftVol);
SwaptionSensitivity pvnvsAd = PRICER_SWAPTION_NORMAL.presentValueSensitivityModelParamsVolatility(SWAPTION_LONG_PAY, MULTI_USD, NORMAL_VOLS_USD_STD);
assertEquals(pvnvsAd.Currency, USD);
assertEquals(pvnvsAd.Sensitivity, pvnvsFd, TOLERANCE_PV_VEGA);
assertEquals(pvnvsAd.VolatilitiesName, NORMAL_VOLS_USD_STD.Name);
assertEquals(pvnvsAd.Expiry, NORMAL_VOLS_USD_STD.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);
}
