/// <summary>
/// Calculates the present value of the fixed coupon bond trade with z-spread from the
/// clean price of the underlying product.
/// <para>
/// The present value of the trade is the value on the valuation date.
/// The result is expressed using the payment currency of the bond.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic
/// compounded rates of the discounting curve.
/// </para>
/// <para>
/// Coupon payments of the underlying product are considered based on the settlement date of the trade.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the discounting provider </param>
/// <param name="refData"> the reference data used to calculate the settlement date </param>
/// <param name="cleanPrice"> the clean price </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>
/// <returns> the present value of the fixed coupon bond trade </returns>
public virtual CurrencyAmount presentValueFromCleanPriceWithZSpread(ResolvedFixedCouponBondTrade trade, LegalEntityDiscountingProvider provider, ReferenceData refData, double cleanPrice, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
ResolvedFixedCouponBond product = trade.Product;
LocalDate standardSettlementDate = this.standardSettlementDate(product, provider, refData);
LocalDate tradeSettlementDate = settlementDate(trade, provider.ValuationDate);
Currency currency = product.Currency;
RepoCurveDiscountFactors repoDf = DiscountingFixedCouponBondProductPricer.repoCurveDf(product, provider);
double df = repoDf.discountFactor(standardSettlementDate);
double pvStandard = (cleanPrice * product.Notional + productPricer.accruedInterest(product, standardSettlementDate)) * df;
if (standardSettlementDate.isEqual(tradeSettlementDate))
{
return(presentValueFromProductPresentValue(trade, provider, CurrencyAmount.of(currency, pvStandard)));
}
// check coupon payment between two settlement dates
IssuerCurveDiscountFactors issuerDf = DiscountingFixedCouponBondProductPricer.issuerCurveDf(product, provider);
double pvDiff = 0d;
if (standardSettlementDate.isAfter(tradeSettlementDate))
{
pvDiff = productPricer.presentValueCouponWithZSpread(product, issuerDf, tradeSettlementDate, standardSettlementDate, zSpread, compoundedRateType, periodsPerYear);
}
else
{
pvDiff = -productPricer.presentValueCouponWithZSpread(product, issuerDf, standardSettlementDate, tradeSettlementDate, zSpread, compoundedRateType, periodsPerYear);
}
return(presentValueFromProductPresentValue(trade, provider, CurrencyAmount.of(currency, pvStandard + pvDiff)));
}
/// <summary>
/// Calculates the present value sensitivity of the settlement of the bond trade from the real clean price
/// with z-spread.
/// <para>
/// The present value sensitivity of the settlement is the sensitivity of the present value to
/// the underlying curves.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider, used to determine price index values </param>
/// <param name="refData"> the reference data used to calculate the settlement date </param>
/// <param name="discountingProvider"> the discount factors 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="cleanRealPrice"> the clean real price </param>
/// <returns> the present value sensitivity of the settlement </returns>
public virtual PointSensitivities presentValueSensitivityFromCleanPriceWithZSpread(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider, ReferenceData refData, double cleanRealPrice, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
validate(ratesProvider, discountingProvider);
LocalDate valuationDate = ratesProvider.ValuationDate;
ResolvedCapitalIndexedBond bond = trade.Product;
LocalDate standardSettlementDate = bond.calculateSettlementDateFromValuation(valuationDate, refData);
LocalDate tradeSettlementDate = settlementDate(trade, valuationDate);
RepoCurveDiscountFactors repoDf = DiscountingCapitalIndexedBondProductPricer.repoCurveDf(bond, discountingProvider);
double df = repoDf.discountFactor(standardSettlementDate);
PointSensitivityBuilder dfSensi = repoDf.zeroRatePointSensitivity(standardSettlementDate);
PointSensitivityBuilder pvSensiStandard = forecastValueSensitivityStandardFromCleanPrice(bond, ratesProvider, standardSettlementDate, cleanRealPrice).multipliedBy(df).combinedWith(dfSensi.multipliedBy(forecastValueStandardFromCleanPrice(bond, ratesProvider, standardSettlementDate, cleanRealPrice).Amount));
if (standardSettlementDate.isEqual(tradeSettlementDate))
{
return(presentValueSensitivityFromProductPresentValueSensitivity(trade, ratesProvider, discountingProvider, pvSensiStandard).build());
}
// check coupon payment between two settlement dates
IssuerCurveDiscountFactors issuerDf = DiscountingCapitalIndexedBondProductPricer.issuerCurveDf(bond, discountingProvider);
PointSensitivityBuilder pvSensiDiff = PointSensitivityBuilder.none();
if (standardSettlementDate.isAfter(tradeSettlementDate))
{
pvSensiDiff = pvSensiDiff.combinedWith(productPricer.presentValueSensitivityCouponWithZSpread(bond, ratesProvider, issuerDf, tradeSettlementDate, standardSettlementDate, zSpread, compoundedRateType, periodsPerYear).multipliedBy(-1d));
}
else
{
pvSensiDiff = pvSensiDiff.combinedWith(productPricer.presentValueSensitivityCouponWithZSpread(bond, ratesProvider, issuerDf, standardSettlementDate, tradeSettlementDate, zSpread, compoundedRateType, periodsPerYear));
}
return(presentValueSensitivityFromProductPresentValueSensitivity(trade, ratesProvider, discountingProvider, pvSensiStandard.combinedWith(pvSensiDiff)).build());
}
/// <summary>
/// Calculates the price sensitivity of the bond future product with z-spread.
/// <para>
/// The price sensitivity of the product is the sensitivity of the price to the underlying curves.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates
/// of the issuer discounting curve.
/// </para>
/// <para>
/// Note that the price sensitivity should be no currency.
///
/// </para>
/// </summary>
/// <param name="future"> the future </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodPerYear"> the number of periods per year </param>
/// <returns> the price curve sensitivity of the product </returns>
public PointSensitivities priceSensitivityWithZSpread(ResolvedBondFuture future, LegalEntityDiscountingProvider discountingProvider, double zSpread, CompoundedRateType compoundedRateType, int periodPerYear)
{
ImmutableList <ResolvedFixedCouponBond> basket = future.DeliveryBasket;
int size = basket.size();
double[] priceBonds = new double[size];
int indexCTD = 0;
double priceMin = 2d;
for (int i = 0; i < size; i++)
{
ResolvedFixedCouponBond bond = basket.get(i);
double dirtyPrice = bondPricer.dirtyPriceFromCurvesWithZSpread(bond, discountingProvider, zSpread, compoundedRateType, periodPerYear, future.LastDeliveryDate);
priceBonds[i] = bondPricer.cleanPriceFromDirtyPrice(bond, future.LastDeliveryDate, dirtyPrice) / future.ConversionFactors.get(i);
if (priceBonds[i] < priceMin)
{
priceMin = priceBonds[i];
indexCTD = i;
}
}
ResolvedFixedCouponBond bond = basket.get(indexCTD);
PointSensitivityBuilder pointSensi = bondPricer.dirtyPriceSensitivityWithZspread(bond, discountingProvider, zSpread, compoundedRateType, periodPerYear, future.LastDeliveryDate);
return(pointSensi.multipliedBy(1d / future.ConversionFactors.get(indexCTD)).build());
}
/// <summary>
/// Calculates the present value of a bill trade with z-spread.
/// <para>
/// If the settlement details are provided, the present value is the sum of the underlying product's present value
/// multiplied by the quantity and the present value of the settlement payment if still due at the valuation date.
/// If not it is the underlying product's present value multiplied by the quantity.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates of
/// the issuer discounting curve. The z-spread is applied only on the legal entity curve, not on the repo curve used
/// for the settlement amount.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the discounting 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>
/// <returns> the present value </returns>
public virtual CurrencyAmount presentValueWithZSpread(ResolvedBillTrade trade, LegalEntityDiscountingProvider provider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
if (provider.ValuationDate.isAfter(trade.Product.Notional.Date))
{
return(CurrencyAmount.of(trade.Product.Currency, 0.0d));
}
CurrencyAmount pvProduct = productPricer.presentValueWithZSpread(trade.Product, provider, zSpread, compoundedRateType, periodsPerYear).multipliedBy(trade.Quantity);
if (trade.Settlement.Present)
{
RepoCurveDiscountFactors repoDf = DiscountingBillProductPricer.repoCurveDf(trade.Product, provider);
CurrencyAmount pvSettle = paymentPricer.presentValue(trade.Settlement.get(), repoDf.DiscountFactors);
return(pvProduct.plus(pvSettle));
}
return(pvProduct);
}
/// <summary>
/// Calculates the present value sensitivity of the bond trade with z-spread.
/// <para>
/// The present value sensitivity of the trade is the sensitivity of the present value to
/// the underlying curves.
/// </para>
/// <para>
/// Coupon payments of the underlying product are considered based on the settlement date of the trade.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider, used to determine price index values </param>
/// <param name="discountingProvider"> the discount factors 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>
/// <returns> the present value sensitivity of the bond trade </returns>
public virtual PointSensitivities presentValueSensitivityWithZSpread(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
validate(ratesProvider, discountingProvider);
LocalDate settlementDate = this.settlementDate(trade, ratesProvider.ValuationDate);
PointSensitivityBuilder productSensi = productPricer.presentValueSensitivityWithZSpread(trade.Product, ratesProvider, discountingProvider, settlementDate, zSpread, compoundedRateType, periodsPerYear);
return(presentValueSensitivityFromProductPresentValueSensitivity(trade, ratesProvider, discountingProvider, productSensi).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>
/// Calculates the present value sensitivity of a bill trade with z-spread.
/// <para>
/// If the settlement details are provided, the sensitivity is the sum of the underlying product's sensitivity
/// multiplied by the quantity and the sensitivity of the settlement payment if still due at the valuation date.
/// If not it is the underlying product's sensitivity multiplied by the quantity.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates of
/// the issuer discounting curve. The z-spread is applied only on the legal entity curve, not on the repo curve used
/// for the settlement amount.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the discounting 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>
/// <returns> the present value sensitivity </returns>
public virtual PointSensitivities presentValueSensitivityWithZSpread(ResolvedBillTrade trade, LegalEntityDiscountingProvider provider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
if (provider.ValuationDate.isAfter(trade.Product.Notional.Date))
{
return(PointSensitivities.empty());
}
PointSensitivities sensiProduct = productPricer.presentValueSensitivityWithZSpread(trade.Product, provider, zSpread, compoundedRateType, periodsPerYear).multipliedBy(trade.Quantity);
if (!trade.Settlement.Present)
{
return(sensiProduct);
}
Payment settlement = trade.Settlement.get();
RepoCurveDiscountFactors repoDf = DiscountingBillProductPricer.repoCurveDf(trade.Product, provider);
PointSensitivities sensiSettle = presentValueSensitivitySettlement(settlement, repoDf);
return(sensiProduct.combinedWith(sensiSettle));
}
/// <summary>
/// Calculates the present value sensitivity of a single payment period with z-spread.
/// <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>
/// <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>
/// <returns> the present value curve sensitivity of the period </returns>
public virtual PointSensitivityBuilder presentValueSensitivityWithZSpread(CapitalIndexedBondPaymentPeriod period, RatesProvider ratesProvider, IssuerCurveDiscountFactors issuerDiscountFactors, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
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.DiscountFactors.discountFactorWithSpread(period.PaymentDate, zSpread, compoundedRateType, periodsPerYear);
ZeroRateSensitivity zeroSensi = issuerDiscountFactors.DiscountFactors.zeroRatePointSensitivityWithSpread(period.PaymentDate, zSpread, compoundedRateType, periodsPerYear);
IssuerCurveZeroRateSensitivity dfSensi = IssuerCurveZeroRateSensitivity.of(zeroSensi, issuerDiscountFactors.LegalEntityGroup);
double factor = period.Notional * period.RealCoupon;
return(rateSensi.multipliedBy(df * factor).combinedWith(dfSensi.multipliedBy((rate + 1d) * factor)));
}
/// <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)));
}
}
/// <summary>
/// Calculates the present value of a bill product with z-spread.
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or
/// periodic compounded rates of the issuer discounting curve.
///
/// </para>
/// </summary>
/// <param name="bill"> the product </param>
/// <param name="provider"> the discounting 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>
/// <returns> the present value of the bill product </returns>
public virtual CurrencyAmount presentValueWithZSpread(ResolvedBill bill, LegalEntityDiscountingProvider provider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
if (provider.ValuationDate.isAfter(bill.Notional.Date))
{
return(CurrencyAmount.of(bill.Currency, 0.0d));
}
IssuerCurveDiscountFactors issuerDf = issuerCurveDf(bill, provider);
double dfMaturity = issuerDf.DiscountFactors.discountFactorWithSpread(bill.Notional.Date, zSpread, compoundedRateType, periodsPerYear);
return(bill.Notional.Value.multipliedBy(dfMaturity));
}
// computes sensitivity with finite difference approximation
private CurrencyParameterSensitivities fdSensitivityWithZSpread(CapitalIndexedBondPaymentPeriod period, ImmutableRatesProvider ratesProvider, LegalEntityDiscountingProvider issuerRatesProvider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
CurrencyParameterSensitivities sensi1 = FD_CAL.sensitivity(issuerRatesProvider, p => CurrencyAmount.of(USD, PRICER.presentValueWithZSpread(period, ratesProvider, p.issuerCurveDiscountFactors(CapitalIndexedBondCurveDataSet.IssuerId, USD), zSpread, compoundedRateType, periodsPerYear)));
CurrencyParameterSensitivities sensi2 = FD_CAL.sensitivity(ratesProvider, p => CurrencyAmount.of(USD, PRICER.presentValueWithZSpread(period, p, issuerRatesProvider.issuerCurveDiscountFactors(CapitalIndexedBondCurveDataSet.IssuerId, USD), zSpread, compoundedRateType, periodsPerYear)));
return(sensi1.combinedWith(sensi2));
}
/// <summary>
/// Calculates the yield for settlement at a given settlement date using curves with z-spread.
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or
/// periodic compounded rates of the issuer discounting curve.
/// </para>
/// <para>
/// The z-spread is applied only on the legal entity curve, not on the repo curve.
///
/// </para>
/// </summary>
/// <param name="bill"> the bill </param>
/// <param name="provider"> the discounting provider </param>
/// <param name="settlementDate"> the settlement date </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>
/// <returns> the yield </returns>
public virtual double yieldFromCurvesWithZSpread(ResolvedBill bill, LegalEntityDiscountingProvider provider, LocalDate settlementDate, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
double price = priceFromCurvesWithZSpread(bill, provider, settlementDate, zSpread, compoundedRateType, periodsPerYear);
return(bill.yieldFromPrice(price, settlementDate));
}
/// <summary>
/// Calculates the price for settlement at a given settlement date using curves with z-spread.
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or
/// periodic compounded rates of the issuer discounting curve.
/// </para>
/// <para>
/// The z-spread is applied only on the legal entity curve, not on the repo curve.
///
/// </para>
/// </summary>
/// <param name="bill"> the bill </param>
/// <param name="provider"> the discounting provider </param>
/// <param name="settlementDate"> the settlement date </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>
/// <returns> the price </returns>
public virtual double priceFromCurvesWithZSpread(ResolvedBill bill, LegalEntityDiscountingProvider provider, LocalDate settlementDate, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
ArgChecker.inOrderNotEqual(settlementDate, bill.Notional.Date, "settlementDate", "endDate");
ArgChecker.inOrderOrEqual(provider.ValuationDate, settlementDate, "valuationDate", "settlementDate");
IssuerCurveDiscountFactors issuerDf = issuerCurveDf(bill, provider);
double dfMaturity = issuerDf.DiscountFactors.discountFactorWithSpread(bill.Notional.Date, zSpread, compoundedRateType, periodsPerYear);
RepoCurveDiscountFactors repoDf = repoCurveDf(bill, provider);
double dfRepoSettle = repoDf.discountFactor(settlementDate);
return(dfMaturity / dfRepoSettle);
}
/// <summary>
/// Calculates the present value sensitivity of the bill product with z-spread.
/// <para>
/// The present value sensitivity of the product is the sensitivity of the present value to
/// the underlying curves.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or
/// periodic compounded rates of the issuer discounting curve.
///
/// </para>
/// </summary>
/// <param name="bill"> the product </param>
/// <param name="provider"> the discounting 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>
/// <returns> the present value curve sensitivity of the product </returns>
public virtual PointSensitivities presentValueSensitivityWithZSpread(ResolvedBill bill, LegalEntityDiscountingProvider provider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
if (provider.ValuationDate.isAfter(bill.Notional.Date))
{
return(PointSensitivities.empty());
}
IssuerCurveDiscountFactors issuerDf = issuerCurveDf(bill, provider);
double dfEndBar = bill.Notional.Amount;
ZeroRateSensitivity zeroSensMaturity = issuerDf.DiscountFactors.zeroRatePointSensitivityWithSpread(bill.Notional.Date, zSpread, compoundedRateType, periodsPerYear);
IssuerCurveZeroRateSensitivity dscSensMaturity = IssuerCurveZeroRateSensitivity.of(zeroSensMaturity, issuerDf.LegalEntityGroup).multipliedBy(dfEndBar);
return(dscSensMaturity.build());
}
/// <summary>
/// Calculates the present value sensitivity of the fixed coupon bond trade with z-spread.
/// <para>
/// The present value sensitivity of the trade is the sensitivity of the present value to
/// the underlying curves.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic
/// compounded rates of the discounting curve.
/// </para>
/// <para>
/// Coupon payments of the underlying product are considered based on the settlement date of the trade.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the discounting 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>
/// <returns> the present value curve sensitivity of the trade </returns>
public virtual PointSensitivities presentValueSensitivityWithZSpread(ResolvedFixedCouponBondTrade trade, LegalEntityDiscountingProvider provider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
LocalDate settlementDate = this.settlementDate(trade, provider.ValuationDate);
PointSensitivityBuilder sensiProduct = productPricer.presentValueSensitivityWithZSpread(trade.Product, provider, zSpread, compoundedRateType, periodsPerYear, settlementDate);
return(presentValueSensitivityFromProductPresentValueSensitivity(trade, provider, sensiProduct).build());
}
/// <summary>
/// Calculates the present value of a single payment period with z-spread.
/// <para>
/// This returns the value of the period with discounting.
/// If the payment date of the period is in the past, zero is returned.
///
/// </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>
/// <returns> the present value of the period </returns>
public virtual double presentValueWithZSpread(CapitalIndexedBondPaymentPeriod period, RatesProvider ratesProvider, IssuerCurveDiscountFactors issuerDiscountFactors, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
double df = issuerDiscountFactors.DiscountFactors.discountFactorWithSpread(period.PaymentDate, zSpread, compoundedRateType, periodsPerYear);
return(df * forecastValue(period, ratesProvider));
}
/// <summary>
/// Calculates the present value sensitivity of a single fixed coupon payment period with z-spread.
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic
/// compounded rates of the discounting curve.
/// </para>
/// <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="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>
/// <returns> the present value curve sensitivity of the period </returns>
public virtual PointSensitivityBuilder presentValueSensitivityWithSpread(FixedCouponBondPaymentPeriod period, IssuerCurveDiscountFactors discountFactors, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
if (period.PaymentDate.isBefore(discountFactors.ValuationDate))
{
return(PointSensitivityBuilder.none());
}
ZeroRateSensitivity zeroSensi = discountFactors.DiscountFactors.zeroRatePointSensitivityWithSpread(period.PaymentDate, zSpread, compoundedRateType, periodsPerYear);
IssuerCurveZeroRateSensitivity dscSensi = IssuerCurveZeroRateSensitivity.of(zeroSensi, discountFactors.LegalEntityGroup);
return(dscSensi.multipliedBy(period.FixedRate * period.Notional * period.YearFraction));
}
/// <summary>
/// Calculates the present value sensitivity of the bond future trade with z-spread.
/// <para>
/// The present value sensitivity of the trade is the sensitivity of the present value to
/// the underlying curves.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates
/// of the issuer discounting curve.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodPerYear"> the number of periods per year </param>
/// <returns> the present value curve sensitivity of the trade </returns>
public PointSensitivities presentValueSensitivityWithZSpread(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider, double zSpread, CompoundedRateType compoundedRateType, int periodPerYear)
{
ResolvedBondFuture product = trade.Product;
PointSensitivities priceSensi = productPricer.priceSensitivityWithZSpread(product, discountingProvider, zSpread, compoundedRateType, periodPerYear);
PointSensitivities marginIndexSensi = productPricer.marginIndexSensitivity(product, priceSensi);
return(marginIndexSensi.multipliedBy(trade.Quantity));
}
/// <summary>
/// Calculates the present value of a single fixed coupon payment period with z-spread.
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic
/// compounded rates of the discounting curve.
/// </para>
/// <para>
/// The amount is expressed in the currency of the period.
/// This returns the value of the period with discounting.
/// </para>
/// <para>
/// The payment date of the period should not be in the past.
/// The result of this method for payment dates in the past is undefined.
///
/// </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>
/// <returns> the present value of the period </returns>
public virtual double presentValueWithSpread(FixedCouponBondPaymentPeriod period, IssuerCurveDiscountFactors discountFactors, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
if (period.PaymentDate.isBefore(discountFactors.ValuationDate))
{
return(0d);
}
double df = discountFactors.DiscountFactors.discountFactorWithSpread(period.PaymentDate, zSpread, compoundedRateType, periodsPerYear);
return(period.FixedRate * period.Notional * period.YearFraction * df);
}
/// <summary>
/// Calculates the par spread of the bond future trade with z-spread.
/// <para>
/// The par spread is defined in the following way. When the reference price (or market quote)
/// is increased by the par spread, the present value of the trade is zero.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates
/// of the issuer discounting curve.
/// </para>
/// <para>
/// This method calculates based on the difference between the model price and the
/// last settlement price, or the trade price if traded on the valuation date.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <param name="lastSettlementPrice"> the last settlement price used for margining, in decimal form </param>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodPerYear"> the number of periods per year </param>
/// <returns> the par spread </returns>
public double parSpreadWithZSpread(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider, double lastSettlementPrice, double zSpread, CompoundedRateType compoundedRateType, int periodPerYear)
{
double referencePrice = this.referencePrice(trade, discountingProvider.ValuationDate, lastSettlementPrice);
return(priceWithZSpread(trade, discountingProvider, zSpread, compoundedRateType, periodPerYear) - referencePrice);
}
/// <summary>
/// Calculates the currency exposure of a bill trade with z-spread.
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the discounting 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>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposureWithZSpread(ResolvedBillTrade trade, LegalEntityDiscountingProvider provider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
return(MultiCurrencyAmount.of(presentValueWithZSpread(trade, provider, zSpread, compoundedRateType, periodsPerYear)));
}
/// <summary>
/// Calculates the par spread sensitivity of the bond future trade with z-spread.
/// <para>
/// The par spread sensitivity of the trade is the sensitivity of the par spread to
/// the underlying curves.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates
/// of the issuer discounting curve.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodPerYear"> the number of periods per year </param>
/// <returns> the par spread curve sensitivity of the trade </returns>
public PointSensitivities parSpreadSensitivityWithZSpread(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider, double zSpread, CompoundedRateType compoundedRateType, int periodPerYear)
{
return(productPricer.priceSensitivityWithZSpread(trade.Product, discountingProvider, zSpread, compoundedRateType, periodPerYear));
}
/// <summary>
/// Calculates the present value of the bond trade with z-spread.
/// <para>
/// The present value of the trade is the value on the valuation date.
/// The result is expressed using the payment currency of the bond.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic
/// compounded rates of the discounting curve.
/// </para>
/// <para>
/// Coupon payments of the underlying product are considered based on the settlement date of the trade.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider, used to determine price index values </param>
/// <param name="discountingProvider"> the discount factors 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>
/// <returns> the present value of the bond trade </returns>
public virtual CurrencyAmount presentValueWithZSpread(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
validate(ratesProvider, discountingProvider);
LocalDate settlementDate = this.settlementDate(trade, ratesProvider.ValuationDate);
CurrencyAmount pvProduct = productPricer.presentValueWithZSpread(trade.Product, ratesProvider, discountingProvider, settlementDate, zSpread, compoundedRateType, periodsPerYear);
return(presentValueFromProductPresentValue(trade, ratesProvider, discountingProvider, pvProduct));
}
/// <summary>
/// Calculates the currency exposure of the bond future trade with z-spread.
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates
/// of the issuer discounting curve.
/// </para>
/// <para>
/// This method calculates based on the difference between the model price and the
/// last settlement price, or the trade price if traded on the valuation date.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <param name="lastSettlementPrice"> the last settlement price used for margining, in decimal form </param>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodPerYear"> the number of periods per year </param>
/// <returns> the currency exposure of the bond future trade </returns>
public MultiCurrencyAmount currencyExposureWithZSpread(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider, double lastSettlementPrice, double zSpread, CompoundedRateType compoundedRateType, int periodPerYear)
{
double price = priceWithZSpread(trade, discountingProvider, zSpread, compoundedRateType, periodPerYear);
double referencePrice = this.referencePrice(trade, discountingProvider.ValuationDate, lastSettlementPrice);
return(MultiCurrencyAmount.of(presentValue(trade, price, referencePrice)));
}
/// <summary>
/// Calculates the present value of the settlement of the bond trade from the clean price with z-spread.
/// <para>
/// Since the sign of the settlement notional is opposite to that of the product, negative amount will be returned
/// for positive quantity of trade.
/// </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="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider, used to determine price index values </param>
/// <param name="discountingProvider"> the discount factors provider </param>
/// <param name="refData"> the reference data used to calculate the settlement date </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="cleanRealPrice"> the clean real price </param>
/// <returns> the present value of the settlement </returns>
public virtual CurrencyAmount presentValueFromCleanPriceWithZSpread(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider, ReferenceData refData, double cleanRealPrice, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
validate(ratesProvider, discountingProvider);
LocalDate valuationDate = ratesProvider.ValuationDate;
ResolvedCapitalIndexedBond bond = trade.Product;
LocalDate standardSettlementDate = bond.calculateSettlementDateFromValuation(valuationDate, refData);
LocalDate tradeSettlementDate = settlementDate(trade, valuationDate);
RepoCurveDiscountFactors repoDf = DiscountingCapitalIndexedBondProductPricer.repoCurveDf(bond, discountingProvider);
double df = repoDf.discountFactor(standardSettlementDate);
CurrencyAmount pvStandard = forecastValueStandardFromCleanPrice(bond, ratesProvider, standardSettlementDate, cleanRealPrice).multipliedBy(df);
if (standardSettlementDate.isEqual(tradeSettlementDate))
{
return(presentValueFromProductPresentValue(trade, ratesProvider, discountingProvider, pvStandard));
}
// check coupon payment between two settlement dates
IssuerCurveDiscountFactors issuerDf = DiscountingCapitalIndexedBondProductPricer.issuerCurveDf(bond, discountingProvider);
double pvDiff = 0d;
if (standardSettlementDate.isAfter(tradeSettlementDate))
{
pvDiff = -productPricer.presentValueCouponWithZSpread(bond, ratesProvider, issuerDf, tradeSettlementDate, standardSettlementDate, zSpread, compoundedRateType, periodsPerYear);
}
else
{
pvDiff = productPricer.presentValueCouponWithZSpread(bond, ratesProvider, issuerDf, standardSettlementDate, tradeSettlementDate, zSpread, compoundedRateType, periodsPerYear);
}
return(presentValueFromProductPresentValue(trade, ratesProvider, discountingProvider, pvStandard.plus(pvDiff)));
}
/// <summary>
/// Calculates the present value of the fixed coupon bond trade with z-spread.
/// <para>
/// The present value of the trade is the value on the valuation date.
/// The result is expressed using the payment currency of the bond.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic
/// compounded rates of the discounting curve.
/// </para>
/// <para>
/// Coupon payments of the underlying product are considered based on the settlement date of the trade.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="provider"> the discounting 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>
/// <returns> the present value of the fixed coupon bond trade </returns>
public virtual CurrencyAmount presentValueWithZSpread(ResolvedFixedCouponBondTrade trade, LegalEntityDiscountingProvider provider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
LocalDate settlementDate = this.settlementDate(trade, provider.ValuationDate);
CurrencyAmount pvProduct = productPricer.presentValueWithZSpread(trade.Product, provider, zSpread, compoundedRateType, periodsPerYear, settlementDate);
return(presentValueFromProductPresentValue(trade, provider, pvProduct));
}
/// <summary>
/// Calculates the currency exposure of the bond trade with z-spread.
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider, used to determine price index values </param>
/// <param name="discountingProvider"> the discount factors 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>
/// <returns> the currency exposure of the trade </returns>
public virtual MultiCurrencyAmount currencyExposureWithZSpread(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider, double zSpread, CompoundedRateType compoundedRateType, int periodsPerYear)
{
CurrencyAmount pv = presentValueWithZSpread(trade, ratesProvider, discountingProvider, zSpread, compoundedRateType, periodsPerYear);
return(MultiCurrencyAmount.of(pv));
}
/// <summary>
/// Calculates the price of the bond future product with z-spread.
/// <para>
/// The price of the product is the price on the valuation date.
/// </para>
/// <para>
/// The z-spread is a parallel shift applied to continuously compounded rates or periodic compounded rates
/// of the issuer discounting curve.
/// </para>
/// <para>
/// Strata uses <i>decimal prices</i> for bond futures. This is coherent with the pricing of <seealso cref="FixedCouponBond"/>.
/// For example, a price of 99.32% is represented in Strata by 0.9932.
///
/// </para>
/// </summary>
/// <param name="future"> the future </param>
/// <param name="discountingProvider"> the discounting provider </param>
/// <param name="zSpread"> the z-spread </param>
/// <param name="compoundedRateType"> the compounded rate type </param>
/// <param name="periodPerYear"> the number of periods per year </param>
/// <returns> the price of the product, in decimal form </returns>
public double priceWithZSpread(ResolvedBondFuture future, LegalEntityDiscountingProvider discountingProvider, double zSpread, CompoundedRateType compoundedRateType, int periodPerYear)
{
ImmutableList <ResolvedFixedCouponBond> basket = future.DeliveryBasket;
int size = basket.size();
double[] priceBonds = new double[size];
for (int i = 0; i < size; ++i)
{
ResolvedFixedCouponBond bond = basket.get(i);
double dirtyPrice = bondPricer.dirtyPriceFromCurvesWithZSpread(bond, discountingProvider, zSpread, compoundedRateType, periodPerYear, future.LastDeliveryDate);
priceBonds[i] = bondPricer.cleanPriceFromDirtyPrice(bond, future.LastDeliveryDate, dirtyPrice) / future.ConversionFactors.get(i);
}
return(Doubles.min(priceBonds));
}
