public void test_of_metadata() { CrossGammaParameterSensitivity test = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD1); assertEquals(test.getMarketDataName(), NAME1); assertEquals(test.getParameterCount(), 2); assertEquals(test.getParameterMetadata(), METADATA_USD1); assertEquals(test.getParameterMetadata(0), METADATA_USD1.get(0)); assertEquals(test.getCurrency(), USD); assertEquals(test.getSensitivity(), MATRIX_USD1); assertEquals(test.getOrder(), ImmutableList.of(Pair.of(NAME1, METADATA_USD1))); }
public void test_convertedTo() { CrossGammaParameterSensitivity base = CrossGammaParameterSensitivity.of(NAME1, METADATA_EUR1, EUR, MATRIX_EUR1); CrossGammaParameterSensitivity test = base.convertedTo(USD, FX_RATE); assertEquals(base.convertedTo(EUR, FX_RATE), base); assertEquals(test, CrossGammaParameterSensitivity.of(NAME1, METADATA_EUR1, USD, MATRIX_EUR1_IN_USD)); }
/** * Returns the diagonal part of the sensitivity values. * * @return the diagonal part */ public CurrencyParameterSensitivities diagonal() { return CurrencyParameterSensitivities.of(sensitivities.stream().map(s -> s.diagonal()).collect(Collectors.toList())); }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 842855857: // marketDataName return ((CrossGammaParameterSensitivity) bean).getMarketDataName(); case -1169106440: // parameterMetadata return ((CrossGammaParameterSensitivity) bean).getParameterMetadata(); case 106006350: // order return ((CrossGammaParameterSensitivity) bean).getOrder(); case 575402001: // currency return ((CrossGammaParameterSensitivity) bean).getCurrency(); case 564403871: // sensitivity return ((CrossGammaParameterSensitivity) bean).getSensitivity(); } return super.propertyGet(bean, propertyName, quiet); }
/** * Returns the diagonal part of the sensitivity as {@code CurrencyParameterSensitivity}. * * @return the diagonal part */ public CurrencyParameterSensitivity diagonal() { CrossGammaParameterSensitivity blockDiagonal = getSensitivity(getMarketDataName()); int size = getParameterCount(); return CurrencyParameterSensitivity.of( getMarketDataName(), getParameterMetadata(), getCurrency(), DoubleArray.of(size, i -> blockDiagonal.getSensitivity().get(i, i))); }
private static void insert(List<CrossGammaParameterSensitivity> mutable, CrossGammaParameterSensitivity addition) { int index = Collections.binarySearch( mutable, addition, CrossGammaParameterSensitivity::compareKey); if (index >= 0) { CrossGammaParameterSensitivity base = mutable.get(index); DoubleMatrix combined = base.getSensitivity().plus(addition.getSensitivity()); mutable.set(index, base.withSensitivity(combined)); } else { int insertionPoint = -(index + 1); mutable.add(insertionPoint, addition); } }
/** * Returns the sensitivity to the market data specified by {@code name}. * <p> * This returns a sensitivity instance which stores the sensitivity of the {@code marketDataName} delta to another * market data of {@code name}. * * @param name the name * @return the sensitivity * @throws IllegalArgumentException if the name does not match an entry */ public CrossGammaParameterSensitivity getSensitivity(MarketDataName<?> name) { Pair<Integer, List<? extends ParameterMetadata>> indexAndMetadata = findStartIndexAndMetadata(name); int startIndex = indexAndMetadata.getFirst(); int rowCt = getParameterCount(); int colCt = indexAndMetadata.getSecond().size(); double[][] sensi = new double[rowCt][colCt]; for (int i = 0; i < rowCt; ++i) { System.arraycopy(getSensitivity().rowArray(i), startIndex, sensi[i], 0, colCt); } return CrossGammaParameterSensitivity.of( getMarketDataName(), getParameterMetadata(), name, indexAndMetadata.getSecond(), getCurrency(), DoubleMatrix.ofUnsafe(sensi)); }
if (!equalWithTolerance(sens1.getSensitivity(), sens2.getSensitivity(), tolerance)) { return false; } else { if (!equalZeroWithTolerance(sens1.getSensitivity(), tolerance)) { return false; if (!equalZeroWithTolerance(sens2.getSensitivity(), tolerance)) { return false;
private CrossGammaParameterSensitivity combineSensitivities( CurrencyParameterSensitivity baseDeltaSingle, CrossGammaParameterSensitivities blockCrossGamma) { double[][] valuesTotal = new double[baseDeltaSingle.getParameterCount()][]; List<Pair<MarketDataName<?>, List<? extends ParameterMetadata>>> order = new ArrayList<>(); for (int i = 0; i < baseDeltaSingle.getParameterCount(); ++i) { ArrayList<Double> innerList = new ArrayList<>(); for (CrossGammaParameterSensitivity gammaSingle : blockCrossGamma.getSensitivities()) { innerList.addAll(gammaSingle.getSensitivity().row(i).toList()); if (i == 0) { order.add(gammaSingle.getOrder().get(0)); } } valuesTotal[i] = Doubles.toArray(innerList); } return CrossGammaParameterSensitivity.of( baseDeltaSingle.getMarketDataName(), baseDeltaSingle.getParameterMetadata(), order, baseDeltaSingle.getCurrency(), DoubleMatrix.ofUnsafe(valuesTotal)); }
public void test_getSensitivity_eurUsd() { CrossGammaParameterSensitivity test = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, ImmutableList.of(Pair.of(NAME1, METADATA_USD1), Pair.of(NAME2, METADATA_EUR1)), USD, MATRIX_USD_EUR); CrossGammaParameterSensitivity expected1 = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD1); assertEquals(test.getSensitivity(NAME1), expected1); CrossGammaParameterSensitivity expected2 = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, NAME2, METADATA_EUR1, USD, MATRIX_EUR1); assertEquals(test.getSensitivity(NAME2), expected2); assertThrowsIllegalArg(() -> test.getSensitivity(CurveName.of("NAME-3"))); }
/** * Obtains an instance from the market data name, metadata, currency and sensitivity. * <p> * This creates a sensitivity instance which stores the second order sensitivity values to a single market data, i.e., * the block diagonal part of the full second order sensitivity matrix. * <p> * The market data name identifies the {@link ParameterizedData} instance that was queried. * The parameter metadata provides information on each parameter. * 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 parameterMetadata the parameter metadata * @param currency the currency of the sensitivity * @param sensitivity the sensitivity values, one for each parameter * @return the sensitivity object */ public static CrossGammaParameterSensitivity of( MarketDataName<?> marketDataName, List<? extends ParameterMetadata> parameterMetadata, Currency currency, DoubleMatrix sensitivity) { return of(marketDataName, parameterMetadata, marketDataName, parameterMetadata, currency, sensitivity); }
public void test_diagonal() { CrossGammaParameterSensitivity base = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD1); CurrencyParameterSensitivity test = base.diagonal(); DoubleArray value = DoubleArray.of(MATRIX_USD1.get(0, 0), MATRIX_USD1.get(1, 1)); assertEquals(test, CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, value)); }
public void test_withSensitivity() { CrossGammaParameterSensitivity base = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD1); CrossGammaParameterSensitivity test = base.withSensitivity(MATRIX_USD_FACTOR); assertEquals(test, CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD_FACTOR)); assertThrowsIllegalArg(() -> base.withSensitivity(DoubleMatrix.of(1, 1, 1d))); }
/** * Finds a single sensitivity instance by name and currency. * <p> * If the sensitivity is not found, optional empty is returned. * * @param name the curve name to find * @param currency the currency to find * @return the matching sensitivity */ public Optional<CrossGammaParameterSensitivity> findSensitivity(MarketDataName<?> name, Currency currency) { return sensitivities.stream() .filter(sens -> sens.getMarketDataName().equals(name) && sens.getCurrency().equals(currency)) .findFirst(); }
public void test_multipliedBy() { CrossGammaParameterSensitivity base = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD1); CrossGammaParameterSensitivity test = base.multipliedBy(FACTOR1); assertEquals(test, CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD_FACTOR)); }
public void test_total() { CrossGammaParameterSensitivity base = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD1); CurrencyAmount test = base.total(); assertEquals(test.getCurrency(), USD); double expected = MATRIX_USD1.get(0, 0) + MATRIX_USD1.get(0, 1) + MATRIX_USD1.get(1, 0) + MATRIX_USD1.get(1, 1); assertEquals(test.getAmount(), expected); }
/** * Converts the sensitivities in this instance to an equivalent in the specified currency. * <p> * Any FX conversion that is required will use rates from the provider. * * @param resultCurrency the currency of the result * @param rateProvider the provider of FX rates * @return the sensitivity object expressed in terms of the result currency * @throws RuntimeException if no FX rate could be found */ @Override public CrossGammaParameterSensitivities convertedTo(Currency resultCurrency, FxRateProvider rateProvider) { List<CrossGammaParameterSensitivity> mutable = new ArrayList<>(); for (CrossGammaParameterSensitivity sens : sensitivities) { insert(mutable, sens.convertedTo(resultCurrency, rateProvider)); } return new CrossGammaParameterSensitivities(ImmutableList.copyOf(mutable)); }
/** * Gets a single sensitivity instance by names and currency. * <p> * This returns the sensitivity of the market data ({@code nameFirst}) delta to another market data ({@code nameSecond}). * The result is sensitive to the order of {@code nameFirst} and {@code nameSecond}. * * @param nameFirst the name * @param nameSecond the name * @param currency the currency * @return the matching sensitivity * @throws IllegalArgumentException if the name and currency do not match an entry */ public CrossGammaParameterSensitivity getSensitivity( MarketDataName<?> nameFirst, MarketDataName<?> nameSecond, Currency currency) { CrossGammaParameterSensitivity sensi = findSensitivity(nameFirst, currency) .orElseThrow(() -> new IllegalArgumentException(Messages.format( "Unable to find sensitivity: {} for {}", nameFirst, currency))); return sensi.getSensitivity(nameSecond); }
public void coverage() { CrossGammaParameterSensitivity test = CrossGammaParameterSensitivity.of(NAME1, METADATA_USD1, USD, MATRIX_USD1); coverImmutableBean(test); CrossGammaParameterSensitivity test2 = CrossGammaParameterSensitivity.of(NAME2, METADATA_EUR1, EUR, MATRIX_EUR1); coverBeanEquals(test, test2); }
public void test_diagonal_eurUsd() { CrossGammaParameterSensitivity base = CrossGammaParameterSensitivity.of( NAME1, METADATA_USD1, ImmutableList.of(Pair.of(NAME1, METADATA_USD1), Pair.of(NAME2, METADATA_EUR1)), USD, MATRIX_USD_EUR); CurrencyParameterSensitivity test = base.diagonal(); DoubleArray value = DoubleArray.of(MATRIX_USD1.get(0, 0), MATRIX_USD1.get(1, 1)); assertEquals(test, CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, value)); }