//-------------------------------------------------------------------------
public override CurrencyAmount parallelCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData)
{
checkCdsBucket(trade, bucketCds);
ResolvedCds product = trade.Product;
Currency currency = product.Currency;
StandardId legalEntityId = product.LegalEntityId;
LocalDate valuationDate = ratesProvider.ValuationDate;
ImmutableCreditRatesProvider immutableRatesProvider = ratesProvider.toImmutableCreditRatesProvider();
int nBucket = bucketCds.Count;
DoubleArray impSp = impliedSpread(bucketCds, ratesProvider, refData);
NodalCurve creditCurveBase = Calibrator.calibrate(bucketCds, impSp, DoubleArray.filled(nBucket), CurveName.of("baseImpliedCreditCurve"), valuationDate, ratesProvider.discountFactors(currency), ratesProvider.recoveryRates(legalEntityId), refData);
Pair <StandardId, Currency> lePair = Pair.of(legalEntityId, currency);
IsdaCreditDiscountFactors df = IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurveBase);
CreditRatesProvider ratesProviderBase = immutableRatesProvider.toBuilder().creditCurves(ImmutableMap.of(lePair, LegalEntitySurvivalProbabilities.of(legalEntityId, df))).build();
CurrencyAmount pvBase = Pricer.presentValueOnSettle(trade, ratesProviderBase, PriceType.DIRTY, refData);
DoubleArray bumpedSp = DoubleArray.of(nBucket, i => impSp.get(i) + bumpAmount);
NodalCurve creditCurveBump = Calibrator.calibrate(bucketCds, bumpedSp, DoubleArray.filled(nBucket), CurveName.of("bumpedImpliedCreditCurve"), valuationDate, ratesProvider.discountFactors(currency), ratesProvider.recoveryRates(legalEntityId), refData);
IsdaCreditDiscountFactors dfBump = IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurveBump);
CreditRatesProvider ratesProviderBump = immutableRatesProvider.toBuilder().creditCurves(ImmutableMap.of(lePair, LegalEntitySurvivalProbabilities.of(legalEntityId, dfBump))).build();
CurrencyAmount pvBumped = Pricer.presentValueOnSettle(trade, ratesProviderBump, PriceType.DIRTY, refData);
return(CurrencyAmount.of(currency, (pvBumped.Amount - pvBase.Amount) / bumpAmount));
}
internal override DoubleArray computedBucketedCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData)
{
checkCdsBucket(trade, bucketCds);
ResolvedCds product = trade.Product;
Currency currency = product.Currency;
StandardId legalEntityId = product.LegalEntityId;
LocalDate valuationDate = ratesProvider.ValuationDate;
int nBucket = bucketCds.Count;
DoubleArray impSp = impliedSpread(bucketCds, ratesProvider, refData);
NodalCurve creditCurveBase = Calibrator.calibrate(bucketCds, impSp, DoubleArray.filled(nBucket), CurveName.of("baseImpliedCreditCurve"), valuationDate, ratesProvider.discountFactors(currency), ratesProvider.recoveryRates(legalEntityId), refData);
IsdaCreditDiscountFactors df = IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurveBase);
CreditRatesProvider ratesProviderBase = ratesProvider.toImmutableCreditRatesProvider().toBuilder().creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), LegalEntitySurvivalProbabilities.of(legalEntityId, df))).build();
double[][] res = new double[nBucket][];
PointSensitivities pointPv = Pricer.presentValueOnSettleSensitivity(trade, ratesProviderBase, refData);
DoubleArray vLambda = ratesProviderBase.singleCreditCurveParameterSensitivity(pointPv, legalEntityId, currency).Sensitivity;
for (int i = 0; i < nBucket; i++)
{
PointSensitivities pointSp = Pricer.parSpreadSensitivity(bucketCds[i], ratesProviderBase, refData);
res[i] = ratesProviderBase.singleCreditCurveParameterSensitivity(pointSp, legalEntityId, currency).Sensitivity.toArray();
}
DoubleMatrix jacT = MATRIX_ALGEBRA.getTranspose(DoubleMatrix.ofUnsafe(res));
LUDecompositionResult luRes = DECOMPOSITION.apply(jacT);
DoubleArray vS = luRes.solve(vLambda);
return(vS);
}
internal override DoubleArray computedBucketedCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData)
{
checkCdsBucket(trade, bucketCds);
ResolvedCds product = trade.Product;
Currency currency = product.Currency;
StandardId legalEntityId = product.LegalEntityId;
LocalDate valuationDate = ratesProvider.ValuationDate;
ImmutableCreditRatesProvider immutableRatesProvider = ratesProvider.toImmutableCreditRatesProvider();
int nBucket = bucketCds.Count;
double[] res = new double[nBucket];
DoubleArray impSp = impliedSpread(bucketCds, ratesProvider, refData);
NodalCurve creditCurveBase = Calibrator.calibrate(bucketCds, impSp, DoubleArray.filled(nBucket), CurveName.of("baseImpliedCreditCurve"), valuationDate, ratesProvider.discountFactors(currency), ratesProvider.recoveryRates(legalEntityId), refData);
Pair <StandardId, Currency> lePair = Pair.of(legalEntityId, currency);
IsdaCreditDiscountFactors df = IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurveBase);
CreditRatesProvider ratesProviderBase = immutableRatesProvider.toBuilder().creditCurves(ImmutableMap.of(lePair, LegalEntitySurvivalProbabilities.of(legalEntityId, df))).build();
double pvBase = Pricer.presentValueOnSettle(trade, ratesProviderBase, PriceType.DIRTY, refData).Amount;
for (int i = 0; i < nBucket; ++i)
{
double[] bumpedSp = impSp.toArray();
bumpedSp[i] += bumpAmount;
NodalCurve creditCurveBump = Calibrator.calibrate(bucketCds, DoubleArray.ofUnsafe(bumpedSp), DoubleArray.filled(nBucket), CurveName.of("bumpedImpliedCreditCurve"), valuationDate, ratesProvider.discountFactors(currency), ratesProvider.recoveryRates(legalEntityId), refData);
IsdaCreditDiscountFactors dfBump = IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurveBump);
CreditRatesProvider ratesProviderBump = immutableRatesProvider.toBuilder().creditCurves(ImmutableMap.of(lePair, LegalEntitySurvivalProbabilities.of(legalEntityId, dfBump))).build();
double pvBumped = Pricer.presentValueOnSettle(trade, ratesProviderBump, PriceType.DIRTY, refData).Amount;
res[i] = (pvBumped - pvBase) / bumpAmount;
}
return(DoubleArray.ofUnsafe(res));
}
internal virtual double recoveryRate(ResolvedCds cds, CreditRatesProvider ratesProvider)
{
RecoveryRates recoveryRates = ratesProvider.recoveryRates(cds.LegalEntityId);
ArgChecker.isTrue(recoveryRates is ConstantRecoveryRates, "recoveryRates must be ConstantRecoveryRates");
return(recoveryRates.recoveryRate(cds.ProtectionEndDate));
}
private double getIndexFactor(ResolvedCds cds, CreditRatesProvider ratesProvider)
{
LegalEntitySurvivalProbabilities survivalProbabilities = ratesProvider.survivalProbabilities(cds.LegalEntityId, cds.Currency);
// instance is checked in pricer
double indexFactor = ((IsdaCreditDiscountFactors)survivalProbabilities.SurvivalProbabilities).Curve.Metadata.getInfo(CurveInfoType.CDS_INDEX_FACTOR);
return(indexFactor);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the par spread of the CDS product.
/// <para>
/// The par spread is a coupon rate such that the clean PV is 0.
/// The result is represented in decimal form.
///
/// </para>
/// </summary>
/// <param name="cds"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the par spread </returns>
public virtual double parSpread(ResolvedCds cds, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
ArgChecker.isTrue(cds.ProtectionEndDate.isAfter(ratesProvider.ValuationDate), "CDS already expired");
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
double recoveryRate = this.recoveryRate(cds, ratesProvider);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
double protectionLeg = this.protectionLeg(cds, rates.First, rates.Second, referenceDate, effectiveStartDate, recoveryRate);
double riskyAnnuity = this.riskyAnnuity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate, PriceType.CLEAN);
return(protectionLeg / riskyAnnuity);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the risky annuity, which is RPV01 per unit notional.
/// </summary>
/// <param name="cds"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="priceType"> the price type </param>
/// <param name="refData"> the reference data </param>
/// <returns> the risky annuity </returns>
public virtual double riskyAnnuity(ResolvedCds cds, CreditRatesProvider ratesProvider, LocalDate referenceDate, PriceType priceType, ReferenceData refData)
{
if (isExpired(cds, ratesProvider))
{
return(0d);
}
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
return(riskyAnnuity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate, priceType));
}
/// <summary>
/// Calculates the expected loss of the CDS product.
/// <para>
/// The expected loss is the (undiscounted) expected default settlement value paid by the protection seller.
/// The resulting value is always positive.
///
/// </para>
/// </summary>
/// <param name="cds"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <returns> the expected loss </returns>
public virtual CurrencyAmount expectedLoss(ResolvedCds cds, CreditRatesProvider ratesProvider)
{
if (isExpired(cds, ratesProvider))
{
return(CurrencyAmount.of(cds.Currency, 0d));
}
double recoveryRate = this.recoveryRate(cds, ratesProvider);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
double survivalProbability = rates.Second.survivalProbability(cds.ProtectionEndDate);
double el = (1d - recoveryRate) * (1d - survivalProbability);
return(CurrencyAmount.of(cds.Currency, Math.Abs(cds.Notional) * el));
}
/// <summary>
/// Calculates the expected loss of the CDS index product.
/// <para>
/// The expected loss is the (undiscounted) expected default settlement value paid by the protection seller.
/// The resulting value is always positive.
///
/// </para>
/// </summary>
/// <param name="cdsIndex"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <returns> the expected loss </returns>
public virtual CurrencyAmount expectedLoss(ResolvedCdsIndex cdsIndex, CreditRatesProvider ratesProvider)
{
if (isExpired(cdsIndex, ratesProvider))
{
return(CurrencyAmount.of(cdsIndex.Currency, 0d));
}
ResolvedCds cds = cdsIndex.toSingleNameCds();
double recoveryRate = underlyingPricer.recoveryRate(cds, ratesProvider);
Triple <CreditDiscountFactors, LegalEntitySurvivalProbabilities, double> rates = reduceDiscountFactors(cds, ratesProvider);
double survivalProbability = rates.Second.survivalProbability(cds.ProtectionEndDate);
double el = (1d - recoveryRate) * (1d - survivalProbability) * rates.Third;
return(CurrencyAmount.of(cds.Currency, Math.Abs(cds.Notional) * el));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the risky PV01 of the CDS index product.
/// <para>
/// RPV01 is defined as minus of the present value sensitivity to coupon rate.
///
/// </para>
/// </summary>
/// <param name="cdsIndex"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="priceType"> the price type </param>
/// <param name="refData"> the reference date </param>
/// <returns> the RPV01 </returns>
public virtual CurrencyAmount rpv01(ResolvedCdsIndex cdsIndex, CreditRatesProvider ratesProvider, LocalDate referenceDate, PriceType priceType, ReferenceData refData)
{
if (isExpired(cdsIndex, ratesProvider))
{
return(CurrencyAmount.of(cdsIndex.Currency, 0d));
}
ResolvedCds cds = cdsIndex.toSingleNameCds();
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
Triple <CreditDiscountFactors, LegalEntitySurvivalProbabilities, double> rates = reduceDiscountFactors(cds, ratesProvider);
double riskyAnnuity = underlyingPricer.riskyAnnuity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate, priceType);
double amount = cds.BuySell.normalize(cds.Notional) * riskyAnnuity * rates.Third;
return(CurrencyAmount.of(cds.Currency, amount));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the recovery01 of the CDS product.
/// <para>
/// The recovery01 is defined as the present value sensitivity to the recovery rate.
/// Since the ISDA standard model requires the recovery rate to be constant throughout the lifetime of the CDS,
/// one currency amount is returned by this method.
///
/// </para>
/// </summary>
/// <param name="cds"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the recovery01 </returns>
public virtual CurrencyAmount recovery01(ResolvedCds cds, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
if (isExpired(cds, ratesProvider))
{
return(CurrencyAmount.of(cds.Currency, 0d));
}
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
validateRecoveryRates(cds, ratesProvider);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
double protectionFull = this.protectionFull(cds, rates.First, rates.Second, referenceDate, effectiveStartDate);
return(CurrencyAmount.of(cds.Currency, -cds.BuySell.normalize(cds.Notional) * protectionFull));
}
/// <summary>
/// Calculates the par spread sensitivity of the product.
/// <para>
/// The par spread sensitivity of the product is the sensitivity of par spread to the underlying curves.
/// The resulting sensitivity is based on the currency of the CDS product.
///
/// </para>
/// </summary>
/// <param name="cds"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the par spread </returns>
public virtual PointSensitivityBuilder parSpreadSensitivity(ResolvedCds cds, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
ArgChecker.isTrue(cds.ProtectionEndDate.isAfter(ratesProvider.ValuationDate), "CDS already expired");
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
double recoveryRate = this.recoveryRate(cds, ratesProvider);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
double protectionLeg = this.protectionLeg(cds, rates.First, rates.Second, referenceDate, effectiveStartDate, recoveryRate);
double riskyAnnuityInv = 1d / riskyAnnuity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate, PriceType.CLEAN);
PointSensitivityBuilder protectionLegSensi = protectionLegSensitivity(cds, rates.First, rates.Second, referenceDate, effectiveStartDate, recoveryRate).multipliedBy(riskyAnnuityInv);
PointSensitivityBuilder riskyAnnuitySensi = riskyAnnuitySensitivity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate).multipliedBy(-protectionLeg * riskyAnnuityInv * riskyAnnuityInv);
return(protectionLegSensi.combinedWith(riskyAnnuitySensi));
}
// internal price computation with specified coupon rate
internal virtual double price(ResolvedCds cds, CreditRatesProvider ratesProvider, double fractionalSpread, LocalDate referenceDate, PriceType priceType, ReferenceData refData)
{
if (!cds.ProtectionEndDate.isAfter(ratesProvider.ValuationDate))
{ //short cut already expired CDSs
return(0d);
}
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
double recoveryRate = this.recoveryRate(cds, ratesProvider);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
double protectionLeg = this.protectionLeg(cds, rates.First, rates.Second, referenceDate, effectiveStartDate, recoveryRate);
double rpv01 = riskyAnnuity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate, priceType);
return(protectionLeg - rpv01 * fractionalSpread);
}
/// <summary>
/// Calculates the price sensitivity of the product.
/// <para>
/// The price sensitivity of the product is the sensitivity of price to the underlying curves.
///
/// </para>
/// </summary>
/// <param name="cds"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the present value sensitivity </returns>
public virtual PointSensitivityBuilder priceSensitivity(ResolvedCds cds, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
if (isExpired(cds, ratesProvider))
{
return(PointSensitivityBuilder.none());
}
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
double recoveryRate = this.recoveryRate(cds, ratesProvider);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
PointSensitivityBuilder protectionLegSensi = protectionLegSensitivity(cds, rates.First, rates.Second, referenceDate, effectiveStartDate, recoveryRate);
PointSensitivityBuilder riskyAnnuitySensi = riskyAnnuitySensitivity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate).multipliedBy(-cds.FixedRate);
return(protectionLegSensi.combinedWith(riskyAnnuitySensi));
}
private System.Func <double, double> getPriceFunction(int index, ResolvedCdsTrade cds, double flactionalSpread, double pointsUpfront, LocalDate valuationDate, NodalCurve creditCurve, CreditDiscountFactors discountFactors, RecoveryRates recoveryRates, ReferenceData refData)
{
ResolvedCds cdsProduct = cds.Product;
Currency currency = cdsProduct.Currency;
StandardId legalEntityId = cdsProduct.LegalEntityId;
Pair <StandardId, Currency> pair = Pair.of(legalEntityId, currency);
ImmutableCreditRatesProvider ratesbase = ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).discountCurves(ImmutableMap.of(currency, discountFactors)).recoveryRateCurves(ImmutableMap.of(legalEntityId, recoveryRates)).build();
System.Func <double, double> func = (double?x) =>
{
NodalCurve tempCreditCurve = creditCurve.withParameter(index, x.Value);
ImmutableCreditRatesProvider rates = ratesbase.toBuilder().creditCurves(ImmutableMap.of(pair, LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, tempCreditCurve)))).build();
double price = TradePricer.price(cds, rates, flactionalSpread, PriceType.CLEAN, refData);
return(price - pointsUpfront);
};
return(func);
}
//-------------------------------------------------------------------------
// extract CDS trades from credit curve
private ImmutableList <ResolvedCdsTrade> getBucketCds(ResolvedCds product, CreditRatesProvider ratesProvider)
{
CreditDiscountFactors creditCurve = ratesProvider.survivalProbabilities(product.LegalEntityId, product.Currency).SurvivalProbabilities;
int nNodes = creditCurve.ParameterCount;
ImmutableList.Builder <ResolvedCdsTrade> builder = ImmutableList.builder();
for (int i = 0; i < nNodes; ++i)
{
ParameterMetadata metadata = creditCurve.getParameterMetadata(i);
ArgChecker.isTrue(metadata is ResolvedTradeParameterMetadata, "ParameterMetadata of credit curve must be ResolvedTradeParameterMetadata");
ResolvedTradeParameterMetadata tradeMetadata = (ResolvedTradeParameterMetadata)metadata;
ResolvedTrade trade = tradeMetadata.Trade;
ArgChecker.isTrue(trade is ResolvedCdsTrade, "ResolvedTrade must be ResolvedCdsTrade");
builder.add((ResolvedCdsTrade)trade);
}
return(builder.build());
}
/// <summary>
/// Converts points upfront to quoted spread.
/// <para>
/// Thus {@code quote} must be {@code CdsQuoteConvention.POINTS_UPFRONT}.
/// </para>
/// <para>
/// The relevant discount curve and recovery rate curve must be stored in {@code ratesProvider}.
/// The credit curve is internally calibrated to convert one quote type to the other quote type.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="quote"> the quote </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the quote </returns>
public virtual CdsQuote quotedSpreadFromPointsUpfront(ResolvedCdsTrade trade, CdsQuote quote, CreditRatesProvider ratesProvider, ReferenceData refData)
{
ArgChecker.notNull(trade, "trade");
ArgChecker.notNull(quote, "quote");
ArgChecker.notNull(ratesProvider, "ratesProvider");
ArgChecker.notNull(refData, "refData");
ArgChecker.isTrue(quote.QuoteConvention.Equals(CdsQuoteConvention.POINTS_UPFRONT), "quote must be points upfront");
ResolvedCds product = trade.Product;
Currency currency = product.Currency;
StandardId legalEntityId = product.LegalEntityId;
LocalDate valuationDate = ratesProvider.ValuationDate;
NodalCurve creditCurve = calibrator.calibrate(ImmutableList.of(trade), DoubleArray.of(product.FixedRate), DoubleArray.of(quote.QuotedValue), CurveName.of("temp"), valuationDate, ratesProvider.discountFactors(currency), ratesProvider.recoveryRates(legalEntityId), refData);
CreditRatesProvider ratesProviderNew = ratesProvider.toImmutableCreditRatesProvider().toBuilder().creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurve)))).build();
double sp = pricer.parSpread(trade, ratesProviderNew, refData);
return(CdsQuote.of(CdsQuoteConvention.QUOTED_SPREAD, sp));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the jump-to-default of the CDS product.
/// <para>
/// The jump-to-default is the value of the product in case of immediate default.
///
/// </para>
/// </summary>
/// <param name="cds"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the jump-to-default </returns>
public virtual JumpToDefault jumpToDefault(ResolvedCds cds, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
StandardId legalEntityId = cds.LegalEntityId;
Currency currency = cds.Currency;
if (isExpired(cds, ratesProvider))
{
return(JumpToDefault.of(currency, ImmutableMap.of(legalEntityId, 0d)));
}
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
double recoveryRate = this.recoveryRate(cds, ratesProvider);
Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> rates = reduceDiscountFactors(cds, ratesProvider);
double protectionFull = this.protectionFull(cds, rates.First, rates.Second, referenceDate, effectiveStartDate);
double lgd = 1d - recoveryRate;
double rpv01 = riskyAnnuity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate, PriceType.CLEAN);
double jtd = lgd - (lgd * protectionFull - cds.FixedRate * rpv01);
return(JumpToDefault.of(currency, ImmutableMap.of(legalEntityId, cds.BuySell.normalize(cds.Notional) * jtd)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the jump-to-default of the CDS index product.
/// <para>
/// The jump-to-default is the value of the product in case of immediate default of a constituent single name.
/// </para>
/// <para>
/// Under the homogeneous pool assumption, the jump-to-default values are the same for all of the undefaulted names,
/// and zero for defaulted names. Thus the resulting object contains a single number.
///
/// </para>
/// </summary>
/// <param name="cdsIndex"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the recovery01 </returns>
public virtual JumpToDefault jumpToDefault(ResolvedCdsIndex cdsIndex, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
StandardId indexId = cdsIndex.CdsIndexId;
Currency currency = cdsIndex.Currency;
if (isExpired(cdsIndex, ratesProvider))
{
return(JumpToDefault.of(currency, ImmutableMap.of(indexId, 0d)));
}
ResolvedCds cds = cdsIndex.toSingleNameCds();
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
double recoveryRate = underlyingPricer.recoveryRate(cds, ratesProvider);
Triple <CreditDiscountFactors, LegalEntitySurvivalProbabilities, double> rates = reduceDiscountFactors(cds, ratesProvider);
double protectionFull = underlyingPricer.protectionFull(cds, rates.First, rates.Second, referenceDate, effectiveStartDate);
double rpv01 = underlyingPricer.riskyAnnuity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate, PriceType.CLEAN);
double lgd = 1d - recoveryRate;
double numTotal = cdsIndex.LegalEntityIds.size();
double jtd = (lgd - (lgd * protectionFull - cds.FixedRate * rpv01)) / numTotal;
return(JumpToDefault.of(currency, ImmutableMap.of(indexId, cds.BuySell.normalize(cds.Notional) * jtd)));
}
// computes protection leg pv per unit notional, without loss-given-default rate multiplied
internal virtual double protectionFull(ResolvedCds cds, CreditDiscountFactors discountFactors, LegalEntitySurvivalProbabilities survivalProbabilities, LocalDate referenceDate, LocalDate effectiveStartDate)
{
DoubleArray integrationSchedule = DoublesScheduleGenerator.getIntegrationsPoints(discountFactors.relativeYearFraction(effectiveStartDate), discountFactors.relativeYearFraction(cds.ProtectionEndDate), discountFactors.ParameterKeys, survivalProbabilities.ParameterKeys);
double pv = 0d;
double ht0 = survivalProbabilities.zeroRate(integrationSchedule.get(0)) * integrationSchedule.get(0);
double rt0 = discountFactors.zeroRate(integrationSchedule.get(0)) * integrationSchedule.get(0);
double b0 = Math.Exp(-ht0 - rt0);
int n = integrationSchedule.size();
for (int i = 1; i < n; ++i)
{
double ht1 = survivalProbabilities.zeroRate(integrationSchedule.get(i)) * integrationSchedule.get(i);
double rt1 = discountFactors.zeroRate(integrationSchedule.get(i)) * integrationSchedule.get(i);
double b1 = Math.Exp(-ht1 - rt1);
double dht = ht1 - ht0;
double drt = rt1 - rt0;
double dhrt = dht + drt;
// The formula has been modified from ISDA (but is equivalent) to avoid log(exp(x)) and explicitly
// calculating the time step - it also handles the limit
double dPV = 0d;
if (Math.Abs(dhrt) < SMALL)
{
dPV = dht * b0 * epsilon(-dhrt);
}
else
{
dPV = (b0 - b1) * dht / dhrt;
}
pv += dPV;
ht0 = ht1;
rt0 = rt1;
b0 = b1;
}
// roll to the cash settle date
double df = discountFactors.discountFactor(referenceDate);
return(pv / df);
}
/// <summary>
/// Calculates the present value sensitivity of the product.
/// <para>
/// The present value sensitivity of the product is the sensitivity of present value to the underlying curves.
///
/// </para>
/// </summary>
/// <param name="cdsIndex"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the present value sensitivity </returns>
public virtual PointSensitivityBuilder presentValueSensitivity(ResolvedCdsIndex cdsIndex, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
if (isExpired(cdsIndex, ratesProvider))
{
return(PointSensitivityBuilder.none());
}
ResolvedCds cds = cdsIndex.toSingleNameCds();
LocalDate stepinDate = cds.StepinDateOffset.adjust(ratesProvider.ValuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
double recoveryRate = underlyingPricer.recoveryRate(cds, ratesProvider);
Triple <CreditDiscountFactors, LegalEntitySurvivalProbabilities, double> rates = reduceDiscountFactors(cds, ratesProvider);
double signedNotional = cds.BuySell.normalize(cds.Notional);
PointSensitivityBuilder protectionLegSensi = underlyingPricer.protectionLegSensitivity(cds, rates.First, rates.Second, referenceDate, effectiveStartDate, recoveryRate);
protectionLegSensi = protectionLegSensi.multipliedBy(signedNotional * rates.Third);
PointSensitivityBuilder riskyAnnuitySensi = underlyingPricer.riskyAnnuitySensitivity(cds, rates.First, rates.Second, referenceDate, stepinDate, effectiveStartDate);
riskyAnnuitySensi = riskyAnnuitySensi.multipliedBy(-cds.FixedRate * signedNotional * rates.Third);
return(protectionLegSensi.combinedWith(riskyAnnuitySensi));
}
internal virtual PointSensitivityBuilder riskyAnnuitySensitivity(ResolvedCds cds, CreditDiscountFactors discountFactors, LegalEntitySurvivalProbabilities survivalProbabilities, LocalDate referenceDate, LocalDate stepinDate, LocalDate effectiveStartDate)
{
double pv = 0d;
PointSensitivityBuilder pvSensi = PointSensitivityBuilder.none();
foreach (CreditCouponPaymentPeriod coupon in cds.PaymentPeriods)
{
if (stepinDate.isBefore(coupon.EndDate))
{
double q = survivalProbabilities.survivalProbability(coupon.EffectiveEndDate);
PointSensitivityBuilder qSensi = survivalProbabilities.zeroRatePointSensitivity(coupon.EffectiveEndDate);
double p = discountFactors.discountFactor(coupon.PaymentDate);
PointSensitivityBuilder pSensi = discountFactors.zeroRatePointSensitivity(coupon.PaymentDate);
pv += coupon.YearFraction * p * q;
pvSensi = pvSensi.combinedWith(pSensi.multipliedBy(coupon.YearFraction * q).combinedWith(qSensi.multipliedBy(coupon.YearFraction * p)));
}
}
if (cds.PaymentOnDefault.AccruedInterest)
{
// This is needed so that the code is consistent with ISDA C when the Markit `fix' is used.
LocalDate start = cds.PaymentPeriods.size() == 1 ? effectiveStartDate : cds.AccrualStartDate;
DoubleArray integrationSchedule = DoublesScheduleGenerator.getIntegrationsPoints(discountFactors.relativeYearFraction(start), discountFactors.relativeYearFraction(cds.ProtectionEndDate), discountFactors.ParameterKeys, survivalProbabilities.ParameterKeys);
foreach (CreditCouponPaymentPeriod coupon in cds.PaymentPeriods)
{
Pair <double, PointSensitivityBuilder> pvAndSensi = singlePeriodAccrualOnDefaultSensitivity(coupon, effectiveStartDate, integrationSchedule, discountFactors, survivalProbabilities);
pv += pvAndSensi.First;
pvSensi = pvSensi.combinedWith(pvAndSensi.Second);
}
}
double df = discountFactors.discountFactor(referenceDate);
PointSensitivityBuilder dfSensi = discountFactors.zeroRatePointSensitivity(referenceDate).multipliedBy(-pv / (df * df));
pvSensi = pvSensi.multipliedBy(1d / df);
return(dfSensi.combinedWith(pvSensi));
}
// computes risky annuity
internal virtual double riskyAnnuity(ResolvedCds cds, CreditDiscountFactors discountFactors, LegalEntitySurvivalProbabilities survivalProbabilities, LocalDate referenceDate, LocalDate stepinDate, LocalDate effectiveStartDate, PriceType priceType)
{
double pv = 0d;
foreach (CreditCouponPaymentPeriod coupon in cds.PaymentPeriods)
{
if (stepinDate.isBefore(coupon.EndDate))
{
double q = survivalProbabilities.survivalProbability(coupon.EffectiveEndDate);
double p = discountFactors.discountFactor(coupon.PaymentDate);
pv += coupon.YearFraction * p * q;
}
}
if (cds.PaymentOnDefault.AccruedInterest)
{
// This is needed so that the code is consistent with ISDA C when the Markit `fix' is used.
LocalDate start = cds.PaymentPeriods.size() == 1 ? effectiveStartDate : cds.AccrualStartDate;
DoubleArray integrationSchedule = DoublesScheduleGenerator.getIntegrationsPoints(discountFactors.relativeYearFraction(start), discountFactors.relativeYearFraction(cds.ProtectionEndDate), discountFactors.ParameterKeys, survivalProbabilities.ParameterKeys);
foreach (CreditCouponPaymentPeriod coupon in cds.PaymentPeriods)
{
pv += singlePeriodAccrualOnDefault(coupon, effectiveStartDate, integrationSchedule, discountFactors, survivalProbabilities);
}
}
// roll to the cash settle date
double df = discountFactors.discountFactor(referenceDate);
pv /= df;
if (priceType.CleanPrice)
{
pv -= cds.accruedYearFraction(stepinDate);
}
return(pv);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price of the CDS index product, which is the minus of the present value per unit notional.
/// <para>
/// This method can calculate the clean or dirty price, see <seealso cref="PriceType"/>.
/// If calculating the clean price, the accrued interest is calculated based on the step-in date.
///
/// </para>
/// </summary>
/// <param name="cdsIndex"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="priceType"> the price type </param>
/// <param name="refData"> the reference data </param>
/// <returns> the price </returns>
public virtual double price(ResolvedCdsIndex cdsIndex, CreditRatesProvider ratesProvider, LocalDate referenceDate, PriceType priceType, ReferenceData refData)
{
ResolvedCds cds = cdsIndex.toSingleNameCds();
return(underlyingPricer.price(cds, ratesProvider, referenceDate, priceType, refData));
}
internal virtual Triple <CreditDiscountFactors, LegalEntitySurvivalProbabilities, double> reduceDiscountFactors(ResolvedCds cds, CreditRatesProvider ratesProvider)
{
Currency currency = cds.Currency;
CreditDiscountFactors discountFactors = ratesProvider.discountFactors(currency);
ArgChecker.isTrue(discountFactors.IsdaCompliant, "discount factors must be IsdaCompliantZeroRateDiscountFactors");
LegalEntitySurvivalProbabilities survivalProbabilities = ratesProvider.survivalProbabilities(cds.LegalEntityId, currency);
ArgChecker.isTrue(survivalProbabilities.SurvivalProbabilities.IsdaCompliant, "survival probabilities must be IsdaCompliantZeroRateDiscountFactors");
ArgChecker.isTrue(discountFactors.DayCount.Equals(survivalProbabilities.SurvivalProbabilities.DayCount), "day count conventions of discounting curve and credit curve must be the same");
double indexFactor = ((IsdaCreditDiscountFactors)survivalProbabilities.SurvivalProbabilities).Curve.Metadata.getInfo(CurveInfoType.CDS_INDEX_FACTOR);
return(Triple.of(discountFactors, survivalProbabilities, indexFactor));
}
/// <summary>
/// Calculates the par spread sensitivity of the product.
/// <para>
/// The par spread sensitivity of the product is the sensitivity of par spread to the underlying curves.
/// The resulting sensitivity is based on the currency of the CDS index product.
///
/// </para>
/// </summary>
/// <param name="cdsIndex"> the product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="referenceDate"> the reference date </param>
/// <param name="refData"> the reference data </param>
/// <returns> the par spread </returns>
public virtual PointSensitivityBuilder parSpreadSensitivity(ResolvedCdsIndex cdsIndex, CreditRatesProvider ratesProvider, LocalDate referenceDate, ReferenceData refData)
{
ResolvedCds cds = cdsIndex.toSingleNameCds();
return(underlyingPricer.parSpreadSensitivity(cds, ratesProvider, referenceDate, refData));
}
public Pricer(FastCreditCurveCalibrator outerInstance, ResolvedCds nodeCds, CreditDiscountFactors yieldCurve, DoubleArray creditCurveKnots, double fractionalSpread, double pointsUpfront, double lgd, LocalDate stepinDate, LocalDate effectiveStartDate, LocalDate settlementDate, double accruedYearFraction)
{
this.outerInstance = outerInstance;
accYearFraction = accruedYearFraction;
cds = nodeCds;
fracSpread = fractionalSpread;
puf = pointsUpfront;
productEffectiveStart = yieldCurve.relativeYearFraction(effectiveStartDate);
double protectionEnd = yieldCurve.relativeYearFraction(cds.ProtectionEndDate);
// protection leg
proLegIntPoints = DoublesScheduleGenerator.getIntegrationsPoints(productEffectiveStart, protectionEnd, yieldCurve.ParameterKeys, creditCurveKnots).toArray();
nProPoints = proLegIntPoints.Length;
valuationDF = yieldCurve.discountFactor(settlementDate);
lgdDF = lgd / valuationDF;
proYieldCurveRT = new double[nProPoints];
proDF = new double[nProPoints];
for (int i = 0; i < nProPoints; i++)
{
proYieldCurveRT[i] = yieldCurve.zeroRate(proLegIntPoints[i]) * proLegIntPoints[i];
proDF[i] = Math.Exp(-proYieldCurveRT[i]);
}
// premium leg
nPayments = cds.PaymentPeriods.size();
paymentDF = new double[nPayments];
int indexTmp = -1;
for (int i = 0; i < nPayments; i++)
{
if (stepinDate.isBefore(cds.PaymentPeriods.get(i).EndDate))
{
paymentDF[i] = yieldCurve.discountFactor(cds.PaymentPeriods.get(i).PaymentDate);
}
else
{
indexTmp = i;
}
}
startPeriodIndex = indexTmp + 1;
// accrual on default
if (cds.PaymentOnDefault.AccruedInterest)
{
LocalDate tmp = nPayments == 1 ? effectiveStartDate : cds.AccrualStartDate;
DoubleArray integrationSchedule = DoublesScheduleGenerator.getIntegrationsPoints(yieldCurve.relativeYearFraction(tmp), protectionEnd, yieldCurve.ParameterKeys, creditCurveKnots);
accRate = new double[nPayments];
offsetAccStart = new double[nPayments];
offsetAccEnd = new double[nPayments];
premLegIntPoints = new double[nPayments][];
premDF = new double[nPayments][];
rt = new double[nPayments][];
premDt = new double[nPayments][];
for (int i = startPeriodIndex; i < nPayments; i++)
{
CreditCouponPaymentPeriod coupon = cds.PaymentPeriods.get(i);
offsetAccStart[i] = yieldCurve.relativeYearFraction(coupon.EffectiveStartDate);
offsetAccEnd[i] = yieldCurve.relativeYearFraction(coupon.EffectiveEndDate);
accRate[i] = coupon.YearFraction / yieldCurve.DayCount.relativeYearFraction(coupon.StartDate, coupon.EndDate);
double start = Math.Max(productEffectiveStart, offsetAccStart[i]);
if (start >= offsetAccEnd[i])
{
continue;
}
premLegIntPoints[i] = DoublesScheduleGenerator.truncateSetInclusive(start, offsetAccEnd[i], integrationSchedule).toArray();
int n = premLegIntPoints[i].Length;
rt[i] = new double[n];
premDF[i] = new double[n];
for (int k = 0; k < n; k++)
{
rt[i][k] = yieldCurve.zeroRate(premLegIntPoints[i][k]) * premLegIntPoints[i][k];
premDF[i][k] = Math.Exp(-rt[i][k]);
}
premDt[i] = new double[n - 1];
for (int k = 1; k < n; k++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double dt = premLegIntPoints[i][k] - premLegIntPoints[i][k - 1];
double dt = premLegIntPoints[i][k] - premLegIntPoints[i][k - 1];
premDt[i][k - 1] = dt;
}
}
}
else
{
accRate = null;
offsetAccStart = null;
offsetAccEnd = null;
premDF = null;
premDt = null;
rt = null;
premLegIntPoints = null;
}
}
//-------------------------------------------------------------------------
public override NodalCurve calibrate(IList <ResolvedCdsTrade> calibrationCDSs, DoubleArray flactionalSpreads, DoubleArray pointsUpfront, CurveName name, LocalDate valuationDate, CreditDiscountFactors discountFactors, RecoveryRates recoveryRates, ReferenceData refData)
{
int n = calibrationCDSs.Count;
double[] guess = new double[n];
double[] t = new double[n];
double[] lgd = new double[n];
for (int i = 0; i < n; i++)
{
LocalDate endDate = calibrationCDSs[i].Product.ProtectionEndDate;
t[i] = discountFactors.relativeYearFraction(endDate);
lgd[i] = 1d - recoveryRates.recoveryRate(endDate);
guess[i] = (flactionalSpreads.get(i) + pointsUpfront.get(i) / t[i]) / lgd[i];
}
DoubleArray times = DoubleArray.ofUnsafe(t);
CurveMetadata baseMetadata = DefaultCurveMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).curveName(name).dayCount(discountFactors.DayCount).build();
NodalCurve creditCurve = n == 1 ? ConstantNodalCurve.of(baseMetadata, t[0], guess[0]) : InterpolatedNodalCurve.of(baseMetadata, times, DoubleArray.ofUnsafe(guess), CurveInterpolators.PRODUCT_LINEAR, CurveExtrapolators.FLAT, CurveExtrapolators.PRODUCT_LINEAR);
for (int i = 0; i < n; i++)
{
ResolvedCds cds = calibrationCDSs[i].Product;
LocalDate stepinDate = cds.StepinDateOffset.adjust(valuationDate, refData);
LocalDate effectiveStartDate = cds.calculateEffectiveStartDate(stepinDate);
LocalDate settlementDate = calibrationCDSs[i].Info.SettlementDate.orElse(cds.SettlementDateOffset.adjust(valuationDate, refData));
double accrued = cds.accruedYearFraction(stepinDate);
Pricer pricer = new Pricer(this, cds, discountFactors, times, flactionalSpreads.get(i), pointsUpfront.get(i), lgd[i], stepinDate, effectiveStartDate, settlementDate, accrued);
System.Func <double, double> func = pricer.getPointFunction(i, creditCurve);
switch (ArbitrageHandling)
{
case IGNORE:
{
try
{
double[] bracket = BRACKETER.getBracketedPoints(func, 0.8 * guess[i], 1.25 * guess[i], double.NegativeInfinity, double.PositiveInfinity);
double zeroRate = bracket[0] > bracket[1] ? ROOTFINDER.getRoot(func, bracket[1], bracket[0]) : ROOTFINDER.getRoot(func, bracket[0], bracket[1]); //Negative guess handled
creditCurve = creditCurve.withParameter(i, zeroRate);
}
//JAVA TO C# CONVERTER WARNING: 'final' catch parameters are not available in C#:
//ORIGINAL LINE: catch (final com.opengamma.strata.math.MathException e)
catch (MathException e)
{ //handling bracketing failure due to small survival probability
if (Math.Abs(func(creditCurve.YValues.get(i - 1))) < 1.e-12)
{
creditCurve = creditCurve.withParameter(i, creditCurve.YValues.get(i - 1));
}
else
{
throw new MathException(e);
}
}
break;
}
case FAIL:
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double minValue = i == 0 ? 0d : creditCurve.getYValues().get(i - 1) * creditCurve.getXValues().get(i - 1) / creditCurve.getXValues().get(i);
double minValue = i == 0 ? 0d : creditCurve.YValues.get(i - 1) * creditCurve.XValues.get(i - 1) / creditCurve.XValues.get(i);
if (i > 0 && func(minValue) > 0.0)
{ //can never fail on the first spread
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final StringBuilder msg = new StringBuilder();
StringBuilder msg = new StringBuilder();
if (pointsUpfront.get(i) == 0.0)
{
msg.Append("The par spread of " + flactionalSpreads.get(i) + " at index " + i);
}
else
{
msg.Append("The premium of " + flactionalSpreads.get(i) + "and points up-front of " + pointsUpfront.get(i) + " at index " + i);
}
msg.Append(" is an arbitrage; cannot fit a curve with positive forward hazard rate. ");
throw new System.ArgumentException(msg.ToString());
}
guess[i] = Math.Max(minValue, guess[i]);
double[] bracket = BRACKETER.getBracketedPoints(func, guess[i], 1.2 * guess[i], minValue, double.PositiveInfinity);
double zeroRate = ROOTFINDER.getRoot(func, bracket[0], bracket[1]).Value;
creditCurve = creditCurve.withParameter(i, zeroRate);
break;
}
case ZERO_HAZARD_RATE:
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double minValue = i == 0 ? 0.0 : creditCurve.getYValues().get(i - 1) * creditCurve.getXValues().get(i - 1) / creditCurve.getXValues().get(i);
double minValue = i == 0 ? 0.0 : creditCurve.YValues.get(i - 1) * creditCurve.XValues.get(i - 1) / creditCurve.XValues.get(i);
if (i > 0 && func(minValue) > 0.0)
{ //can never fail on the first spread
creditCurve = creditCurve.withParameter(i, minValue);
}
else
{
guess[i] = Math.Max(minValue, guess[i]);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double[] bracket = BRACKETER.getBracketedPoints(func, guess[i], 1.2 * guess[i], minValue, Double.POSITIVE_INFINITY);
double[] bracket = BRACKETER.getBracketedPoints(func, guess[i], 1.2 * guess[i], minValue, double.PositiveInfinity);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double zeroRate = ROOTFINDER.getRoot(func, bracket[0], bracket[1]);
double zeroRate = ROOTFINDER.getRoot(func, bracket[0], bracket[1]).Value;
creditCurve = creditCurve.withParameter(i, zeroRate);
}
break;
}
default:
throw new System.ArgumentException("unknown case " + ArbitrageHandling);
}
}
return(creditCurve);
}
internal virtual void validateRecoveryRates(ResolvedCds cds, CreditRatesProvider ratesProvider)
{
RecoveryRates recoveryRates = ratesProvider.recoveryRates(cds.LegalEntityId);
ArgChecker.isTrue(recoveryRates is ConstantRecoveryRates, "recoveryRates must be ConstantRecoveryRates");
}
private Pair <CreditDiscountFactors, LegalEntitySurvivalProbabilities> reduceDiscountFactors(ResolvedCds cds, CreditRatesProvider ratesProvider)
{
Currency currency = cds.Currency;
CreditDiscountFactors discountFactors = ratesProvider.discountFactors(currency);
ArgChecker.isTrue(discountFactors.IsdaCompliant, "discount factors must be IsdaCompliantZeroRateDiscountFactors");
LegalEntitySurvivalProbabilities survivalProbabilities = ratesProvider.survivalProbabilities(cds.LegalEntityId, currency);
ArgChecker.isTrue(survivalProbabilities.SurvivalProbabilities.IsdaCompliant, "survival probabilities must be IsdaCompliantZeroRateDiscountFactors");
ArgChecker.isTrue(discountFactors.DayCount.Equals(survivalProbabilities.SurvivalProbabilities.DayCount), "day count conventions of discounting curve and credit curve must be the same");
return(Pair.of(discountFactors, survivalProbabilities));
}
