private static Collector<CurrencyParameterSensitivities, CurrencyParameterSensitivitiesBuilder, CurrencyParameterSensitivities> mergeSensitivities() { return Collector.of( CurrencyParameterSensitivities::builder, CurrencyParameterSensitivitiesBuilder::add, (l, r) -> l.add(r.build()), CurrencyParameterSensitivitiesBuilder::build); }
/** * Adds sensitivities to the builder. * <p> * Values with the same market data name and currency will be merged. * * @param sensitivities the sensitivities to add * @return this, for chaining */ public CurrencyParameterSensitivitiesBuilder add(CurrencyParameterSensitivities sensitivities) { return add(sensitivities.getSensitivities()); }
/** * Adds a sensitivity to the builder. * <p> * Values with the same market data name and currency will be merged. * * @param type the sensitivity type * @param sensitivity the sensitivity to ad * @return this, for chaining */ public CurveSensitivitiesBuilder add( CurveSensitivitiesType type, CurrencyParameterSensitivity sensitivity) { data.computeIfAbsent(type, t -> CurrencyParameterSensitivities.builder()) .add(sensitivity); return this; }
/** * Adds a single sensitivity to the builder. * <p> * Values with the same market data name and currency will be merged. * * @param type the sensitivity type * @param curveName the curve name * @param currency the currency of the sensitivity * @param metadata the sensitivity metadata, not empty * @param sensitivityValue the sensitivity value * @return this, for chaining */ public CurveSensitivitiesBuilder add( CurveSensitivitiesType type, CurveName curveName, Currency currency, ParameterMetadata metadata, double sensitivityValue) { data.computeIfAbsent(type, t -> CurrencyParameterSensitivities.builder()) .add(curveName, currency, metadata, sensitivityValue); return this; }
/** * Merges this parameter sensitivities with another instance taking the metadata into account. * <p> * This returns a new sensitivity instance with a combined set of parameter sensitivities. * This instance is immutable and unaffected by this method. * <p> * The sensitivities are merged using market data name and currency as a key. * Each sensitivity is then merged taking into account the metadata, such as the tenor. * As such, this method can only be used if the parameter metadata instances are not be empty. * * @param other the other parameter sensitivities * @return an instance based on this one, with the other instance added * @throws IllegalArgumentException if any metadata instance is empty */ public CurrencyParameterSensitivities mergedWith(CurrencyParameterSensitivities other) { return toBuilder().add(other).build(); }
/** * 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 test_builder_emptyMetadata() { assertThrows(IllegalArgumentException.class, () -> CurrencyParameterSensitivities.builder().add(ENTRY_USD)); }
/** * Checks and adjusts the market data names. * <p> * The supplied function is invoked for each market data name in this sensitivities. * If the function returns the same name for two different inputs, the sensitivity values will be summed. * A typical use case would be to convert index names to curve names valid for an underlying system. * * @param nameFn the function for checking and adjusting the name * @return the adjusted sensitivity * @throws RuntimeException if the function throws an exception */ public CurrencyParameterSensitivities withMarketDataNames(Function<MarketDataName<?>, MarketDataName<?>> nameFn) { CurrencyParameterSensitivitiesBuilder builder = CurrencyParameterSensitivities.builder(); for (CurrencyParameterSensitivity sensitivity : sensitivities) { builder.add(sensitivity.toBuilder() .marketDataName(nameFn.apply(sensitivity.getMarketDataName())) .build()); } return builder.build(); }
public void test_builder() { 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 test = CurrencyParameterSensitivities.builder() .add(entry1) .add(CurrencyParameterSensitivities.of(entry1)) .add(entry2) .build(); assertEquals(test.getSensitivities().size(), 1); assertEquals(test.getSensitivities().get(0).getParameterMetadata(), METADATA1B); assertEquals(test.getSensitivities().get(0).getSensitivity(), DoubleArray.of(300, 600, 600, 246)); }
public void test_builder_filterSensitivity() { CurrencyParameterSensitivity entry1 = CurrencyParameterSensitivity.of(NAME1, METADATA1B, USD, DoubleArray.of(0, 1, 2, 3)); CurrencyParameterSensitivity expected = CurrencyParameterSensitivity.of(NAME1, METADATA1B.subList(1, 4), USD, DoubleArray.of(1, 2, 3)); CurrencyParameterSensitivities test = CurrencyParameterSensitivities.builder() .add(entry1) .filterSensitivity(v -> v != 0) .build(); assertEquals(test.getSensitivities().size(), 1); assertEquals(test.getSensitivities().get(0), expected); }
public void test_builder_mapMetadata() { CurrencyParameterSensitivity entry1 = CurrencyParameterSensitivity.of(NAME1, METADATA1B, USD, DoubleArray.of(0, 1, 2, 3)); CurrencyParameterSensitivity expected = CurrencyParameterSensitivity.of(NAME1, ImmutableList.of(TENOR_MD_1Y), USD, DoubleArray.of(6)); CurrencyParameterSensitivities test = CurrencyParameterSensitivities.builder() .add(entry1) .mapMetadata(md -> TENOR_MD_1Y) .build(); assertEquals(test.getSensitivities().size(), 1); assertEquals(test.getSensitivities().get(0), expected); }