public void test_empty() { ParameterMetadata test = ParameterMetadata.empty(); assertEquals(test.getLabel(), ""); assertEquals(test.getIdentifier(), ""); }
@ImmutablePreBuild private static void preBuild(Builder builder) { if (builder.parameterMetadata.size() == 0) { if (builder.initialGuess != null) { builder.parameterMetadata = ParameterMetadata.listOfEmpty(builder.initialGuess.size()); } } }
private double shiftForNode(int scenarioIndex, ParameterMetadata meta) { Integer nodeIndex = nodeIndices.get(meta.getIdentifier()); if (nodeIndex != null) { return shifts.get(scenarioIndex, nodeIndex); } nodeIndex = nodeIndices.get(meta.getLabel()); if (nodeIndex != null) { return shifts.get(scenarioIndex, nodeIndex); } return 0; }
@Override public ParameterMetadata getParameterMetadata(int parameterIndex) { return ParameterMetadata.empty(); }
private String metadataString(ImmutableList<ParameterMetadata> parameterMetadata) { return parameterMetadata.stream().map(md -> md.getLabel()).collect(joining(", ")); }
/** * Converts this instance to a map of sensitivities, keyed by the identifier. * <p> * This returns a {@code Map} keyed by the identifier of the metadata. * For example, this could be used to extract a {@code Map<Tenor, Double>}. * * @param <T> the type of the identifier * @param identifierType the type of the parameter metadata identifier * @return a map containing the parameter metadata identifier and the sensitivity value * @throws ClassCastException if the identifier of the parameter metadata does not match the specified type */ public <T> ImmutableMap<T, Double> toSensitivityMap(Class<T> identifierType) { return sensitivities() .mapKeys(k -> identifierType.cast(k.getIdentifier())) .toMap(); }
/** * Adds a single sensitivity to the builder. * <p> * If the key already exists, the sensitivity value will be merged. * * @param metadata the sensitivity metadata * @param sensitivityValue the sensitivity value * @return this, for chaining */ CurrencyParameterSensitivityBuilder add(ParameterMetadata metadata, double sensitivityValue) { if (metadata.equals(ParameterMetadata.empty())) { throw new IllegalArgumentException("Builder does not allow empty parameter metadata"); } this.sensitivity.merge(metadata, sensitivityValue, Double::sum); return this; }
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(); }
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()); }
/** * Gets the metadata of the parameter at the specified index. * <p> * If there is no specific parameter metadata, an empty instance will be returned. * * @param parameterIndex the zero-based index of the parameter to get * @return the metadata of the parameter * @throws IndexOutOfBoundsException if the index is invalid */ public default ParameterMetadata getParameterMetadata(int parameterIndex) { return getParameterMetadata().map(pm -> pm.get(parameterIndex)).orElse(ParameterMetadata.empty()); }
ArgChecker.isTrue(nodeMetadata instanceof DatedParameterMetadata, "re-bucketing requires sensitivity date for node {} which is of type {} while 'DatedParameterMetadata' is expected", nodeMetadata.getLabel(), nodeMetadata.getClass().getName()); DatedParameterMetadata datedParameterMetadata = (DatedParameterMetadata) nodeMetadata; LocalDate nodeDate = datedParameterMetadata.getDate();
public void test_listOfEmpty() { List<ParameterMetadata> test = ParameterMetadata.listOfEmpty(2); assertEquals(test.size(), 2); }
public void test_pointShifts() { SabrParametersSwaptionVolatilities base = SabrParametersSwaptionVolatilities.of(NAME, CONV, DATE_TIME, PARAM); PointShiftsBuilder builder = PointShifts.builder(ShiftType.ABSOLUTE); for (int i = 0; i < base.getParameterCount(); ++i) { builder.addShift(0, base.getParameterMetadata(i).getIdentifier(), 0.1d * (i + 1d)); builder.addShift(1, base.getParameterMetadata(i).getIdentifier(), 10d * (i + 1d)); } PointShifts shifts = builder.build(); MarketDataBox<ParameterizedData> resBox = shifts.applyTo(MarketDataBox.ofSingleValue(base), REF_DATA); SabrParametersSwaptionVolatilities computed0 = (SabrParametersSwaptionVolatilities) resBox.getValue(0); SabrParametersSwaptionVolatilities computed1 = (SabrParametersSwaptionVolatilities) resBox.getValue(1); for (int i = 0; i < base.getParameterCount(); ++i) { assertEquals(computed0.getParameter(i), base.getParameter(i) + 0.1d * (i + 1d)); assertEquals(computed1.getParameter(i), base.getParameter(i) + 10d * (i + 1d)); } }
/** * Gets the metadata of the parameter at the specified index. * <p> * If there is no specific parameter metadata, an empty instance will be returned. * * @param parameterIndex the zero-based index of the parameter to get * @return the metadata of the parameter * @throws IndexOutOfBoundsException if the index is invalid */ public default ParameterMetadata getParameterMetadata(int parameterIndex) { return getParameterMetadata().map(pm -> pm.get(parameterIndex)).orElse(ParameterMetadata.empty()); }
public void test_metadata_end() { IborFutureCurveNode node = IborFutureCurveNode.of(TEMPLATE, QUOTE_ID, SPREAD, LABEL); LocalDate date = LocalDate.of(2015, 10, 20); LocalDate referenceDate = TEMPLATE.calculateReferenceDateFromTradeDate(date, REF_DATA); LocalDate maturityDate = TEMPLATE.getIndex().calculateMaturityFromEffective(referenceDate, REF_DATA); ParameterMetadata metadata = node.metadata(date, REF_DATA); assertEquals(metadata.getLabel(), LABEL); assertTrue(metadata instanceof YearMonthDateParameterMetadata); assertEquals(((YearMonthDateParameterMetadata) metadata).getDate(), maturityDate); assertEquals(((YearMonthDateParameterMetadata) metadata).getYearMonth(), YearMonth.from(referenceDate)); }
/** * Obtains an instance from the market data name and sensitivity. * <p> * The market data name identifies the {@link ParameterizedData} instance that was queried. * The parameter metadata will be empty. * The size of the parameter metadata list must match the size of the sensitivity array. * * @param marketDataName the name of the market data that the sensitivity refers to * @param sensitivity the sensitivity values, one for each parameter * @return the sensitivity object */ public static UnitParameterSensitivity of(MarketDataName<?> marketDataName, DoubleArray sensitivity) { return of(marketDataName, ParameterMetadata.listOfEmpty(sensitivity.size()), sensitivity); }
@Override public ParameterMetadata getParameterMetadata(int parameterIndex) { return ParameterMetadata.empty(); }
(nodeMetadata instanceof TenorParameterMetadata), "re-bucketing requires sensitivity date or node for node {} which is of type {}", nodeMetadata.getLabel(), nodeMetadata.getClass().getName()); LocalDate nodeDate; if (nodeMetadata instanceof DatedParameterMetadata) {
/** * Obtains an instance from the market data name, currency and sensitivity. * <p> * The market data name identifies the {@link ParameterizedData} instance that was queried. * The parameter metadata will be empty. * The size of the parameter metadata list must match the size of the sensitivity array. * * @param marketDataName the name of the market data that the sensitivity refers to * @param currency the currency of the sensitivity * @param sensitivity the sensitivity values, one for each parameter * @return the sensitivity object */ public static CurrencyParameterSensitivity of( MarketDataName<?> marketDataName, Currency currency, DoubleArray sensitivity) { return of(marketDataName, ParameterMetadata.listOfEmpty(sensitivity.size()), currency, sensitivity); }
public void coverage() { ParameterMetadata test = ParameterMetadata.empty(); coverImmutableBean(test); }