public virtual void negativeRates()
{
double shift = 0.05;
Curve surface = ConstantCurve.of("shfit", shift);
SabrParameters @params = SabrParameters.of(ALPHA_CURVE, BETA_CURVE, RHO_CURVE, NU_CURVE, surface, FORMULA);
double expiry = 2.0;
assertEquals(@params.alpha(expiry), ALPHA_CURVE.yValue(expiry));
assertEquals(@params.beta(expiry), BETA_CURVE.yValue(expiry));
assertEquals(@params.rho(expiry), RHO_CURVE.yValue(expiry));
assertEquals(@params.nu(expiry), NU_CURVE.yValue(expiry));
double strike = -0.02;
double forward = 0.015;
double alpha = ALPHA_CURVE.yValue(expiry);
double beta = BETA_CURVE.yValue(expiry);
double rho = RHO_CURVE.yValue(expiry);
double nu = NU_CURVE.yValue(expiry);
assertEquals(@params.volatility(expiry, strike, forward), FORMULA.volatility(forward + shift, strike + shift, expiry, alpha, beta, rho, nu));
double[] adjCmp = @params.volatilityAdjoint(expiry, strike, forward).Derivatives.toArray();
double[] adjExp = FORMULA.volatilityAdjoint(forward + shift, strike + shift, expiry, alpha, beta, rho, nu).Derivatives.toArray();
for (int i = 0; i < 4; ++i)
{
assertEquals(adjCmp[i], adjExp[i]);
}
}
//-------------------------------------------------------------------------
// creates a simple provider
private SimpleRatesProvider createProvider(LocalDate valDate)
{
Curve curve = ConstantCurve.of(Curves.discountFactors("Test", DAY_COUNT), DISCOUNT_FACTOR);
DiscountFactors df = SimpleDiscountFactors.of(GBP, valDate, curve);
SimpleRatesProvider prov = new SimpleRatesProvider(valDate);
prov.DayCount = DAY_COUNT;
prov.DiscountFactors = df;
return(prov);
}
public virtual void test_of_interface()
{
ConstantCurve curve = ConstantCurve.of(DefaultCurveMetadata.builder().yValueType(ValueType.RECOVERY_RATE).curveName("recoveryRate").build(), RECOVERY_RATE);
ConstantRecoveryRates test = (ConstantRecoveryRates)RecoveryRates.of(LEGAL_ENTITY, VALUATION, curve);
assertEquals(test.LegalEntityId, LEGAL_ENTITY);
assertEquals(test.RecoveryRate, RECOVERY_RATE);
assertEquals(test.ValuationDate, VALUATION);
assertEquals(test.recoveryRate(DATE_AFTER), RECOVERY_RATE);
assertEquals(test.findData(CurveName.of("Rubbish")), null);
assertEquals(test.getParameter(0), RECOVERY_RATE);
assertEquals(test.ParameterCount, 1);
assertEquals(test.getParameterMetadata(0), ParameterMetadata.empty());
assertEquals(test.withParameter(0, 0.5), ConstantRecoveryRates.of(LEGAL_ENTITY, VALUATION, 0.5));
}
public virtual void test_ofFixedBeta_shift()
{
SabrIborCapletFloorletVolatilityBootstrapDefinition test = SabrIborCapletFloorletVolatilityBootstrapDefinition.ofFixedBeta(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, 0.5, 0.01, LINEAR, FLAT, FLAT, SabrVolatilityFormula.hagan());
assertEquals(test.DayCount, ACT_ACT_ISDA);
assertEquals(test.Index, USD_LIBOR_3M);
assertEquals(test.Interpolator, LINEAR);
assertEquals(test.ExtrapolatorLeft, FLAT);
assertEquals(test.ExtrapolatorRight, FLAT);
assertEquals(test.Name, NAME);
assertEquals(test.BetaCurve.get(), ConstantCurve.of(Curves.sabrParameterByExpiry(NAME.Name + "-Beta", ACT_ACT_ISDA, SABR_BETA), 0.5));
assertFalse(test.RhoCurve.Present);
assertEquals(test.SabrVolatilityFormula, SabrVolatilityFormula.hagan());
assertEquals(test.ShiftCurve, ConstantCurve.of("Shift curve", 0.01));
}
public virtual void test_builder()
{
Curve betaCurve = ConstantCurve.of(Curves.sabrParameterByExpiry(NAME.Name + "-Beta", ACT_ACT_ISDA, SABR_BETA), 0.65);
SabrIborCapletFloorletVolatilityBootstrapDefinition test = SabrIborCapletFloorletVolatilityBootstrapDefinition.builder().index(USD_LIBOR_3M).name(NAME).interpolator(LINEAR).extrapolatorLeft(FLAT).extrapolatorRight(CurveExtrapolators.LINEAR).dayCount(ACT_ACT_ISDA).sabrVolatilityFormula(SabrVolatilityFormula.hagan()).betaCurve(betaCurve).build();
assertEquals(test.DayCount, ACT_ACT_ISDA);
assertEquals(test.Index, USD_LIBOR_3M);
assertEquals(test.Interpolator, LINEAR);
assertEquals(test.ExtrapolatorLeft, FLAT);
assertEquals(test.ExtrapolatorRight, CurveExtrapolators.LINEAR);
assertEquals(test.Name, NAME);
assertEquals(test.BetaCurve.get(), betaCurve);
assertFalse(test.RhoCurve.Present);
assertEquals(test.SabrVolatilityFormula, SabrVolatilityFormula.hagan());
assertEquals(test.ShiftCurve, ConstantCurve.of("Zero shift", 0d));
}
static CreditDataSet()
{
ImmutableList.Builder <StandardId> builder = ImmutableList.builder();
for (int i = 0; i < 97; ++i)
{
builder.add(StandardId.of("OG", i.ToString()));
}
LEGAL_ENTITIES = builder.build();
double flatRate = 0.05;
double t = 20.0;
IsdaCreditDiscountFactors yieldCurve = IsdaCreditDiscountFactors.of(USD, VALUATION_DATE, CurveName.of("discount"), DoubleArray.of(t), DoubleArray.of(flatRate), ACT_365F);
DISCOUNT_CURVE = yieldCurve.Curve;
RecoveryRates recoveryRate = ConstantRecoveryRates.of(LEGAL_ENTITY, VALUATION_DATE, RECOVERY_RATE);
// create the curve nodes and input market quotes
ImmutableMarketDataBuilder marketQuoteBuilder = 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);
marketQuoteBuilder.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 marketQuotes = marketQuoteBuilder.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, recoveryRate)).discountCurves(ImmutableMap.of(USD, yieldCurve)).build();
IsdaCreditCurveDefinition definition = IsdaCreditCurveDefinition.of(CREDIT_CURVE_NAME, USD, VALUATION_DATE, ACT_365F, nodes, true, true);
// calibrate
LegalEntitySurvivalProbabilities calibrated = BUILDER.calibrate(definition, marketQuotes, rates, REF_DATA);
NodalCurve underlyingCurve = ((IsdaCreditDiscountFactors)calibrated.SurvivalProbabilities).Curve;
CDS_CREDIT_CURVE = underlyingCurve;
INDEX_CREDIT_CURVE = underlyingCurve.withMetadata(underlyingCurve.Metadata.withInfo(CurveInfoType.CDS_INDEX_FACTOR, INDEX_FACTOR).withParameterMetadata(CDS_INDEX_METADATA)); // replace parameter metadata
CDS_RECOVERY_RATE = ConstantCurve.of(Curves.recoveryRates("CDS recovery rate", ACT_365F), RECOVERY_RATE);
INDEX_RECOVERY_RATE = ConstantCurve.of(Curves.recoveryRates("Index recovery rate", ACT_365F), RECOVERY_RATE);
}
public virtual void test_multipleCurves()
{
Curve curve1 = ConstantCurve.of(CURVE_NAME1, (double)1);
Curve curve2 = ConstantCurve.of(CURVE_NAME2, (double)2);
CurveId curveId1 = CurveId.of(GROUP_NAME, CURVE_NAME1);
CurveId curveId2 = CurveId.of(GROUP_NAME, CURVE_NAME2);
RatesCurveGroupId groupId = RatesCurveGroupId.of(GROUP_NAME);
RatesCurveGroup curveGroup = RatesCurveGroup.of(GROUP_NAME, ImmutableMap.of(Currency.AUD, curve1, Currency.GBP, curve2), ImmutableMap.of());
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addValue(groupId, curveGroup).build();
MarketDataConfig config = MarketDataConfig.builder().add(GROUP_NAME, RatesCurveGroupDefinition.builder().name(GROUP_NAME).build()).build();
CurveMarketDataFunction test = new CurveMarketDataFunction();
MarketDataBox <Curve> result1 = test.build(curveId1, config, marketData, REF_DATA);
assertEquals(result1, MarketDataBox.ofSingleValue(curve1));
MarketDataBox <Curve> result2 = test.build(curveId2, config, marketData, REF_DATA);
assertEquals(result2, MarketDataBox.ofSingleValue(curve2));
}
public virtual void absoluteScenarios()
{
CurveName curveName = CurveName.of("curveName");
CurveGroupName curveGroupName = CurveGroupName.of("curveGroupName");
Curve curve = ConstantCurve.of(curveName, 2);
PerturbationMapping <Curve> mapping = PerturbationMapping.of(MarketDataFilter.ofName(curveName), CurveParallelShifts.absolute(0.1, 0.2, 0.3));
CurveId curveId = CurveId.of(curveGroupName, curveName);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(TestHelper.date(2011, 3, 8)).addValue(curveId, curve).build();
ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(mapping);
MarketDataFactory marketDataFactory = MarketDataFactory.of(mock(typeof(ObservableDataProvider)), mock(typeof(TimeSeriesProvider)));
MarketDataRequirements requirements = MarketDataRequirements.builder().addValues(curveId).build();
ScenarioMarketData scenarioData = marketDataFactory.createMultiScenario(requirements, MarketDataConfig.empty(), marketData, REF_DATA, scenarioDefinition);
MarketDataBox <Curve> curves = scenarioData.getValue(curveId);
assertThat(curves.ScenarioCount).isEqualTo(3);
checkCurveValues(curves.getValue(0), 2.1);
checkCurveValues(curves.getValue(1), 2.2);
checkCurveValues(curves.getValue(2), 2.3);
}
//-------------------------------------------------------------------------
public virtual void test_singleCurve()
{
Curve curve = ConstantCurve.of(CURVE_NAME1, (double)1);
CurveId curveId1 = CurveId.of(GROUP_NAME, CURVE_NAME1, OBS_SOURCE);
CurveId curveId2 = CurveId.of(GROUP_NAME, CURVE_NAME2, OBS_SOURCE);
CurveId curveId3 = CurveId.of(GROUP_NAME2, CURVE_NAME1, OBS_SOURCE);
RatesCurveGroupId groupId = RatesCurveGroupId.of(GROUP_NAME, OBS_SOURCE);
RatesCurveGroup curveGroup = RatesCurveGroup.of(GROUP_NAME, ImmutableMap.of(Currency.AUD, curve), ImmutableMap.of());
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addValue(groupId, curveGroup).build();
MarketDataConfig config = MarketDataConfig.builder().add(GROUP_NAME, RatesCurveGroupDefinition.builder().name(GROUP_NAME).build()).build();
CurveMarketDataFunction test = new CurveMarketDataFunction();
MarketDataRequirements reqs = test.requirements(curveId1, config);
assertEquals(reqs.NonObservables, ImmutableSet.of(groupId));
MarketDataBox <Curve> result = test.build(curveId1, config, marketData, REF_DATA);
assertEquals(result, MarketDataBox.ofSingleValue(curve));
assertThrowsIllegalArg(() => test.build(curveId2, config, marketData, REF_DATA));
assertThrowsIllegalArg(() => test.build(curveId3, config, marketData, REF_DATA));
}
public virtual void test_bondDiscountingProvider()
{
ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X);
ImmutableMap <LegalEntityId, RepoGroup> repoGroups = ImmutableMap.of(ISSUER_B, GROUP_REPO_X);
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1);
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M);
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3);
LegalEntityDiscountingMarketDataLookup test = LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, repoGroups, repoCurves, issuerGroups, issuerCurves);
LocalDate valDate = date(2015, 6, 30);
Curve repoCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_USD1.CurveName, ACT_360), 1d);
Curve issuerCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_USD3.CurveName, ACT_360), 2d);
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(CURVE_ID_USD1, repoCurve, CURVE_ID_USD3, issuerCurve));
LegalEntityDiscountingProvider provider = test.discountingProvider(md);
assertEquals(provider.ValuationDate, valDate);
assertEquals(provider.findData(CURVE_ID_USD1.CurveName), repoCurve);
assertEquals(provider.findData(CURVE_ID_USD3.CurveName), issuerCurve);
assertEquals(provider.findData(CurveName.of("Rubbish")), null);
// check repo
RepoCurveDiscountFactors rcdf = provider.repoCurveDiscountFactors(SEC_A1, ISSUER_A, USD);
SimpleDiscountFactors rdf = (SimpleDiscountFactors)rcdf.DiscountFactors;
assertEquals(rdf.Curve.Name, repoCurve.Name);
assertEquals(rcdf, provider.repoCurveDiscountFactors(SEC_B1, ISSUER_B, USD));
assertThrowsIllegalArg(() => provider.repoCurveDiscountFactors(SEC_A1, ISSUER_A, GBP));
assertThrowsIllegalArg(() => provider.repoCurveDiscountFactors(SEC_C1, ISSUER_C, USD));
// check issuer
IssuerCurveDiscountFactors icdf = provider.issuerCurveDiscountFactors(ISSUER_A, USD);
SimpleDiscountFactors idf = (SimpleDiscountFactors)icdf.DiscountFactors;
assertEquals(idf.Curve.Name, issuerCurve.Name);
assertThrowsIllegalArg(() => provider.issuerCurveDiscountFactors(ISSUER_A, GBP));
assertThrowsIllegalArg(() => provider.issuerCurveDiscountFactors(ISSUER_C, USD));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
SabrIborCapletFloorletVolatilityBootstrapDefinition test1 = SabrIborCapletFloorletVolatilityBootstrapDefinition.ofFixedBeta(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, 0.5, LINEAR, FLAT, FLAT, SabrVolatilityFormula.hagan());
coverImmutableBean(test1);
SabrIborCapletFloorletVolatilityBootstrapDefinition test2 = SabrIborCapletFloorletVolatilityBootstrapDefinition.builder().index(GBP_LIBOR_3M).name(IborCapletFloorletVolatilitiesName.of("other")).interpolator(STEP_UPPER).extrapolatorLeft(FLAT).extrapolatorRight(CurveExtrapolators.LINEAR).rhoCurve(ConstantCurve.of("rho", 0.1d)).shiftCurve(ConstantCurve.of("shift", 0.01d)).dayCount(ACT_365F).sabrVolatilityFormula(SabrVolatilityFormula.hagan()).build();
coverBeanEquals(test1, test2);
}
