/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(CurrencyParameterSensitivity beanToCopy) { this.marketDataName = beanToCopy.getMarketDataName(); this.parameterMetadata = beanToCopy.getParameterMetadata(); this.currency = beanToCopy.getCurrency(); this.sensitivity = beanToCopy.getSensitivity(); this.parameterSplit = beanToCopy.parameterSplit; }
public void test_combine() { CurrencyParameterSensitivity base1 = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1); CurrencyParameterSensitivity base2 = CurrencyParameterSensitivity.of(NAME2, METADATA_USD2, USD, VECTOR_USD2); CurrencyParameterSensitivity test = CurrencyParameterSensitivity.combine(NAME_COMBINED, base1, base2); assertEquals(test.getMarketDataName(), NAME_COMBINED); assertEquals(test.getParameterCount(), VECTOR_USD_COMBINED.size()); assertEquals(test.getParameterMetadata(), METADATA_COMBINED); assertEquals(test.getParameterMetadata(0), METADATA_COMBINED.get(0)); assertEquals(test.getSensitivity(), VECTOR_USD_COMBINED); assertEquals(test.getParameterSplit(), Optional.of(PARAM_SPLIT)); }
public void test_convertedTo() { CurrencyParameterSensitivity base = CurrencyParameterSensitivity.of(NAME1, METADATA_EUR1, EUR, VECTOR_EUR1); CurrencyParameterSensitivity test = base.convertedTo(USD, FX_RATE); assertEquals(test, CurrencyParameterSensitivity.of(NAME1, METADATA_EUR1, USD, VECTOR_EUR1_IN_USD)); }
@Override public DoubleArray apply(DoubleArray t) { Curve newCurve = replaceParameters(curve, t); ImmutableRatesProvider newRates = ratesProviderFn.apply(newCurve); CurrencyParameterSensitivities sensiMulti = sensitivitiesFn.apply(newRates); return sensiMulti.getSensitivity(baseDeltaSingle.getMarketDataName(), baseDeltaSingle.getCurrency()).getSensitivity(); } };
private static void insert(List<CurrencyParameterSensitivity> mutable, CurrencyParameterSensitivity addition) { int index = Collections.binarySearch( mutable, addition, CurrencyParameterSensitivity::compareKey); if (index >= 0) { CurrencyParameterSensitivity base = mutable.get(index); DoubleArray combined = base.getSensitivity().plus(addition.getSensitivity()); mutable.set(index, base.withSensitivity(combined)); } else { int insertionPoint = -(index + 1); mutable.add(insertionPoint, addition); } }
public void test_of_map() { ImmutableMap<ParameterMetadata, Double> map = ImmutableMap.of( TenorParameterMetadata.of(Tenor.TENOR_1Y), 12d, TenorParameterMetadata.of(Tenor.TENOR_2Y), -32d, TenorParameterMetadata.of(Tenor.TENOR_5Y), 5d); CurrencyParameterSensitivity test = CurrencyParameterSensitivity.of(NAME1, USD, map); assertEquals(test.getMarketDataName(), NAME1); assertEquals(test.getParameterCount(), 3); assertEquals(test.getParameterMetadata(), map.keySet().asList()); assertEquals(test.getCurrency(), USD); assertEquals(test.getSensitivity(), DoubleArray.copyOf(map.values())); assertEquals(test.sensitivities().toMap(), map); assertEquals(test.toSensitivityMap(Tenor.class), MapStream.of(map).mapKeys(pm -> pm.getIdentifier()).toMap()); }
public void test_withParameterMetadatas() { CurrencyParameterSensitivity entry1 = CurrencyParameterSensitivity.of(NAME1, METADATA1B, USD, DoubleArray.of(0, 1, 2, 3)); CurrencyParameterSensitivities base = CurrencyParameterSensitivities.of(entry1); CurrencyParameterSensitivities test = base.withParameterMetadatas(md -> TENOR_MD_1Y); assertEquals(test.getSensitivities().get(0).getParameterMetadata().size(), 1); assertEquals(test.getSensitivities().get(0).getParameterMetadata(0), TENOR_MD_1Y); assertEquals(test.getSensitivities().get(0).getSensitivity(), DoubleArray.of(6)); }
private String getSensitivityString( CurrencyParameterSensitivity sensitivity, DoubleFunction<String> formatFn, boolean pad) { StringBuilder sb = new StringBuilder(); List<ParameterMetadata> parameterMetadata = sensitivity.getParameterMetadata(); IntFunction<String> labelProvider = i -> Objects.toString(Strings.emptyToNull(parameterMetadata.get(i).getLabel()), String.valueOf(i + 1)); for (int i = 0; i < sensitivity.getSensitivity().size(); i++) { String formattedSensitivity = formatFn.apply(sensitivity.getSensitivity().get(i)); String field = labelProvider.apply(i) + " = " + formattedSensitivity; if (pad) { field = Strings.padEnd(field, PADDED_FIELD_WIDTH, ' '); } sb.append(field); if (i < sensitivity.getSensitivity().size() - 1) { sb.append(" | "); } } return sb.toString(); }
@Override public Set<String> tokens(CurrencyParameterSensitivity sensitivity) { return ImmutableSet.of( sensitivity.getCurrency().getCode().toLowerCase(Locale.ENGLISH), sensitivity.getMarketDataName().getName().toLowerCase(Locale.ENGLISH)); }
@Override public DoubleArray apply(DoubleArray t) { Curve newCurve = replaceParameters(curve, t); ImmutableRatesProvider newRates = ratesProviderFn.apply(newCurve); CurrencyParameterSensitivities sensiMulti = sensitivitiesFn.apply(newRates); return sensiMulti.getSensitivity(newCurve.getName(), sensitivityCurrency).getSensitivity(); } };
CrossGammaParameterSensitivity computeGammaForCurve( CurrencyParameterSensitivity baseDeltaSingle, Curve curve, Function<Curve, ImmutableRatesProvider> ratesProviderFn, Function<ImmutableRatesProvider, CurrencyParameterSensitivities> sensitivitiesFn) { Function<DoubleArray, DoubleArray> function = new Function<DoubleArray, DoubleArray>() { @Override public DoubleArray apply(DoubleArray t) { Curve newCurve = replaceParameters(curve, t); ImmutableRatesProvider newRates = ratesProviderFn.apply(newCurve); CurrencyParameterSensitivities sensiMulti = sensitivitiesFn.apply(newRates); return sensiMulti.getSensitivity(baseDeltaSingle.getMarketDataName(), baseDeltaSingle.getCurrency()).getSensitivity(); } }; int nParams = curve.getParameterCount(); DoubleMatrix sensi = fd.differentiate(function).apply(DoubleArray.of(nParams, n -> curve.getParameter(n))); List<ParameterMetadata> metadata = IntStream.range(0, nParams) .mapToObj(i -> curve.getParameterMetadata(i)) .collect(toImmutableList()); return CrossGammaParameterSensitivity.of( baseDeltaSingle.getMarketDataName(), baseDeltaSingle.getParameterMetadata(), curve.getName(), metadata, baseDeltaSingle.getCurrency(), sensi); }
/** * Adds a sensitivity to the builder. * <p> * Values with the same market data name and currency will be merged. * * @param sensToAdd the sensitivity to add * @return this, for chaining */ public CurrencyParameterSensitivitiesBuilder add(CurrencyParameterSensitivity sensToAdd) { sensToAdd.sensitivities() .forEach((md, value) -> add(sensToAdd.getMarketDataName(), sensToAdd.getCurrency(), md, value)); return this; }
public void coverage() { CurrencyParameterSensitivity test = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1); coverImmutableBean(test); CurrencyParameterSensitivity test2 = CurrencyParameterSensitivity.of(NAME2, METADATA_EUR1, EUR, VECTOR_EUR1); coverBeanEquals(test, test2); }
private void testSurfaceParameterSensitivities( CurrencyParameterSensitivities computed, CurrencyParameterSensitivities expected, double tol) { List<CurrencyParameterSensitivity> listComputed = new ArrayList<>(computed.getSensitivities()); List<CurrencyParameterSensitivity> listExpected = new ArrayList<>(expected.getSensitivities()); for (CurrencyParameterSensitivity sensExpected : listExpected) { int index = Math.abs(Collections.binarySearch(listComputed, sensExpected, CurrencyParameterSensitivity::compareKey)); CurrencyParameterSensitivity sensComputed = listComputed.get(index); int nSens = sensExpected.getParameterCount(); assertEquals(sensComputed.getParameterCount(), nSens); for (int i = 0; i < nSens; ++i) { assertEquals(sensComputed.getSensitivity().get(i), sensExpected.getSensitivity().get(i), tol); } listComputed.remove(index); } }
private static void checkCurrency(CurrencyParameterSensitivities paramSensitivities) { List<CurrencyParameterSensitivity> sensitivitiesList = paramSensitivities.getSensitivities(); if (sensitivitiesList.size() > 0) { // When no sensitivity, no check required. Currency ccy = sensitivitiesList.get(0).getCurrency(); for (int i = 1; i < sensitivitiesList.size(); i++) { ArgChecker.isTrue(ccy.equals(sensitivitiesList.get(i).getCurrency()), "sensitivities must be in the same currency for aggregation"); } } }
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); }
public void test_plus_array() { CurrencyParameterSensitivity base = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1); CurrencyParameterSensitivity test = base.plus(VECTOR_USD1); assertEquals(test, base.multipliedBy(2)); }
public void test_parse_grid_dateColumn() { CharSource source = CharSource.wrap( "Sensitivity Type,Sensitivity Date,GBP\n" + "ZeroRateGamma,2018-06-30,1\n"); assertEquals(LOADER_DATE.isKnownFormat(source), true); ValueWithFailures<ListMultimap<String, CurveSensitivities>> test = LOADER_DATE.parse(ImmutableList.of(source)); assertEquals(test.getFailures().size(), 0, test.getFailures().toString()); assertEquals(test.getValue().size(), 1); List<CurveSensitivities> list = test.getValue().get(""); assertEquals(list.size(), 1); CurveSensitivities csens0 = list.get(0); assertEquals(csens0.getTypedSensitivities().size(), 1); CurrencyParameterSensitivities cpss = csens0.getTypedSensitivity(ZERO_RATE_GAMMA); assertEquals(cpss.getSensitivities().size(), 1); CurrencyParameterSensitivity cps = cpss.getSensitivities().get(0); assertEquals(cps.getParameterMetadata().size(), 1); assertEquals(cps.getParameterMetadata().get(0), LabelDateParameterMetadata.of(date(2018, 6, 30), "2018-06-30")); }
public void test_split2() { CurrencyParameterSensitivity base1 = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1); CurrencyParameterSensitivity base2 = CurrencyParameterSensitivity.of(NAME2, METADATA_USD2, USD, VECTOR_USD2); CurrencyParameterSensitivity combined = CurrencyParameterSensitivity.combine(NAME_COMBINED, base1, base2); ImmutableList<CurrencyParameterSensitivity> test = combined.split(); assertEquals(test.size(), 2); assertEquals(test.get(0), base1); assertEquals(test.get(1), base2); }
public void test_combine_duplicateNames() { CurrencyParameterSensitivity base1 = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1); CurrencyParameterSensitivity base2 = CurrencyParameterSensitivity.of(NAME1, METADATA_USD2, USD, VECTOR_USD2); assertThrowsIllegalArg(() -> CurrencyParameterSensitivity.combine(NAME_COMBINED, base1, base2)); }