//-------------------------------------------------------------------------
public virtual void test_priceSensitivity()
{
PointSensitivities point = FUTURE_PRICER.priceSensitivity(FUTURE_PRODUCT, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, (p) => CurrencyAmount.of(USD, FUTURE_PRICER.price(FUTURE_PRODUCT, (p))));
assertTrue(computed.equalWithTolerance(expected, EPS * 10.0));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the bond future trade.
/// <para>
/// The present value sensitivity of the trade is the sensitivity of the present value to
/// the underlying curves.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <returns> the present value curve sensitivity of the trade </returns>
public PointSensitivities presentValueSensitivity(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider)
{
ResolvedBondFuture product = trade.Product;
PointSensitivities priceSensi = productPricer.priceSensitivity(product, discountingProvider);
PointSensitivities marginIndexSensi = productPricer.marginIndexSensitivity(product, priceSensi);
return(marginIndexSensi.multipliedBy(trade.Quantity));
}
/// <summary>
/// Calculates the price sensitivity of the bond future option product based on the price of the underlying future.
/// <para>
/// The price sensitivity of the product is the sensitivity of the price to the underlying curves.
/// The volatility is unchanged for a fixed strike in the sensitivity computation, hence the "StickyStrike" name.
///
/// </para>
/// </summary>
/// <param name="futureOption"> the option product </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <param name="futurePrice"> the price of the underlying future </param>
/// <returns> the price curve sensitivity of the product </returns>
public PointSensitivities priceSensitivityRatesStickyStrike(ResolvedBondFutureOption futureOption, LegalEntityDiscountingProvider discountingProvider, BlackBondFutureVolatilities volatilities, double futurePrice)
{
double delta = deltaStickyStrike(futureOption, discountingProvider, volatilities, futurePrice);
PointSensitivities futurePriceSensitivity = futurePricer.priceSensitivity(futureOption.UnderlyingFuture, discountingProvider);
return(futurePriceSensitivity.multipliedBy(delta));
}
//-------------------------------------------------------------------------
public virtual void test_priceSensitivity()
{
PointSensitivities point = OPTION_PRICER.priceSensitivityRatesStickyStrike(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOLS);
CurrencyParameterSensitivities computed = RATE_PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATE_PROVIDER, (p) => CurrencyAmount.of(EUR, OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, (p), VOLS)));
double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.UnderlyingFuture, RATE_PROVIDER);
double strike = FUTURE_OPTION_PRODUCT.StrikePrice;
double expiryTime = ACT_365F.relativeYearFraction(VAL_DATE, FUTURE_OPTION_PRODUCT.ExpiryDate);
double logMoneyness = Math.Log(strike / futurePrice);
double logMoneynessUp = Math.Log(strike / (futurePrice + EPS));
double logMoneynessDw = Math.Log(strike / (futurePrice - EPS));
double vol = SURFACE.zValue(expiryTime, logMoneyness);
double volUp = SURFACE.zValue(expiryTime, logMoneynessUp);
double volDw = SURFACE.zValue(expiryTime, logMoneynessDw);
double volSensi = 0.5 * (volUp - volDw) / EPS;
double vega = BlackFormulaRepository.vega(futurePrice, strike, expiryTime, vol);
CurrencyParameterSensitivities sensiVol = RATE_PROVIDER.parameterSensitivity(FUTURE_PRICER.priceSensitivity(FUTURE_OPTION_PRODUCT.UnderlyingFuture, RATE_PROVIDER)).multipliedBy(-vega * volSensi);
expected = expected.combinedWith(sensiVol);
assertTrue(computed.equalWithTolerance(expected, 30d * EPS));
}