static DiscountingKnownAmountPaymentPeriodPricerTest() { DoubleArray time_gbp = DoubleArray.of(0.0, 0.5, 1.0, 2.0, 3.0, 4.0, 5.0, 10.0); DoubleArray rate_gbp = DoubleArray.of(0.0160, 0.0135, 0.0160, 0.0185, 0.0185, 0.0195, 0.0200, 0.0210); DISCOUNT_CURVE_GBP = InterpolatedNodalCurve.of(Curves.zeroRates("GBP-Discount", ACT_ACT_ISDA), time_gbp, rate_gbp, INTERPOLATOR); }
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]); } }
// It's not possible to do an equality test on the curves because shifting them wraps them in a different type private void checkCurveValues(Curve curve, double expectedValue) { for (int i = 0; i < 10; i++) { assertThat(curve.yValue((double)i)).isEqualTo(expectedValue); } }
//------------------------------------------------------------------------- private static CurrencyParameterSensitivity buildSensitivities(Curve bumpedCurve, ImmutableRatesProvider ratesProvider) { //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: RatesProvider bumpedRatesProvider = ratesProvider.toBuilder().discountCurves(ratesProvider.DiscountCurves.Keys.collect(toImmutableMap(System.Func.identity(), k => bumpedCurve))).indexCurves(ratesProvider.IndexCurves.Keys.collect(toImmutableMap(System.Func.identity(), k => bumpedCurve))).build(); PointSensitivities pointSensitivities = PRICER_SWAP.presentValueSensitivity(SWAP, bumpedRatesProvider).build(); CurrencyParameterSensitivities paramSensitivities = bumpedRatesProvider.parameterSensitivity(pointSensitivities); return(Iterables.getOnlyElement(paramSensitivities.Sensitivities)); }
static DiscountingTermDepositTradePricerTest() { CurveInterpolator interp = CurveInterpolators.DOUBLE_QUADRATIC; DoubleArray time_eur = DoubleArray.of(0.0, 0.5, 1.0, 2.0, 3.0, 4.0, 5.0, 10.0); DoubleArray rate_eur = DoubleArray.of(0.0160, 0.0135, 0.0160, 0.0185, 0.0185, 0.0195, 0.0200, 0.0210); CURVE = InterpolatedNodalCurve.of(Curves.zeroRates("EUR-Discount", ACT_360), time_eur, rate_eur, interp); IMM_PROV = ImmutableRatesProvider.builder(VAL_DATE).discountCurve(EUR, CURVE).build(); }
//------------------------------------------------------------------------- // 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_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)); }
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 semiParallelGammaValue() { ImmutableRatesProvider provider = SINGLE; Currency curveCurrency = SINGLE_CURRENCY; DoubleArray y = USD_SINGLE_CURVE.YValues; int nbNode = y.size(); DoubleArray gammaExpected = DoubleArray.of(nbNode, i => { //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[][][] yBumped = new double[2][2][nbNode]; double[][][] yBumped = RectangularArrays.ReturnRectangularDoubleArray(2, 2, nbNode); //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[][] pv = new double[2][2]; double[][] pv = RectangularArrays.ReturnRectangularDoubleArray(2, 2); for (int pmi = 0; pmi < 2; pmi++) { for (int pmP = 0; pmP < 2; pmP++) { yBumped[pmi][pmP] = y.toArray(); yBumped[pmi][pmP][i] += (pmi == 0 ? 1.0 : -1.0) * FD_SHIFT; for (int j = 0; j < nbNode; j++) { yBumped[pmi][pmP][j] += (pmP == 0 ? 1.0 : -1.0) * FD_SHIFT; } Curve curveBumped = USD_SINGLE_CURVE.withYValues(DoubleArray.copyOf(yBumped[pmi][pmP])); ImmutableRatesProvider providerBumped = provider.toBuilder().discountCurves(provider.DiscountCurves.Keys.collect(toImmutableMap(Function.identity(), k => curveBumped))).indexCurves(provider.IndexCurves.Keys.collect(toImmutableMap(Function.identity(), k => curveBumped))).build(); pv[pmi][pmP] = PRICER_SWAP.presentValue(SWAP, providerBumped).getAmount(USD).Amount; } } return((pv[1][1] - pv[1][0] - pv[0][1] + pv[0][0]) / (4 * FD_SHIFT * FD_SHIFT)); }); CurrencyParameterSensitivity sensitivityComputed = GAMMA_CAL.calculateSemiParallelGamma(USD_SINGLE_CURVE, curveCurrency, c => buildSensitivities(c, provider)); assertEquals(sensitivityComputed.MarketDataName, USD_SINGLE_CURVE.Name); DoubleArray gammaComputed = sensitivityComputed.Sensitivity; assertTrue(gammaComputed.equalWithTolerance(gammaExpected, TOLERANCE_GAMMA)); }
// Checks that different finite difference types and shifts give similar results. public virtual void semiParallelGammaCoherency() { ImmutableRatesProvider provider = SINGLE; Curve curve = Iterables.getOnlyElement(provider.DiscountCurves.values()); Currency curveCurrency = SINGLE_CURRENCY; double toleranceCoherency = 1.0E+5; CurveGammaCalculator calculatorForward5 = CurveGammaCalculator.ofForwardDifference(FD_SHIFT); CurveGammaCalculator calculatorBackward5 = CurveGammaCalculator.ofBackwardDifference(FD_SHIFT); CurveGammaCalculator calculatorCentral4 = CurveGammaCalculator.ofCentralDifference(1.0E-4); DoubleArray gammaCentral5 = GAMMA_CAL.calculateSemiParallelGamma(curve, curveCurrency, c => buildSensitivities(c, provider)).Sensitivity; DoubleArray gammaForward5 = calculatorForward5.calculateSemiParallelGamma(curve, curveCurrency, c => buildSensitivities(c, provider)).Sensitivity; assertTrue(gammaForward5.equalWithTolerance(gammaCentral5, toleranceCoherency)); DoubleArray gammaBackward5 = calculatorBackward5.calculateSemiParallelGamma(curve, curveCurrency, c => buildSensitivities(c, provider)).Sensitivity; assertTrue(gammaForward5.equalWithTolerance(gammaBackward5, toleranceCoherency)); DoubleArray gammaCentral4 = calculatorCentral4.calculateSemiParallelGamma(curve, curveCurrency, c => buildSensitivities(c, provider)).Sensitivity; assertTrue(gammaForward5.equalWithTolerance(gammaCentral4, toleranceCoherency)); }
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)); }