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