/// <summary>
/// Calculates the forecast value of a single payment period.
/// </summary>
/// <param name="period"> the period to price </param>
/// <param name="ratesProvider"> the rates provider, used to determine price index values </param>
/// <returns> the forecast value of the period </returns>
public virtual double forecastValue(CapitalIndexedBondPaymentPeriod period, RatesProvider ratesProvider)
{
if (period.PaymentDate.isBefore(ratesProvider.ValuationDate))
{
return(0d);
}
double rate = rateComputationFn.rate(period.RateComputation, period.StartDate, period.EndDate, ratesProvider);
return(period.Notional * period.RealCoupon * (rate + 1d));
}
//-------------------------------------------------------------------------
public virtual double rate(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(((FixedRateComputation)computation).Rate);
}
else if (computation is IborRateComputation)
{
return(iborRateComputationFn.rate((IborRateComputation)computation, startDate, endDate, provider));
}
else if (computation is IborInterpolatedRateComputation)
{
return(iborInterpolatedRateComputationFn.rate((IborInterpolatedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is IborAveragedRateComputation)
{
return(iborAveragedRateComputationFn.rate((IborAveragedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is OvernightAveragedRateComputation)
{
return(overnightAveragedRateComputationFn.rate((OvernightAveragedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is OvernightCompoundedRateComputation)
{
return(overnightCompoundedRateComputationFn.rate((OvernightCompoundedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is OvernightAveragedDailyRateComputation)
{
return(overnightAveragedDailyRateComputationFn.rate((OvernightAveragedDailyRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationMonthlyRateComputation)
{
return(inflationMonthlyRateComputationFn.rate((InflationMonthlyRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationInterpolatedRateComputation)
{
return(inflationInterpolatedRateComputationFn.rate((InflationInterpolatedRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationEndMonthRateComputation)
{
return(inflationEndMonthRateComputationFn.rate((InflationEndMonthRateComputation)computation, startDate, endDate, provider));
}
else if (computation is InflationEndInterpolatedRateComputation)
{
return(inflationEndInterpolatedRateComputationFn.rate((InflationEndInterpolatedRateComputation)computation, startDate, endDate, provider));
}
else
{
throw new System.ArgumentException("Unknown Rate type: " + computation.GetType().Name);
}
}
// finds the raw rate for the accrual period
// the raw rate is the rate before gearing, spread and negative checks are applied
private double rawRate(RateAccrualPeriod accrualPeriod, RatesProvider provider)
{
return(rateComputationFn.rate(accrualPeriod.RateComputation, accrualPeriod.StartDate, accrualPeriod.EndDate, provider));
}
//-------------------------------------------------------------------------
// query the forward rate
private double forwardRate(ResolvedFra fra, RatesProvider provider)
{
return(rateComputationFn.rate(fra.FloatingRate, fra.StartDate, fra.EndDate, provider));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price of the Overnight rate 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>
/// <returns> the price of the product, in decimal form </returns>
public virtual double price(ResolvedOvernightFuture future, RatesProvider ratesProvider)
{
double forwardRate = rateComputationFn.rate(future.OvernightRate, future.OvernightRate.StartDate, future.OvernightRate.EndDate, ratesProvider);
return(1d - forwardRate);
}
