/// <summary>
/// Calculates the price sensitivity of the Ibor 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="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 curve sensitivity of the product </returns>
public virtual PointSensitivities priceSensitivityRatesStickyStrike(ResolvedIborFutureOption futureOption, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities, double futurePrice)
{
double delta = deltaStickyStrike(futureOption, ratesProvider, volatilities, futurePrice);
PointSensitivities futurePriceSensitivity = futurePricer.priceSensitivity(futureOption.UnderlyingFuture, ratesProvider);
return(futurePriceSensitivity.multipliedBy(delta));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the number related to Ibor futures product on which the daily margin is computed.
/// <para>
/// For two consecutive settlement prices C1 and C2, the daily margin is computed as
/// {@code marginIndex(future, C2) - marginIndex(future, C1)}.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="price"> the price of the product, in decimal form </param>
/// <returns> the index </returns>
internal virtual double marginIndex(ResolvedIborFutureOption option, double price)
{
double notional = option.UnderlyingFuture.Notional;
double accrualFactor = option.UnderlyingFuture.AccrualFactor;
return(price * notional * accrualFactor);
}
/// <summary>
/// Calculates the margin index sensitivity of the Ibor future product.
/// <para>
/// The margin index sensitivity if the sensitivity of the margin index to the underlying curves.
/// For two consecutive settlement prices C1 and C2, the daily margin is computed as
/// {@code marginIndex(future, C2) - marginIndex(future, C1)}.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="priceSensitivity"> the price sensitivity of the product </param>
/// <returns> the index sensitivity </returns>
internal virtual PointSensitivities marginIndexSensitivity(ResolvedIborFutureOption option, PointSensitivities priceSensitivity)
{
double notional = option.UnderlyingFuture.Notional;
double accrualFactor = option.UnderlyingFuture.AccrualFactor;
return(priceSensitivity.multipliedBy(notional * accrualFactor));
}
//-------------------------------------------------------------------------
/// <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));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the Ibor future option 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="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the present value curve sensitivity of the trade </returns>
public PointSensitivities presentValueSensitivityRates(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities)
{
ResolvedIborFutureOption product = trade.Product;
PointSensitivities priceSensi = futureOptionPricer.priceSensitivityRatesStickyStrike(product, ratesProvider, volatilities);
PointSensitivities marginIndexSensi = futureOptionPricer.marginIndexSensitivity(product, priceSensi);
return(marginIndexSensi.multipliedBy(trade.Quantity));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price sensitivity of the Ibor future option product based on curves.
/// <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>
/// <para>
/// This calculates the underlying future price using the future pricer.
///
/// </para>
/// </summary>
/// <param name="futureOption"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the price curve sensitivity of the product </returns>
public virtual PointSensitivities priceSensitivityRatesStickyStrike(ResolvedIborFutureOption futureOption, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities)
{
ArgChecker.isTrue(futureOption.PremiumStyle.Equals(FutureOptionPremiumStyle.DAILY_MARGIN), "Premium style should be DAILY_MARGIN");
double futurePrice = this.futurePrice(futureOption, ratesProvider);
return(priceSensitivityRatesStickyStrike(futureOption, ratesProvider, volatilities, futurePrice));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value of the Ibor future option trade from the current option price.
/// <para>
/// The present value of the product is the value on the valuation date.
/// The current price is specified, not calculated.
/// </para>
/// <para>
/// This method calculates based on the difference between the specified current price and the
/// last settlement price, or the trade price if traded on the valuation date.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="valuationDate"> the valuation date; required to asses if the trade or last closing price should be used </param>
/// <param name="currentOptionPrice"> the current price for the option, in decimal form </param>
/// <param name="lastOptionSettlementPrice"> the last settlement price used for margining for the option, in decimal form </param>
/// <returns> the present value </returns>
public CurrencyAmount presentValue(ResolvedIborFutureOptionTrade trade, LocalDate valuationDate, double currentOptionPrice, double lastOptionSettlementPrice)
{
ResolvedIborFutureOption option = trade.Product;
double referencePrice = this.referencePrice(trade, valuationDate, lastOptionSettlementPrice);
double priceIndex = futureOptionPricer.marginIndex(option, currentOptionPrice);
double referenceIndex = futureOptionPricer.marginIndex(option, referencePrice);
double pv = (priceIndex - referenceIndex) * trade.Quantity;
return(CurrencyAmount.of(option.UnderlyingFuture.Currency, pv));
}
/// <summary>
/// Calculates the delta of the Ibor future option product
/// based on the price of the underlying future.
/// <para>
/// The delta of the product is the sensitivity of the option price to the future price.
/// 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="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 curve sensitivity of the product </returns>
public virtual double deltaStickyStrike(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);
return(NormalFormulaRepository.delta(futurePrice, strike, timeToExpiry, volatility, futureOption.PutCall));
}
//-------------------------------------------------------------------------
// calculate the price of the underlying future
private double futurePrice(ResolvedIborFutureOption futureOption, RatesProvider ratesProvider)
{
ResolvedIborFuture future = futureOption.UnderlyingFuture;
return(futurePricer.price(future, ratesProvider));
}
/// <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));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price sensitivity to the normal volatility used for the pricing of the Ibor future option.
/// <para>
/// This sensitivity is also called the <i>price normal vega</i>.
/// </para>
/// <para>
/// This calculates the underlying future price using the future pricer.
///
/// </para>
/// </summary>
/// <param name="futureOption"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the sensitivity </returns>
public virtual IborFutureOptionSensitivity priceSensitivityModelParamsVolatility(ResolvedIborFutureOption futureOption, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities)
{
double futurePrice = this.futurePrice(futureOption, ratesProvider);
return(priceSensitivityModelParamsVolatility(futureOption, ratesProvider, volatilities, futurePrice));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the delta of the Ibor future option product.
/// <para>
/// The delta of the product is the sensitivity of the option price to the future price.
/// The volatility is unchanged for a fixed strike in the sensitivity computation, hence the "StickyStrike" name.
/// </para>
/// <para>
/// This calculates the underlying future price using the future pricer.
///
/// </para>
/// </summary>
/// <param name="futureOption"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the price curve sensitivity of the product </returns>
public virtual double deltaStickyStrike(ResolvedIborFutureOption futureOption, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities)
{
double futurePrice = this.futurePrice(futureOption, ratesProvider);
return(deltaStickyStrike(futureOption, ratesProvider, volatilities, futurePrice));
}