public virtual void test_zeroRatePointSensitivity_sensitivityCurrency()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, DFS.zeroRatePointSensitivity(DATE_AFTER, GBP));
assertEquals(test.zeroRatePointSensitivity(DATE_AFTER, GBP), expected);
}
//-------------------------------------------------------------------------
// proper end-to-end FD tests are in pricer test
public virtual void test_parameterSensitivity()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity point = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, ZeroRateSensitivity.of(USD, 1d, 1d));
assertEquals(test.parameterSensitivity(point).size(), 1);
}
//-------------------------------------------------------------------------
public virtual void test_unitParameterSensitivity()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity sens = test.zeroRatePointSensitivity(DATE_AFTER);
CurrencyParameterSensitivities expected = DFS.parameterSensitivity(DFS.zeroRatePointSensitivity(DATE_AFTER));
assertEquals(test.parameterSensitivity(sens), expected);
}
public virtual void test_zeroRatePointSensitivity_sensitivityCurrency_yearFraction()
{
double yearFraction = DFS.relativeYearFraction(DATE_AFTER);
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, DFS.zeroRatePointSensitivity(yearFraction, GBP));
assertEquals(test.zeroRatePointSensitivity(yearFraction, GBP), expected);
}
public virtual void test_zeroRate()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
double relativeYearFraction = ACT_365F.relativeYearFraction(VALUATION, DATE_AFTER);
double discountFactor = test.survivalProbability(DATE_AFTER);
double zeroRate = test.zeroRate(relativeYearFraction);
assertEquals(Math.Exp(-zeroRate * relativeYearFraction), discountFactor);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
LegalEntitySurvivalProbabilities test1 = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
coverImmutableBean(test1);
LegalEntitySurvivalProbabilities test2 = LegalEntitySurvivalProbabilities.of(StandardId.of("OG", "CCC"), IsdaCreditDiscountFactors.of(GBP, VALUATION, CURVE_NAME, DoubleArray.of(5.0), DoubleArray.of(0.014), ACT_365F));
coverBeanEquals(test1, test2);
}
public virtual void test_of()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
assertEquals(test.Currency, USD);
assertEquals(test.LegalEntityId, LEGAL_ENTITY);
assertEquals(test.ParameterKeys, TIME);
assertEquals(test.SurvivalProbabilities, DFS);
assertEquals(test.ValuationDate, VALUATION);
}
public virtual void test_singleCreditCurveParameterSensitivity()
{
ZeroRateSensitivity zeroPt = ZeroRateSensitivity.of(USD, 10d, 5d);
CreditCurveZeroRateSensitivity creditPt = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY_ABC, JPY, 2d, 3d);
FxForwardSensitivity fxPt = FxForwardSensitivity.of(CurrencyPair.of(JPY, USD), USD, LocalDate.of(2017, 2, 14), 15d);
CreditRatesProvider test = ImmutableCreditRatesProvider.builder().creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD), Pair.of(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY), Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, CRD_DEF))).discountCurves(ImmutableMap.of(USD, DSC_USD, JPY, DSC_JPY)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, RR_ABC, LEGAL_ENTITY_DEF, RR_DEF)).valuationDate(VALUATION).build();
CurrencyParameterSensitivities computed = CurrencyParameterSensitivities.of(test.singleCreditCurveParameterSensitivity(zeroPt.combinedWith(creditPt).combinedWith(fxPt).build(), LEGAL_ENTITY_ABC, JPY));
CurrencyParameterSensitivities expected = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY).parameterSensitivity(creditPt);
assertTrue(computed.equalWithTolerance(expected, 1.0e-14));
}
public virtual void test_getter()
{
ImmutableCreditRatesProvider test = ImmutableCreditRatesProvider.builder().valuationDate(VALUATION).creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD), Pair.of(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY), Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, CRD_DEF))).discountCurves(ImmutableMap.of(USD, DSC_USD, JPY, DSC_JPY)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, RR_ABC, LEGAL_ENTITY_DEF, RR_DEF)).build();
assertEquals(test.discountFactors(USD), DSC_USD);
assertEquals(test.discountFactors(JPY), DSC_JPY);
assertEquals(test.survivalProbabilities(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD));
assertEquals(test.survivalProbabilities(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY));
assertEquals(test.survivalProbabilities(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, CRD_DEF));
assertEquals(test.recoveryRates(LEGAL_ENTITY_ABC), RR_ABC);
assertEquals(test.recoveryRates(LEGAL_ENTITY_DEF), RR_DEF);
StandardId entity = StandardId.of("OG", "NONE");
assertThrowsIllegalArg(() => test.discountFactors(EUR));
assertThrowsIllegalArg(() => test.survivalProbabilities(LEGAL_ENTITY_DEF, USD));
assertThrowsIllegalArg(() => test.survivalProbabilities(entity, USD));
assertThrowsIllegalArg(() => test.recoveryRates(entity));
}
static SpreadSensitivityCalculatorTest()
{
double flatRate = 0.05;
double t = 20.0;
YIELD_CURVE = IsdaCreditDiscountFactors.of(USD, VALUATION_DATE, CurveName.of("discount"), DoubleArray.of(t), DoubleArray.of(flatRate), ACT_365F);
ImmutableMarketDataBuilder dataBuilder = ImmutableMarketData.builder(VALUATION_DATE);
ImmutableList.Builder <CdsIsdaCreditCurveNode> nodesBuilder = ImmutableList.builder();
ImmutableList.Builder <ResolvedTradeParameterMetadata> cdsMetadataBuilder = ImmutableList.builder();
ImmutableList.Builder <ResolvedTradeParameterMetadata> cdsIndexMetadataBuilder = ImmutableList.builder();
for (int i = 0; i < NUM_MARKET_CDS; i++)
{
QuoteId quoteId = QuoteId.of(StandardId.of("OG", PAR_SPD_DATES[i].ToString()));
CdsIsdaCreditCurveNode node = CdsIsdaCreditCurveNode.ofParSpread(DatesCdsTemplate.of(VALUATION_DATE, PAR_SPD_DATES[i], CDS_CONV), quoteId, LEGAL_ENTITY);
MARKET_CDS[i] = CdsTrade.builder().product(Cds.of(BUY, LEGAL_ENTITY, USD, NOTIONAL, VALUATION_DATE, PAR_SPD_DATES[i], P3M, SAT_SUN, PAR_SPREADS[i] * ONE_BP)).info(TradeInfo.of(VALUATION_DATE)).build().resolve(REF_DATA);
MARKET_CDS_INDEX[i] = CdsIndexTrade.builder().product(CdsIndex.of(BuySell.BUY, INDEX_ID, LEGAL_ENTITIES, USD, NOTIONAL, VALUATION_DATE, PAR_SPD_DATES[i], P3M, SAT_SUN, PAR_SPREADS[i] * ONE_BP)).info(TradeInfo.of(VALUATION_DATE)).build().resolve(REF_DATA);
dataBuilder.addValue(quoteId, PAR_SPREADS[i] * ONE_BP);
nodesBuilder.add(node);
cdsMetadataBuilder.add(ResolvedTradeParameterMetadata.of(MARKET_CDS[i], MARKET_CDS[i].Product.ProtectionEndDate.ToString()));
cdsIndexMetadataBuilder.add(ResolvedTradeParameterMetadata.of(MARKET_CDS_INDEX[i], MARKET_CDS_INDEX[i].Product.ProtectionEndDate.ToString()));
}
ImmutableMarketData marketData = dataBuilder.build();
ImmutableList <CdsIsdaCreditCurveNode> nodes = nodesBuilder.build();
CDS_METADATA = cdsMetadataBuilder.build();
CDS_INDEX_METADATA = cdsIndexMetadataBuilder.build();
ImmutableCreditRatesProvider rates = ImmutableCreditRatesProvider.builder().valuationDate(VALUATION_DATE).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY, RECOVERY_CURVE)).discountCurves(ImmutableMap.of(USD, YIELD_CURVE)).build();
IsdaCreditCurveDefinition definition = IsdaCreditCurveDefinition.of(CREDIT_CURVE_NAME, USD, VALUATION_DATE, ACT_365F, nodes, true, true);
CREDIT_CURVE = BUILDER.calibrate(definition, marketData, rates, REF_DATA);
NodalCurve underlyingCurve = ((IsdaCreditDiscountFactors)CREDIT_CURVE.SurvivalProbabilities).Curve;
NodalCurve curveWithFactor = underlyingCurve.withMetadata(underlyingCurve.Metadata.withInfo(CurveInfoType.CDS_INDEX_FACTOR, INDEX_FACTOR).withParameterMetadata(CDS_INDEX_METADATA)); // replace parameter metadata
CREDIT_CURVE_INDEX = LegalEntitySurvivalProbabilities.of(INDEX_ID, IsdaCreditDiscountFactors.of(USD, VALUATION_DATE, curveWithFactor));
}
/// <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));
}
//-------------------------------------------------------------------------
private static CreditRatesProvider createCreditRatesProviderSingle(LocalDate valuationDate, bool isSingle)
{
IsdaCreditDiscountFactors yc = IsdaCreditDiscountFactors.of(USD, valuationDate, NODAL_YC);
CreditDiscountFactors cc = isSingle ? IsdaCreditDiscountFactors.of(USD, valuationDate, NODAL_CC_SINGLE) : IsdaCreditDiscountFactors.of(USD, valuationDate, NODAL_CC);
ConstantRecoveryRates rr = ConstantRecoveryRates.of(INDEX_ID, valuationDate, RECOVERY_RATE);
return(ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).creditCurves(ImmutableMap.of(Pair.of(INDEX_ID, USD), LegalEntitySurvivalProbabilities.of(INDEX_ID, cc))).discountCurves(ImmutableMap.of(USD, yc)).recoveryRateCurves(ImmutableMap.of(INDEX_ID, rr)).build());
}
public virtual void test_valuationDateMismatch()
{
ConstantRecoveryRates rr_wrong = ConstantRecoveryRates.of(LEGAL_ENTITY_ABC, VALUATION.plusWeeks(1), RECOVERY_RATE_ABC);
assertThrowsIllegalArg(() => ImmutableCreditRatesProvider.builder().valuationDate(VALUATION).creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD), Pair.of(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY), Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, CRD_DEF))).discountCurves(ImmutableMap.of(USD, DSC_USD, JPY, DSC_JPY)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, rr_wrong, LEGAL_ENTITY_DEF, RR_DEF)).build());
IsdaCreditDiscountFactors crd_wrong = IsdaCreditDiscountFactors.of(JPY, VALUATION.plusWeeks(1), NAME_CRD_DEF, TIME_CRD_DEF, RATE_CRD_DEF, ACT_365F);
assertThrowsIllegalArg(() => ImmutableCreditRatesProvider.builder().valuationDate(VALUATION).creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD), Pair.of(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY), Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, crd_wrong))).discountCurves(ImmutableMap.of(USD, DSC_USD, JPY, DSC_JPY)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, RR_ABC, LEGAL_ENTITY_DEF, RR_DEF)).build());
IsdaCreditDiscountFactors dsc_wrong = IsdaCreditDiscountFactors.of(USD, VALUATION.plusWeeks(1), NAME_DSC_USD, TIME_DSC_USD, RATE_DSC_USD, ACT_365F);
assertThrowsIllegalArg(() => ImmutableCreditRatesProvider.builder().valuationDate(VALUATION).creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD), Pair.of(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY), Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, CRD_DEF))).discountCurves(ImmutableMap.of(USD, dsc_wrong, JPY, DSC_JPY)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, RR_ABC, LEGAL_ENTITY_DEF, RR_DEF)).build());
}
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 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);
}
//-------------------------------------------------------------------------
public virtual void test_survivalProbability()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
assertEquals(test.survivalProbability(DATE_AFTER), DFS.discountFactor(DATE_AFTER));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
ImmutableCreditRatesProvider test1 = ImmutableCreditRatesProvider.builder().creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD))).discountCurves(ImmutableMap.of(USD, DSC_USD)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, RR_ABC)).valuationDate(VALUATION).build();
coverImmutableBean(test1);
IsdaCreditDiscountFactors dsc = IsdaCreditDiscountFactors.of(JPY, VALUATION.plusDays(1), NAME_DSC_JPY, TIME_DSC_JPY, RATE_DSC_JPY, ACT_365F);
IsdaCreditDiscountFactors hzd = IsdaCreditDiscountFactors.of(JPY, VALUATION.plusDays(1), NAME_CRD_DEF, TIME_CRD_DEF, RATE_CRD_DEF, ACT_365F);
ConstantRecoveryRates rr = ConstantRecoveryRates.of(LEGAL_ENTITY_DEF, VALUATION.plusDays(1), RECOVERY_RATE_DEF);
ImmutableCreditRatesProvider test2 = ImmutableCreditRatesProvider.builder().creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, hzd))).discountCurves(ImmutableMap.of(JPY, dsc)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_DEF, rr)).valuationDate(VALUATION.plusDays(1)).build();
coverBeanEquals(test1, test2);
}
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>
/// The par spread quotes are converted to points upfronts or quoted spreads.
/// <para>
/// The relevant discount curve and recovery rate curve must be stored in {@code ratesProvider}.
/// The credit curve is internally calibrated to par spread values.
/// </para>
/// <para>
/// {@code trades} must be sorted in ascending order in maturity and coherent to {@code quotes}.
/// </para>
/// <para>
/// The resultant quote is specified by {@code targetConvention}.
///
/// </para>
/// </summary>
/// <param name="trades"> the trades </param>
/// <param name="quotes"> the quotes </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="targetConvention"> the target convention </param>
/// <param name="refData"> the reference data </param>
/// <returns> the quotes </returns>
public virtual IList <CdsQuote> quotesFromParSpread(IList <ResolvedCdsTrade> trades, IList <CdsQuote> quotes, CreditRatesProvider ratesProvider, CdsQuoteConvention targetConvention, ReferenceData refData)
{
ArgChecker.noNulls(trades, "trades");
ArgChecker.noNulls(quotes, "quotes");
ArgChecker.notNull(ratesProvider, "ratesProvider");
ArgChecker.notNull(targetConvention, "targetConvention");
ArgChecker.notNull(refData, "refData");
int nNodes = trades.Count;
ArgChecker.isTrue(quotes.Count == nNodes, "trades and quotes must be the same size");
quotes.ForEach(q => ArgChecker.isTrue(q.QuoteConvention.Equals(CdsQuoteConvention.PAR_SPREAD), "quote must be par spread"));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IEnumerator <StandardId> legalEntities = trades.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:
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 trades");
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IEnumerator <Currency> currencies = trades.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:
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 trades");
LocalDate valuationDate = ratesProvider.ValuationDate;
CreditDiscountFactors discountFactors = ratesProvider.discountFactors(currency);
RecoveryRates recoveryRates = ratesProvider.recoveryRates(legalEntityId);
NodalCurve creditCurve = calibrator.calibrate(trades, DoubleArray.of(nNodes, q => quotes[q].QuotedValue), DoubleArray.filled(nNodes), CurveName.of("temp"), valuationDate, discountFactors, recoveryRates, refData);
CreditRatesProvider ratesProviderNew = ratesProvider.toImmutableCreditRatesProvider().toBuilder().creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), LegalEntitySurvivalProbabilities.of(legalEntityId, IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurve)))).build();
System.Func <ResolvedCdsTrade, CdsQuote> quoteValueFunction = createQuoteValueFunction(ratesProviderNew, targetConvention, refData);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
ImmutableList <CdsQuote> result = trades.Select(c => quoteValueFunction(c)).collect(Collectors.collectingAndThen(Collectors.toList(), ImmutableList.copyOf));
return(result);
}
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));
}
//-------------------------------------------------------------------------
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));
}
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);
}
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)));
}