@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 3373707: // name return ((CurveParameterSize) bean).getName(); case 1107332838: // parameterCount return ((CurveParameterSize) bean).getParameterCount(); } return super.propertyGet(bean, propertyName, quiet); }
/** * Splits the array according to the curve order. * <p> * The input array must be of the same size as the total number of parameters. * The result consists of a map of arrays, where each array is the appropriate * section of the input array as defined by the curve order. * * @param array the array to split * @return a map splitting the array by curve name */ public Map<CurveName, DoubleArray> splitValues(DoubleArray array) { LinkedHashMap<CurveName, DoubleArray> result = new LinkedHashMap<>(); int start = 0; for (CurveParameterSize paramSizes : order) { int size = paramSizes.getParameterCount(); result.put(paramSizes.getName(), array.subArray(start, start + size)); start += size; } return result; }
private ImmutableMap<CurveName, DoubleArray> sensitivityToMarketQuoteForGroup( ImmutableRatesProvider provider, ImmutableList<ResolvedTrade> trades, ImmutableList<CurveParameterSize> orderGroup) { Builder<CurveName, DoubleArray> mqsGroup = new Builder<>(); int nodeIndex = 0; for (CurveParameterSize cps : orderGroup) { int nbParameters = cps.getParameterCount(); double[] mqsCurve = new double[nbParameters]; for (int looptrade = 0; looptrade < nbParameters; looptrade++) { DoubleArray mqsNode = pvMeasures.derivative(trades.get(nodeIndex), provider, orderGroup); mqsCurve[looptrade] = mqsNode.get(nodeIndex); nodeIndex++; } mqsGroup.put(cps.getName(), DoubleArray.ofUnsafe(mqsCurve)); } return mqsGroup.build(); }
int totalParamsAll = orderAll.stream().mapToInt(e -> e.getParameterCount()).sum(); DoubleMatrix res = derivatives(trades, provider, orderAll, totalParamsAll); int totalParamsGroup = orderGroup.stream().mapToInt(e -> e.getParameterCount()).sum(); int totalParamsPrevious = totalParamsAll - totalParamsGroup; DoubleMatrix pDmCurrentMatrix = jacobianDirect(res, nbTrades, totalParamsGroup, totalParamsPrevious); int startIndex = 0; for (CurveParameterSize order : orderGroup) { int paramCount = order.getParameterCount(); double[][] pDmCurveArray = new double[paramCount][totalParamsAll];
startIndexBefore[i] = startIndexBefore[i - 1] + orderPrevious.get(i - 1).getParameterCount(); int paramCountOuter = orderPrevious.get(i).getParameterCount(); JacobianCalibrationMatrix thisInfo = jacobiansPrevious.get(orderPrevious.get(i).getName()); DoubleMatrix thisMatrix = thisInfo.getJacobianMatrix(); int startIndexInner = 0; for (int j = 0; j < orderPrevious.size(); j++) { int paramCountInner = orderPrevious.get(j).getParameterCount(); if (thisInfo.containsCurve(orderPrevious.get(j).getName())) { // If not, the matrix stay with 0 for (int k = 0; k < paramCountOuter; k++) {
public void test_of() { CurveParameterSize test = CurveParameterSize.of(CURVE_NAME, 3); assertEquals(test.getName(), CURVE_NAME); assertEquals(test.getParameterCount(), 3); }
/** * Calculates the sensitivity with respect to the rates provider. * <p> * The result array is composed of the concatenated curve sensitivities from * all curves currently being processed. * * @param trade the trade * @param provider the rates provider * @param curveOrder the order of the curves * @return the sensitivity derivative */ public DoubleArray derivative(ResolvedTrade trade, RatesProvider provider, List<CurveParameterSize> curveOrder) { UnitParameterSensitivities unitSens = extractSensitivities(trade, provider); // expand to a concatenated array DoubleArray result = DoubleArray.EMPTY; for (CurveParameterSize curveParams : curveOrder) { DoubleArray sens = unitSens.findSensitivity(curveParams.getName()) .map(s -> s.getSensitivity()) .orElseGet(() -> DoubleArray.filled(curveParams.getParameterCount())); result = result.concat(sens); } return result; }
/** * Computes the row corresponding to a trade for the Jacobian matrix. * * @param curveOrder the curve order * @param parameterSensitivities the sensitivities * @param ccy the currency common to all sensitivities * @return the row */ private static DoubleArray row( List<CurveParameterSize> curveOrder, CurrencyParameterSensitivities parameterSensitivities, Currency ccy) { DoubleArray row = DoubleArray.EMPTY; for (CurveParameterSize curveNameAndSize : curveOrder) { Optional<CurrencyParameterSensitivity> sensitivityOneCurve = parameterSensitivities.findSensitivity(curveNameAndSize.getName(), ccy); if (sensitivityOneCurve.isPresent()) { row = row.concat(sensitivityOneCurve.get().getSensitivity()); } else { row = row.concat(DoubleArray.filled(curveNameAndSize.getParameterCount())); } } return row; }
int nodeIndex = 0; for (CurveParameterSize cps : order) { int nbParameters = cps.getParameterCount(); double[] mqsCurve = new double[nbParameters]; for (int looptrade = 0; looptrade < nbParameters; looptrade++) {