//------------------------------------------------------------------------- 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); }