public virtual void test_withPerturbation()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE).withPerturbation((i, v, m) => v + 1d);
IsdaCreditDiscountFactors exp = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE.withPerturbation((i, v, m) => v + 1d));
assertEquals(test, exp);
}
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 test_withCurve()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE).withCurve(CONST_CURVE);
assertEquals(test.Curve, CONST_CURVE);
assertEquals(test.DayCount, ACT_365L);
}
public virtual void test_ofValues()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, METADATA.CurveName, TIME, RATE, ACT_365F);
IsdaCreditDiscountFactors expected = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
assertEquals(test, expected);
}
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));
}
//-------------------------------------------------------------------------
// proper end-to-end FD tests are in pricer test
public virtual void test_parameterSensitivity()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
ZeroRateSensitivity point = ZeroRateSensitivity.of(USD, 1d, 1d);
assertEquals(test.parameterSensitivity(point).size(), 1);
}
//-------------------------------------------------------------------------
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));
}
//-------------------------------------------------------------------------
protected internal virtual void testJacobian(LegalEntitySurvivalProbabilities curve, ImmutableCreditRatesProvider ratesProvider, IList <CdsIndexIsdaCreditCurveNode> nodes, double[] quotes)
{
int nNode = nodes.Count;
IsdaCreditDiscountFactors df = (IsdaCreditDiscountFactors)curve.SurvivalProbabilities;
int nCurveNode = df.ParameterCount;
for (int i = 0; i < nCurveNode; ++i)
{
double[] quotesUp = Arrays.copyOf(quotes, nNode);
double[] quotesDw = Arrays.copyOf(quotes, nNode);
quotesUp[i] += EPS;
quotesDw[i] -= EPS;
ImmutableMarketDataBuilder builderCreditUp = MARKET_DATA.toBuilder();
ImmutableMarketDataBuilder builderCreditDw = MARKET_DATA.toBuilder();
for (int j = 0; j < nNode; ++j)
{
builderCreditUp.addValue(nodes[j].ObservableId, quotesUp[j]);
builderCreditDw.addValue(nodes[j].ObservableId, quotesDw[j]);
}
ImmutableMarketData marketDataUp = builderCreditUp.build();
ImmutableMarketData marketDataDw = builderCreditDw.build();
IsdaCreditCurveDefinition definition = IsdaCreditCurveDefinition.of(df.Curve.Name, df.Currency, df.ValuationDate, df.DayCount, nodes, false, false);
IsdaCreditDiscountFactors ccUp = (IsdaCreditDiscountFactors)CALIBRATOR.calibrate(definition, marketDataUp, ratesProvider, REF_DATA).SurvivalProbabilities;
IsdaCreditDiscountFactors ccDw = (IsdaCreditDiscountFactors)CALIBRATOR.calibrate(definition, marketDataDw, ratesProvider, REF_DATA).SurvivalProbabilities;
for (int j = 0; j < nNode; ++j)
{
double computed = df.Curve.Metadata.findInfo(CurveInfoType.JACOBIAN).get().JacobianMatrix.get(j, i);
double expected = 0.5 * (ccUp.Curve.YValues.get(j) - ccDw.Curve.YValues.get(j)) / EPS;
assertEquals(computed, expected, EPS * 10d);
}
}
}
protected internal virtual void testJacobian(IsdaCompliantCreditCurveCalibrator builder, LegalEntitySurvivalProbabilities curve, ImmutableCreditRatesProvider ratesProvider, IList <CdsIsdaCreditCurveNode> nodes, double[] quotes, double quoteScale, double eps)
{
LocalDate valuationDate = curve.ValuationDate;
int nNode = nodes.Count;
IsdaCreditDiscountFactors df = (IsdaCreditDiscountFactors)curve.SurvivalProbabilities;
CurveName name = df.Curve.Name;
int nCurveNode = df.ParameterCount;
for (int i = 0; i < nCurveNode; ++i)
{
double[] quotesUp = Arrays.copyOf(quotes, nNode);
double[] quotesDw = Arrays.copyOf(quotes, nNode);
quotesUp[i] += eps / quoteScale;
quotesDw[i] -= eps / quoteScale;
ImmutableMarketDataBuilder builderCreditUp = ImmutableMarketData.builder(valuationDate);
ImmutableMarketDataBuilder builderCreditDw = ImmutableMarketData.builder(valuationDate);
for (int j = 0; j < nNode; ++j)
{
builderCreditUp.addValue(nodes[j].ObservableId, quotesUp[j] * quoteScale);
builderCreditDw.addValue(nodes[j].ObservableId, quotesDw[j] * quoteScale);
}
ImmutableMarketData marketDataUp = builderCreditUp.build();
ImmutableMarketData marketDataDw = builderCreditDw.build();
IsdaCreditDiscountFactors ccUp = (IsdaCreditDiscountFactors)builder.calibrate(nodes, name, marketDataUp, ratesProvider, curve.SurvivalProbabilities.DayCount, curve.Currency, false, false, REF_DATA).SurvivalProbabilities;
IsdaCreditDiscountFactors ccDw = (IsdaCreditDiscountFactors)builder.calibrate(nodes, name, marketDataDw, ratesProvider, curve.SurvivalProbabilities.DayCount, curve.Currency, false, false, REF_DATA).SurvivalProbabilities;
for (int j = 0; j < nNode; ++j)
{
double computed = df.Curve.Metadata.findInfo(CurveInfoType.JACOBIAN).get().JacobianMatrix.get(j, i);
double expected = 0.5 * (ccUp.Curve.YValues.get(j) - ccDw.Curve.YValues.get(j)) / eps;
assertEquals(computed, expected, eps * 10d);
}
}
}
public virtual void test_ofValue()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, METADATA_SINGLE.CurveName, DoubleArray.of(TIME_SINGLE), DoubleArray.of(RATE_SINGLE), ACT_365L);
IsdaCreditDiscountFactors expected = IsdaCreditDiscountFactors.of(USD, VALUATION, CONST_CURVE);
assertEquals(test, expected);
}
public virtual void test_withParameter()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE).withParameter(1, 0.55);
IsdaCreditDiscountFactors exp = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE.withParameter(1, 0.55));
assertEquals(test, exp);
}
//-------------------------------------------------------------------------
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_createParameterSensitivity()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
DoubleArray sensitivities = DoubleArray.of(0.12, 0.1, 0.49, 0.15, 0.56, 0.17, 0.32, 0.118, 0.456, 5.0, 12.0, 0.65, 0.34, 0.75, 0.12, 0.15, 0.12, 0.15, 0.04);
CurrencyParameterSensitivities sens = test.createParameterSensitivity(USD, sensitivities);
assertEquals(sens.Sensitivities.get(0), CURVE.createParameterSensitivity(USD, sensitivities));
}
//-------------------------------------------------------------------------
public virtual void test_discountFactor()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
double relativeYearFraction = ACT_365F.relativeYearFraction(VALUATION, DATE_AFTER);
double expected = Math.Exp(-relativeYearFraction * CURVE.yValue(relativeYearFraction));
assertEquals(test.discountFactor(DATE_AFTER), expected);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
IsdaCreditDiscountFactors test1 = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
coverImmutableBean(test1);
IsdaCreditDiscountFactors test2 = IsdaCreditDiscountFactors.of(GBP, VALUATION.plusDays(1), CONST_CURVE);
coverBeanEquals(test1, test2);
}
public virtual void test_zeroRatePointSensitivity_sensitivityCurrency()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
double relativeYearFraction = ACT_365F.relativeYearFraction(VALUATION, DATE_AFTER);
double df = Math.Exp(-relativeYearFraction * CURVE.yValue(relativeYearFraction));
ZeroRateSensitivity expected = ZeroRateSensitivity.of(USD, relativeYearFraction, GBP, -df * relativeYearFraction);
assertEquals(test.zeroRatePointSensitivity(DATE_AFTER, GBP), expected);
}
public virtual void test_zeroRate()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
double relativeYearFraction = ACT_365F.relativeYearFraction(VALUATION, DATE_AFTER);
double discountFactor = test.discountFactor(DATE_AFTER);
double zeroRate = test.zeroRate(DATE_AFTER);
assertEquals(Math.Exp(-zeroRate * relativeYearFraction), discountFactor);
}
//-------------------------------------------------------------------------
public virtual void test_unitParameterSensitivity()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
ZeroRateSensitivity sens = test.zeroRatePointSensitivity(DATE_AFTER);
double relativeYearFraction = ACT_365F.relativeYearFraction(VALUATION, DATE_AFTER);
CurrencyParameterSensitivities expected = CurrencyParameterSensitivities.of(CURVE.yValueParameterSensitivity(relativeYearFraction).multipliedBy(sens.Currency, sens.Sensitivity));
assertEquals(test.parameterSensitivity(sens), expected);
}
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());
}
//-------------------------------------------------------------------------
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 static ImmutableCreditRatesProvider createRatesProvider(LocalDate tradeDate, LocalDate snapDate, double rateScale, double recoveryRate)
{
ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(snapDate);
for (int j = 0; j < NUM_INSTRUMENTS; j++)
{
builder.addValue(QuoteId.of(StandardId.of("OG", ID_VALUES[j])), RATES[j] * rateScale);
}
ImmutableMarketData quotes = builder.build();
IsdaCreditCurveDefinition curveDefinition = IsdaCreditCurveDefinition.of(CurveName.of("yield"), EUR, tradeDate, ACT_365F, DSC_NODES, false, false);
IsdaCreditDiscountFactors yc = IsdaCompliantDiscountCurveCalibrator.standard().calibrate(curveDefinition, quotes, REF_DATA);
return(ImmutableCreditRatesProvider.builder().valuationDate(tradeDate).discountCurves(ImmutableMap.of(EUR, yc)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY, ConstantRecoveryRates.of(LEGAL_ENTITY, tradeDate, recoveryRate))).creditCurves(ImmutableMap.of()).build());
}
public virtual void parSpreadTest()
{
LocalDate valuationDate = LocalDate.of(2013, 2, 27);
DoubleArray ycTime = DoubleArray.ofUnsafe(new double[] { 0.09041095890410959, 0.1726027397260274, 0.26301369863013696, 0.5123287671232877, 0.7616438356164383, 1.010958904109589, 2.008219178082192, 3.008219178082192, 4.008219178082192, 5.008219178082192, 6.008219178082192, 7.013698630136987, 8.01095890410959, 9.01095890410959, 10.01095890410959, 12.01917808219178, 15.016438356164384, 20.01917808219178, 25.021917808219175, 30.027397260273972 });
DoubleArray ycRate = DoubleArray.ofUnsafe(new double[] { 0.0020651105531615476, 0.0024506037920717797, 0.0028872269869485313, 0.004599628230463427, 0.006160809466806469, 0.0075703969168129295, 0.003965128877560435, 0.005059104202201957, 0.0069669135253734825, 0.009361825469323602, 0.011916895611422482, 0.014311922779901886, 0.016519187063048578, 0.018512121993907647, 0.020289623737560873, 0.02329885162861984, 0.026399509889410745, 0.029087919732133784, 0.03037740056662963, 0.03110021763406523 });
IsdaCreditDiscountFactors yc = IsdaCreditDiscountFactors.of(EUR, valuationDate, CurveName.of("yc_usd"), ycTime, ycRate, ACT_365F);
double[] timeNodeExp = new double[] { 0.5616438356164384, 1.0575342465753426, 2.0575342465753423, 3.0602739726027397, 4.06027397260274, 5.06027397260274, 6.06027397260274, 7.063013698630137, 8.063013698630137, 9.063013698630137, 10.063013698630137 };
double[] rateNodeExp = new double[] { 0.00876054089781935, 0.011037345646850688, 0.015955126945240167, 0.020617953392829177, 0.025787811343896218, 0.030329992053915133, 0.03313419899444371, 0.03528129159875671, 0.03675340516560903, 0.037946169956317416, 0.038951101800190346 };
double[] rateNodeExpMf = new double[] { 0.008754510260229803, 0.011030502992814844, 0.01594817866773906, 0.02060947097554756, 0.025776720596175737, 0.030316032527460755, 0.03311839631615255, 0.03526404051997617, 0.03673513322394772, 0.03792689865945585, 0.03893107891569398 };
ImmutableCreditRatesProvider ratesProvider = ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).discountCurves(ImmutableMap.of(EUR, yc)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY, ConstantRecoveryRates.of(LEGAL_ENTITY, valuationDate, 0.25))).creditCurves(ImmutableMap.of()).build();
LocalDate startDate = LocalDate.of(2012, 12, 20);
LocalDate[] pillarDates = new LocalDate[] { LocalDate.of(2013, 9, 20), LocalDate.of(2014, 3, 20), LocalDate.of(2015, 3, 20), LocalDate.of(2016, 3, 20), LocalDate.of(2017, 3, 20), LocalDate.of(2018, 3, 20), LocalDate.of(2019, 3, 20), LocalDate.of(2020, 3, 20), LocalDate.of(2021, 3, 20), LocalDate.of(2022, 3, 20), LocalDate.of(2023, 3, 20) };
int nPillars = pillarDates.Length;
ImmutableMarketDataBuilder builderCredit = ImmutableMarketData.builder(valuationDate);
IList <CdsIsdaCreditCurveNode> nodes = new List <CdsIsdaCreditCurveNode>(nPillars);
double[] quotes = new double[] { 0.006485, 0.008163, 0.011763, 0.015136, 0.018787, 0.021905, 0.023797, 0.025211, 0.02617, 0.026928, 0.027549 };
for (int i = 0; i < nPillars; ++i)
{
CdsConvention conv = ImmutableCdsConvention.of("conv", EUR, ACT_360, Frequency.P3M, BUS_ADJ, CDS_SETTLE_STD);
CdsTemplate temp = DatesCdsTemplate.of(startDate, pillarDates[i], conv);
QuoteId id = QuoteId.of(StandardId.of("OG", pillarDates[i].ToString()));
nodes.Add(CdsIsdaCreditCurveNode.ofParSpread(temp, id, LEGAL_ENTITY));
builderCredit.addValue(id, quotes[i]);
}
ImmutableMarketData marketData = builderCredit.build();
IsdaCreditCurveDefinition curveDefinition = IsdaCreditCurveDefinition.of(CurveName.of("zz"), EUR, valuationDate, ACT_365F, nodes, true, true);
LegalEntitySurvivalProbabilities cc = BUILDER_ISDA.calibrate(curveDefinition, marketData, ratesProvider, REF_DATA);
NodalCurve resCurve = ((IsdaCreditDiscountFactors)cc.SurvivalProbabilities).Curve;
for (int i = 0; i < nPillars; ++i)
{
ParameterMetadata param = resCurve.getParameterMetadata(i);
assertTrue(param is ResolvedTradeParameterMetadata);
ResolvedTradeParameterMetadata tradeParam = (ResolvedTradeParameterMetadata)param;
assertTrue(tradeParam.Trade is ResolvedCdsTrade);
}
assertTrue(DoubleArrayMath.fuzzyEquals(resCurve.XValues.toArray(), timeNodeExp, TOL));
assertTrue(DoubleArrayMath.fuzzyEquals(resCurve.YValues.toArray(), rateNodeExp, TOL));
testJacobian(BUILDER_ISDA, cc, ratesProvider, nodes, quotes, 1d, EPS);
LegalEntitySurvivalProbabilities ccMf = BUILDER_MARKIT.calibrate(curveDefinition, marketData, ratesProvider, REF_DATA);
NodalCurve resCurveMf = ((IsdaCreditDiscountFactors)ccMf.SurvivalProbabilities).Curve;
assertTrue(DoubleArrayMath.fuzzyEquals(resCurveMf.XValues.toArray(), timeNodeExp, TOL));
assertTrue(DoubleArrayMath.fuzzyEquals(resCurveMf.YValues.toArray(), rateNodeExpMf, TOL));
testJacobian(BUILDER_MARKIT, ccMf, ratesProvider, nodes, quotes, 1d, EPS);
}
public virtual void test_of_fail()
{
DefaultCurveMetadata metadata = DefaultCurveMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).curveName("yieldUsd").build();
InterpolatedNodalCurve curveNoDcc = InterpolatedNodalCurve.of(metadata, TIME, RATE, CurveInterpolators.PRODUCT_LINEAR, CurveExtrapolators.FLAT, CurveExtrapolators.PRODUCT_LINEAR);
assertThrowsIllegalArg(() => IsdaCreditDiscountFactors.of(USD, VALUATION, curveNoDcc));
InterpolatedNodalCurve curveWrongLeft = InterpolatedNodalCurve.of(METADATA, TIME, RATE, CurveInterpolators.PRODUCT_LINEAR, CurveExtrapolators.PRODUCT_LINEAR, CurveExtrapolators.PRODUCT_LINEAR);
assertThrowsIllegalArg(() => IsdaCreditDiscountFactors.of(USD, VALUATION, curveWrongLeft));
InterpolatedNodalCurve curveWrongInterp = InterpolatedNodalCurve.of(METADATA, TIME, RATE, CurveInterpolators.NATURAL_SPLINE, CurveExtrapolators.FLAT, CurveExtrapolators.PRODUCT_LINEAR);
assertThrowsIllegalArg(() => IsdaCreditDiscountFactors.of(USD, VALUATION, curveWrongInterp));
InterpolatedNodalCurve curveWrongRight = InterpolatedNodalCurve.of(METADATA, TIME, RATE, CurveInterpolators.PRODUCT_LINEAR, CurveExtrapolators.FLAT, CurveExtrapolators.FLAT);
assertThrowsIllegalArg(() => IsdaCreditDiscountFactors.of(USD, VALUATION, curveWrongRight));
}
public virtual void test_of_constant_interface()
{
IsdaCreditDiscountFactors test = (IsdaCreditDiscountFactors)CreditDiscountFactors.of(USD, VALUATION, CONST_CURVE);
assertEquals(test.Currency, USD);
assertEquals(test.Curve, CONST_CURVE);
assertEquals(test.DayCount, ACT_365L);
assertEquals(test.ParameterCount, 1);
assertEquals(test.getParameter(0), RATE_SINGLE);
assertEquals(test.ParameterKeys, DoubleArray.of(TIME_SINGLE));
assertEquals(test.getParameterMetadata(0), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME_SINGLE));
assertEquals(test.ValuationDate, VALUATION);
assertEquals(test.findData(CONST_CURVE.Name), CONST_CURVE);
assertEquals(test.findData(CurveName.of("Rubbish")), null);
assertEquals(test.toDiscountFactors(), ZeroRateDiscountFactors.of(USD, VALUATION, CONST_CURVE));
assertEquals(test.IsdaCompliant, true);
}
public virtual void test_of()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
assertEquals(test.Currency, USD);
assertEquals(test.Curve, CURVE);
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.ParameterCount, RATE.size());
assertEquals(test.getParameter(3), RATE.get(3));
assertEquals(test.getParameter(1), RATE.get(1));
assertEquals(test.ParameterKeys, TIME);
assertEquals(test.getParameterMetadata(4), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME.get(4)));
assertEquals(test.getParameterMetadata(6), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME.get(6)));
assertEquals(test.ValuationDate, VALUATION);
assertEquals(test.findData(CURVE.Name), CURVE);
assertEquals(test.findData(CurveName.of("Rubbish")), null);
assertEquals(test.toDiscountFactors(), ZeroRateDiscountFactors.of(USD, VALUATION, CURVE));
assertEquals(test.IsdaCompliant, true);
}
public virtual void pufTest()
{
LocalDate valuationDate = LocalDate.of(2013, 4, 10);
DoubleArray ycTime = DoubleArray.ofUnsafe(new double[] { 0.09041095890410959, 0.1726027397260274, 0.2547945205479452, 0.5123287671232877, 0.7616438356164383, 1.010958904109589, 2.008219178082192, 3.008219178082192, 4.008219178082192, 5.008219178082192, 6.008219178082192, 7.013698630136987, 8.01095890410959, 9.01095890410959, 10.01095890410959, 12.01917808219178, 15.016438356164384, 20.01917808219178, 25.021917808219175, 30.027397260273972 });
DoubleArray ycRate = DoubleArray.ofUnsafe(new double[] { 0.0020205071813561414, 0.0024226927083852126, 0.00280147037504029, 0.004449041082144009, 0.005821804782808804, 0.007254879152733453, 0.00378133614924816, 0.004815163234294319, 0.006576302084547871, 0.00884241431837336, 0.011358805989279104, 0.013793391727035883, 0.016014197840890115, 0.01801564209277191, 0.019757164421290663, 0.022773295945438254, 0.025862337032619587, 0.02848646344754061, 0.029753383126110852, 0.03045277462637107 });
IsdaCreditDiscountFactors yc = IsdaCreditDiscountFactors.of(EUR, valuationDate, CurveName.of("yc_usd"), ycTime, ycRate, ACT_365F);
double[] timeNodeExp = new double[] { 0.19452054794520549, 0.4465753424657534, 0.6958904109589041, 0.9424657534246575, 1.1945205479452055, 1.4465753424657535, 1.6958904109589041, 1.9424657534246574, 2.1945205479452055, 2.4465753424657533, 2.695890410958904, 2.9452054794520546, 3.197260273972603, 3.4493150684931506, 3.6986301369863015, 3.9452054794520546, 4.197260273972603, 4.449315068493151, 4.698630136986301, 4.945205479452055, 5.197260273972603, 5.449315068493151, 5.698630136986301, 5.945205479452055, 6.197260273972603, 6.449315068493151, 6.698630136986301, 6.947945205479452, 7.2, 7.4520547945205475, 7.701369863013698, 7.947945205479452, 8.2, 8.452054794520548, 8.7013698630137, 8.947945205479453, 9.2, 9.452054794520548, 9.7013698630137, 9.947945205479453, 10.2 };
double[] rateNodeExp = new double[] { 0.11219168510100914, 0.11085321179769615, 0.11753783265486063, 0.11806409789291543, 0.12007843111645247, 0.12273722191216528, 0.12541993298405366, 0.12773640093265545, 0.1290535220739981, 0.13294183149211675, 0.13659302947963856, 0.13988488561043758, 0.1429469312254705, 0.14606538453369572, 0.14916286828444447, 0.15219682906227, 0.1548315745851032, 0.158141193071526, 0.16163981714033765, 0.1650400193930357, 0.1682351993447916, 0.1683744003954113, 0.168657453080796, 0.16915067878510565, 0.1694852880010724, 0.16990705130936645, 0.1704456138969621, 0.17105852486248443, 0.1717088423125347, 0.1727906445582425, 0.17407566745397665, 0.17547300248653266, 0.17679395545074758, 0.17769841457372118, 0.1788064602071617, 0.18001498257267778, 0.18123747758791092, 0.18253661761388457, 0.18406319235262744, 0.18582983758830868, 0.18750386499176422 };
double[] rateNodeExpMf = new double[] { 0.11107220823737506, 0.11011543264900588, 0.11685607164947402, 0.11742079953945683, 0.1194445192166302, 0.12220026187805585, 0.12494798294628297, 0.12731185688090763, 0.12860146674492023, 0.1325216904413876, 0.1362014254649678, 0.13951646788193767, 0.14254141853655264, 0.14567581048732742, 0.1487851622438674, 0.15182838855605538, 0.15442415754322128, 0.15774061191016645, 0.16124288871765308, 0.1646451035564102, 0.167796451103847, 0.16794456750248196, 0.16823438468063495, 0.1687328171292339, 0.16904360885724334, 0.16947020572961907, 0.17001201556723175, 0.17062724832190826, 0.17125190473373603, 0.17233319414449558, 0.17361785479583028, 0.1750136127341691, 0.17630530410589512, 0.17720871748506664, 0.17831270423353415, 0.17951604233911425, 0.18070939732103264, 0.18200162521943403, 0.18351891000003046, 0.1852740041292825, 0.18691086960422418 };
ImmutableCreditRatesProvider ratesProvider = ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).discountCurves(ImmutableMap.of(EUR, yc)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY, ConstantRecoveryRates.of(LEGAL_ENTITY, valuationDate, 0.4))).creditCurves(ImmutableMap.of()).build();
LocalDate startDate = LocalDate.of(2013, 3, 20);
LocalDate[] pillarDate = new LocalDate[] { LocalDate.of(2013, 6, 20), LocalDate.of(2013, 9, 20), LocalDate.of(2013, 12, 20), LocalDate.of(2014, 3, 20), LocalDate.of(2014, 6, 20), LocalDate.of(2014, 9, 20), LocalDate.of(2014, 12, 20), LocalDate.of(2015, 3, 20), LocalDate.of(2015, 6, 20), LocalDate.of(2015, 9, 20), LocalDate.of(2015, 12, 20), LocalDate.of(2016, 3, 20), LocalDate.of(2016, 6, 20), LocalDate.of(2016, 9, 20), LocalDate.of(2016, 12, 20), LocalDate.of(2017, 3, 20), LocalDate.of(2017, 6, 20), LocalDate.of(2017, 9, 20), LocalDate.of(2017, 12, 20), LocalDate.of(2018, 3, 20), LocalDate.of(2018, 6, 20), LocalDate.of(2018, 9, 20), LocalDate.of(2018, 12, 20), LocalDate.of(2019, 3, 20), LocalDate.of(2019, 6, 20), LocalDate.of(2019, 9, 20), LocalDate.of(2019, 12, 20), LocalDate.of(2020, 3, 20), LocalDate.of(2020, 6, 20), LocalDate.of(2020, 9, 20), LocalDate.of(2020, 12, 20), LocalDate.of(2021, 3, 20), LocalDate.of(2021, 6, 20), LocalDate.of(2021, 9, 20), LocalDate.of(2021, 12, 20), LocalDate.of(2022, 3, 20), LocalDate.of(2022, 6, 20), LocalDate.of(2022, 9, 20), LocalDate.of(2022, 12, 20), LocalDate.of(2023, 3, 20), LocalDate.of(2023, 6, 20) };
int nPillars = pillarDate.Length;
double coupon = 500d * ONE_BP;
ImmutableMarketDataBuilder builderCredit = ImmutableMarketData.builder(valuationDate);
IList <CdsIsdaCreditCurveNode> nodes = new List <CdsIsdaCreditCurveNode>(nPillars);
double[] quotes = new double[] { 0.32, 0.69, 1.32, 1.79, 2.36, 3.01, 3.7, 4.39, 5.02, 5.93, 6.85, 7.76, 8.67, 9.6, 10.53, 11.45, 12.33, 13.29, 14.26, 15.2, 16.11, 16.62, 17.12, 17.62, 18.09, 18.55, 19, 19.44, 19.87, 20.33, 20.79, 21.24, 21.67, 22.04, 22.41, 22.77, 23.12, 23.46, 23.8, 24.14, 24.46 };
for (int i = 0; i < nPillars; ++i)
{
CdsConvention conv = ImmutableCdsConvention.of("conv", EUR, ACT_360, Frequency.P3M, BUS_ADJ, CDS_SETTLE_STD);
CdsTemplate temp = DatesCdsTemplate.of(startDate, pillarDate[i], conv);
QuoteId id = QuoteId.of(StandardId.of("OG", pillarDate[i].ToString()));
nodes.Add(CdsIsdaCreditCurveNode.ofPointsUpfront(temp, id, LEGAL_ENTITY, coupon));
builderCredit.addValue(id, quotes[i] * ONE_PC);
}
ImmutableMarketData marketData = builderCredit.build();
IsdaCreditCurveDefinition curveDefinition = IsdaCreditCurveDefinition.of(CurveName.of("cc"), EUR, valuationDate, ACT_365F, nodes, true, false);
LegalEntitySurvivalProbabilities cc = BUILDER_ISDA.calibrate(curveDefinition, marketData, ratesProvider, REF_DATA);
NodalCurve resCurve = ((IsdaCreditDiscountFactors)cc.SurvivalProbabilities).Curve;
assertTrue(DoubleArrayMath.fuzzyEquals(resCurve.XValues.toArray(), timeNodeExp, TOL));
assertTrue(DoubleArrayMath.fuzzyEquals(resCurve.YValues.toArray(), rateNodeExp, TOL));
testJacobian(BUILDER_ISDA, cc, ratesProvider, nodes, quotes, ONE_PC, EPS);
LegalEntitySurvivalProbabilities ccMf = BUILDER_MARKIT.calibrate(curveDefinition, marketData, ratesProvider, REF_DATA);
NodalCurve resCurveMf = ((IsdaCreditDiscountFactors)ccMf.SurvivalProbabilities).Curve;
assertTrue(DoubleArrayMath.fuzzyEquals(resCurveMf.XValues.toArray(), timeNodeExp, TOL));
assertTrue(DoubleArrayMath.fuzzyEquals(resCurveMf.YValues.toArray(), rateNodeExpMf, TOL));
testJacobian(BUILDER_MARKIT, ccMf, ratesProvider, nodes, quotes, ONE_PC, EPS);
}
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>
/// Calibrates the ISDA compliant discount curve to the market data.
/// <para>
/// This creates the single discount curve for a specified currency.
/// The curve nodes in {@code IsdaCreditCurveDefinition} should be term deposit or fixed-for-Ibor swap,
/// and the number of nodes should be greater than 1.
///
/// </para>
/// </summary>
/// <param name="curveDefinition"> the curve definition </param>
/// <param name="marketData"> the market data </param>
/// <param name="refData"> the reference data </param>
/// <returns> the ISDA compliant discount curve </returns>
public IsdaCreditDiscountFactors calibrate(IsdaCreditCurveDefinition curveDefinition, MarketData marketData, ReferenceData refData)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<? extends com.opengamma.strata.market.curve.IsdaCreditCurveNode> curveNodes = curveDefinition.getCurveNodes();
IList <IsdaCreditCurveNode> curveNodes = curveDefinition.CurveNodes;
int nNodes = curveNodes.Count;
ArgChecker.isTrue(nNodes > 1, "the number of curve nodes must be greater than 1");
LocalDate curveSnapDate = marketData.ValuationDate;
LocalDate curveValuationDate = curveDefinition.CurveValuationDate;
DayCount curveDayCount = curveDefinition.DayCount;
BasicFixedLeg[] swapLeg = new BasicFixedLeg[nNodes];
double[] termDepositYearFraction = new double[nNodes];
double[] curveNodeTime = new double[nNodes];
double[] rates = new double[nNodes];
ImmutableList.Builder <ParameterMetadata> paramMetadata = ImmutableList.builder();
int nTermDeposit = 0;
LocalDate curveSpotDate = null;
for (int i = 0; i < nNodes; i++)
{
LocalDate cvDateTmp;
IsdaCreditCurveNode node = curveNodes[i];
rates[i] = marketData.getValue(node.ObservableId);
LocalDate adjMatDate = node.date(curveSnapDate, refData);
paramMetadata.add(node.metadata(adjMatDate));
if (node is DepositIsdaCreditCurveNode)
{
DepositIsdaCreditCurveNode termDeposit = (DepositIsdaCreditCurveNode)node;
cvDateTmp = termDeposit.SpotDateOffset.adjust(curveSnapDate, refData);
curveNodeTime[i] = curveDayCount.relativeYearFraction(cvDateTmp, adjMatDate);
termDepositYearFraction[i] = termDeposit.DayCount.relativeYearFraction(cvDateTmp, adjMatDate);
ArgChecker.isTrue(nTermDeposit == i, "TermDepositCurveNode should not be after FixedIborSwapCurveNode");
++nTermDeposit;
}
else if (node is SwapIsdaCreditCurveNode)
{
SwapIsdaCreditCurveNode swap = (SwapIsdaCreditCurveNode)node;
cvDateTmp = swap.SpotDateOffset.adjust(curveSnapDate, refData);
curveNodeTime[i] = curveDayCount.relativeYearFraction(cvDateTmp, adjMatDate);
BusinessDayAdjustment busAdj = swap.BusinessDayAdjustment;
swapLeg[i] = new BasicFixedLeg(this, cvDateTmp, cvDateTmp.plus(swap.Tenor), swap.PaymentFrequency.Period, swap.DayCount, curveDayCount, busAdj, refData);
}
else
{
throw new System.ArgumentException("unsupported cuve node type");
}
if (i > 0)
{
ArgChecker.isTrue(curveNodeTime[i] - curveNodeTime[i - 1] > 0, "curve nodes should be ascending in terms of tenor");
ArgChecker.isTrue(cvDateTmp.Equals(curveSpotDate), "spot lag should be common for all of the curve nodes");
}
else
{
ArgChecker.isTrue(curveNodeTime[i] >= 0d, "the first node should be after curve spot date");
curveSpotDate = cvDateTmp;
}
}
ImmutableList <ParameterMetadata> parameterMetadata = paramMetadata.build();
double[] ratesMod = Arrays.copyOf(rates, nNodes);
for (int i = 0; i < nTermDeposit; ++i)
{
double dfInv = 1d + ratesMod[i] * termDepositYearFraction[i];
ratesMod[i] = Math.Log(dfInv) / curveNodeTime[i];
}
InterpolatedNodalCurve curve = curveDefinition.curve(DoubleArray.ofUnsafe(curveNodeTime), DoubleArray.ofUnsafe(ratesMod));
for (int i = nTermDeposit; i < nNodes; ++i)
{
curve = fitSwap(i, swapLeg[i], curve, rates[i]);
}
Currency currency = curveDefinition.Currency;
DoubleMatrix sensi = quoteValueSensitivity(nTermDeposit, termDepositYearFraction, swapLeg, ratesMod, curve, curveDefinition.ComputeJacobian);
if (curveValuationDate.isEqual(curveSpotDate))
{
if (curveDefinition.ComputeJacobian)
{
JacobianCalibrationMatrix jacobian = JacobianCalibrationMatrix.of(ImmutableList.of(CurveParameterSize.of(curveDefinition.Name, nNodes)), MATRIX_ALGEBRA.getInverse(sensi));
NodalCurve curveWithParamMetadata = curve.withMetadata(curve.Metadata.withInfo(CurveInfoType.JACOBIAN, jacobian).withParameterMetadata(parameterMetadata));
return(IsdaCreditDiscountFactors.of(currency, curveValuationDate, curveWithParamMetadata));
}
NodalCurve curveWithParamMetadata = curve.withMetadata(curve.Metadata.withParameterMetadata(parameterMetadata));
return(IsdaCreditDiscountFactors.of(currency, curveValuationDate, curveWithParamMetadata));
}
double offset = curveDayCount.relativeYearFraction(curveSpotDate, curveValuationDate);
return(IsdaCreditDiscountFactors.of(currency, curveValuationDate, withShift(curve, parameterMetadata, sensi, curveDefinition.ComputeJacobian, offset)));
}
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);
}
/// <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);
}