//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of a single payment period.
/// <para>
/// The present value sensitivity of the period is the sensitivity of the present value to
/// the underlying curves.
///
/// </para>
/// </summary>
/// <param name="period"> the period to price </param>
/// <param name="ratesProvider"> the rates provider, used to determine price index values </param>
/// <param name="issuerDiscountFactors"> the discount factor provider </param>
/// <returns> the present value curve sensitivity of the period </returns>
public virtual PointSensitivityBuilder presentValueSensitivity(CapitalIndexedBondPaymentPeriod period, RatesProvider ratesProvider, IssuerCurveDiscountFactors issuerDiscountFactors)
{
if (period.PaymentDate.isBefore(ratesProvider.ValuationDate))
{
return(PointSensitivityBuilder.none());
}
double rate = rateComputationFn.rate(period.RateComputation, period.StartDate, period.EndDate, ratesProvider);
PointSensitivityBuilder rateSensi = rateComputationFn.rateSensitivity(period.RateComputation, period.StartDate, period.EndDate, ratesProvider);
double df = issuerDiscountFactors.discountFactor(period.PaymentDate);
PointSensitivityBuilder dfSensi = issuerDiscountFactors.zeroRatePointSensitivity(period.PaymentDate);
double factor = period.Notional * period.RealCoupon;
return(rateSensi.multipliedBy(df * factor).combinedWith(dfSensi.multipliedBy((rate + 1d) * factor)));
}
/// <summary>
/// Calculates the price sensitivity of the Overnight rate 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>
/// <returns> the price curve sensitivity of the product </returns>
public virtual PointSensitivities priceSensitivity(ResolvedOvernightFuture future, RatesProvider ratesProvider)
{
PointSensitivityBuilder forwardRateSensitivity = rateComputationFn.rateSensitivity(future.OvernightRate, future.OvernightRate.StartDate, future.OvernightRate.EndDate, ratesProvider);
// 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(forwardRateSensitivity.build().multipliedBy(-1d));
}
public virtual PointSensitivityBuilder rateSensitivity(RateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider)
{
// dispatch by runtime type
if (computation is FixedRateComputation)
{
// inline code (performance) avoiding need for FixedRateComputationFn implementation
return(PointSensitivityBuilder.none());
}
else if (computation is IborRateComputation)
{
return(iborRateComputationFn.rateSensitivity((IborRateComputation)computation, startDate, endDate, provider));
}
else if (computation is IborInterpolatedRateComputation)
{
return(iborInterpolatedRateComputationFn.rateSensitivity((IborInterpolatedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is IborAveragedRateComputation)
{
return(iborAveragedRateComputationFn.rateSensitivity((IborAveragedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is OvernightAveragedRateComputation)
{
return(overnightAveragedRateComputationFn.rateSensitivity((OvernightAveragedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is OvernightCompoundedRateComputation)
{
return(overnightCompoundedRateComputationFn.rateSensitivity((OvernightCompoundedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is OvernightAveragedDailyRateComputation)
{
return(overnightAveragedDailyRateComputationFn.rateSensitivity((OvernightAveragedDailyRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationMonthlyRateComputation)
{
return(inflationMonthlyRateComputationFn.rateSensitivity((InflationMonthlyRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationInterpolatedRateComputation)
{
return(inflationInterpolatedRateComputationFn.rateSensitivity((InflationInterpolatedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationEndMonthRateComputation)
{
return(inflationEndMonthRateComputationFn.rateSensitivity((InflationEndMonthRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationEndInterpolatedRateComputation)
{
return(inflationEndInterpolatedRateComputationFn.rateSensitivity((InflationEndInterpolatedRateComputation)computation, startDate, endDate, provider));
}
else
{
throw new System.ArgumentException("Unknown Rate type: " + computation.GetType().Name);
}
}
// computes the sensitivity of the accrual period to the rate observations (not to discount factors)
private PointSensitivityBuilder unitNotionalSensitivityAccrual(RateAccrualPeriod period, Currency ccy, RatesProvider provider)
{
PointSensitivityBuilder sensi = rateComputationFn.rateSensitivity(period.RateComputation, period.StartDate, period.EndDate, provider);
return(sensi.multipliedBy(period.Gearing * period.YearFraction));
}
// query the sensitivity
private PointSensitivityBuilder forwardRateSensitivity(ResolvedFra fra, RatesProvider provider)
{
return(rateComputationFn.rateSensitivity(fra.FloatingRate, fra.StartDate, fra.EndDate, provider));
}
