// unit price for one scenario
internal double unitPrice(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
// mark to model
NormalIborFutureOptionVolatilities normalVols = checkNormalVols(volatilities);
return(tradePricer.price(trade, ratesProvider, normalVols));
}
//-------------------------------------------------------------------------
// gets the settlement price
private double settlementPrice(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider)
{
StandardId standardId = trade.Product.SecurityId.StandardId;
QuoteId id = QuoteId.of(standardId, FieldName.SETTLEMENT_PRICE);
return(ratesProvider.data(id));
}
// calibrated sum PV01 for one scenario
internal MultiCurrencyAmount pv01CalibratedSum(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
NormalIborFutureOptionVolatilities normalVols = checkNormalVols(volatilities);
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivityRates(trade, ratesProvider, normalVols);
return(ratesProvider.parameterSensitivity(pointSensitivity).total().multipliedBy(ONE_BASIS_POINT));
}
// present value for one scenario
internal CurrencyAmount presentValue(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
// mark to model
double settlementPrice = this.settlementPrice(trade, ratesProvider);
NormalIborFutureOptionVolatilities normalVols = checkNormalVols(volatilities);
return(tradePricer.presentValue(trade, ratesProvider, normalVols, settlementPrice));
}
//-------------------------------------------------------------------------
/// <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));
}
// market quote bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01MarketQuoteBucketed(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
NormalIborFutureOptionVolatilities normalVols = checkNormalVols(volatilities);
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivityRates(trade, ratesProvider, normalVols);
CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity);
return(MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider).multipliedBy(ONE_BASIS_POINT));
}
//-------------------------------------------------------------------------
/// <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>
/// 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));
}
//-------------------------------------------------------------------------
// calculates unit price for all scenarios
internal DoubleScenarioArray unitPrice(ResolvedIborFutureOptionTrade trade, RatesScenarioMarketData ratesMarketData, IborFutureOptionScenarioMarketData optionMarketData)
{
IborIndex index = trade.Product.UnderlyingFuture.Index;
return(DoubleScenarioArray.of(ratesMarketData.ScenarioCount, i => unitPrice(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(index))));
}
//-------------------------------------------------------------------------
// calculates market quote bucketed PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01MarketQuoteBucketed(ResolvedIborFutureOptionTrade trade, RatesScenarioMarketData ratesMarketData, IborFutureOptionScenarioMarketData optionMarketData)
{
IborIndex index = trade.Product.UnderlyingFuture.Index;
return(ScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01MarketQuoteBucketed(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(index))));
}
/// <summary>
/// Calculates present value for a single set of market data.
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the market data </param>
/// <param name="volatilities"> the option volatilities </param>
/// <returns> the present value </returns>
public virtual CurrencyAmount presentValue(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
return(calc.presentValue(trade, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates present value across one or more scenarios.
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesLookup"> the lookup used to query the rates market data </param>
/// <param name="optionLookup"> the lookup used to query the option market data </param>
/// <param name="marketData"> the market data </param>
/// <returns> the present value, one entry per scenario </returns>
public virtual CurrencyScenarioArray presentValue(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData)
{
return(calc.presentValue(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price of the Ibor future option trade.
/// <para>
/// The price of the trade is the price on the valuation date.
/// The price is calculated using the volatility model.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the price of the product, in decimal form </returns>
public double price(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities)
{
return(futureOptionPricer.price(trade.Product, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
// calculates calibrated sum PV01 for all scenarios
internal MultiCurrencyScenarioArray pv01CalibratedSum(ResolvedIborFutureOptionTrade trade, RatesScenarioMarketData ratesMarketData, IborFutureOptionScenarioMarketData optionMarketData)
{
IborIndex index = trade.Product.UnderlyingFuture.Index;
return(MultiCurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01CalibratedSum(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(index))));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates present value sensitivity across one or more scenarios.
/// <para>
/// This is the sensitivity of
/// <seealso cref="#presentValue(ResolvedIborFutureOptionTrade, RatesMarketDataLookup, IborFutureOptionMarketDataLookup, ScenarioMarketData) present value"/>
/// to a one basis point shift in the market quotes used to calibrate the curves.
/// The result is provided for each affected curve and currency, bucketed by curve node.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesLookup"> the lookup used to query the rates market data </param>
/// <param name="optionLookup"> the lookup used to query the option market data </param>
/// <param name="marketData"> the market data </param>
/// <returns> the present value sensitivity, one entry per scenario </returns>
public virtual ScenarioArray <CurrencyParameterSensitivities> pv01MarketQuoteBucketed(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData)
{
return(calc.pv01MarketQuoteBucketed(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData)));
}
/// <summary>
/// Calculates present value sensitivity for a single set of market data.
/// <para>
/// This is the sensitivity of
/// <seealso cref="#presentValue(ResolvedIborFutureOptionTrade, RatesMarketDataLookup, IborFutureOptionMarketDataLookup, ScenarioMarketData) present value"/>
/// to a one basis point shift in the market quotes used to calibrate the curves.
/// The result is the sum of the sensitivities of all affected curves.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the market data </param>
/// <param name="volatilities"> the option volatilities </param>
/// <returns> the present value sensitivity </returns>
public virtual MultiCurrencyAmount pv01MarketQuoteSum(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
return(calc.pv01MarketQuoteSum(trade, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates present value sensitivity across one or more scenarios.
/// <para>
/// This is the sensitivity of
/// <seealso cref="#presentValue(ResolvedIborFutureOptionTrade, RatesMarketDataLookup, IborFutureOptionMarketDataLookup, ScenarioMarketData) present value"/>
/// to a one basis point shift in the market quotes used to calibrate the curves.
/// The result is the sum of the sensitivities of all affected curves.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesLookup"> the lookup used to query the rates market data </param>
/// <param name="optionLookup"> the lookup used to query the option market data </param>
/// <param name="marketData"> the market data </param>
/// <returns> the present value sensitivity, one entry per scenario </returns>
public virtual MultiCurrencyScenarioArray pv01MarketQuoteSum(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData)
{
return(calc.pv01MarketQuoteSum(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Computes the present value sensitivity to the normal volatility used in the pricing.
/// <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>
/// <para>
/// This calculates the underlying future price using the future pricer.
///
/// </para>
/// </summary>
/// <param name="futureOptionTrade"> the trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the price sensitivity </returns>
public IborFutureOptionSensitivity presentValueSensitivityModelParamsVolatility(ResolvedIborFutureOptionTrade futureOptionTrade, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities)
{
ResolvedIborFuture future = futureOptionTrade.Product.UnderlyingFuture;
double futurePrice = futureOptionPricer.FuturePricer.price(future, ratesProvider);
return(presentValueSensitivityModelParamsVolatility(futureOptionTrade, ratesProvider, volatilities, futurePrice));
}
/// <summary>
/// Calculates unit price for a single set of market data.
/// <para>
/// This is the price of a single unit of the security.
/// </para>
/// <para>
/// Strata uses <i>decimal prices</i> for Ibor futures in the trade model, pricers and market data.
/// The decimal price is based on the decimal rate equivalent to the percentage.
/// For example, a price of 99.32 implies an interest rate of 0.68% which is represented in Strata by 0.9932.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the market data </param>
/// <param name="volatilities"> the option volatilities </param>
/// <returns> the present value </returns>
public virtual double unitPrice(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
return(calc.unitPrice(trade, ratesProvider, volatilities));
}
/// <summary>
/// Calculates present value sensitivity for a single set of market data.
/// <para>
/// This is the sensitivity of
/// <seealso cref="#presentValue(ResolvedIborFutureOptionTrade, RatesMarketDataLookup, IborFutureOptionMarketDataLookup, ScenarioMarketData) present value"/>
/// to a one basis point shift in the market quotes used to calibrate the curves.
/// The result is provided for each affected curve and currency, bucketed by curve node.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the market data </param>
/// <param name="volatilities"> the option volatilities </param>
/// <returns> the present value sensitivity </returns>
public virtual CurrencyParameterSensitivities pv01MarketQuoteBucketed(ResolvedIborFutureOptionTrade trade, RatesProvider ratesProvider, IborFutureOptionVolatilities volatilities)
{
return(calc.pv01MarketQuoteBucketed(trade, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the reference price for the trade.
/// <para>
/// If the valuation date equals the trade date, then the reference price is the trade price.
/// Otherwise, the reference price is the last settlement price used for margining.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="valuationDate"> the date for which the reference price should be calculated </param>
/// <param name="lastSettlementPrice"> the last settlement price used for margining, in decimal form </param>
/// <returns> the reference price, in decimal form </returns>
private double referencePrice(ResolvedIborFutureOptionTrade trade, LocalDate valuationDate, double lastSettlementPrice)
{
ArgChecker.notNull(valuationDate, "valuationDate");
return(trade.TradedPrice.filter(tp => tp.TradeDate.Equals(valuationDate)).map(tp => tp.Price).orElse(lastSettlementPrice));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates unit price across one or more scenarios.
/// <para>
/// This is the price of a single unit of the security.
/// </para>
/// <para>
/// Strata uses <i>decimal prices</i> for Ibor futures in the trade model, pricers and market data.
/// The decimal price is based on the decimal rate equivalent to the percentage.
/// For example, a price of 99.32 implies an interest rate of 0.68% which is represented in Strata by 0.9932.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesLookup"> the lookup used to query the rates market data </param>
/// <param name="optionLookup"> the lookup used to query the option market data </param>
/// <param name="marketData"> the market data </param>
/// <returns> the present value, one entry per scenario </returns>
public virtual DoubleScenarioArray unitPrice(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData)
{
return(calc.unitPrice(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value of the Ibor future option trade from the underlying future price.
/// <para>
/// The present value of the product is the value on the valuation date.
/// The current price is calculated using the volatility model with a known future price.
/// </para>
/// <para>
/// This method calculates based on the difference between the model 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="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <param name="futurePrice"> the price of the underlying future, 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, RatesProvider ratesProvider, NormalIborFutureOptionVolatilities volatilities, double futurePrice, double lastOptionSettlementPrice)
{
double optionPrice = futureOptionPricer.price(trade.Product, ratesProvider, volatilities, futurePrice);
return(presentValue(trade, ratesProvider.ValuationDate, optionPrice, lastOptionSettlementPrice));
}
