public void test_of_single() { CurrencyParameterSensitivities test = CurrencyParameterSensitivities.of(ENTRY_USD); assertEquals(test.size(), 1); assertEquals(test.getSensitivities(), ImmutableList.of(ENTRY_USD)); }
public void test_getSensitivity() { CurrencyParameterSensitivities test = CurrencyParameterSensitivities.of(ENTRY_USD); assertEquals(test.getSensitivity(NAME1, USD), ENTRY_USD); assertThrowsIllegalArg(() -> test.getSensitivity(NAME1, EUR)); assertThrowsIllegalArg(() -> test.getSensitivity(NAME0, USD)); assertThrowsIllegalArg(() -> test.getSensitivity(NAME0, EUR)); }
public void pointToParameterMultiple() { CurrencyParameterSensitivities psComputed = PROVIDER.parameterSensitivity(POINT); assertEquals(psComputed.getSensitivities().size(), 6); CurrencyParameterSensitivities psExpected = CurrencyParameterSensitivities.empty(); for (int i = 0; i < POINTS.length; i++) { psExpected = psExpected.combinedWith(PROVIDER.parameterSensitivity(POINTS[i])); } assertTrue(psComputed.equalWithTolerance(psExpected, TOLERANCE_SENSI)); }
public void test_multipliedBy_vs_combinedWith() { CurrencyParameterSensitivities multiplied = SENSI_2.multipliedBy(2d); CurrencyParameterSensitivities added = SENSI_2.combinedWith(SENSI_2); assertEquals(multiplied, added); }
public void test_convertedTo_multipleCurrency_mergeWhenSameName() { CurrencyParameterSensitivities test = SENSI_1.combinedWith(ENTRY_USD2_IN_EUR).convertedTo(USD, FX_RATE); assertEquals(test.getSensitivities(), ImmutableList.of(ENTRY_USD_TOTAL)); }
public void test_withMarketDataNames() { CurrencyParameterSensitivity entry1 = CurrencyParameterSensitivity.of(NAME1, METADATA1B, USD, DoubleArray.of(0, 1, 2, 3)); CurrencyParameterSensitivities base = CurrencyParameterSensitivities.of(entry1); CurrencyParameterSensitivities test = base.withMarketDataNames(name -> NAME2); assertEquals(SENSI_1.getSensitivities().get(0).getMarketDataName(), NAME1); assertEquals(test.getSensitivities().get(0).getMarketDataName(), NAME2); }
@Override public Set<String> tokens(CurrencyParameterSensitivities sensitivities) { return sensitivities.getSensitivities().stream() .flatMap(this::tokensForSensitivity) .collect(toImmutableSet()); }
public void test_presentValueSensitivity_parity() { CurrencyParameterSensitivities pvSensiRecLong = RATE_PROVIDER.parameterSensitivity( PRICER.presentValueSensitivityRates(SWAPTION_REC_LONG, RATE_PROVIDER, HW_PROVIDER).build()); CurrencyParameterSensitivities pvSensiRecShort = RATE_PROVIDER.parameterSensitivity( PRICER.presentValueSensitivityRates(SWAPTION_REC_SHORT, RATE_PROVIDER, HW_PROVIDER).build()); CurrencyParameterSensitivities pvSensiPayLong = RATE_PROVIDER.parameterSensitivity( PRICER.presentValueSensitivityRates(SWAPTION_PAY_LONG, RATE_PROVIDER, HW_PROVIDER).build()); CurrencyParameterSensitivities pvSensiPayShort = RATE_PROVIDER.parameterSensitivity( PRICER.presentValueSensitivityRates(SWAPTION_PAY_SHORT, RATE_PROVIDER, HW_PROVIDER).build()); assertTrue(pvSensiRecLong.equalWithTolerance(pvSensiRecShort.multipliedBy(-1d), NOTIONAL * TOL)); assertTrue(pvSensiPayLong.equalWithTolerance(pvSensiPayShort.multipliedBy(-1d), NOTIONAL * TOL)); PointSensitivities expectedPoint = SWAP_PRICER.presentValueSensitivity(RSWAP_PAY, RATE_PROVIDER).build(); CurrencyParameterSensitivities expected = RATE_PROVIDER.parameterSensitivity(expectedPoint); assertTrue(expected.equalWithTolerance(pvSensiPayLong.combinedWith(pvSensiRecLong.multipliedBy(-1d)), NOTIONAL * TOL)); assertTrue(expected.equalWithTolerance(pvSensiRecShort.combinedWith(pvSensiPayShort.multipliedBy(-1d)), NOTIONAL * TOL)); }
public void test_empty() { CurrencyParameterSensitivities test = CurrencyParameterSensitivities.empty(); assertEquals(test.size(), 0); assertEquals(test.getSensitivities().size(), 0); }
public void test_mergedWith() { CurrencyParameterSensitivity entry1 = CurrencyParameterSensitivity.of(NAME1, METADATA1B, USD, VECTOR_USD1); CurrencyParameterSensitivity entry2 = CurrencyParameterSensitivity.of(NAME1, METADATA1B.subList(0, 2), USD, VECTOR_USD1.subArray(0, 2)); CurrencyParameterSensitivities base1 = CurrencyParameterSensitivities.of(entry1); CurrencyParameterSensitivities base2 = CurrencyParameterSensitivities.of(entry2); CurrencyParameterSensitivities test = base1.mergedWith(base2); assertEquals(test.getSensitivities().size(), 1); assertEquals(test.getSensitivities().get(0).getParameterMetadata(), METADATA1B); assertEquals(test.getSensitivities().get(0).getSensitivity(), DoubleArray.of(200, 400, 300, 123)); }
public void test_convertedTo_multipleCurrency() { CurrencyParameterSensitivities test = SENSI_2.convertedTo(USD, FX_RATE); assertEquals(test.getSensitivities(), ImmutableList.of(ENTRY_USD2, ENTRY_EUR_IN_USD)); }
public void test_presentValueSensitivityFromCleanPrice_early_exCoupon() { PointSensitivities point = PRICER.presentValueSensitivityFromCleanPrice( TRADE_EARLY, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE); CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point) .combinedWith(RATES_PROVIDER.parameterSensitivity(point)); CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATES_PROVIDER, p -> PRICER.presentValueFromCleanPrice(TRADE_EARLY, p, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE)) .combinedWith(FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p -> PRICER.presentValueFromCleanPrice(TRADE_EARLY, RATES_PROVIDER, p, REF_DATA, TRADE_PRICE))); assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS)); }
/** * Obtains an instance from an array of sensitivity entries. * <p> * The sensitivities are sorted using {@link CurrencyParameterSensitivity#compareKey}. * * @param sensitivities the sensitivities * @return the sensitivities instance */ public static CurrencyParameterSensitivities of(CurrencyParameterSensitivity... sensitivities) { return of(Arrays.asList(sensitivities)); }
public void pvCurveSensiRegression() { PointSensitivityBuilder point = PRICER.presentValueSensitivityRatesStickyStrike(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); CurrencyParameterSensitivities computed = RATE_PROVIDER.parameterSensitivity(point.build()); computed.getSensitivity(DSC_NAME, EUR).getSensitivity(); DoubleArray dscSensi = DoubleArray.of( 0.0, 0.0, 0.0, -7143525.908886078, -1749520.4110068753, -719115.4683096837); // 2.x DoubleArray fwdSensi = DoubleArray.of( 0d, 0d, 0d, 1.7943318714062232E8, -3.4987983718159467E8, -2.6516758066404995E8); // 2.x CurrencyParameterSensitivity dsc = DSC_CURVE.createParameterSensitivity(EUR, dscSensi); CurrencyParameterSensitivity fwd = FWD6_CURVE.createParameterSensitivity(EUR, fwdSensi); CurrencyParameterSensitivities expected = CurrencyParameterSensitivities.of(ImmutableList.of(dsc, fwd)); assertTrue(computed.equalWithTolerance(expected, NOTIONAL * TOL)); }
public void test_diagonal() { assertEquals(SENSI_2.diagonal().size(), 2); assertEquals(SENSI_2.diagonal().getSensitivity(NAME1, USD), ENTRY_USD2.diagonal()); assertEquals(SENSI_2.diagonal().getSensitivity(NAME2, EUR), ENTRY_EUR.diagonal()); assertEquals(SENSI_3.diagonal().getSensitivity(NAME1, USD), ENTRY_USD12.diagonal()); assertEquals(SENSI_3.diagonal().getSensitivity(NAME2, USD), ENTRY_USD21.diagonal()); }
public void test_sensitivity_LegalEntityDiscountingProvider() { CurrencyParameterSensitivities computed = CALC.sensitivity(PARAMETER_SENSITIVITIES, PROVIDER); assertEquals(computed.getSensitivities().size(), 4); DoubleArray expected11 = (DoubleArray) MATRIX_ALGEBRA.multiply(SENSI_1, DoubleMatrix.copyOf(MATRIX_11)); DoubleArray expected12 = (DoubleArray) MATRIX_ALGEBRA.multiply(SENSI_1, DoubleMatrix.copyOf(MATRIX_12)); DoubleArray expected21 = (DoubleArray) MATRIX_ALGEBRA.multiply(SENSI_2, DoubleMatrix.copyOf(MATRIX_21)); DoubleArray expected22 = (DoubleArray) MATRIX_ALGEBRA.multiply(SENSI_2, DoubleMatrix.copyOf(MATRIX_22)); assertTrue(computed.getSensitivity(CURVE_NAME_1, USD).getSensitivity().equalWithTolerance(expected11, TOL)); assertTrue(computed.getSensitivity(CURVE_NAME_1, GBP).getSensitivity().equalWithTolerance(expected21, TOL)); assertTrue(computed.getSensitivity(CURVE_NAME_2, USD).getSensitivity().equalWithTolerance(expected12, TOL)); assertTrue(computed.getSensitivity(CURVE_NAME_2, GBP).getSensitivity().equalWithTolerance(expected22, TOL)); }
@Override public CurrencyParameterSensitivities parameterSensitivity(PointSensitivities pointSensitivities) { CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty(); for (PointSensitivity point : pointSensitivities.getSensitivities()) { if (point instanceof FxOptionSensitivity) { FxOptionSensitivity pt = (FxOptionSensitivity) point; if (pt.getVolatilitiesName().equals(getName())) { sens = sens.combinedWith(parameterSensitivity(pt)); } } } return sens; }
public void test_multipliedBy() { CurrencyParameterSensitivities multiplied = SENSI_1.multipliedBy(FACTOR1); DoubleArray test = multiplied.getSensitivities().get(0).getSensitivity(); for (int i = 0; i < VECTOR_USD1.size(); i++) { assertEquals(test.get(i), VECTOR_USD1.get(i) * FACTOR1); } }
@Test public void sensitivity_single_curve() { CurrencyParameterSensitivities sensiComputed = FD_CALCULATOR.sensitivity(RatesProviderDataSets.SINGLE_USD, this::fn); DoubleArray times = RatesProviderDataSets.TIMES_1; assertEquals(sensiComputed.size(), 1); DoubleArray s = sensiComputed.getSensitivities().get(0).getSensitivity(); assertEquals(s.size(), times.size()); for (int i = 0; i < times.size(); i++) { assertEquals(s.get(i), times.get(i) * 4.0d, TOLERANCE_DELTA); } }