//-------------------------------------------------------------------------
/// <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));
}
// point sensitivity
private PointSensitivities pointSensitivity(ResolvedIborCapFloorTrade trade, RatesProvider ratesProvider, IborCapletFloorletVolatilities volatilities)
{
return(tradePricer.presentValueSensitivityRates(trade, ratesProvider, volatilities));
}
// calibrated bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01RatesCalibratedBucketed(ResolvedIborCapFloorTrade trade, RatesProvider ratesProvider, IborCapletFloorletVolatilities volatilities)
{
PointSensitivities pointSensitivity = this.pointSensitivity(trade, ratesProvider, volatilities);
return(ratesProvider.parameterSensitivity(pointSensitivity).multipliedBy(ONE_BASIS_POINT));
}
// point sensitivity
private CurrencyParameterSensitivities pointSensitivity(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method)
{
PointSensitivities pointSens;
if (method == FxVanillaOptionMethod.VANNA_VOLGA)
{
pointSens = vannaVolgaPricer.presentValueSensitivityRatesStickyStrike(trade, ratesProvider, checkVannaVolgaVolatilities(volatilities));
}
else
{
pointSens = blackPricer.presentValueSensitivityRatesStickyStrike(trade, ratesProvider, checkBlackVolatilities(volatilities));
}
return(ratesProvider.parameterSensitivity(pointSens));
}
// calibrated sum PV01 for one scenario
internal MultiCurrencyAmount pv01RatesCalibratedSum(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method)
{
CurrencyParameterSensitivities paramSens = pointSensitivity(trade, ratesProvider, volatilities, method);
return(paramSens.total().multipliedBy(ONE_BASIS_POINT));
}
/// <summary>
/// Calculates the price sensitivity of the Ibor future product.
/// <para>
/// The price sensitivity of the product is the sensitivity of the price to the underlying curves.
///
/// </para>
/// </summary>
/// <param name="future"> the future </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="hwProvider"> the Hull-White model parameter provider </param>
/// <returns> the price curve sensitivity of the product </returns>
public virtual PointSensitivities priceSensitivityRates(ResolvedIborFuture future, RatesProvider ratesProvider, HullWhiteOneFactorPiecewiseConstantParametersProvider hwProvider)
{
IborIndexObservation obs = future.IborRate.Observation;
LocalDate fixingStartDate = obs.EffectiveDate;
LocalDate fixingEndDate = obs.MaturityDate;
double convexity = hwProvider.futuresConvexityFactor(future.LastTradeDate, fixingStartDate, fixingEndDate);
IborRateSensitivity sensi = IborRateSensitivity.of(obs, -convexity);
// The sensitivity should be to no currency or currency XXX. To avoid useless conversion, the dimension-less
// price sensitivity is reported in the future currency.
return(PointSensitivities.of(sensi));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price of the Ibor future product.
/// <para>
/// The price of the product is the price on the valuation date.
///
/// </para>
/// </summary>
/// <param name="future"> the future </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="hwProvider"> the Hull-White model parameter provider </param>
/// <returns> the price of the product, in decimal form </returns>
public virtual double price(ResolvedIborFuture future, RatesProvider ratesProvider, HullWhiteOneFactorPiecewiseConstantParametersProvider hwProvider)
{
double parRate = this.parRate(future, ratesProvider, hwProvider);
return(1d - parRate);
}
// current cash for one scenario
internal CurrencyAmount currentCash(ResolvedFxNdfTrade trade, RatesProvider ratesProvider)
{
return(tradePricer.currentCash(trade, ratesProvider));
}
// current cash for one scenario
internal FxRate forwardFxRate(ResolvedFxNdfTrade trade, RatesProvider ratesProvider)
{
return(tradePricer.forwardFxRate(trade, ratesProvider));
}
// market quote bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01MarketQuoteBucketed(ResolvedFxNdfTrade trade, RatesProvider ratesProvider)
{
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider);
CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity);
return(MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider).multipliedBy(ONE_BASIS_POINT));
}
// currency exposure for one scenario
internal MultiCurrencyAmount currencyExposure(ResolvedFxNdfTrade trade, RatesProvider ratesProvider)
{
return(tradePricer.currencyExposure(trade, ratesProvider));
}
//-------------------------------------------------------------------------
/// <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, SwaptionVolatilities swaptionVolatilities)
{
return(MultiCurrencyAmount.of(presentValue(trade, ratesProvider, swaptionVolatilities)));
}
//-------------------------------------------------------------------------
/// <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 the present value sensitivity to the SABR model parameters of the Ibor cap/floor.
/// <para>
/// The sensitivity of the present value to the SABR model parameters, alpha, beta, rho and nu.
///
/// </para>
/// </summary>
/// <param name="capFloorLeg"> the Ibor cap/floor </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the point sensitivity to the SABR model parameters </returns>
public virtual PointSensitivityBuilder presentValueSensitivityModelParamsSabr(ResolvedIborCapFloorLeg capFloorLeg, RatesProvider ratesProvider, SabrIborCapletFloorletVolatilities volatilities)
{
validate(ratesProvider, volatilities);
return(capFloorLeg.CapletFloorletPeriods.Select(period => periodPricer.presentValueSensitivityModelParamsSabr(period, ratesProvider, volatilities)).Aggregate((c1, c2) => c1.combinedWith(c2)).get());
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value of the FRA trade.
/// <para>
/// The present value of the trade is the value on the valuation date.
/// This is the discounted forecast value.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the present value of the trade </returns>
public virtual CurrencyAmount presentValue(ResolvedFraTrade trade, RatesProvider provider)
{
return(productPricer.presentValue(trade.Product, provider));
}
// present value for one scenario
internal CurrencyAmount presentValue(ResolvedFxNdfTrade trade, RatesProvider ratesProvider)
{
return(tradePricer.presentValue(trade, ratesProvider));
}
/// <summary>
/// Explains the present value of the FRA product.
/// <para>
/// This returns explanatory information about the calculation.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the explanatory information </returns>
public virtual ExplainMap explainPresentValue(ResolvedFraTrade trade, RatesProvider provider)
{
return(productPricer.explainPresentValue(trade.Product, provider));
}
// calibrated bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01CalibratedBucketed(ResolvedFxNdfTrade trade, RatesProvider ratesProvider)
{
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider);
return(ratesProvider.parameterSensitivity(pointSensitivity).multipliedBy(ONE_BASIS_POINT));
}
/// <summary>
/// Calculates the price sensitivity to piecewise constant volatility parameters of the Hull-White model.
/// </summary>
/// <param name="future"> the future </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="hwProvider"> the Hull-White model parameter provider </param>
/// <returns> the price parameter sensitivity of the product </returns>
public virtual DoubleArray priceSensitivityModelParamsHullWhite(ResolvedIborFuture future, RatesProvider ratesProvider, HullWhiteOneFactorPiecewiseConstantParametersProvider hwProvider)
{
IborIndexObservation obs = future.IborRate.Observation;
double forward = ratesProvider.iborIndexRates(future.Index).rate(obs);
LocalDate fixingStartDate = obs.EffectiveDate;
LocalDate fixingEndDate = obs.MaturityDate;
double fixingYearFraction = obs.YearFraction;
DoubleArray convexityDeriv = hwProvider.futuresConvexityFactorAdjoint(future.LastTradeDate, fixingStartDate, fixingEndDate).Derivatives;
convexityDeriv = convexityDeriv.multipliedBy(-forward - 1d / fixingYearFraction);
return(convexityDeriv);
}
/// <summary>
/// Calculates the forecast value sensitivity of the FRA trade.
/// <para>
/// The forecast value sensitivity of the product is the sensitivity of the forecast value to
/// the underlying curves.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the point sensitivity of the forecast value </returns>
public virtual PointSensitivities forecastValueSensitivity(ResolvedFraTrade trade, RatesProvider provider)
{
return(productPricer.forecastValueSensitivity(trade.Product, provider));
}
// market quote bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01RatesMarketQuoteBucketed(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method)
{
CurrencyParameterSensitivities paramSens = pointSensitivity(trade, ratesProvider, volatilities, method);
return(MARKET_QUOTE_SENS.sensitivity(paramSens, ratesProvider).multipliedBy(ONE_BASIS_POINT));
}
/// <summary>
/// Calculates the par spread of the FRA trade.
/// <para>
/// This is spread to be added to the fixed rate to have a present value of 0.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the par spread </returns>
public virtual double parSpread(ResolvedFraTrade trade, RatesProvider provider)
{
return(productPricer.parSpread(trade.Product, provider));
}
// present value for one scenario
internal MultiCurrencyAmount presentValue(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method)
{
if (method == FxVanillaOptionMethod.VANNA_VOLGA)
{
return(vannaVolgaPricer.presentValue(trade, ratesProvider, checkVannaVolgaVolatilities(volatilities)));
}
else
{
return(blackPricer.presentValue(trade, ratesProvider, checkBlackVolatilities(volatilities)));
}
}
/// <summary>
/// Calculates the par spread curve sensitivity of the FRA trade.
/// <para>
/// The par spread curve sensitivity of the product is the sensitivity of the par spread to
/// the underlying curves.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the par spread sensitivity </returns>
public virtual PointSensitivities parSpreadSensitivity(ResolvedFraTrade trade, RatesProvider provider)
{
return(productPricer.parSpreadSensitivity(trade.Product, provider));
}
// market quote bucketed PV01 for one scenario
internal CurrencyParameterSensitivities pv01RatesMarketQuoteBucketed(ResolvedIborCapFloorTrade trade, RatesProvider ratesProvider, IborCapletFloorletVolatilities volatilities)
{
PointSensitivities pointSensitivity = this.pointSensitivity(trade, ratesProvider, volatilities);
CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity);
return(MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider).multipliedBy(ONE_BASIS_POINT));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the future cash flow of the FRA trade.
/// <para>
/// There is only one cash flow on the payment date for the FRA trade.
/// The expected currency amount of the cash flow is the same as <seealso cref="#forecastValue(ResolvedFraTrade, RatesProvider)"/>.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the cash flows </returns>
public virtual CashFlows cashFlows(ResolvedFraTrade trade, RatesProvider provider)
{
return(productPricer.cashFlows(trade.Product, provider));
}
// present value for one scenario
internal MultiCurrencyAmount presentValue(ResolvedIborCapFloorTrade trade, RatesProvider ratesProvider, IborCapletFloorletVolatilities volatilities)
{
return(tradePricer.presentValue(trade, ratesProvider, volatilities));
}
/// <summary>
/// Calculates the currency exposure of the FRA trade.
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposure(ResolvedFraTrade trade, RatesProvider provider)
{
return(MultiCurrencyAmount.of(presentValue(trade, provider)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the swaption trade 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, SabrSwaptionVolatilities swaptionVolatilities)
{
// product
ResolvedSwaption product = trade.Product;
PointSensitivityBuilder pointSens = isCash(product) ? cashParYieldPricer.presentValueSensitivityRatesStickyStrike(product, ratesProvider, swaptionVolatilities) : physicalPricer.presentValueSensitivityRatesStickyStrike(product, ratesProvider, swaptionVolatilities);
// premium
Payment premium = trade.Premium;
PointSensitivityBuilder pvcsPremium = paymentPricer.presentValueSensitivity(premium, ratesProvider);
// total
return(pointSens.combinedWith(pvcsPremium).build());
}
public virtual PointSensitivityBuilder presentValueSensitivity(SwapPaymentPeriod paymentPeriod, RatesProvider provider)
{
// dispatch by runtime type
if (paymentPeriod is RatePaymentPeriod)
{
return(ratePaymentPeriodPricer.presentValueSensitivity((RatePaymentPeriod)paymentPeriod, provider));
}
else if (paymentPeriod is KnownAmountSwapPaymentPeriod)
{
return(knownAmountPaymentPeriodPricer.presentValueSensitivity((KnownAmountSwapPaymentPeriod)paymentPeriod, provider));
}
else
{
throw new System.ArgumentException("Unknown PaymentPeriod type: " + paymentPeriod.GetType().Name);
}
}
