//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity to the SABR model parameters of the swaption trade.
/// <para>
/// The sensitivity of the present value to the SABR model parameters, alpha, beta, rho and nu.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the point sensitivity to the SABR model parameters </returns>
public virtual PointSensitivities presentValueSensitivityModelParamsSabr(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SabrSwaptionVolatilities swaptionVolatilities)
{
ResolvedSwaption product = trade.Product;
PointSensitivityBuilder pointSens = isCash(product) ? cashParYieldPricer.presentValueSensitivityModelParamsSabr(product, ratesProvider, swaptionVolatilities) : physicalPricer.presentValueSensitivityModelParamsSabr(product, ratesProvider, swaptionVolatilities);
return(pointSens.build());
}
// market quote bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01RatesMarketQuoteBucketed(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
PointSensitivities pointSensitivity = this.pointSensitivity(trade, ratesProvider, volatilities);
CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity);
return(MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider).multipliedBy(ONE_BASIS_POINT));
}
// point sensitivity
private PointSensitivities pointSensitivity(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
if (volatilities is SabrSwaptionVolatilities)
{
return(sabrTradePricer.presentValueSensitivityRatesStickyModel(trade, ratesProvider, (SabrSwaptionVolatilities)volatilities));
}
return(tradePricer.presentValueSensitivityRatesStickyStrike(trade, ratesProvider, volatilities));
}
/// <summary>
/// Calculates the present value of the swaption trade.
/// <para>
/// The result is expressed using the currency of the swapion.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="hwProvider"> the Hull-White model parameter trade </param>
/// <returns> the present value </returns>
public virtual CurrencyAmount presentValue(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, HullWhiteOneFactorPiecewiseConstantParametersProvider hwProvider)
{
ResolvedSwaption product = trade.Product;
CurrencyAmount pvProduct = PRICER_PRODUCT.presentValue(product, ratesProvider, hwProvider);
Payment premium = trade.Premium;
CurrencyAmount pvPremium = PRICER_PREMIUM.presentValue(premium, ratesProvider);
return(pvProduct.plus(pvPremium));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the swaption product.
/// <para>
/// The present value sensitivity of the product is the sensitivity of the present value to
/// the underlying curves.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="hwProvider"> the Hull-White model parameter provider </param>
/// <returns> the point sensitivity to the rate curves </returns>
public virtual PointSensitivities presentValueSensitivityRates(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, HullWhiteOneFactorPiecewiseConstantParametersProvider hwProvider)
{
ResolvedSwaption product = trade.Product;
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRates(product, ratesProvider, hwProvider);
Payment premium = trade.Premium;
PointSensitivityBuilder pvcsPremium = PRICER_PREMIUM.presentValueSensitivity(premium, ratesProvider);
return(pvcsProduct.combinedWith(pvcsPremium).build());
}
/// <summary>
/// Calculates the current cash of the swaption trade.
/// <para>
/// Only the premium is contributing to the current cash for non-cash settle swaptions.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="valuationDate"> the valuation date </param>
/// <returns> the current cash amount </returns>
public virtual CurrencyAmount currentCash(ResolvedSwaptionTrade trade, LocalDate valuationDate)
{
Payment premium = trade.Premium;
if (premium.Date.Equals(valuationDate))
{
return(CurrencyAmount.of(premium.Currency, premium.Amount));
}
return(CurrencyAmount.of(premium.Currency, 0d));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value of the swaption trade.
/// <para>
/// The result is expressed using the currency of the swaption.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the present value </returns>
public virtual CurrencyAmount presentValue(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SabrSwaptionVolatilities swaptionVolatilities)
{
// product
ResolvedSwaption product = trade.Product;
CurrencyAmount pvProduct = isCash(product) ? cashParYieldPricer.presentValue(product, ratesProvider, swaptionVolatilities) : physicalPricer.presentValue(product, ratesProvider, swaptionVolatilities);
// premium
Payment premium = trade.Premium;
CurrencyAmount pvPremium = paymentPricer.presentValue(premium, ratesProvider);
// total
return(pvProduct.plus(pvPremium));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the swaption trade to the rate curves.
/// <para>
/// The present value sensitivity is computed in a "sticky model parameter" style, i.e. the sensitivity to the
/// curve nodes with the SABR model parameters unchanged. This sensitivity does not include a potential
/// re-calibration of the model parameters to the raw market data.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the point sensitivity to the rate curves </returns>
public virtual PointSensitivities presentValueSensitivityRatesStickyModel(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SabrSwaptionVolatilities swaptionVolatilities)
{
// product
ResolvedSwaption product = trade.Product;
PointSensitivityBuilder pointSens = isCash(product) ? cashParYieldPricer.presentValueSensitivityRatesStickyModel(product, ratesProvider, swaptionVolatilities) : physicalPricer.presentValueSensitivityRatesStickyModel(product, ratesProvider, swaptionVolatilities);
// premium
Payment premium = trade.Premium;
PointSensitivityBuilder pvcsPremium = paymentPricer.presentValueSensitivity(premium, ratesProvider);
// total
return(pointSens.combinedWith(pvcsPremium).build());
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the swaption to the rate curves.
/// <para>
/// The present value sensitivity is computed in a "sticky strike" style, i.e. the sensitivity to the
/// curve nodes with the volatility at the swaption strike unchanged. This sensitivity does not include a potential
/// change of volatility due to the implicit change of forward rate or moneyness.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the point sensitivity to the rate curves </returns>
public virtual PointSensitivities presentValueSensitivityRatesStickyStrike(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities swaptionVolatilities)
{
// product
ResolvedSwaption product = trade.Product;
PointSensitivityBuilder pvcsProduct = productPricer.presentValueSensitivityRatesStickyStrike(product, ratesProvider, swaptionVolatilities);
// premium
Payment premium = trade.Premium;
PointSensitivityBuilder pvcsPremium = paymentPricer.presentValueSensitivity(premium, ratesProvider);
// total
return(pvcsProduct.combinedWith(pvcsPremium).build());
}
// calibrated sum PV01 for one scenario
internal MultiCurrencyAmount pv01RatesCalibratedSum(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
PointSensitivities pointSensitivity = this.pointSensitivity(trade, ratesProvider, volatilities);
return(ratesProvider.parameterSensitivity(pointSensitivity).total().multipliedBy(ONE_BASIS_POINT));
}
//-------------------------------------------------------------------------
// calculates calibrated sum PV01 for all scenarios
internal MultiCurrencyScenarioArray pv01RatesCalibratedSum(ResolvedSwaptionTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
IborIndex index = trade.Product.Index;
return(MultiCurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesCalibratedSum(trade, ratesMarketData.scenario(i).ratesProvider(), swaptionMarketData.scenario(i).volatilities(index))));
}
// present value for one scenario
internal CurrencyAmount presentValue(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
return(tradePricer.presentValue(trade, ratesProvider, volatilities));
}
/// <summary>
/// Calculates currency exposure for a single set of market data.
/// <para>
/// The currency risk, expressed as the equivalent amount in each currency.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the market data </param>
/// <param name="volatilities"> the swaption volatilities </param>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposure(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
return(calc.currencyExposure(trade, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
/// <summary>
/// Computes the currency exposure of the swaption trade.
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="hwProvider"> the Hull-White model parameter provider </param>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposure(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, HullWhiteOneFactorPiecewiseConstantParametersProvider hwProvider)
{
return(MultiCurrencyAmount.of(presentValue(trade, ratesProvider, hwProvider)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates present value sensitivity across one or more scenarios.
/// <para>
/// This is the sensitivity of 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 market data </param>
/// <param name="swaptionLookup"> the lookup used to query the swaption market data </param>
/// <param name="marketData"> the market data </param>
/// <returns> the present value sensitivity, one entry per scenario </returns>
public virtual MultiCurrencyScenarioArray pv01RatesMarketQuoteSum(ResolvedSwaptionTrade trade, RatesMarketDataLookup ratesLookup, SwaptionMarketDataLookup swaptionLookup, ScenarioMarketData marketData)
{
return(calc.pv01RatesMarketQuoteSum(trade, ratesLookup.marketDataView(marketData), swaptionLookup.marketDataView(marketData)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates present value sensitivity across one or more scenarios.
/// <para>
/// This is the sensitivity of 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 market data </param>
/// <param name="marketData"> the market data </param>
/// <param name="swaptionLookup"> the lookup used to query the swaption market data </param>
/// <returns> the present value sensitivity, one entry per scenario </returns>
public virtual ScenarioArray <CurrencyParameterSensitivities> pv01RatesMarketQuoteBucketed(ResolvedSwaptionTrade trade, RatesMarketDataLookup ratesLookup, SwaptionMarketDataLookup swaptionLookup, ScenarioMarketData marketData)
{
return(calc.pv01RatesMarketQuoteBucketed(trade, ratesLookup.marketDataView(marketData), swaptionLookup.marketDataView(marketData)));
}
/// <summary>
/// Calculates present value sensitivity for a single set of market data.
/// <para>
/// This is the sensitivity of 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 swaption volatilities </param>
/// <returns> the present value sensitivity </returns>
public virtual CurrencyParameterSensitivities pv01RatesMarketQuoteBucketed(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
return(calc.pv01RatesMarketQuoteBucketed(trade, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
// calculates market quote bucketed PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01RatesMarketQuoteBucketed(ResolvedSwaptionTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
IborIndex index = trade.Product.Index;
return(ScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesMarketQuoteBucketed(trade, ratesMarketData.scenario(i).ratesProvider(), swaptionMarketData.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 swaption volatilities </param>
/// <returns> the present value </returns>
public virtual CurrencyAmount presentValue(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities 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 market data </param>
/// <param name="swaptionLookup"> the lookup used to query the swaption market data </param>
/// <param name="marketData"> the market data </param>
/// <returns> the present value, one entry per scenario </returns>
public virtual CurrencyScenarioArray presentValue(ResolvedSwaptionTrade trade, RatesMarketDataLookup ratesLookup, SwaptionMarketDataLookup swaptionLookup, ScenarioMarketData marketData)
{
return(calc.presentValue(trade, ratesLookup.marketDataView(marketData), swaptionLookup.marketDataView(marketData)));
}
/// <summary>
/// Calculates current cash for a single set of market data.
/// <para>
/// The sum of all cash flows paid on the valuation date.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the market data </param>
/// <param name="volatilities"> the swaption volatilities </param>
/// <returns> the current cash </returns>
public virtual CurrencyAmount currentCash(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
return(calc.currentCash(trade, ratesProvider.ValuationDate));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity to the implied volatility of the swaption trade.
/// <para>
/// The sensitivity to the normal volatility is also called normal vega.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the point sensitivity to the normal volatility </returns>
public virtual PointSensitivities presentValueSensitivityModelParamsVolatility(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, NormalSwaptionVolatilities swaptionVolatilities)
{
ResolvedSwaption product = trade.Product;
SwaptionSensitivity pointSens = isCash(product) ? cashParYieldPricer.presentValueSensitivityModelParamsVolatility(product, ratesProvider, swaptionVolatilities) : physicalPricer.presentValueSensitivityModelParamsVolatility(product, ratesProvider, swaptionVolatilities);
return(PointSensitivities.of(pointSens));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity to the implied volatility of the swaption trade.
/// <para>
/// The sensitivity to the implied volatility is also called vega.
///
/// </para>
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the point sensitivity to the implied volatility </returns>
public virtual PointSensitivities presentValueSensitivityModelParamsVolatility(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities swaptionVolatilities)
{
ResolvedSwaption product = trade.Product;
SwaptionSensitivity pointSens = productPricer.presentValueSensitivityModelParamsVolatility(product, ratesProvider, swaptionVolatilities);
return(PointSensitivities.of(pointSens));
}
/// <summary>
/// Calculates present value sensitivity for a single set of market data.
/// <para>
/// This is the sensitivity of 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 swaption volatilities </param>
/// <returns> the present value sensitivity </returns>
public virtual MultiCurrencyAmount pv01RatesMarketQuoteSum(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
return(calc.pv01RatesMarketQuoteSum(trade, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
// calculates current cash for all scenarios
internal CurrencyScenarioArray currentCash(ResolvedSwaptionTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
return(CurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => currentCash(trade, ratesMarketData.scenario(i).ValuationDate)));
}
// current cash for one scenario
internal CurrencyAmount currentCash(ResolvedSwaptionTrade trade, LocalDate valuationDate)
{
return(tradePricer.currentCash(trade, valuationDate));
}
//-------------------------------------------------------------------------
/// <summary>
/// Computes the currency exposure of the swaption trade.
/// </summary>
/// <param name="trade"> the swaption trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the volatilities </param>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposure(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SabrSwaptionVolatilities swaptionVolatilities)
{
return(MultiCurrencyAmount.of(presentValue(trade, ratesProvider, swaptionVolatilities)));
}
//-------------------------------------------------------------------------
// calculates present value for all scenarios
internal CurrencyScenarioArray presentValue(ResolvedSwaptionTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
IborIndex index = trade.Product.Index;
return(CurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => presentValue(trade, ratesMarketData.scenario(i).ratesProvider(), swaptionMarketData.scenario(i).volatilities(index))));
}
// currency exposure for one scenario
internal MultiCurrencyAmount currencyExposure(ResolvedSwaptionTrade trade, RatesProvider ratesProvider, SwaptionVolatilities volatilities)
{
return(tradePricer.currencyExposure(trade, ratesProvider, volatilities));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates currency exposure across one or more scenarios.
/// <para>
/// The currency risk, expressed as the equivalent amount in each currency.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesLookup"> the lookup used to query the market data </param>
/// <param name="swaptionLookup"> the lookup used to query the swaption market data </param>
/// <param name="marketData"> the market data </param>
/// <returns> the currency exposure, one entry per scenario </returns>
public virtual MultiCurrencyScenarioArray currencyExposure(ResolvedSwaptionTrade trade, RatesMarketDataLookup ratesLookup, SwaptionMarketDataLookup swaptionLookup, ScenarioMarketData marketData)
{
return(calc.currencyExposure(trade, ratesLookup.marketDataView(marketData), swaptionLookup.marketDataView(marketData)));
}
