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