//------------------------------------------------------------------------- /// <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); } }