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"); } } }
@Override public Set<String> tokens(CurrencyParameterSensitivity sensitivity) { return ImmutableSet.of( sensitivity.getCurrency().getCode().toLowerCase(Locale.ENGLISH), sensitivity.getMarketDataName().getName().toLowerCase(Locale.ENGLISH)); }
/** * 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<CurrencyParameterSensitivity> findSensitivity(MarketDataName<?> name, Currency currency) { return sensitivities.stream() .filter(sens -> sens.getMarketDataName().equals(name) && sens.getCurrency().equals(currency)) .findFirst(); }
@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 Stream<String> tokensForSensitivity(CurrencyParameterSensitivity sensitivity) { return ImmutableSet.of( sensitivity.getCurrency().getCode(), sensitivity.getMarketDataName().getName()) .stream() .map(v -> v.toLowerCase(Locale.ENGLISH)); }
@Override public PortfolioItemSummary summarize() { String typesStr = typedSensitivities.keySet().stream() .map(CurveSensitivitiesType::toString) .sorted() .collect(joining(", ", "CurveSensitivities[", "]")); return PortfolioItemSummary.of( getId().orElse(null), PortfolioItemType.SENSITIVITIES, ProductType.SENSITIVITIES, typedSensitivities.values().stream() .flatMap(s -> s.getSensitivities().stream()) .map(s -> s.getCurrency()) .collect(toImmutableSet()), typesStr); }
private boolean matchesToken(CurrencyParameterSensitivity sensitivity, String token) { return token.equalsIgnoreCase(sensitivity.getCurrency().getCode()) || token.equalsIgnoreCase(sensitivity.getMarketDataName().getName()); }
/** * Construct the inverse Jacobian matrix from the sensitivities of the trades market quotes to the curve parameters. * <p> * All the trades and sensitivities must be in the same currency. The data should be coherent with the * market quote sensitivities passed in an order coherent with the list of curves. * <p> * For each trade describing the market quotes, the sensitivity provided should be the sensitivity of that * market quote to the curve parameters. * * @param curveOrder the order in which the curves should be represented in the jacobian * @param marketQuoteSensitivities the market quotes sensitivity to the curve parameters * @return inverse jacobian matrix, which correspond to the sensitivity of the parameters to the market quotes */ public static DoubleMatrix jacobianFromMarketQuoteSensitivities( List<CurveParameterSize> curveOrder, List<CurrencyParameterSensitivities> marketQuoteSensitivities) { Currency ccy = marketQuoteSensitivities.get(0).getSensitivities().get(0).getCurrency(); DoubleMatrix jacobianMatrix = DoubleMatrix.ofArrayObjects( marketQuoteSensitivities.size(), marketQuoteSensitivities.size(), i -> row(curveOrder, marketQuoteSensitivities.get(i), ccy)); return MATRIX_ALGEBRA.getInverse(jacobianMatrix); }
@Override public EvaluationResult evaluate( CurrencyParameterSensitivity sensitivity, CalculationFunctions functions, String firstToken, List<String> remainingTokens) { if (firstToken.equalsIgnoreCase(sensitivity.getCurrency().getCode()) || firstToken.equalsIgnoreCase(sensitivity.getMarketDataName().getName())) { return EvaluationResult.success(sensitivity, remainingTokens); } else { return invalidTokenFailure(sensitivity, firstToken); } }
/** * 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; }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 842855857: // marketDataName return ((CurrencyParameterSensitivity) bean).getMarketDataName(); case -1169106440: // parameterMetadata return ((CurrencyParameterSensitivity) bean).getParameterMetadata(); case 575402001: // currency return ((CurrencyParameterSensitivity) bean).getCurrency(); case 564403871: // sensitivity return ((CurrencyParameterSensitivity) bean).getSensitivity(); case 1122130161: // parameterSplit return ((CurrencyParameterSensitivity) bean).parameterSplit; } return super.propertyGet(bean, propertyName, quiet); }
/** * 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_of_metadata() { CurrencyParameterSensitivity test = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1); assertEquals(test.getMarketDataName(), NAME1); assertEquals(test.getParameterCount(), VECTOR_USD1.size()); assertEquals(test.getParameterMetadata(), METADATA_USD1); assertEquals(test.getParameterMetadata(0), METADATA_USD1.get(0)); assertEquals(test.getCurrency(), USD); assertEquals(test.getSensitivity(), VECTOR_USD1); }
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_parameterSensitivity() { ZeroRatePeriodicDiscountFactors test = ZeroRatePeriodicDiscountFactors.of(GBP, DATE_VAL, CURVE); double sensiValue = 25d; ZeroRateSensitivity point = test.zeroRatePointSensitivity(DATE_AFTER); point = point.multipliedBy(sensiValue); CurrencyParameterSensitivities sensiObject = test.parameterSensitivity(point); assertEquals(sensiObject.size(), 1); CurrencyParameterSensitivity sensi1 = sensiObject.getSensitivities().get(0); assertEquals(sensi1.getCurrency(), GBP); }
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()); }
private void assertSens( CurveSensitivities sens, CurveSensitivitiesType type, String curveNameStr, Currency currency, String tenors, double... values) { CurveName curveName = CurveName.of(curveNameStr); CurrencyParameterSensitivity sensitivity = sens.getTypedSensitivity(type).getSensitivity(curveName, currency); assertEquals(sensitivity.getMarketDataName(), CurveName.of(curveNameStr)); assertEquals(sensitivity.getCurrency(), currency); assertEquals(metadataString(sensitivity.getParameterMetadata()), tenors); assertEquals(sensitivity.getSensitivity(), DoubleArray.ofUnsafe(values)); }
public void test_createParameterSensitivity_currency() { Surface test = new TestingSurface(2d); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getMarketDataName(), SURFACE_NAME); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getParameterCount(), 1); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getParameterMetadata(), ImmutableList.of(PARAM_META)); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getCurrency(), USD); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getSensitivity(), DoubleArray.of(2d)); }
public void test_createParameterSensitivity_currency() { Curve test = new TestingCurve(2d); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getMarketDataName(), CURVE_NAME); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getParameterCount(), 1); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getParameterMetadata(), ImmutableList.of(PARAM_META)); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getCurrency(), USD); assertEquals(test.createParameterSensitivity(USD, DoubleArray.of(2d)).getSensitivity(), DoubleArray.of(2d)); }
public void calibration_transition_coherence_par_rate() { RatesProvider provider = CALIBRATOR.calibrate(CURVE_GROUP_DEFN, ALL_QUOTES, REF_DATA); ImmutableList<ResolvedTrade> dscTrades = CURVE_GROUP_DEFN.resolvedTrades(ALL_QUOTES, REF_DATA); for (int loopnode = 0; loopnode < dscTrades.size(); loopnode++) { PointSensitivities pts = SWAP_PRICER.parRateSensitivity( ((ResolvedSwapTrade) dscTrades.get(loopnode)).getProduct(), provider).build(); CurrencyParameterSensitivities ps = provider.parameterSensitivity(pts); CurrencyParameterSensitivities mqs = MQC.sensitivity(ps, provider); assertEquals(mqs.size(), 1); CurrencyParameterSensitivity mqsDsc = mqs.getSensitivity(ALL_CURVE_NAME, BRL); assertTrue(mqsDsc.getMarketDataName().equals(ALL_CURVE_NAME)); assertTrue(mqsDsc.getCurrency().equals(BRL)); DoubleArray mqsData = mqsDsc.getSensitivity(); assertEquals(mqsData.size(), dscTrades.size()); for (int i = 0; i < mqsData.size(); i++) { assertEquals(mqsData.get(i), (i == loopnode) ? 1.0 : 0.0, TOLERANCE_DELTA); } } }