@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); }
public void test_of() { CurveParameterSize test = CurveParameterSize.of(CURVE_NAME, 3); assertEquals(test.getName(), CURVE_NAME); assertEquals(test.getParameterCount(), 3); }
@Override public CurveParameterSize build() { return new CurveParameterSize( name, parameterCount); }
/** * Converts this definition to the summary form. * <p> * The {@link CurveParameterSize} class provides a summary of this definition * consisting of the name and parameter size. * * @return the summary form */ public default CurveParameterSize toCurveParameterSize() { return CurveParameterSize.of(getName(), getParameterCount()); }
/** * Checks if this info contains the specified curve. * * @param name the curve to find * @return true if the curve is matched */ public boolean containsCurve(CurveName name) { return order.stream().anyMatch(o -> o.getName().equals(name)); }
public void test_serialization() { CurveParameterSize test = CurveParameterSize.of(CURVE_NAME, 3); assertSerialization(test); }
if (order.get(0).getName().equals(EUR_DSCON_OIS)) { trades.addAll(tradesDsc); trades.addAll(tradesE3); assertEquals(jiComputed.columnCount(), jiExpectedDsc.columnCount()); assertEquals(jiComputed.columnCount(), jiExpectedE3.columnCount()); int shiftDsc = order.get(0).getName().equals(EUR_DSCON_OIS) ? 0 : jiExpectedE3.rowCount(); for (int i = 0; i < jiExpectedDsc.rowCount(); i++) { for (int j = 0; j < jiExpectedDsc.columnCount(); j++) { int shiftE3 = order.get(0).getName().equals(EUR_DSCON_OIS) ? jiExpectedDsc.rowCount() : 0; for (int i = 0; i < jiExpectedE3.rowCount(); i++) { for (int j = 0; j < jiExpectedDsc.columnCount(); j++) {
/** * 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; }
public void test_toCurveParameterSize() { InflationNodalCurveDefinition test = new InflationNodalCurveDefinition( UNDERLYING_DEF, LAST_FIX_MONTH, LAST_FIX_VALUE, SEASONALITY_DEF); assertEquals(test.toCurveParameterSize(), CurveParameterSize.of(CURVE_NAME, NODES.size())); }
/** * Obtains an instance, specifying the name and parameter count. * * @param name the curve name * @param parameterCount the parameter count * @return the curve data */ public static CurveParameterSize of(CurveName name, int parameterCount) { return new CurveParameterSize(name, parameterCount); }
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]; jacobianBuilder.put(order.getName(), JacobianCalibrationMatrix.of(orderAll, pDmCurveMatrix)); startIndex += paramCount;
sensi = (DoubleMatrix) MATRIX_ALGEBRA.multiply(DoubleMatrix.ofUnsafe(diag), sensi); JacobianCalibrationMatrix jacobian = JacobianCalibrationMatrix.of( ImmutableList.of(CurveParameterSize.of(name, nNodes)), MATRIX_ALGEBRA.getInverse(sensi)); nodalCurve = nodalCurve.withMetadata(nodalCurve.getMetadata().withInfo(CurveInfoType.JACOBIAN, jacobian));
/** * 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; }
public void test_toCurveParameterSize() { InterpolatedNodalCurveDefinition test = InterpolatedNodalCurveDefinition.builder() .name(CURVE_NAME) .xValueType(ValueType.YEAR_FRACTION) .yValueType(ValueType.ZERO_RATE) .dayCount(ACT_365F) .nodes(NODES) .interpolator(CurveInterpolators.LINEAR) .extrapolatorLeft(CurveExtrapolators.FLAT) .extrapolatorRight(CurveExtrapolators.FLAT) .build(); assertEquals(test.toCurveParameterSize(), CurveParameterSize.of(CURVE_NAME, NODES.size())); }
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++) { System.arraycopy(
public void test_toCurveParameterSize() { ParameterizedFunctionalCurveDefinition test = ParameterizedFunctionalCurveDefinition.builder() .dayCount(ACT_365F) .valueFunction(VALUE_FUNCTION) .derivativeFunction(DERIVATIVE_FUNCTION) .sensitivityFunction(SENSITIVITY_FUNCTION) .initialGuess(INITIAL_PARAMS) .name(CURVE_NAME) .nodes(NODES) .parameterMetadata(PARAM_METADATA) .xValueType(ValueType.YEAR_FRACTION) .yValueType(ValueType.ZERO_RATE) .build(); assertEquals(test.toCurveParameterSize(), CurveParameterSize.of(CURVE_NAME, INITIAL_PARAMS.size())); }
/** * 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; }
if (curveDefinition.isComputeJacobian()) { JacobianCalibrationMatrix jacobian = JacobianCalibrationMatrix.of( ImmutableList.of(CurveParameterSize.of(curveDefinition.getName(), nNodes)), MATRIX_ALGEBRA.getInverse(sensi)); NodalCurve curveWithParamMetadata = curve.withMetadata( curve.getMetadata().withInfo(CurveInfoType.JACOBIAN, jacobian).withParameterMetadata(parameterMetadata));