/// <summary>
/// Computes the present value sensitivity to SABR parameters by replication in SABR framework with extrapolation on the right.
/// </summary>
/// <param name="cmsPeriod"> the CMS </param>
/// <param name="provider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the swaption volatilities </param>
/// <returns> the present value sensitivity </returns>
public PointSensitivityBuilder presentValueSensitivityModelParamsSabr(CmsPeriod cmsPeriod, RatesProvider provider, SabrSwaptionVolatilities swaptionVolatilities)
{
Currency ccy = cmsPeriod.Currency;
SwapIndex index = cmsPeriod.Index;
ResolvedSwap swap = cmsPeriod.UnderlyingSwap;
double dfPayment = provider.discountFactor(ccy, cmsPeriod.PaymentDate);
ZonedDateTime valuationDate = swaptionVolatilities.ValuationDateTime;
LocalDate fixingDate = cmsPeriod.FixingDate;
ZonedDateTime expiryDate = fixingDate.atTime(index.FixingTime).atZone(index.FixingZone);
double tenor = swaptionVolatilities.tenor(swap.StartDate, swap.EndDate);
if (provider.ValuationDate.isAfter(cmsPeriod.PaymentDate))
{
return(PointSensitivityBuilder.none());
}
if (!fixingDate.isAfter(valuationDate.toLocalDate()))
{
double?fixedRate = provider.timeSeries(cmsPeriod.Index).get(fixingDate);
if (fixedRate.HasValue)
{
return(PointSensitivityBuilder.none());
}
else if (fixingDate.isBefore(valuationDate.toLocalDate()))
{
throw new System.ArgumentException(Messages.format("Unable to get fixing for {} on date {}, no time-series supplied", cmsPeriod.Index, fixingDate));
}
}
double expiryTime = swaptionVolatilities.relativeTime(expiryDate);
double shift = swaptionVolatilities.shift(expiryTime, tenor);
double strikeCpn = cmsPeriod.CmsPeriodType.Equals(CmsPeriodType.COUPON) ? -shift : cmsPeriod.Strike;
double forward = swapPricer.parRate(swap, provider);
double eta = index.Template.Convention.FixedLeg.DayCount.relativeYearFraction(cmsPeriod.PaymentDate, swap.StartDate);
CmsIntegrantProvider intProv = new CmsIntegrantProvider(this, cmsPeriod, swap, swaptionVolatilities, forward, strikeCpn, expiryTime, tenor, cutOffStrike, eta);
double factor = dfPayment / intProv.h(forward) * intProv.g(forward);
double factor2 = factor * intProv.k(strikeCpn);
double[] strikePartPrice = intProv.SabrExtrapolation.priceAdjointSabr(Math.Max(0d, strikeCpn + shift), intProv.PutCall).Derivatives.multipliedBy(factor2).toArray();
RungeKuttaIntegrator1D integrator = new RungeKuttaIntegrator1D(ABS_TOL, REL_TOL_VEGA, NUM_ITER);
double[] totalSensi = new double[4];
for (int loopparameter = 0; loopparameter < 4; loopparameter++)
{
double integralPart = 0d;
System.Func <double, double> integrant = intProv.integrantVega(loopparameter);
try
{
if (intProv.PutCall.Call)
{
integralPart = dfPayment * integrateCall(integrator, integrant, swaptionVolatilities, forward, strikeCpn, expiryTime, tenor);
}
else
{
integralPart = -dfPayment *integrator.integrate(integrant, -shift + ZERO_SHIFT, strikeCpn);
}
}
catch (Exception e)
{
throw new Exception(e);
}
totalSensi[loopparameter] = (strikePartPrice[loopparameter] + integralPart) * cmsPeriod.Notional * cmsPeriod.YearFraction;
}
SwaptionVolatilitiesName name = swaptionVolatilities.Name;
return(PointSensitivityBuilder.of(SwaptionSabrSensitivity.of(name, expiryTime, tenor, ALPHA, ccy, totalSensi[0]), SwaptionSabrSensitivity.of(name, expiryTime, tenor, BETA, ccy, totalSensi[1]), SwaptionSabrSensitivity.of(name, expiryTime, tenor, RHO, ccy, totalSensi[2]), SwaptionSabrSensitivity.of(name, expiryTime, tenor, NU, ccy, totalSensi[3])));
}
/// <summary>
/// Computes the present value sensitivity to strike by replication in SABR framework with extrapolation on the right.
/// </summary>
/// <param name="cmsPeriod"> the CMS </param>
/// <param name="provider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the swaption volatilities </param>
/// <returns> the present value sensitivity </returns>
public double presentValueSensitivityStrike(CmsPeriod cmsPeriod, RatesProvider provider, SabrSwaptionVolatilities swaptionVolatilities)
{
ArgChecker.isFalse(cmsPeriod.CmsPeriodType.Equals(CmsPeriodType.COUPON), "presentValueSensitivityStrike is not relevant for CMS coupon");
Currency ccy = cmsPeriod.Currency;
SwapIndex index = cmsPeriod.Index;
if (provider.ValuationDate.isAfter(cmsPeriod.PaymentDate))
{
return(0d);
}
ResolvedSwap swap = cmsPeriod.UnderlyingSwap;
double dfPayment = provider.discountFactor(ccy, cmsPeriod.PaymentDate);
ZonedDateTime valuationDate = swaptionVolatilities.ValuationDateTime;
LocalDate fixingDate = cmsPeriod.FixingDate;
double tenor = swaptionVolatilities.tenor(swap.StartDate, swap.EndDate);
ZonedDateTime expiryDate = fixingDate.atTime(index.FixingTime).atZone(index.FixingZone);
double expiryTime = swaptionVolatilities.relativeTime(expiryDate);
double strike = cmsPeriod.Strike;
double shift = swaptionVolatilities.shift(expiryTime, tenor);
if (!fixingDate.isAfter(valuationDate.toLocalDate()))
{
double?fixedRate = provider.timeSeries(cmsPeriod.Index).get(fixingDate);
if (fixedRate.HasValue)
{
double payoff = 0d;
switch (cmsPeriod.CmsPeriodType)
{
case CAPLET:
payoff = fixedRate.Value >= strike ? -1d : 0d;
break;
case FLOORLET:
payoff = fixedRate.Value < strike ? 1d : 0d;
break;
default:
throw new System.ArgumentException("unsupported CMS type");
}
return(payoff * cmsPeriod.Notional * cmsPeriod.YearFraction * dfPayment);
}
else if (fixingDate.isBefore(valuationDate.toLocalDate()))
{
throw new System.ArgumentException(Messages.format("Unable to get fixing for {} on date {}, no time-series supplied", cmsPeriod.Index, fixingDate));
}
}
double forward = swapPricer.parRate(swap, provider);
double eta = index.Template.Convention.FixedLeg.DayCount.relativeYearFraction(cmsPeriod.PaymentDate, swap.StartDate);
CmsIntegrantProvider intProv = new CmsIntegrantProvider(this, cmsPeriod, swap, swaptionVolatilities, forward, strike, expiryTime, tenor, cutOffStrike, eta);
double factor = dfPayment * intProv.g(forward) / intProv.h(forward);
RungeKuttaIntegrator1D integrator = new RungeKuttaIntegrator1D(ABS_TOL, REL_TOL_STRIKE, NUM_ITER);
double[] kpkpp = intProv.kpkpp(strike);
double firstPart;
double thirdPart;
System.Func <double, double> integrant = intProv.integrantDualDelta();
if (intProv.PutCall.Call)
{
firstPart = -kpkpp[0] * intProv.bs(strike);
thirdPart = integrateCall(integrator, integrant, swaptionVolatilities, forward, strike, expiryTime, tenor);
}
else
{
firstPart = -kpkpp[0] * intProv.bs(strike);
thirdPart = -integrator.integrate(integrant, -shift + ZERO_SHIFT, strike).Value;
}
double secondPart = intProv.k(strike) * intProv.SabrExtrapolation.priceDerivativeStrike(strike + shift, intProv.PutCall);
return(cmsPeriod.Notional * cmsPeriod.YearFraction * factor * (firstPart + secondPart + thirdPart));
}
//-------------------------------------------------------------------------
/// <summary>
/// Computes the present value by replication in SABR framework with extrapolation on the right.
/// </summary>
/// <param name="cmsPeriod"> the CMS </param>
/// <param name="provider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the swaption volatilities </param>
/// <returns> the present value </returns>
public CurrencyAmount presentValue(CmsPeriod cmsPeriod, RatesProvider provider, SabrSwaptionVolatilities swaptionVolatilities)
{
Currency ccy = cmsPeriod.Currency;
if (provider.ValuationDate.isAfter(cmsPeriod.PaymentDate))
{
return(CurrencyAmount.zero(ccy));
}
SwapIndex index = cmsPeriod.Index;
ResolvedSwap swap = cmsPeriod.UnderlyingSwap;
double dfPayment = provider.discountFactor(ccy, cmsPeriod.PaymentDate);
ZonedDateTime valuationDate = swaptionVolatilities.ValuationDateTime;
LocalDate fixingDate = cmsPeriod.FixingDate;
double expiryTime = swaptionVolatilities.relativeTime(fixingDate.atTime(index.FixingTime).atZone(index.FixingZone));
double tenor = swaptionVolatilities.tenor(swap.StartDate, swap.EndDate);
double shift = swaptionVolatilities.shift(expiryTime, tenor);
double strikeCpn = cmsPeriod.CmsPeriodType.Equals(CmsPeriodType.COUPON) ? -shift : cmsPeriod.Strike;
if (!fixingDate.isAfter(valuationDate.toLocalDate()))
{
double?fixedRate = provider.timeSeries(cmsPeriod.Index).get(fixingDate);
if (fixedRate.HasValue)
{
double payoff = payOff(cmsPeriod.CmsPeriodType, strikeCpn, fixedRate.Value);
return(CurrencyAmount.of(ccy, dfPayment * payoff * cmsPeriod.Notional * cmsPeriod.YearFraction));
}
else if (fixingDate.isBefore(valuationDate.toLocalDate()))
{
throw new System.ArgumentException(Messages.format("Unable to get fixing for {} on date {}, no time-series supplied", cmsPeriod.Index, fixingDate));
}
}
double forward = swapPricer.parRate(swap, provider);
if (expiryTime < MIN_TIME)
{
double payoff = payOff(cmsPeriod.CmsPeriodType, strikeCpn, forward);
return(CurrencyAmount.of(ccy, dfPayment * payoff * cmsPeriod.Notional * cmsPeriod.YearFraction));
}
double eta = index.Template.Convention.FixedLeg.DayCount.relativeYearFraction(cmsPeriod.PaymentDate, swap.StartDate);
CmsIntegrantProvider intProv = new CmsIntegrantProvider(this, cmsPeriod, swap, swaptionVolatilities, forward, strikeCpn, expiryTime, tenor, cutOffStrike, eta);
double factor = dfPayment / intProv.h(forward) * intProv.g(forward);
double strikePart = factor * intProv.k(strikeCpn) * intProv.bs(strikeCpn);
RungeKuttaIntegrator1D integrator = new RungeKuttaIntegrator1D(ABS_TOL, REL_TOL, NUM_ITER);
double integralPart = 0d;
System.Func <double, double> integrant = intProv.integrant();
try
{
if (intProv.PutCall.Call)
{
integralPart = dfPayment * integrateCall(integrator, integrant, swaptionVolatilities, forward, strikeCpn, expiryTime, tenor);
}
else
{
integralPart = -dfPayment *integrator.integrate(integrant, -shift + ZERO_SHIFT, strikeCpn);
}
}
catch (Exception e)
{
throw new MathException(e);
}
double priceCMS = (strikePart + integralPart);
if (cmsPeriod.CmsPeriodType.Equals(CmsPeriodType.COUPON))
{
priceCMS -= dfPayment * shift;
}
priceCMS *= cmsPeriod.Notional * cmsPeriod.YearFraction;
return(CurrencyAmount.of(ccy, priceCMS));
}