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 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);
}
//-------------------------------------------------------------------------
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));
}
/// <summary>
/// Computes bucketed CS01 for CDS.
/// <para>
/// The relevant credit curve must be stored in {@code RatesProvider}.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="bucketCds"> the CDS bucket </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the bucketed CS01 </returns>
public virtual CurrencyParameterSensitivity bucketedCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <ResolvedTradeParameterMetadata> metadata = bucketCds.Select(t => ResolvedTradeParameterMetadata.of(t, t.Product.ProtectionEndDate.ToString())).collect(Guavate.toImmutableList());
return(bucketedCs01(trade, bucketCds, metadata, ratesProvider, refData));
}
/// <summary>
/// Computes parallel CS01 for CDS index using a single credit curve.
/// <para>
/// This is coherent to the pricer <seealso cref="IsdaHomogenousCdsIndexTradePricer"/>.
/// The relevant credit curve must be stored in {@code RatesProvider}.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="bucketCdsIndex"> the CDS index bucket </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the parallel CS01 </returns>
public virtual CurrencyAmount parallelCs01(ResolvedCdsIndexTrade trade, IList <ResolvedCdsIndexTrade> bucketCdsIndex, CreditRatesProvider ratesProvider, ReferenceData refData)
{
ResolvedCdsTrade cdsTrade = trade.toSingleNameCds();
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
IList <ResolvedCdsTrade> bucketCds = bucketCdsIndex.Select(ResolvedCdsIndexTrade::toSingleNameCds).ToList();
CurrencyAmount cs01Cds = parallelCs01(cdsTrade, bucketCds, ratesProvider, refData);
double indexFactor = getIndexFactor(cdsTrade.Product, ratesProvider);
return(cs01Cds.multipliedBy(indexFactor));
}
// calculate one measure
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private com.opengamma.strata.collect.result.Result<?> calculate(com.opengamma.strata.calc.Measure measure, com.opengamma.strata.product.credit.ResolvedCdsTrade trade, CreditRatesScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData)
private Result <object> calculate(Measure measure, ResolvedCdsTrade trade, CreditRatesScenarioMarketData marketData, ReferenceData refData)
{
SingleMeasureCalculation calculator = CALCULATORS.get(measure);
if (calculator == null)
{
return(Result.failure(FailureReason.UNSUPPORTED, "Unsupported measure for CdsTrade: {}", measure));
}
return(Result.of(() => calculator(trade, marketData, refData)));
}
/// <summary>
/// Computes bucketed CS01 for CDS index using a single credit curve.
/// <para>
/// This is coherent to the pricer <seealso cref="IsdaHomogenousCdsIndexTradePricer"/>.
/// The relevant credit curve must be stored in {@code RatesProvider}.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="bucketCdsIndex"> the CDS index bucket </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the bucketed CS01 </returns>
public virtual CurrencyParameterSensitivity bucketedCs01(ResolvedCdsIndexTrade trade, IList <ResolvedCdsIndexTrade> bucketCdsIndex, CreditRatesProvider ratesProvider, ReferenceData refData)
{
ResolvedCdsTrade cdsTrade = trade.toSingleNameCds();
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
IList <ResolvedCdsTrade> bucketCds = bucketCdsIndex.Select(ResolvedCdsIndexTrade::toSingleNameCds).ToList();
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <ResolvedTradeParameterMetadata> metadata = bucketCdsIndex.Select(t => ResolvedTradeParameterMetadata.of(t, t.Product.ProtectionEndDate.ToString())).collect(Guavate.toImmutableList());
CurrencyParameterSensitivity bucketedCs01 = this.bucketedCs01(cdsTrade, bucketCds, metadata, ratesProvider, refData);
double indexFactor = getIndexFactor(cdsTrade.Product, ratesProvider);
return(bucketedCs01.multipliedBy(indexFactor));
}
public virtual void pricePufTest()
{
double premium = 150d * ONE_BP;
Cds product = Cds.of(BUY, LEGAL_ENTITY, GBP, 1.0e6, START_DATE, END_DATE, Frequency.P3M, DEFAULT_CALENDAR, premium);
TradeInfo info = TradeInfo.builder().tradeDate(TODAY).settlementDate(product.SettlementDateOffset.adjust(TODAY, REF_DATA)).build();
ResolvedCdsTrade trade = CdsTrade.builder().product(product).info(info).build().resolve(REF_DATA);
NodalCurve cc = CALIB.calibrate(ImmutableList.of(trade), DoubleArray.of(0.0123), DoubleArray.of(0.0), CurveName.of("test"), TODAY, DSC_CURVE, REC_RATES, REF_DATA);
CreditRatesProvider rates = RATES_PROVIDER.toImmutableCreditRatesProvider().toBuilder().creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY, GBP), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, IsdaCreditDiscountFactors.of(GBP, TODAY, cc)))).build();
double pointsUpFront = CONV.pointsUpfront(trade, rates, REF_DATA);
double cleanPrice = CONV.cleanPrice(trade, rates, REF_DATA);
double cleanPriceRe = CONV.cleanPriceFromPointsUpfront(pointsUpFront);
assertEquals(cleanPrice, cleanPriceRe, TOL);
}
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);
}
// check legal entity and currency are common for all of the CDSs
protected internal virtual void checkCdsBucket(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IEnumerator <StandardId> legalEntities = bucketCds.Select(t => t.Product.LegalEntityId).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
ArgChecker.isTrue(legalEntities.next().Equals(trade.Product.LegalEntityId), "legal entity must be common");
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
ArgChecker.isFalse(legalEntities.hasNext(), "legal entity must be common");
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IEnumerator <Currency> currencies = bucketCds.Select(t => t.Product.Currency).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
ArgChecker.isTrue(currencies.next().Equals(trade.Product.Currency), "currency must be common");
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
ArgChecker.isFalse(currencies.hasNext(), "currency must be common");
}
/// <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));
}
public virtual void standardQuoteTest2()
{
double quotedSpread = 143.4 * ONE_BP;
double expectedPuf = -0.2195134271137960; // taken from Excel-ISDA 1.8.2
double premium = 500d * ONE_BP;
Cds product = Cds.of(SELL, LEGAL_ENTITY, GBP, 1.0e8, START_DATE, END_DATE, Frequency.P6M, DEFAULT_CALENDAR, premium);
TradeInfo info = TradeInfo.builder().tradeDate(TODAY).settlementDate(product.SettlementDateOffset.adjust(TODAY, REF_DATA)).build();
ResolvedCdsTrade trade = CdsTrade.builder().product(product).info(info).build().resolve(REF_DATA);
CdsQuote quotedSpreadQuoted = CdsQuote.of(CdsQuoteConvention.QUOTED_SPREAD, quotedSpread);
CdsQuote derivedPuf = CONV.pointsUpFrontFromQuotedSpread(trade, quotedSpreadQuoted, RATES_PROVIDER, REF_DATA);
assertEquals(derivedPuf.QuotedValue, expectedPuf, 5e-13);
assertTrue(derivedPuf.QuoteConvention.Equals(CdsQuoteConvention.POINTS_UPFRONT));
CdsQuote derivedQuotedSpread = CONV.quotedSpreadFromPointsUpfront(trade, derivedPuf, RATES_PROVIDER, REF_DATA);
assertEquals(derivedQuotedSpread.QuotedValue, quotedSpread, 1e-15);
assertTrue(derivedQuotedSpread.QuoteConvention.Equals(CdsQuoteConvention.QUOTED_SPREAD));
}
public virtual void standardQuoteTest()
{
double pointsUpFront = 0.007;
double expectedParSpread = 0.011112592882846; // taken from Excel-ISDA 1.8.2
double premium = 100d * ONE_BP;
Cds product = Cds.of(BUY, LEGAL_ENTITY, GBP, 1.0e6, START_DATE, END_DATE, Frequency.P3M, DEFAULT_CALENDAR, premium);
TradeInfo info = TradeInfo.builder().tradeDate(TODAY).settlementDate(product.SettlementDateOffset.adjust(TODAY, REF_DATA)).build();
ResolvedCdsTrade trade = CdsTrade.builder().product(product).info(info).build().resolve(REF_DATA);
CdsQuote pufQuote = CdsQuote.of(CdsQuoteConvention.POINTS_UPFRONT, pointsUpFront);
CdsQuote quotedSpread = CONV.quotedSpreadFromPointsUpfront(trade, pufQuote, RATES_PROVIDER, REF_DATA);
assertEquals(quotedSpread.QuotedValue, expectedParSpread, 1e-14);
assertTrue(quotedSpread.QuoteConvention.Equals(CdsQuoteConvention.QUOTED_SPREAD));
CdsQuote derivedPuf = CONV.pointsUpFrontFromQuotedSpread(trade, quotedSpread, RATES_PROVIDER, REF_DATA);
assertEquals(derivedPuf.QuotedValue, pointsUpFront, 1e-15);
assertTrue(derivedPuf.QuoteConvention.Equals(CdsQuoteConvention.POINTS_UPFRONT));
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: @Override public java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.product.credit.CdsTrade trade, java.util.Set<com.opengamma.strata.calc.Measure> measures, com.opengamma.strata.calc.runner.CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData scenarioMarketData, com.opengamma.strata.basics.ReferenceData refData)
public virtual IDictionary <Measure, Result <object> > calculate(CdsTrade trade, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData)
{
// resolve the trade once for all measures and all scenarios
ResolvedCdsTrade resolved = trade.resolve(refData);
// use lookup to query market data
CreditRatesMarketDataLookup ledLookup = parameters.getParameter(typeof(CreditRatesMarketDataLookup));
CreditRatesScenarioMarketData marketData = ledLookup.marketDataView(scenarioMarketData);
// loop around measures, calculating all scenarios for one measure
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> results = new java.util.HashMap<>();
IDictionary <Measure, Result <object> > results = new Dictionary <Measure, Result <object> >();
foreach (Measure measure in measures)
{
results[measure] = calculate(measure, resolved, marketData, refData);
}
return(results);
}
//-------------------------------------------------------------------------
protected internal virtual void testCalibrationAgainstISDA(IsdaCompliantCreditCurveCalibrator builder, DayCount dayCount, Currency currency, double tol)
{
IsdaCdsProductPricer pricer = new IsdaCdsProductPricer(builder.AccrualOnDefaultFormula);
for (int i = 0; i < NUM_TESTS; i++)
{
LegalEntitySurvivalProbabilities creditCurve = builder.calibrate(ImmutableList.copyOf(NODE_CDS[i]), CurveName.of("credit"), CDS_MARKET_DATA[i], YIELD_CURVES[i], dayCount, currency, false, false, REF_DATA);
ResolvedCdsTrade[] expectedCds = EXP_NODE_CDS[i];
ImmutableCreditRatesProvider provider = YIELD_CURVES[i].toBuilder().creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY, EUR), creditCurve)).build();
double[] expected = builder.AccrualOnDefaultFormula == AccrualOnDefaultFormula.MARKIT_FIX ? EXP_PROB_MARKIT_FIX[i] : EXP_PROB_ISDA[i];
for (int k = 0; k < N_OBS; k++)
{
assertEquals(creditCurve.SurvivalProbabilities.discountFactor(OBS_TIMES[k]), expected[k], tol);
}
int m = expectedCds.Length;
for (int j = 0; j < m; j++)
{
ResolvedCdsTrade cdsFromNode = NODE_CDS[i][j].trade(1d, CDS_MARKET_DATA[i], REF_DATA).UnderlyingTrade.resolve(REF_DATA);
assertEquals(cdsFromNode.Product, expectedCds[j].Product);
double price1 = pricer.price(cdsFromNode.Product, provider, SPREADS[i][j], cdsFromNode.Info.SettlementDate.get(), PriceType.CLEAN, REF_DATA);
assertEquals(price1, 0.0, 5e-16);
}
}
}
private double[] getStandardQuoteForm(ResolvedCdsTrade calibrationCds, CdsQuote marketQuote, LocalDate valuationDate, CreditDiscountFactors discountFactors, RecoveryRates recoveryRates, bool computeJacobian, ReferenceData refData)
{
double[] res = new double[3];
res[2] = 1d;
if (marketQuote.QuoteConvention.Equals(CdsQuoteConvention.PAR_SPREAD))
{
res[0] = marketQuote.QuotedValue;
}
else if (marketQuote.QuoteConvention.Equals(CdsQuoteConvention.QUOTED_SPREAD))
{
double qSpread = marketQuote.QuotedValue;
CurveName curveName = CurveName.of("quoteConvertCurve");
NodalCurve tempCreditCurve = calibrate(ImmutableList.of(calibrationCds), DoubleArray.of(qSpread), DoubleArray.of(0d), curveName, valuationDate, discountFactors, recoveryRates, refData);
Currency currency = calibrationCds.Product.Currency;
StandardId legalEntityId = calibrationCds.Product.LegalEntityId;
ImmutableCreditRatesProvider rates = ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).discountCurves(ImmutableMap.of(currency, discountFactors)).recoveryRateCurves(ImmutableMap.of(legalEntityId, recoveryRates)).creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, tempCreditCurve)))).build();
res[0] = calibrationCds.Product.FixedRate;
res[1] = tradePricer.price(calibrationCds, rates, PriceType.CLEAN, refData);
if (computeJacobian)
{
CurrencyParameterSensitivities pufSensi = rates.parameterSensitivity(tradePricer.priceSensitivity(calibrationCds, rates, refData));
CurrencyParameterSensitivities spSensi = rates.parameterSensitivity(tradePricer.parSpreadSensitivity(calibrationCds, rates, refData));
res[2] = spSensi.getSensitivity(curveName, currency).Sensitivity.get(0) / pufSensi.getSensitivity(curveName, currency).Sensitivity.get(0);
}
}
else if (marketQuote.QuoteConvention.Equals(CdsQuoteConvention.POINTS_UPFRONT))
{
res[0] = calibrationCds.Product.FixedRate;
res[1] = marketQuote.QuotedValue;
}
else
{
throw new System.ArgumentException("Unknown CDSQuoteConvention type " + marketQuote.GetType());
}
return(res);
}
/// <summary>
/// Computes the market clean price.
/// <para>
/// The market clean price is usually expressed in percentage.
/// Here a fraction of notional is returned, e.g., 0.98 is 98(%) clean price.
/// </para>
/// <para>
/// A relevant credit curve must be pre-calibrated and stored in {@code ratesProvider}.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the clean price </returns>
public virtual double cleanPrice(ResolvedCdsTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData)
{
double puf = pointsUpfront(trade, ratesProvider, refData);
return(1d - puf);
}
/// <summary>
/// Computes the points upfront.
/// <para>
/// The points upfront quote is usually expressed in percentage.
/// Here a fraction of notional is returned, e.g., 0.01 is 1(%) points up-front
/// </para>
/// <para>
/// The relevant credit curve must be pre-calibrated and stored in {@code ratesProvider}.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the points upfront </returns>
public virtual double pointsUpfront(ResolvedCdsTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData)
{
return(pricer.price(trade, ratesProvider, PriceType.CLEAN, refData));
}
//-------------------------------------------------------------------------
/// <summary>
/// Computes parallel CS01 for CDS.
/// <para>
/// The relevant credit curve must be stored in {@code RatesProvider}.
/// </para>
/// <para>
/// The CDS trades used in the curve calibration are reused as bucket CDS by this method.
/// Thus the credit curve must store <seealso cref="ResolvedTradeParameterMetadata"/>.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the parallel CS01 </returns>
public virtual CurrencyAmount parallelCs01(ResolvedCdsTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData)
{
IList <ResolvedCdsTrade> bucketCds = getBucketCds(trade.Product, ratesProvider);
return(parallelCs01(trade, bucketCds, ratesProvider, refData));
}
static IsdaCompliantCreditCurveCalibratorBase()
{
ImmutableList.Builder <IsdaCreditCurveNode> dscNodeBuilder = ImmutableList.builder();
for (int i = 0; i < NUM_MM; i++)
{
Tenor tenor = Tenor.ofMonths(MM_MONTHS[i]);
dscNodeBuilder.add(DepositIsdaCreditCurveNode.of(QuoteId.of(StandardId.of("OG", ID_VALUES[i])), ADJ_3D, BUS_ADJ, tenor, ACT_360));
}
for (int i = NUM_MM; i < NUM_INSTRUMENTS; i++)
{
Tenor tenor = Tenor.ofYears(SWAP_YEARS[i - NUM_MM]);
dscNodeBuilder.add(SwapIsdaCreditCurveNode.of(QuoteId.of(StandardId.of("OG", ID_VALUES[i])), ADJ_3D, BUS_ADJ, tenor, THIRTY_U_360, Frequency.P12M));
}
DSC_NODES = dscNodeBuilder.build();
EXP_NODE_CDS = new ResolvedCdsTrade[NUM_TESTS][];
NODE_CDS = new CdsIsdaCreditCurveNode[NUM_TESTS][];
CDS_MARKET_DATA = new ImmutableMarketData[NUM_TESTS];
SPREADS = new double[NUM_TESTS][];
YIELD_CURVES = new ImmutableCreditRatesProvider[NUM_TESTS];
// case0
LocalDate tradeDate0 = LocalDate.of(2011, 6, 19);
LocalDate startDate0 = LocalDate.of(2011, 3, 21);
YIELD_CURVES[0] = createRatesProvider(tradeDate0, tradeDate0, 1d, 0.4);
Period[] tenors = new Period[] { Period.ofMonths(6), Period.ofYears(1), Period.ofYears(3), Period.ofYears(5), Period.ofYears(7), Period.ofYears(10) };
int nTenors = tenors.Length;
EXP_NODE_CDS[0] = new ResolvedCdsTrade[nTenors];
NODE_CDS[0] = new CdsIsdaCreditCurveNode[nTenors];
ImmutableMarketDataBuilder builderCredit0 = ImmutableMarketData.builder(tradeDate0);
SPREADS[0] = new double[] { 0.00886315689995649, 0.00886315689995649, 0.0133044689825873, 0.0171490070952563, 0.0183903639181293, 0.0194721890639724 };
for (int i = 0; i < nTenors; ++i)
{
Cds product = Cds.of(BUY, LEGAL_ENTITY, EUR, 1d, startDate0, LocalDate.of(2011, 6, 20).plus(tenors[i]), Frequency.P3M, DEFAULT_CALENDAR, SPREADS[0][i]);
EXP_NODE_CDS[0][i] = CdsTrade.builder().info(TradeInfo.builder().settlementDate(product.SettlementDateOffset.adjust(tradeDate0, REF_DATA)).build()).product(product).build().resolve(REF_DATA);
CdsConvention conv = ImmutableCdsConvention.of("conv", EUR, ACT_360, Frequency.P3M, BUS_ADJ, CDS_SETTLE_STD);
CdsTemplate temp = DatesCdsTemplate.of(startDate0, LocalDate.of(2011, 6, 20).plus(tenors[i]), conv);
QuoteId id = QuoteId.of(StandardId.of("OG", tenors[i].ToString()));
NODE_CDS[0][i] = CdsIsdaCreditCurveNode.ofParSpread(temp, id, LEGAL_ENTITY);
builderCredit0.addValue(id, SPREADS[0][i]);
}
CDS_MARKET_DATA[0] = builderCredit0.build();
// case1
LocalDate tradeDate1 = LocalDate.of(2011, 3, 21);
LocalDate snapDate1 = LocalDate.of(2011, 3, 18);
LocalDate effDate1 = LocalDate.of(2011, 3, 20); //note this is a Sunday - for a standard CDS this would roll to the Monday.
YIELD_CURVES[1] = createRatesProvider(tradeDate1, snapDate1, 1d, 0.4);
tenors = new Period[] { Period.ofMonths(6), Period.ofYears(1), Period.ofYears(3), Period.ofYears(5), Period.ofYears(7), Period.ofYears(10) };
nTenors = tenors.Length;
NODE_CDS[1] = new CdsIsdaCreditCurveNode[nTenors];
ImmutableMarketDataBuilder builderCredit1 = ImmutableMarketData.builder(tradeDate1);
EXP_NODE_CDS[1] = new ResolvedCdsTrade[nTenors];
SPREADS[1] = new double[] { 0.027, 0.018, 0.012, 0.009, 0.007, 0.006 };
for (int i = 0; i < nTenors; ++i)
{
Cds product = Cds.of(BUY, LEGAL_ENTITY, EUR, 1d, effDate1, LocalDate.of(2011, 6, 20).plus(tenors[i]), P3M, DEFAULT_CALENDAR, SPREADS[1][i]);
EXP_NODE_CDS[1][i] = CdsTrade.builder().info(TradeInfo.builder().settlementDate(product.SettlementDateOffset.adjust(tradeDate1, REF_DATA)).build()).product(product).build().resolve(REF_DATA);
CdsConvention conv = ImmutableCdsConvention.builder().name("conv").currency(EUR).dayCount(ACT_360).paymentFrequency(P3M).startDateBusinessDayAdjustment(BusinessDayAdjustment.NONE).businessDayAdjustment(BUS_ADJ).settlementDateOffset(CDS_SETTLE_STD).build();
CdsTemplate temp = DatesCdsTemplate.of(effDate1, LocalDate.of(2011, 6, 20).plus(tenors[i]), conv);
QuoteId id = QuoteId.of(StandardId.of("OG", tenors[i].ToString()));
NODE_CDS[1][i] = CdsIsdaCreditCurveNode.ofParSpread(temp, id, LEGAL_ENTITY);
builderCredit1.addValue(id, SPREADS[1][i]);
}
CDS_MARKET_DATA[1] = builderCredit1.build();
// case2
LocalDate tradeDate2 = LocalDate.of(2011, 5, 30);
LocalDate snapDate2 = LocalDate.of(2011, 5, 29);
YIELD_CURVES[2] = createRatesProvider(tradeDate2, snapDate2, 1d, 0.25);
LocalDate[] matDates2 = new LocalDate[] { LocalDate.of(2011, 6, 20), LocalDate.of(2012, 5, 30), LocalDate.of(2014, 6, 20), LocalDate.of(2016, 6, 20), LocalDate.of(2018, 6, 20) };
int nMatDates2 = matDates2.Length;
NODE_CDS[2] = new CdsIsdaCreditCurveNode[nMatDates2];
ImmutableMarketDataBuilder builderCredit2 = ImmutableMarketData.builder(tradeDate2);
EXP_NODE_CDS[2] = new ResolvedCdsTrade[nMatDates2];
SPREADS[2] = new double[] { 0.05, 0.05, 0.05, 0.05, 0.05 };
for (int i = 0; i < nMatDates2; ++i)
{
Cds product = Cds.of(BUY, LEGAL_ENTITY, EUR, 1d, tradeDate2.plusDays(1), matDates2[i], P3M, DEFAULT_CALENDAR, SPREADS[2][i]).toBuilder().dayCount(THIRTY_U_360).build();
EXP_NODE_CDS[2][i] = CdsTrade.builder().info(TradeInfo.builder().settlementDate(product.SettlementDateOffset.adjust(tradeDate2, REF_DATA)).build()).product(product).build().resolve(REF_DATA);
CdsConvention conv = ImmutableCdsConvention.builder().name("conv").currency(EUR).dayCount(THIRTY_U_360).paymentFrequency(P3M).rollConvention(RollConventions.NONE).businessDayAdjustment(BUS_ADJ).settlementDateOffset(CDS_SETTLE_STD).build();
CdsTemplate temp = DatesCdsTemplate.of(tradeDate2.plusDays(1), matDates2[i], conv);
QuoteId id = QuoteId.of(StandardId.of("OG", matDates2[i].ToString()));
NODE_CDS[2][i] = CdsIsdaCreditCurveNode.ofParSpread(temp, id, LEGAL_ENTITY);
builderCredit2.addValue(id, SPREADS[2][i]);
}
CDS_MARKET_DATA[2] = builderCredit2.build();
// case3
LocalDate tradeDate3 = LocalDate.of(2011, 5, 30);
LocalDate snapDate3 = LocalDate.of(2011, 5, 29);
LocalDate effDate3 = LocalDate.of(2011, 7, 31);
YIELD_CURVES[3] = createRatesProvider(tradeDate3, snapDate3, 1d, 0.25);
LocalDate[] matDates3 = new LocalDate[] { LocalDate.of(2011, 11, 30), LocalDate.of(2012, 5, 30), LocalDate.of(2014, 5, 30), LocalDate.of(2016, 5, 30), LocalDate.of(2018, 5, 30), LocalDate.of(2021, 5, 30) };
int nMatDates3 = matDates3.Length;
NODE_CDS[3] = new CdsIsdaCreditCurveNode[nMatDates3];
ImmutableMarketDataBuilder builderCredit3 = ImmutableMarketData.builder(tradeDate3);
EXP_NODE_CDS[3] = new ResolvedCdsTrade[nMatDates3];
SPREADS[3] = new double[] { 0.07, 0.06, 0.05, 0.055, 0.06, 0.065 };
for (int i = 0; i < nMatDates3; ++i)
{
Cds product = Cds.builder().buySell(BUY).legalEntityId(LEGAL_ENTITY).currency(EUR).dayCount(ACT_365F).fixedRate(SPREADS[3][i]).notional(1d).paymentSchedule(PeriodicSchedule.builder().businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, DEFAULT_CALENDAR)).startDate(effDate3).endDate(matDates3[i]).startDateBusinessDayAdjustment(BusinessDayAdjustment.NONE).endDateBusinessDayAdjustment(BusinessDayAdjustment.NONE).frequency(Frequency.P6M).rollConvention(RollConventions.NONE).stubConvention(StubConvention.LONG_INITIAL).build()).paymentOnDefault(PaymentOnDefault.ACCRUED_PREMIUM).protectionStart(ProtectionStartOfDay.BEGINNING).stepinDateOffset(DaysAdjustment.ofCalendarDays(1)).settlementDateOffset(CDS_SETTLE_STD).build();
EXP_NODE_CDS[3][i] = CdsTrade.builder().info(TradeInfo.builder().settlementDate(product.SettlementDateOffset.adjust(tradeDate3, REF_DATA)).build()).product(product).build().resolve(REF_DATA);
CdsConvention conv = ImmutableCdsConvention.builder().name("conv").currency(EUR).dayCount(ACT_365F).paymentFrequency(Frequency.P6M).rollConvention(RollConventions.NONE).stubConvention(StubConvention.LONG_INITIAL).startDateBusinessDayAdjustment(BusinessDayAdjustment.NONE).businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, DEFAULT_CALENDAR)).settlementDateOffset(CDS_SETTLE_STD).build();
CdsTemplate temp = DatesCdsTemplate.of(effDate3, matDates3[i], conv);
QuoteId id = QuoteId.of(StandardId.of("OG", matDates3[i].ToString()));
NODE_CDS[3][i] = CdsIsdaCreditCurveNode.ofParSpread(temp, id, LEGAL_ENTITY);
builderCredit3.addValue(id, SPREADS[3][i]);
}
CDS_MARKET_DATA[3] = builderCredit3.build();
// case4: designed to trip the low rates/low spreads branch
LocalDate tradeDate4 = LocalDate.of(2014, 1, 14);
LocalDate snapDate4 = LocalDate.of(2014, 1, 13);
YIELD_CURVES[4] = createRatesProvider(tradeDate4, snapDate4, 1d / 1000d, 0.4);
int nSpreads4 = 6;
NODE_CDS[4] = new CdsIsdaCreditCurveNode[nSpreads4];
ImmutableMarketDataBuilder builderCredit4 = ImmutableMarketData.builder(tradeDate4);
SPREADS[4] = new double[nSpreads4];
Arrays.fill(SPREADS[4], 1.0e-4);
EXP_NODE_CDS[4] = new ResolvedCdsTrade[nSpreads4];
for (int i = 0; i < nSpreads4; ++i)
{
Cds product = Cds.of(BUY, LEGAL_ENTITY, EUR, 1d, LocalDate.of(2013, 12, 20), LocalDate.of(2014, 3, 20).plus(tenors[i]), P3M, DEFAULT_CALENDAR, SPREADS[4][i]);
EXP_NODE_CDS[4][i] = CdsTrade.builder().info(TradeInfo.builder().settlementDate(product.SettlementDateOffset.adjust(tradeDate4, REF_DATA)).build()).product(product).build().resolve(REF_DATA);
CdsConvention conv = ImmutableCdsConvention.of("conv", EUR, ACT_360, P3M, BUS_ADJ, CDS_SETTLE_STD);
CdsTemplate temp = DatesCdsTemplate.of(LocalDate.of(2013, 12, 20), LocalDate.of(2014, 3, 20).plus(tenors[i]), conv);
QuoteId id = QuoteId.of(StandardId.of("OG", tenors[i].ToString()));
NODE_CDS[4][i] = CdsIsdaCreditCurveNode.ofParSpread(temp, id, LEGAL_ENTITY);
builderCredit4.addValue(id, SPREADS[4][i]);
}
CDS_MARKET_DATA[4] = builderCredit4.build();
}
private CurrencyParameterSensitivity bucketedCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, IList <ResolvedTradeParameterMetadata> metadata, CreditRatesProvider ratesProvider, ReferenceData refData)
{
DoubleArray sensiValue = computedBucketedCs01(trade, bucketCds, ratesProvider, refData);
return(CurrencyParameterSensitivity.of(CurveName.of("impliedSpreads"), metadata, trade.Product.Currency, sensiValue));
}
//-------------------------------------------------------------------------
/// <summary>
/// Computes bucketed CS01 for CDS.
/// <para>
/// The relevant credit curve must be stored in {@code RatesProvider}.
/// </para>
/// <para>
/// The CDS trades used in the curve calibration are reused as bucket CDS by this method.
/// Thus the credit curve must store <seealso cref="ResolvedTradeParameterMetadata"/>.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the bucketed CS01 </returns>
public virtual CurrencyParameterSensitivity bucketedCs01(ResolvedCdsTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData)
{
IList <ResolvedCdsTrade> bucketCds = getBucketCds(trade.Product, ratesProvider);
return(bucketedCs01(trade, bucketCds, ratesProvider, refData));
}
/// <summary>
/// Computes parallel CS01 for CDS.
/// <para>
/// The relevant credit curve must be stored in {@code RatesProvider}.
///
/// </para>
/// </summary>
/// <param name="trade"> the trade </param>
/// <param name="bucketCds"> the CDS bucket </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="refData"> the reference data </param>
/// <returns> the parallel CS01 </returns>
public abstract CurrencyAmount parallelCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData);
//-------------------------------------------------------------------------
public override CurrencyAmount parallelCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData)
{
DoubleArray temp = computedBucketedCs01(trade, bucketCds, ratesProvider, refData);
return(CurrencyAmount.of(trade.Product.Currency, temp.sum()));
}
internal virtual LegalEntitySurvivalProbabilities calibrate(IList <CdsIsdaCreditCurveNode> curveNodes, CurveName name, MarketData marketData, ImmutableCreditRatesProvider ratesProvider, DayCount definitionDayCount, Currency definitionCurrency, bool computeJacobian, bool storeTrade, ReferenceData refData)
{
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IEnumerator <StandardId> legalEntities = curveNodes.Select(CdsIsdaCreditCurveNode::getLegalEntityId).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
StandardId legalEntityId = legalEntities.next();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
ArgChecker.isFalse(legalEntities.hasNext(), "legal entity must be common to curve nodes");
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IEnumerator <Currency> currencies = curveNodes.Select(n => n.Template.Convention.Currency).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
Currency currency = currencies.next();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
ArgChecker.isFalse(currencies.hasNext(), "currency must be common to curve nodes");
ArgChecker.isTrue(definitionCurrency.Equals(currency), "curve definition currency must be the same as the currency of CDS");
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IEnumerator <CdsQuoteConvention> quoteConventions = curveNodes.Select(n => n.QuoteConvention).collect(Collectors.toSet()).GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
CdsQuoteConvention quoteConvention = quoteConventions.next();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
ArgChecker.isFalse(quoteConventions.hasNext(), "quote convention must be common to curve nodes");
LocalDate valuationDate = marketData.ValuationDate;
ArgChecker.isTrue(valuationDate.Equals(marketData.ValuationDate), "ratesProvider and marketDate must be based on the same valuation date");
CreditDiscountFactors discountFactors = ratesProvider.discountFactors(currency);
ArgChecker.isTrue(definitionDayCount.Equals(discountFactors.DayCount), "credit curve and discount curve must be based on the same day count convention");
RecoveryRates recoveryRates = ratesProvider.recoveryRates(legalEntityId);
int nNodes = curveNodes.Count;
double[] coupons = new double[nNodes];
double[] pufs = new double[nNodes];
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: double[][] diag = new double[nNodes][nNodes];
double[][] diag = RectangularArrays.ReturnRectangularDoubleArray(nNodes, nNodes);
ImmutableList.Builder <ResolvedCdsTrade> tradesBuilder = ImmutableList.builder();
for (int i = 0; i < nNodes; i++)
{
CdsCalibrationTrade tradeCalibration = curveNodes[i].trade(1d, marketData, refData);
ResolvedCdsTrade trade = tradeCalibration.UnderlyingTrade.resolve(refData);
tradesBuilder.add(trade);
double[] temp = getStandardQuoteForm(trade, tradeCalibration.Quote, valuationDate, discountFactors, recoveryRates, computeJacobian, refData);
coupons[i] = temp[0];
pufs[i] = temp[1];
diag[i][i] = temp[2];
}
ImmutableList <ResolvedCdsTrade> trades = tradesBuilder.build();
NodalCurve nodalCurve = calibrate(trades, DoubleArray.ofUnsafe(coupons), DoubleArray.ofUnsafe(pufs), name, valuationDate, discountFactors, recoveryRates, refData);
if (computeJacobian)
{
LegalEntitySurvivalProbabilities creditCurve = LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, nodalCurve));
ImmutableCreditRatesProvider ratesProviderNew = ratesProvider.toBuilder().creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), creditCurve)).build();
System.Func <ResolvedCdsTrade, DoubleArray> sensiFunc = quoteConvention.Equals(CdsQuoteConvention.PAR_SPREAD) ? getParSpreadSensitivityFunction(ratesProviderNew, name, currency, refData) : getPointsUpfrontSensitivityFunction(ratesProviderNew, name, currency, refData);
DoubleMatrix sensi = DoubleMatrix.ofArrayObjects(nNodes, nNodes, i => sensiFunc(trades.get(i)));
sensi = (DoubleMatrix)MATRIX_ALGEBRA.multiply(DoubleMatrix.ofUnsafe(diag), sensi);
JacobianCalibrationMatrix jacobian = JacobianCalibrationMatrix.of(ImmutableList.of(CurveParameterSize.of(name, nNodes)), MATRIX_ALGEBRA.getInverse(sensi));
nodalCurve = nodalCurve.withMetadata(nodalCurve.Metadata.withInfo(CurveInfoType.JACOBIAN, jacobian));
}
ImmutableList <ParameterMetadata> parameterMetadata;
if (storeTrade)
{
parameterMetadata = IntStream.range(0, nNodes).mapToObj(n => ResolvedTradeParameterMetadata.of(trades.get(n), curveNodes[n].Label)).collect(Guavate.toImmutableList());
}
else
{
parameterMetadata = IntStream.range(0, nNodes).mapToObj(n => curveNodes[n].metadata(trades.get(n).Product.ProtectionEndDate)).collect(Guavate.toImmutableList());
}
nodalCurve = nodalCurve.withMetadata(nodalCurve.Metadata.withParameterMetadata(parameterMetadata));
return(LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, nodalCurve)));
}
// internal bucketed CS01 computation internal abstract DoubleArray computedBucketedCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData);
