private CurrencyParameterSensitivity parameterSensitivity(IborFutureOptionSensitivity point) { double simpleMoneyness = moneynessOnPrice ? point.StrikePrice - point.FuturePrice : point.FuturePrice - point.StrikePrice; UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(point.Expiry, simpleMoneyness); return(unitSens.multipliedBy(point.Currency, point.Sensitivity)); }
//------------------------------------------------------------------------- public virtual void test_build() { IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); PointSensitivities test = @base.build(); assertEquals(test.Sensitivities, ImmutableList.of(@base)); }
//------------------------------------------------------------------------- public virtual void test_cloned() { IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity test = @base.cloned(); assertSame(test, @base); }
//------------------------------------------------------------------------- public virtual void test_compareKey() { IborFutureOptionSensitivity a1 = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity a2 = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity b = IborFutureOptionSensitivity.of(NAME2, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity c = IborFutureOptionSensitivity.of(NAME, 13d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity d = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 9, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity e = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.99, 0.99, GBP, 32d); IborFutureOptionSensitivity f = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 1.00, GBP, 32d); IborFutureOptionSensitivity g = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, USD, 32d); ZeroRateSensitivity other = ZeroRateSensitivity.of(GBP, 2d, 32d); assertEquals(a1.compareKey(a2), 0); assertEquals(a1.compareKey(b) < 0, true); assertEquals(b.compareKey(a1) > 0, true); assertEquals(a1.compareKey(c) < 0, true); assertEquals(c.compareKey(a1) > 0, true); assertEquals(a1.compareKey(d) < 0, true); assertEquals(d.compareKey(a1) > 0, true); assertEquals(a1.compareKey(e) < 0, true); assertEquals(e.compareKey(a1) > 0, true); assertEquals(a1.compareKey(f) < 0, true); assertEquals(f.compareKey(a1) > 0, true); assertEquals(a1.compareKey(g) < 0, true); assertEquals(g.compareKey(a1) > 0, true); assertEquals(a1.compareKey(other) < 0, true); assertEquals(other.compareKey(a1) > 0, true); }
//------------------------------------------------------------------------- public virtual void test_withSensitivity() { IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity expected = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 20d); IborFutureOptionSensitivity test = @base.withSensitivity(20d); assertEquals(test, expected); }
//------------------------------------------------------------------------- public virtual void test_multipliedBy() { IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); IborFutureOptionSensitivity expected = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d * 3.5d); IborFutureOptionSensitivity test = @base.multipliedBy(3.5d); assertEquals(test, expected); }
//------------------------------------------------------------------------- /// <summary> /// Computes the present value sensitivity to the normal volatility used in the pricing /// based on the price of the underlying future. /// <para> /// The result is a single sensitivity to the volatility used. /// The volatility is associated with the expiry/delay/strike/future price key combination. /// /// </para> /// </summary> /// <param name="futureOptionTrade"> the trade </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="volatilities"> the volatilities </param> /// <param name="futurePrice"> the price of the underlying future, in decimal form </param> /// <returns> the price sensitivity </returns> public IborFutureOptionSensitivity presentValueSensitivityModelParamsVolatility(ResolvedIborFutureOptionTrade futureOptionTrade, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities, double futurePrice) { ResolvedIborFutureOption product = futureOptionTrade.Product; IborFutureOptionSensitivity priceSensitivity = futureOptionPricer.priceSensitivityModelParamsVolatility(product, ratesProvider, volatilities, futurePrice); double factor = futureOptionPricer.marginIndex(product, 1) * futureOptionTrade.Quantity; return(priceSensitivity.multipliedBy(factor)); }
//------------------------------------------------------------------------- public virtual void test_buildInto() { IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); MutablePointSensitivities combo = new MutablePointSensitivities(); MutablePointSensitivities test = @base.buildInto(combo); assertSame(test, combo); assertEquals(test.Sensitivities, ImmutableList.of(@base)); }
//------------------------------------------------------------------------- public virtual void coverage() { IborFutureOptionSensitivity test = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); coverImmutableBean(test); IborFutureOptionSensitivity test2 = IborFutureOptionSensitivity.of(NAME2, 13d, date(2015, 8, 29), 0.99, 0.995, USD, 33d); coverBeanEquals(test, test2); }
public int compareKey(PointSensitivity other) { if (other is IborFutureOptionSensitivity) { IborFutureOptionSensitivity otherOption = (IborFutureOptionSensitivity)other; return(ComparisonChain.start().compare(volatilitiesName, otherOption.volatilitiesName).compare(currency, otherOption.currency).compare(expiry, otherOption.expiry).compare(fixingDate, otherOption.fixingDate).compare(strikePrice, otherOption.strikePrice).compare(futurePrice, otherOption.futurePrice).result()); } return(this.GetType().Name.CompareTo(other.GetType().Name)); }
//------------------------------------------------------------------------- public virtual void test_withCurrency() { IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); assertSame(@base.withCurrency(GBP), @base); IborFutureOptionSensitivity expected = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, USD, 32d); IborFutureOptionSensitivity test = @base.withCurrency(USD); assertEquals(test, expected); }
public virtual void test_of() { IborFutureOptionSensitivity test = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); assertEquals(test.VolatilitiesName, NAME); assertEquals(test.Currency, GBP); assertEquals(test.Expiry, 12d); assertEquals(test.FixingDate, date(2015, 8, 28)); assertEquals(test.StrikePrice, 0.98); assertEquals(test.FuturePrice, 0.99); assertEquals(test.Sensitivity, 32d); }
/// <summary> /// Calculates the price sensitivity to the normal volatility used for the pricing of the Ibor future option /// based on the price of the underlying future. /// <para> /// This sensitivity is also called the <i>price normal vega</i>. /// /// </para> /// </summary> /// <param name="futureOption"> the option product </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="volatilities"> the volatilities </param> /// <param name="futurePrice"> the underlying future price, in decimal form </param> /// <returns> the sensitivity </returns> public virtual IborFutureOptionSensitivity priceSensitivityModelParamsVolatility(ResolvedIborFutureOption futureOption, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities, double futurePrice) { ArgChecker.isTrue(futureOption.PremiumStyle.Equals(FutureOptionPremiumStyle.DAILY_MARGIN), "Premium style should be DAILY_MARGIN"); double timeToExpiry = volatilities.relativeTime(futureOption.Expiry); double strike = futureOption.StrikePrice; ResolvedIborFuture future = futureOption.UnderlyingFuture; double volatility = volatilities.volatility(timeToExpiry, future.LastTradeDate, strike, futurePrice); double vega = NormalFormulaRepository.vega(futurePrice, strike, timeToExpiry, volatility, futureOption.PutCall); return(IborFutureOptionSensitivity.of(volatilities.Name, timeToExpiry, future.LastTradeDate, strike, futurePrice, future.Currency, vega)); }
//----------------------------------------------------------------------- public override bool Equals(object obj) { if (obj == this) { return(true); } if (obj != null && obj.GetType() == this.GetType()) { IborFutureOptionSensitivity other = (IborFutureOptionSensitivity)obj; return(JodaBeanUtils.equal(volatilitiesName, other.volatilitiesName) && JodaBeanUtils.equal(expiry, other.expiry) && JodaBeanUtils.equal(fixingDate, other.fixingDate) && JodaBeanUtils.equal(strikePrice, other.strikePrice) && JodaBeanUtils.equal(futurePrice, other.futurePrice) && JodaBeanUtils.equal(currency, other.currency) && JodaBeanUtils.equal(sensitivity, other.sensitivity)); } return(false); }
// ---------- present value normal vol sensitivity ---------- public virtual void presentvalue_normalVolSensitivity_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); IborFutureOptionSensitivity psProduct = OPTION_PRODUCT_PRICER.priceSensitivityModelParamsVolatility(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); IborFutureOptionSensitivity psExpected = psProduct.withSensitivity(psProduct.Sensitivity * OPTION_PRODUCT_PRICER.marginIndex(OPTION, 1) * OPTION_QUANTITY); IborFutureOptionSensitivity psComputed = OPTION_TRADE_PRICER.presentValueSensitivityModelParamsVolatility(FUTURE_OPTION_TRADE, prov, VOL_SIMPLE_MONEY_PRICE); assertTrue(psExpected.compareKey(psComputed) == 0); assertEquals(psComputed.Sensitivity, psExpected.Sensitivity, TOLERANCE_PV_DELTA); }
public virtual void priceSensitivityNormalVolatility_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); double futurePrice = 1.0 - RATE; IborFutureOptionSensitivity optionVegaExpected = OPTION_PRICER.priceSensitivityModelParamsVolatility(OPTION, prov, VOL_SIMPLE_MONEY_PRICE, futurePrice); IborFutureOptionSensitivity optionVegaComputed = OPTION_PRICER.priceSensitivityModelParamsVolatility(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); assertTrue(optionVegaExpected.compareKey(optionVegaComputed) == 0); assertEquals(optionVegaComputed.Sensitivity, optionVegaExpected.Sensitivity, TOLERANCE_PRICE_DELTA); }
public CurrencyParameterSensitivities parameterSensitivity(PointSensitivities pointSensitivities) { CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty(); foreach (PointSensitivity point in pointSensitivities.Sensitivities) { if (point is IborFutureOptionSensitivity) { IborFutureOptionSensitivity pt = (IborFutureOptionSensitivity)point; if (pt.VolatilitiesName.Equals(Name)) { sens = sens.combinedWith(parameterSensitivity(pt)); } } } return(sens); }
//------------------------------------------------------------------------- public virtual void test_convertedTo() { LocalDate fixingDate = date(2015, 8, 28); double strike = 0.98d; double forward = 0.99d; double sensi = 32d; IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, fixingDate, strike, forward, GBP, sensi); double rate = 1.5d; FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate); IborFutureOptionSensitivity test1 = (IborFutureOptionSensitivity)@base.convertedTo(USD, matrix); IborFutureOptionSensitivity expected = IborFutureOptionSensitivity.of(NAME, 12d, fixingDate, strike, forward, USD, sensi * rate); assertEquals(test1, expected); IborFutureOptionSensitivity test2 = (IborFutureOptionSensitivity)@base.convertedTo(GBP, matrix); assertEquals(test2, @base); }
//------------------------------------------------------------------------- public virtual void test_parameterSensitivity() { double expiry = ACT_365F.relativeYearFraction(VAL_DATE, LocalDate.of(2015, 8, 14)); LocalDate fixing = LocalDate.of(2016, 9, 14); double strikePrice = 1.0025; double futurePrice = 0.9975; double sensitivity = 123456; IborFutureOptionSensitivity point = IborFutureOptionSensitivity.of(VOL_SIMPLE_MONEY_RATE.Name, expiry, fixing, strikePrice, futurePrice, EUR, sensitivity); CurrencyParameterSensitivities ps = VOL_SIMPLE_MONEY_RATE.parameterSensitivity(point); double shift = 1.0E-6; double v0 = VOL_SIMPLE_MONEY_RATE.volatility(expiry, fixing, strikePrice, futurePrice); for (int i = 0; i < NORMAL_VOL_RATES.size(); i++) { DoubleArray v = NORMAL_VOL_RATES.with(i, NORMAL_VOL_RATES.get(i) + shift); InterpolatedNodalSurface param = InterpolatedNodalSurface.of(Surfaces.normalVolatilityByExpirySimpleMoneyness("Rate", ACT_365F, MoneynessType.RATES), TIMES, MONEYNESS_RATES, v, INTERPOLATOR_2D); NormalIborFutureOptionExpirySimpleMoneynessVolatilities vol = NormalIborFutureOptionExpirySimpleMoneynessVolatilities.of(EUR_EURIBOR_3M, VAL_DATE_TIME, param); double vP = vol.volatility(expiry, fixing, strikePrice, futurePrice); double s = ps.getSensitivity(PARAMETERS_RATE.Name, EUR).Sensitivity.get(i); assertEquals(s, (vP - v0) / shift * sensitivity, TOLERANCE_DELTA); } }
// ---------- priceSensitivityNormalVolatility ---------- public virtual void priceSensitivityNormalVolatility_from_future_price() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); double futurePrice = 0.9875; double strike = OPTION.StrikePrice; double timeToExpiry = ACT_365F.relativeYearFraction(VAL_DATE, OPTION.ExpiryDate); double priceSimpleMoneyness = strike - futurePrice; double normalVol = PARAMETERS_PRICE.zValue(timeToExpiry, priceSimpleMoneyness); EuropeanVanillaOption option = EuropeanVanillaOption.of(strike, timeToExpiry, OPTION.PutCall); NormalFunctionData normalPoint = NormalFunctionData.of(futurePrice, 1.0, normalVol); double optionVegaExpected = NORMAL_FUNCTION.getVega(option, normalPoint); IborFutureOptionSensitivity optionVegaComputed = OPTION_PRICER.priceSensitivityModelParamsVolatility(OPTION, prov, VOL_SIMPLE_MONEY_PRICE, futurePrice); assertEquals(optionVegaComputed.Sensitivity, optionVegaExpected, TOLERANCE_PRICE); assertEquals(optionVegaComputed.Expiry, timeToExpiry); assertEquals(optionVegaComputed.FixingDate, OPTION.UnderlyingFuture.IborRate.Observation.FixingDate); assertEquals(optionVegaComputed.StrikePrice, OPTION.StrikePrice); assertEquals(optionVegaComputed.FuturePrice, futurePrice); }
public virtual void test_serialization() { IborFutureOptionSensitivity test = IborFutureOptionSensitivity.of(NAME, 12d, date(2015, 8, 28), 0.98, 0.99, GBP, 32d); assertSerialization(test); }