//-------------------------------------------------------------------------
public virtual void explainPresentValue(FxResetNotionalExchange @event, RatesProvider provider, ExplainMapBuilder builder)
{
Currency currency = @event.Currency;
LocalDate paymentDate = @event.PaymentDate;
builder.put(ExplainKey.ENTRY_TYPE, "FxResetNotionalExchange");
builder.put(ExplainKey.PAYMENT_DATE, paymentDate);
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
builder.put(ExplainKey.TRADE_NOTIONAL, @event.NotionalAmount);
if (paymentDate.isBefore(provider.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
builder.addListEntry(ExplainKey.OBSERVATIONS, child =>
{
child.put(ExplainKey.ENTRY_TYPE, "FxObservation");
child.put(ExplainKey.INDEX, @event.Observation.Index);
child.put(ExplainKey.FIXING_DATE, @event.Observation.FixingDate);
child.put(ExplainKey.INDEX_VALUE, fxRate(@event, provider));
});
builder.put(ExplainKey.DISCOUNT_FACTOR, provider.discountFactor(currency, paymentDate));
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.of(currency, forecastValue(@event, provider)));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.of(currency, presentValue(@event, provider)));
}
}
public virtual double explainRate(RateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider, ExplainMapBuilder builder)
{
// dispatch by runtime type
if (computation is FixedRateComputation)
{
// inline code (performance) avoiding need for FixedRateComputationFn implementation
double rate = ((FixedRateComputation)computation).Rate;
builder.put(ExplainKey.FIXED_RATE, rate);
builder.put(ExplainKey.COMBINED_RATE, rate);
return(rate);
}
else if (computation is IborRateComputation)
{
return(iborRateComputationFn.explainRate((IborRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is IborInterpolatedRateComputation)
{
return(iborInterpolatedRateComputationFn.explainRate((IborInterpolatedRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is IborAveragedRateComputation)
{
return(iborAveragedRateComputationFn.explainRate((IborAveragedRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is OvernightAveragedRateComputation)
{
return(overnightAveragedRateComputationFn.explainRate((OvernightAveragedRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is OvernightCompoundedRateComputation)
{
return(overnightCompoundedRateComputationFn.explainRate((OvernightCompoundedRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is OvernightAveragedDailyRateComputation)
{
return(overnightAveragedDailyRateComputationFn.explainRate((OvernightAveragedDailyRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is InflationMonthlyRateComputation)
{
return(inflationMonthlyRateComputationFn.explainRate((InflationMonthlyRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is InflationInterpolatedRateComputation)
{
return(inflationInterpolatedRateComputationFn.explainRate((InflationInterpolatedRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is InflationEndMonthRateComputation)
{
return(inflationEndMonthRateComputationFn.explainRate((InflationEndMonthRateComputation)computation, startDate, endDate, provider, builder));
}
else if (computation is InflationEndInterpolatedRateComputation)
{
return(inflationEndInterpolatedRateComputationFn.explainRate((InflationEndInterpolatedRateComputation)computation, startDate, endDate, provider, builder));
}
else
{
throw new System.ArgumentException("Unknown Rate type: " + computation.GetType().Name);
}
}
// common parts of explain
private void explainBasics(FixedCouponBondPaymentPeriod period, ExplainMapBuilder builder, Currency currency, LocalDate paymentDate)
{
builder.put(ExplainKey.ENTRY_TYPE, "FixedCouponBondPaymentPeriod");
builder.put(ExplainKey.PAYMENT_DATE, paymentDate);
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
builder.put(ExplainKey.START_DATE, period.StartDate);
builder.put(ExplainKey.UNADJUSTED_START_DATE, period.UnadjustedStartDate);
builder.put(ExplainKey.END_DATE, period.EndDate);
builder.put(ExplainKey.UNADJUSTED_END_DATE, period.UnadjustedEndDate);
builder.put(ExplainKey.ACCRUAL_YEAR_FRACTION, period.YearFraction);
builder.put(ExplainKey.DAYS, (int)DAYS.between(period.StartDate, period.EndDate));
}
public virtual double explainRate(OvernightAveragedDailyRateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider, ExplainMapBuilder builder)
{
double rate = this.rate(computation, startDate, endDate, provider);
builder.put(ExplainKey.COMBINED_RATE, rate);
return(rate);
}
public virtual double explainRate(IborRateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider, ExplainMapBuilder builder)
{
IborIndexRates rates = provider.iborIndexRates(computation.Index);
double rate = rates.explainRate(computation.Observation, builder, child =>
{
});
builder.put(ExplainKey.COMBINED_RATE, rate);
return(rate);
}
public virtual double explainRate(InflationEndMonthRateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider, ExplainMapBuilder builder)
{
PriceIndexValues values = provider.priceIndexValues(computation.Index);
double indexEnd = values.value(computation.EndObservation);
builder.addListEntry(ExplainKey.OBSERVATIONS, child => child.put(ExplainKey.ENTRY_TYPE, "InflationObservation").put(ExplainKey.FIXING_DATE, computation.EndObservation.FixingMonth.atEndOfMonth()).put(ExplainKey.INDEX, computation.Index).put(ExplainKey.INDEX_VALUE, indexEnd));
double rate = this.rate(computation, startDate, endDate, provider);
builder.put(ExplainKey.COMBINED_RATE, rate);
return(rate);
}
public virtual double explainRate(IborAveragedRateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider, ExplainMapBuilder builder)
{
IborIndexRates rates = provider.iborIndexRates(computation.Index);
foreach (IborAveragedFixing fixing in computation.Fixings)
{
rates.explainRate(fixing.Observation, builder, child => child.put(ExplainKey.WEIGHT, fixing.Weight));
}
double rate = this.rate(computation, startDate, endDate, provider);
builder.put(ExplainKey.COMBINED_RATE, rate);
return(rate);
}
//-------------------------------------------------------------------------
public virtual void explainPresentValue(NotionalExchange @event, RatesProvider provider, ExplainMapBuilder builder)
{
Currency currency = @event.Currency;
LocalDate paymentDate = @event.PaymentDate;
builder.put(ExplainKey.ENTRY_TYPE, "NotionalExchange");
builder.put(ExplainKey.PAYMENT_DATE, paymentDate);
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
builder.put(ExplainKey.TRADE_NOTIONAL, @event.PaymentAmount);
if (paymentDate.isBefore(provider.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
builder.put(ExplainKey.DISCOUNT_FACTOR, provider.discountFactor(currency, paymentDate));
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.of(currency, forecastValue(@event, provider)));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.of(currency, presentValue(@event, provider)));
}
}
public virtual double explainRate(IborInterpolatedRateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider, ExplainMapBuilder builder)
{
IborIndexObservation obs1 = computation.ShortObservation;
IborIndexObservation obs2 = computation.LongObservation;
DoublesPair weights = this.weights(obs1, obs2, endDate);
IborIndexRates rates1 = provider.iborIndexRates(obs1.Index);
IborIndexRates rates2 = provider.iborIndexRates(obs2.Index);
rates1.explainRate(obs1, builder, child => child.put(ExplainKey.WEIGHT, weights.First));
rates2.explainRate(obs2, builder, child => child.put(ExplainKey.WEIGHT, weights.Second));
double rate = this.rate(computation, startDate, endDate, provider);
builder.put(ExplainKey.COMBINED_RATE, rate);
return(rate);
}
public virtual double explainRate(InflationInterpolatedRateComputation computation, LocalDate startDate, LocalDate endDate, RatesProvider provider, ExplainMapBuilder builder)
{
PriceIndexValues values = provider.priceIndexValues(computation.Index);
double w1 = computation.Weight;
double w2 = 1d - w1;
builder.addListEntry(ExplainKey.OBSERVATIONS, child => child.put(ExplainKey.ENTRY_TYPE, "InflationObservation").put(ExplainKey.FIXING_DATE, computation.StartObservation.FixingMonth.atEndOfMonth()).put(ExplainKey.INDEX, computation.Index).put(ExplainKey.INDEX_VALUE, values.value(computation.StartObservation)).put(ExplainKey.WEIGHT, w1));
builder.addListEntry(ExplainKey.OBSERVATIONS, child => child.put(ExplainKey.ENTRY_TYPE, "InflationObservation").put(ExplainKey.FIXING_DATE, computation.StartSecondObservation.FixingMonth.atEndOfMonth()).put(ExplainKey.INDEX, computation.Index).put(ExplainKey.INDEX_VALUE, values.value(computation.StartSecondObservation)).put(ExplainKey.WEIGHT, w2));
builder.addListEntry(ExplainKey.OBSERVATIONS, child => child.put(ExplainKey.ENTRY_TYPE, "InflationObservation").put(ExplainKey.FIXING_DATE, computation.EndObservation.FixingMonth.atEndOfMonth()).put(ExplainKey.INDEX, computation.Index).put(ExplainKey.INDEX_VALUE, values.value(computation.EndObservation)).put(ExplainKey.WEIGHT, w1));
builder.addListEntry(ExplainKey.OBSERVATIONS, child => child.put(ExplainKey.ENTRY_TYPE, "InflationObservation").put(ExplainKey.FIXING_DATE, computation.EndSecondObservation.FixingMonth.atEndOfMonth()).put(ExplainKey.INDEX, computation.Index).put(ExplainKey.INDEX_VALUE, values.value(computation.EndSecondObservation)).put(ExplainKey.WEIGHT, w2));
double rate = this.rate(computation, startDate, endDate, provider);
builder.put(ExplainKey.COMBINED_RATE, rate);
return(rate);
}
//-------------------------------------------------------------------------
/// <summary>
/// Explains the present value of a CMS leg.
/// <para>
/// This returns explanatory information about the calculation.
///
/// </para>
/// </summary>
/// <param name="cmsLeg"> the CMS leg </param>
/// <param name="provider"> the rates provider </param>
/// <param name="volatilities"> the swaption volatilities </param>
/// <returns> the explanatory information </returns>
public virtual ExplainMap explainPresentValue(ResolvedCmsLeg cmsLeg, RatesProvider provider, SabrSwaptionVolatilities volatilities)
{
ExplainMapBuilder builder = ExplainMap.builder();
builder.put(ExplainKey.ENTRY_TYPE, "CmsLeg");
builder.put(ExplainKey.PAY_RECEIVE, cmsLeg.PayReceive);
builder.put(ExplainKey.PAYMENT_CURRENCY, cmsLeg.Currency);
builder.put(ExplainKey.START_DATE, cmsLeg.StartDate);
builder.put(ExplainKey.END_DATE, cmsLeg.EndDate);
builder.put(ExplainKey.INDEX, cmsLeg.Index);
foreach (CmsPeriod period in cmsLeg.CmsPeriods)
{
builder.addListEntry(ExplainKey.PAYMENT_PERIODS, child => cmsPeriodPricer.explainPresentValue(period, provider, volatilities, child));
}
builder.put(ExplainKey.PRESENT_VALUE, presentValue(cmsLeg, provider, volatilities));
return(builder.build());
}
/// <summary>
/// Explains the present value of the payment.
/// <para>
/// This returns explanatory information about the calculation.
///
/// </para>
/// </summary>
/// <param name="payment"> the payment </param>
/// <param name="provider"> the provider </param>
/// <returns> the explanatory information </returns>
public virtual ExplainMap explainPresentValue(Payment payment, BaseProvider provider)
{
Currency currency = payment.Currency;
LocalDate paymentDate = payment.Date;
ExplainMapBuilder builder = ExplainMap.builder();
builder.put(ExplainKey.ENTRY_TYPE, "Payment");
builder.put(ExplainKey.PAYMENT_DATE, paymentDate);
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
if (paymentDate.isBefore(provider.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
builder.put(ExplainKey.DISCOUNT_FACTOR, provider.discountFactor(currency, paymentDate));
builder.put(ExplainKey.FORECAST_VALUE, forecastValue(payment, provider));
builder.put(ExplainKey.PRESENT_VALUE, presentValue(payment, provider));
}
return(builder.build());
}
/// <summary>
/// Explains the present value of a single fixed coupon payment period with z-spread.
/// <para>
/// This adds information to the <seealso cref="ExplainMapBuilder"/> to aid understanding of the calculation.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic
/// compounded rates of the discounting curve.
///
/// </para>
/// </summary>
/// <param name="period"> the period to price </param>
/// <param name="discountFactors"> the discount factor provider </param>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodsPerYear"> the number of periods per year </param>
/// <param name="builder"> the builder to populate </param>
public virtual void explainPresentValueWithSpread(FixedCouponBondPaymentPeriod period, IssuerCurveDiscountFactors discountFactors, ExplainMapBuilder builder, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
Currency currency = period.Currency;
LocalDate paymentDate = period.PaymentDate;
explainBasics(period, builder, currency, paymentDate);
if (paymentDate.isBefore(discountFactors.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
builder.put(ExplainKey.DISCOUNT_FACTOR, discountFactors.DiscountFactors.discountFactorWithSpread(paymentDate, zSpread, compoundedRateType, periodsPerYear));
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.of(currency, forecastValue(period, discountFactors)));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.of(currency, presentValueWithSpread(period, discountFactors, zSpread, compoundedRateType, periodsPerYear)));
}
}
/// <summary>
/// Explains the present value of a single payment period with z-spread.
/// <para>
/// This adds information to the <seealso cref="ExplainMapBuilder"/> to aid understanding of the calculation.
///
/// </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>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodsPerYear"> the number of periods per year </param>
/// <param name="builder"> the builder to populate </param>
public virtual void explainPresentValueWithZSpread(CapitalIndexedBondPaymentPeriod period, RatesProvider ratesProvider, IssuerCurveDiscountFactors issuerDiscountFactors, ExplainMapBuilder builder, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
Currency currency = period.Currency;
LocalDate paymentDate = period.PaymentDate;
builder.put(ExplainKey.ENTRY_TYPE, "CapitalIndexedBondPaymentPeriod");
builder.put(ExplainKey.PAYMENT_DATE, paymentDate);
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
builder.put(ExplainKey.START_DATE, period.StartDate);
builder.put(ExplainKey.UNADJUSTED_START_DATE, period.UnadjustedStartDate);
builder.put(ExplainKey.END_DATE, period.EndDate);
builder.put(ExplainKey.UNADJUSTED_END_DATE, period.UnadjustedEndDate);
builder.put(ExplainKey.DAYS, (int)DAYS.between(period.UnadjustedStartDate, period.UnadjustedEndDate));
if (paymentDate.isBefore(ratesProvider.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
builder.put(ExplainKey.DISCOUNT_FACTOR, issuerDiscountFactors.discountFactor(paymentDate));
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.of(currency, forecastValue(period, ratesProvider)));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.of(currency, presentValueWithZSpread(period, ratesProvider, issuerDiscountFactors, zSpread, compoundedRateType, periodsPerYear)));
}
}
// explain PV for an accrual period, ignoring compounding
private void explainPresentValue(RateAccrualPeriod accrualPeriod, DayCount dayCount, Currency currency, double notional, RatesProvider provider, ExplainMapBuilder builder)
{
double rawRate = rateComputationFn.explainRate(accrualPeriod.RateComputation, accrualPeriod.StartDate, accrualPeriod.EndDate, provider, builder);
double payOffRate = rawRate * accrualPeriod.Gearing + accrualPeriod.Spread;
double ua = unitNotionalAccrual(accrualPeriod, accrualPeriod.Spread, provider);
// Note that the forecast value is not published since this is potentially misleading when
// compounding is being applied, and when it isn't then it's the same as the forecast
// value of the payment period.
builder.put(ExplainKey.ENTRY_TYPE, "AccrualPeriod");
builder.put(ExplainKey.START_DATE, accrualPeriod.StartDate);
builder.put(ExplainKey.UNADJUSTED_START_DATE, accrualPeriod.UnadjustedStartDate);
builder.put(ExplainKey.END_DATE, accrualPeriod.EndDate);
builder.put(ExplainKey.UNADJUSTED_END_DATE, accrualPeriod.UnadjustedEndDate);
builder.put(ExplainKey.ACCRUAL_YEAR_FRACTION, accrualPeriod.YearFraction);
builder.put(ExplainKey.ACCRUAL_DAYS, dayCount.days(accrualPeriod.StartDate, accrualPeriod.EndDate));
builder.put(ExplainKey.DAYS, (int)DAYS.between(accrualPeriod.StartDate, accrualPeriod.EndDate));
builder.put(ExplainKey.GEARING, accrualPeriod.Gearing);
builder.put(ExplainKey.SPREAD, accrualPeriod.Spread);
builder.put(ExplainKey.PAY_OFF_RATE, accrualPeriod.NegativeRateMethod.adjust(payOffRate));
builder.put(ExplainKey.UNIT_AMOUNT, ua);
}
//-------------------------------------------------------------------------
public virtual void explainPresentValue(RatePaymentPeriod paymentPeriod, RatesProvider provider, ExplainMapBuilder builder)
{
Currency currency = paymentPeriod.Currency;
LocalDate paymentDate = paymentPeriod.PaymentDate;
double fxRate = this.fxRate(paymentPeriod, provider);
double notional = paymentPeriod.Notional * fxRate;
builder.put(ExplainKey.ENTRY_TYPE, "RatePaymentPeriod");
builder.put(ExplainKey.PAYMENT_DATE, paymentDate);
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
builder.put(ExplainKey.NOTIONAL, CurrencyAmount.of(currency, notional));
builder.put(ExplainKey.TRADE_NOTIONAL, paymentPeriod.NotionalAmount);
if (paymentDate.isBefore(provider.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
paymentPeriod.FxReset.ifPresent(fxReset =>
{
builder.addListEntry(ExplainKey.OBSERVATIONS, child =>
{
child.put(ExplainKey.ENTRY_TYPE, "FxObservation");
child.put(ExplainKey.INDEX, fxReset.Observation.Index);
child.put(ExplainKey.FIXING_DATE, fxReset.Observation.FixingDate);
child.put(ExplainKey.INDEX_VALUE, fxRate);
});
});
foreach (RateAccrualPeriod accrualPeriod in paymentPeriod.AccrualPeriods)
{
builder.addListEntry(ExplainKey.ACCRUAL_PERIODS, child => explainPresentValue(accrualPeriod, paymentPeriod.DayCount, currency, notional, provider, child));
}
builder.put(ExplainKey.COMPOUNDING, paymentPeriod.CompoundingMethod);
builder.put(ExplainKey.DISCOUNT_FACTOR, provider.discountFactor(currency, paymentDate));
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.of(currency, forecastValue(paymentPeriod, provider)));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.of(currency, presentValue(paymentPeriod, provider)));
}
}
//-------------------------------------------------------------------------
public virtual void explainPresentValue(KnownAmountSwapPaymentPeriod period, RatesProvider provider, ExplainMapBuilder builder)
{
Currency currency = period.Currency;
LocalDate paymentDate = period.PaymentDate;
builder.put(ExplainKey.ENTRY_TYPE, "KnownAmountPaymentPeriod");
builder.put(ExplainKey.PAYMENT_DATE, paymentDate);
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
builder.put(ExplainKey.START_DATE, period.StartDate);
builder.put(ExplainKey.UNADJUSTED_START_DATE, period.UnadjustedStartDate);
builder.put(ExplainKey.END_DATE, period.EndDate);
builder.put(ExplainKey.UNADJUSTED_END_DATE, period.UnadjustedEndDate);
builder.put(ExplainKey.DAYS, (int)DAYS.between(period.StartDate, period.EndDate));
if (paymentDate.isBefore(provider.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
builder.put(ExplainKey.DISCOUNT_FACTOR, provider.discountFactor(currency, paymentDate));
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.of(currency, forecastValue(period, provider)));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.of(currency, presentValue(period, provider)));
}
}
//-------------------------------------------------------------------------
/// <summary>
/// Explains the present value of the FRA product.
/// <para>
/// This returns explanatory information about the calculation.
///
/// </para>
/// </summary>
/// <param name="fra"> the FRA product for which present value should be computed </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the explanatory information </returns>
public virtual ExplainMap explainPresentValue(ResolvedFra fra, RatesProvider provider)
{
ExplainMapBuilder builder = ExplainMap.builder();
Currency currency = fra.Currency;
builder.put(ExplainKey.ENTRY_TYPE, "FRA");
builder.put(ExplainKey.PAYMENT_DATE, fra.PaymentDate);
builder.put(ExplainKey.START_DATE, fra.StartDate);
builder.put(ExplainKey.END_DATE, fra.EndDate);
builder.put(ExplainKey.ACCRUAL_YEAR_FRACTION, fra.YearFraction);
builder.put(ExplainKey.DAYS, (int)DAYS.between(fra.StartDate, fra.EndDate));
builder.put(ExplainKey.PAYMENT_CURRENCY, currency);
builder.put(ExplainKey.NOTIONAL, CurrencyAmount.of(currency, fra.Notional));
builder.put(ExplainKey.TRADE_NOTIONAL, CurrencyAmount.of(currency, fra.Notional));
if (fra.PaymentDate.isBefore(provider.ValuationDate))
{
builder.put(ExplainKey.COMPLETED, true);
builder.put(ExplainKey.FORECAST_VALUE, CurrencyAmount.zero(currency));
builder.put(ExplainKey.PRESENT_VALUE, CurrencyAmount.zero(currency));
}
else
{
double rate = rateComputationFn.explainRate(fra.FloatingRate, fra.StartDate, fra.EndDate, provider, builder);
builder.put(ExplainKey.FIXED_RATE, fra.FixedRate);
builder.put(ExplainKey.DISCOUNT_FACTOR, provider.discountFactor(currency, fra.PaymentDate));
builder.put(ExplainKey.PAY_OFF_RATE, rate);
builder.put(ExplainKey.UNIT_AMOUNT, unitAmount(fra, provider));
builder.put(ExplainKey.FORECAST_VALUE, forecastValue(fra, provider));
builder.put(ExplainKey.PRESENT_VALUE, presentValue(fra, provider));
}
return(builder.build());
}
