private CurrencyParameterSensitivities sensitivityCreidtCurve <T>(ImmutableCreditRatesProvider provider, System.Func <ImmutableCreditRatesProvider, CurrencyAmount> valueFn, MetaProperty <ImmutableMap <T, LegalEntitySurvivalProbabilities> > metaProperty, CurrencyAmount valueInit)
{
ImmutableMap <T, LegalEntitySurvivalProbabilities> baseCurves = metaProperty.get(provider);
CurrencyParameterSensitivities result = CurrencyParameterSensitivities.empty();
foreach (T key in baseCurves.Keys)
{
LegalEntitySurvivalProbabilities credit = baseCurves.get(key);
CreditDiscountFactors creditDiscountFactors = credit.SurvivalProbabilities;
DiscountFactors discountFactors = creditDiscountFactors.toDiscountFactors();
Curve curve = checkDiscountFactors(discountFactors);
int paramCount = curve.ParameterCount;
double[] sensitivity = new double[paramCount];
for (int i = 0; i < paramCount; i++)
{
Curve dscBumped = curve.withParameter(i, curve.getParameter(i) + shift);
IDictionary <T, LegalEntitySurvivalProbabilities> mapBumped = new Dictionary <T, LegalEntitySurvivalProbabilities>(baseCurves);
mapBumped[key] = LegalEntitySurvivalProbabilities.of(credit.LegalEntityId, createCreditDiscountFactors(creditDiscountFactors, dscBumped));
ImmutableCreditRatesProvider providerDscBumped = provider.toBuilder().set(metaProperty, mapBumped).build();
sensitivity[i] = (valueFn(providerDscBumped).Amount - valueInit.Amount) / shift;
}
result = result.combinedWith(curve.createParameterSensitivity(valueInit.Currency, DoubleArray.copyOf(sensitivity)));
}
return(result);
}
//-------------------------------------------------------------------------
public LegalEntitySurvivalProbabilities survivalProbabilities(StandardId legalEntityId, Currency currency)
{
CurveId curveId = lookup.CreditCurveIds.get(Pair.of(legalEntityId, currency));
if (curveId == null)
{
throw new MarketDataNotFoundException("Unable to find credit curve: " + legalEntityId + ", " + currency);
}
Curve curve = marketData.getValue(curveId);
CreditDiscountFactors survivalProbabilities = CreditDiscountFactors.of(currency, ValuationDate, curve);
return(LegalEntitySurvivalProbabilities.of(legalEntityId, survivalProbabilities));
}
public virtual void test_bondDiscountingProvider()
{
LocalDate valDate = LocalDate.of(2015, 6, 30);
Curve ccAUsd = ConstantNodalCurve.of(Curves.zeroRates(CC_A_USD.CurveName, ACT_365F), 0.5d, 1.5d);
Curve ccBGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_B_GBP.CurveName, ACT_365F), 0.5d, 2d);
Curve ccAGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_A_GBP.CurveName, ACT_365F), 0.5d, 3d);
Curve dcGbp = ConstantNodalCurve.of(Curves.zeroRates(DC_GBP.CurveName, ACT_365F), 0.5d, 0.1d);
Curve dcUsd = ConstantNodalCurve.of(Curves.zeroRates(DC_USD.CurveName, ACT_365F), 0.5d, 0.05d);
Curve rcA = ConstantCurve.of(Curves.recoveryRates(RC_A.CurveName, ACT_365F), 0.5d);
Curve rcB = ConstantCurve.of(Curves.recoveryRates(RC_B.CurveName, ACT_365F), 0.4234d);
IDictionary <CurveId, Curve> curveMap = new Dictionary <CurveId, Curve>();
curveMap[CC_A_USD] = ccAUsd;
curveMap[CC_B_GBP] = ccBGbp;
curveMap[CC_A_GBP] = ccAGbp;
curveMap[DC_USD] = dcUsd;
curveMap[DC_GBP] = dcGbp;
curveMap[RC_A] = rcA;
curveMap[RC_B] = rcB;
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.copyOf(curveMap));
CreditRatesProvider provider = LOOKUP_WITH_SOURCE.creditRatesProvider(md);
assertEquals(provider.ValuationDate, valDate);
assertEquals(provider.findData(CC_A_USD.CurveName), ccAUsd);
assertEquals(provider.findData(DC_USD.CurveName), dcUsd);
assertEquals(provider.findData(RC_B.CurveName), rcB);
assertEquals(provider.findData(CurveName.of("Rubbish")), null);
// check credit curve
LegalEntitySurvivalProbabilities cc = provider.survivalProbabilities(ISSUER_A, GBP);
IsdaCreditDiscountFactors ccUnder = (IsdaCreditDiscountFactors)cc.SurvivalProbabilities;
assertEquals(ccUnder.Curve.Name, ccAGbp.Name);
assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_B, USD));
assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_C, USD));
// check discount curve
IsdaCreditDiscountFactors dc = (IsdaCreditDiscountFactors)provider.discountFactors(USD);
assertEquals(dc.Curve.Name, dcUsd.Name);
assertThrowsRuntime(() => provider.discountFactors(EUR));
// check recovery rate curve
ConstantRecoveryRates rc = (ConstantRecoveryRates)provider.recoveryRates(ISSUER_B);
assertEquals(rc.RecoveryRate, rcB.getParameter(0));
assertThrowsRuntime(() => provider.recoveryRates(ISSUER_C));
}
//-------------------------------------------------------------------------
public ImmutableCreditRatesProvider toImmutableCreditRatesProvider()
{
LocalDate valuationDate = ValuationDate;
// credit curves
IDictionary <Pair <StandardId, Currency>, LegalEntitySurvivalProbabilities> creditCurves = new Dictionary <Pair <StandardId, Currency>, LegalEntitySurvivalProbabilities>();
foreach (Pair <StandardId, Currency> pair in lookup.CreditCurveIds.Keys)
{
CurveId curveId = lookup.CreditCurveIds.get(pair);
if (marketData.containsValue(curveId))
{
Curve curve = marketData.getValue(curveId);
CreditDiscountFactors survivalProbabilities = CreditDiscountFactors.of(pair.Second, valuationDate, curve);
creditCurves[pair] = LegalEntitySurvivalProbabilities.of(pair.First, survivalProbabilities);
}
}
// discount curves
IDictionary <Currency, CreditDiscountFactors> discountCurves = new Dictionary <Currency, CreditDiscountFactors>();
foreach (Currency currency in lookup.DiscountCurveIds.Keys)
{
CurveId curveId = lookup.DiscountCurveIds.get(currency);
if (marketData.containsValue(curveId))
{
Curve curve = marketData.getValue(curveId);
discountCurves[currency] = CreditDiscountFactors.of(currency, valuationDate, curve);
}
}
// recovery rate curves
IDictionary <StandardId, RecoveryRates> recoveryRateCurves = new Dictionary <StandardId, RecoveryRates>();
foreach (StandardId legalEntityId in lookup.RecoveryRateCurveIds.Keys)
{
CurveId curveId = lookup.RecoveryRateCurveIds.get(legalEntityId);
if (marketData.containsValue(curveId))
{
Curve curve = marketData.getValue(curveId);
RecoveryRates recoveryRate = RecoveryRates.of(legalEntityId, valuationDate, curve);
recoveryRateCurves[legalEntityId] = recoveryRate;
}
}
// build result
return(ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).creditCurves(creditCurves).discountCurves(discountCurves).recoveryRateCurves(recoveryRateCurves).build());
}
public CurrencyParameterSensitivity singleCreditCurveParameterSensitivity(PointSensitivities pointSensitivities, StandardId legalEntityId, Currency currency)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is CreditCurveZeroRateSensitivity)
{
CreditCurveZeroRateSensitivity pt = (CreditCurveZeroRateSensitivity)point;
if (pt.LegalEntityId.Equals(legalEntityId) && pt.Currency.Equals(currency))
{
LegalEntitySurvivalProbabilities factors = survivalProbabilities(pt.LegalEntityId, pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
}
}
ArgChecker.isTrue(sens.size() == 1, "sensitivity must be unique");
return(sens.Sensitivities.get(0));
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(PointSensitivities pointSensitivities)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is CreditCurveZeroRateSensitivity)
{
CreditCurveZeroRateSensitivity pt = (CreditCurveZeroRateSensitivity)point;
LegalEntitySurvivalProbabilities factors = survivalProbabilities(pt.LegalEntityId, pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
else if (point is ZeroRateSensitivity)
{
ZeroRateSensitivity pt = (ZeroRateSensitivity)point;
CreditDiscountFactors factors = discountFactors(pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
}
return(sens);
}
//-------------------------------------------------------------------------
/// <summary>
/// Creates credit rates provider with valuation date specified.
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <returns> the rates provider </returns>
public static ImmutableCreditRatesProvider createCreditRatesProvider(LocalDate valuationDate)
{
IsdaCreditDiscountFactors ycUsd = IsdaCreditDiscountFactors.of(USD, valuationDate, NODAL_YC_USD);
IsdaCreditDiscountFactors ycJpy = IsdaCreditDiscountFactors.of(JPY, valuationDate, NODAL_YC_JPY);
IsdaCreditDiscountFactors ccUs = IsdaCreditDiscountFactors.of(USD, valuationDate, NODAL_CC_US);
IsdaCreditDiscountFactors ccJp = IsdaCreditDiscountFactors.of(JPY, valuationDate, NODAL_CC_JP);
ConstantRecoveryRates rrUs = ConstantRecoveryRates.of(LEGAL_ENTITY_US, valuationDate, RECOVERY_RATE_US);
ConstantRecoveryRates rrJp = ConstantRecoveryRates.of(LEGAL_ENTITY_JP, valuationDate, RECOVERY_RATE_JP);
return(ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_US, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_US, ccUs), Pair.of(LEGAL_ENTITY_JP, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_JP, ccJp))).discountCurves(ImmutableMap.of(USD, ycUsd, JPY, ycJpy)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_US, rrUs, LEGAL_ENTITY_JP, rrJp)).build());
}
