public void test_equalWithTolerance_date() { PointSensitivities test1 = PointSensitivities.of(Lists.newArrayList(CS3, CS1)).normalized(); PointSensitivities test2 = PointSensitivities.of(Lists.newArrayList(CS3, CS2)).normalized(); assertFalse(test1.equalWithTolerance(test2, 1.0E+1)); }
public void test_equalWithTolerance_length() { PointSensitivities test1 = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1)).normalized(); PointSensitivities test2 = PointSensitivities.of(Lists.newArrayList(CS3, CS2)).normalized(); assertFalse(test1.equalWithTolerance(test2, 1.0E+1)); }
public void test_equalWithTolerance_value() { PointSensitivities test1 = PointSensitivities.of(Lists.newArrayList(CS3, CS1)).normalized(); PointSensitivities test2 = PointSensitivities.of(Lists.newArrayList(CS3B, CS1)).normalized(); assertFalse(test1.equalWithTolerance(test2, 1.0E+1)); }
public void test_normalized_sorts() { PointSensitivities test = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1)); assertEquals(test.normalized().getSensitivities(), ImmutableList.of(CS1, CS2, CS3)); }
public void test_normalized_empty() { assertEquals(PointSensitivities.empty().normalized(), PointSensitivities.empty()); }
public void test_equalWithTolerance_true() { PointSensitivity cs1b = DummyPointSensitivity.of(GBP, date(2015, 6, 30), 12.1d); PointSensitivities test1 = PointSensitivities.of(Lists.newArrayList(CS3, CS1)).normalized(); PointSensitivities test2 = PointSensitivities.of(Lists.newArrayList(CS3, cs1b)).normalized(); assertTrue(test1.equalWithTolerance(test2, 1.0E-1)); }
public void test_convertedTo_singleCurrency() { double rate = 1.5d; FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate); PointSensitivities base = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1)); PointSensitivities test1 = base.convertedTo(USD, matrix); PointSensitivity c1Conv = CS1.convertedTo(USD, matrix); PointSensitivity c2Conv = CS2.convertedTo(USD, matrix); PointSensitivity c3Conv = CS3.convertedTo(USD, matrix); PointSensitivities expected = PointSensitivities.of(Lists.newArrayList(c3Conv, c2Conv, c1Conv)); assertEquals(test1.normalized(), expected.normalized()); PointSensitivities test2 = base.convertedTo(GBP, matrix); assertEquals(test2.normalized(), base.normalized()); }
public void test_normalized_merges() { PointSensitivities test = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1, CS3B)); assertEquals(test.normalized().getSensitivities(), ImmutableList.of(CS1, CS2, CS3.withSensitivity(35d))); }
public void test_presentValueCurveSensitivityVsForex() { PointSensitivities pvcsNDF = PRICER.presentValueSensitivity(NDF, PROVIDER).normalized(); CurrencyParameterSensitivities sensiNDF = PROVIDER.parameterSensitivity(pvcsNDF); PointSensitivities pvcsFX = PRICER_FX.presentValueSensitivity(FOREX, PROVIDER).normalized(); CurrencyParameterSensitivities sensiFX = PROVIDER.parameterSensitivity(pvcsFX); assertTrue(sensiNDF.equalWithTolerance(sensiFX.convertedTo(USD, PROVIDER), NOMINAL_USD * TOL)); }
public void test_convertedTo_multipleCurrency() { double rate = 1.5d; FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate); PointSensitivities base = PointSensitivities.of(Lists.newArrayList(CS4, CS3, CS1)); PointSensitivities test1 = base.convertedTo(USD, matrix); PointSensitivity c1Conv = CS1.convertedTo(USD, matrix); PointSensitivity c3Conv = CS3.convertedTo(USD, matrix); PointSensitivity c3c4Usd = c3Conv.withSensitivity(c3Conv.getSensitivity() + CS4.getSensitivity()); PointSensitivities expected1 = PointSensitivities.of(Lists.newArrayList(c3c4Usd, c1Conv)); assertEquals(test1.normalized(), expected1.normalized()); PointSensitivities test2 = base.convertedTo(GBP, matrix); PointSensitivity c4Conv = CS4.convertedTo(GBP, matrix); PointSensitivity c3c4GBP = CS3.withSensitivity(CS3.getSensitivity() + c4Conv.getSensitivity()); PointSensitivities expected2 = PointSensitivities.of(Lists.newArrayList(c3c4GBP, CS1)); assertEquals(test2.normalized(), expected2.normalized()); }
/** Test for the case where publication lag=0, effective offset=0 (GBP conventions) and no cutoff period. * The arithmetic average coupons are used mainly in USD. This test is more for completeness than a real case. */ public void rateGbpNoCutOffSensitivity() { OvernightIndexRates mockRates = mock(OvernightIndexRates.class); when(mockRates.getIndex()).thenReturn(GBP_SONIA); SimpleRatesProvider simpleProv = new SimpleRatesProvider(mockRates); for (int i = 0; i < GBP_OBS.length; i++) { when(mockRates.rate(GBP_OBS[i])).thenReturn(FIXING_RATES[i]); OvernightRateSensitivity sensitivity = OvernightRateSensitivity.of(GBP_OBS[i], GBP_SONIA.getCurrency(), 1d); when(mockRates.ratePointSensitivity(GBP_OBS[i])).thenReturn(sensitivity); } OvernightAveragedRateComputation ro = OvernightAveragedRateComputation.of(GBP_SONIA, START_DATE, END_DATE, 0, REF_DATA); ForwardOvernightAveragedRateComputationFn obsFn = ForwardOvernightAveragedRateComputationFn.DEFAULT; PointSensitivityBuilder sensitivityBuilderComputed = obsFn.rateSensitivity(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, simpleProv); PointSensitivities sensitivityComputed = sensitivityBuilderComputed.build().normalized(); Double[] sensitivityExpected = computedSensitivityFD(ro, GBP_SONIA, GBP_OBS); assertEquals(sensitivityComputed.getSensitivities().size(), sensitivityExpected.length); for (int i = 0; i < sensitivityExpected.length; ++i) { assertEquals(sensitivityComputed.getSensitivities().get(i).getSensitivity(), sensitivityExpected[i], EPS_FD); } }
public void test_rateSensitivity() { ImmutableRatesProvider prov = createProvider(RATE_END); ImmutableRatesProvider provEndUp = createProvider(RATE_END + EPS_FD); ImmutableRatesProvider provEndDw = createProvider(RATE_END - EPS_FD); InflationEndMonthRateComputation ro = InflationEndMonthRateComputation.of(GB_RPIX, START_INDEX_VALUE, REFERENCE_END_MONTH); ForwardInflationEndMonthRateComputationFn obsFn = ForwardInflationEndMonthRateComputationFn.DEFAULT; double rateEndUp = obsFn.rate(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, provEndUp); double rateEndDw = obsFn.rate(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, provEndDw); PointSensitivityBuilder sensiExpected = InflationRateSensitivity.of( PriceIndexObservation.of(GB_RPIX, REFERENCE_END_MONTH), 0.5 * (rateEndUp - rateEndDw) / EPS_FD); PointSensitivityBuilder sensiComputed = obsFn.rateSensitivity(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, prov); assertTrue(sensiComputed.build().normalized().equalWithTolerance(sensiExpected.build().normalized(), EPS_FD)); }
public void test_forecastValueSensitivity_inflation() { DiscountingSwapLegPricer pricerLeg = DiscountingSwapLegPricer.DEFAULT; DiscountingSwapProductPricer pricerSwap = new DiscountingSwapProductPricer(pricerLeg); ImmutableRatesProvider prov = ImmutableRatesProvider.builder(VAL_DATE_INFLATION) .discountCurves(RATES_GBP_INFLATION.getDiscountCurves()) .priceIndexCurve(GB_RPI, PRICE_CURVE) .timeSeries(GB_RPI, TS_INFLATION) .build(); PointSensitivityBuilder fvSensiComputed = pricerSwap.forecastValueSensitivity(SWAP_INFLATION, prov); PointSensitivityBuilder fvSensiInflationLeg = pricerLeg.forecastValueSensitivity(INFLATION_MONTHLY_SWAP_LEG_REC_GBP, prov); PointSensitivityBuilder fvSensiFixedLeg = pricerLeg.forecastValueSensitivity(INFLATION_FIXED_SWAP_LEG_PAY_GBP, prov); PointSensitivityBuilder fvSensiExpected = fvSensiFixedLeg.combinedWith(fvSensiInflationLeg); assertTrue(fvSensiComputed.build().normalized() .equalWithTolerance(fvSensiExpected.build().normalized(), TOLERANCE_RATE * NOTIONAL)); }
public void test_presentValueSensitivity_inflation() { DiscountingSwapLegPricer pricerLeg = DiscountingSwapLegPricer.DEFAULT; DiscountingSwapProductPricer pricerSwap = new DiscountingSwapProductPricer(pricerLeg); ImmutableRatesProvider prov = ImmutableRatesProvider.builder(VAL_DATE_INFLATION) .discountCurves(RATES_GBP_INFLATION.getDiscountCurves()) .priceIndexCurve(GB_RPI, PRICE_CURVE) .timeSeries(GB_RPI, TS_INFLATION) .build(); PointSensitivityBuilder pvSensiComputed = pricerSwap.presentValueSensitivity(SWAP_INFLATION, prov); PointSensitivityBuilder pvSensiInflationLeg = pricerLeg.presentValueSensitivity(INFLATION_MONTHLY_SWAP_LEG_REC_GBP, prov); PointSensitivityBuilder pvSensiFixedLeg = pricerLeg.presentValueSensitivity(INFLATION_FIXED_SWAP_LEG_PAY_GBP, prov); PointSensitivityBuilder pvSensiExpected = pvSensiFixedLeg.combinedWith(pvSensiInflationLeg); assertTrue(pvSensiComputed.build().normalized() .equalWithTolerance(pvSensiExpected.build().normalized(), TOLERANCE_RATE * NOTIONAL)); }
public void test_marginIndexSensitivity() { double notional = FUTURE.getNotional(); double accrualFactor = FUTURE.getAccrualFactor(); PointSensitivities sensiExpected = PointSensitivities.of( IborRateSensitivity.of(FUTURE.getIborRate().getObservation(), -notional * accrualFactor)); PointSensitivities priceSensitivity = PRICER.priceSensitivity(FUTURE, new MockRatesProvider()); PointSensitivities sensiComputed = PRICER.marginIndexSensitivity(FUTURE, priceSensitivity).normalized(); assertTrue(sensiComputed.equalWithTolerance(sensiExpected, 1e-5)); }
public void test_forecastValueSensitivity_compoundNone_fx() { DiscountingRatePaymentPeriodPricer pricer = DiscountingRatePaymentPeriodPricer.DEFAULT; ImmutableRatesProvider provider = MULTI_GBP_USD; PointSensitivityBuilder pointSensiComputedUSD = pricer.forecastValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_USD, provider); CurrencyParameterSensitivities sensiComputedUSD = provider.parameterSensitivity(pointSensiComputedUSD.build().normalized()); CurrencyParameterSensitivities sensiExpectedUSD = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(USD, pricer.forecastValue(PAYMENT_PERIOD_FULL_GS_FX_USD, (p)))); assertTrue(sensiComputedUSD.equalWithTolerance( sensiExpectedUSD, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_USD.getNotional())); PointSensitivityBuilder pointSensiComputedGBP = pricer.forecastValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_GBP, provider); CurrencyParameterSensitivities sensiComputedGBP = provider.parameterSensitivity(pointSensiComputedGBP.build().normalized()); CurrencyParameterSensitivities sensiExpectedGBP = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(GBP, pricer.forecastValue(PAYMENT_PERIOD_FULL_GS_FX_GBP, (p)))); assertTrue(sensiComputedGBP.equalWithTolerance( sensiExpectedGBP, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_GBP.getNotional())); }
public void test_presentValueSensitivity_compoundNone_fx_dfCurve() { DiscountingRatePaymentPeriodPricer pricer = DiscountingRatePaymentPeriodPricer.DEFAULT; ImmutableRatesProvider provider = MULTI_GBP_USD_SIMPLE; PointSensitivityBuilder pointSensiComputedUSD = pricer.presentValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_USD, provider); CurrencyParameterSensitivities sensiComputedUSD = provider.parameterSensitivity(pointSensiComputedUSD.build().normalized()); CurrencyParameterSensitivities sensiExpectedUSD = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(USD, pricer.presentValue(PAYMENT_PERIOD_FULL_GS_FX_USD, (p)))); assertTrue(sensiComputedUSD.equalWithTolerance( sensiExpectedUSD, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_USD.getNotional())); PointSensitivityBuilder pointSensiComputedGBP = pricer.presentValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_GBP, provider); CurrencyParameterSensitivities sensiComputedGBP = provider.parameterSensitivity(pointSensiComputedGBP.build().normalized()); CurrencyParameterSensitivities sensiExpectedGBP = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(GBP, pricer.presentValue(PAYMENT_PERIOD_FULL_GS_FX_GBP, (p)))); assertTrue(sensiComputedGBP.equalWithTolerance( sensiExpectedGBP, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_GBP.getNotional())); }
public void test_presentValueSensitivity_compoundNone_fx() { DiscountingRatePaymentPeriodPricer pricer = DiscountingRatePaymentPeriodPricer.DEFAULT; ImmutableRatesProvider provider = MULTI_GBP_USD; PointSensitivityBuilder pointSensiComputedUSD = pricer.presentValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_USD, provider); CurrencyParameterSensitivities sensiComputedUSD = provider.parameterSensitivity(pointSensiComputedUSD.build().normalized()); CurrencyParameterSensitivities sensiExpectedUSD = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(USD, pricer.presentValue(PAYMENT_PERIOD_FULL_GS_FX_USD, (p)))); assertTrue(sensiComputedUSD.equalWithTolerance( sensiExpectedUSD, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_USD.getNotional())); PointSensitivityBuilder pointSensiComputedGBP = pricer.presentValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_GBP, provider); CurrencyParameterSensitivities sensiComputedGBP = provider.parameterSensitivity(pointSensiComputedGBP.build().normalized()); CurrencyParameterSensitivities sensiExpectedGBP = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(GBP, pricer.presentValue(PAYMENT_PERIOD_FULL_GS_FX_GBP, (p)))); assertTrue(sensiComputedGBP.equalWithTolerance( sensiExpectedGBP, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_GBP.getNotional())); }
public void test_forecastValueSensitivity_compoundNone_fx_dfCurve() { DiscountingRatePaymentPeriodPricer pricer = DiscountingRatePaymentPeriodPricer.DEFAULT; ImmutableRatesProvider provider = MULTI_GBP_USD_SIMPLE; PointSensitivityBuilder pointSensiComputedUSD = pricer.forecastValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_USD, provider); CurrencyParameterSensitivities sensiComputedUSD = provider.parameterSensitivity(pointSensiComputedUSD.build().normalized()); CurrencyParameterSensitivities sensiExpectedUSD = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(USD, pricer.forecastValue(PAYMENT_PERIOD_FULL_GS_FX_USD, (p)))); assertTrue(sensiComputedUSD.equalWithTolerance( sensiExpectedUSD, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_USD.getNotional())); PointSensitivityBuilder pointSensiComputedGBP = pricer.forecastValueSensitivity(PAYMENT_PERIOD_FULL_GS_FX_GBP, provider); CurrencyParameterSensitivities sensiComputedGBP = provider.parameterSensitivity(pointSensiComputedGBP.build().normalized()); CurrencyParameterSensitivities sensiExpectedGBP = CAL_FD.sensitivity( provider, (p) -> CurrencyAmount.of(GBP, pricer.forecastValue(PAYMENT_PERIOD_FULL_GS_FX_GBP, (p)))); assertTrue(sensiComputedGBP.equalWithTolerance( sensiExpectedGBP, EPS_FD * PAYMENT_PERIOD_FULL_GS_FX_GBP.getNotional())); }
public void test_rateSensitivity() { ImmutableRatesProvider prov = createProvider(RATE_END, RATE_END_INTERP); ImmutableRatesProvider provEndUp = createProvider(RATE_END + EPS_FD, RATE_END_INTERP); ImmutableRatesProvider provEndDw = createProvider(RATE_END - EPS_FD, RATE_END_INTERP); ImmutableRatesProvider provEndIntUp = createProvider(RATE_END, RATE_END_INTERP + EPS_FD); ImmutableRatesProvider provEndIntDw = createProvider(RATE_END, RATE_END_INTERP - EPS_FD); InflationEndInterpolatedRateComputation ro = InflationEndInterpolatedRateComputation.of(GB_RPIX, START_INDEX_VALUE, REF_END_MONTH, WEIGHT); ForwardInflationEndInterpolatedRateComputationFn obsFn = ForwardInflationEndInterpolatedRateComputationFn.DEFAULT; double rateEndUp = obsFn.rate(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, provEndUp); double rateEndDw = obsFn.rate(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, provEndDw); double rateEndIntUp = obsFn.rate(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, provEndIntUp); double rateEndIntDw = obsFn.rate(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, provEndIntDw); PointSensitivityBuilder sensEnd = InflationRateSensitivity.of( PriceIndexObservation.of(GB_RPIX, REF_END_MONTH), 0.5 * (rateEndUp - rateEndDw) / EPS_FD); PointSensitivityBuilder sensEndInt = InflationRateSensitivity.of( PriceIndexObservation.of(GB_RPIX, REF_END_MONTH_INTERP), 0.5 * (rateEndIntUp - rateEndIntDw) / EPS_FD); PointSensitivityBuilder sensiExpected = sensEnd.combinedWith(sensEndInt); PointSensitivityBuilder sensiComputed = obsFn.rateSensitivity(ro, DUMMY_ACCRUAL_START_DATE, DUMMY_ACCRUAL_END_DATE, prov); assertTrue(sensiComputed.build().normalized().equalWithTolerance(sensiExpected.build().normalized(), EPS_FD)); }