@Override public CurveMetadata getMetadata() { return underlyingCurve.getMetadata(); }
@Override public double getParameter(int parameterIndex) { if (parameterIndex == underlyingCurve.getParameterCount()) { return shiftAmount; } return underlyingCurve.getParameter(parameterIndex); }
@Override public UnitParameterSensitivity yValueParameterSensitivity(double x) { return underlyingCurve.yValueParameterSensitivity(x); }
@Override public ParameterMetadata getParameterMetadata(int parameterIndex) { if (parameterIndex < baseCurve.getParameterCount()) { return baseCurve.getParameterMetadata(parameterIndex); } return spreadCurve.getParameterMetadata(parameterIndex - baseCurve.getParameterCount()); }
@Override public double discountFactorTimeDerivative(double yearFraction) { double zr = curve.yValue(yearFraction); return -Math.exp(-yearFraction * curve.yValue(yearFraction)) * (zr + curve.firstDerivative(yearFraction) * yearFraction); }
private <T> CurrencyParameterSensitivities sensitivity( ImmutableRatesProvider provider, Map<T, Curve> baseCurves, BiFunction<ImmutableRatesProvider, Map<T, Curve>, ImmutableRatesProvider> storeBumpedFn, Function<ImmutableRatesProvider, CurrencyAmount> valueFn, CurrencyAmount valueInit) { CurrencyParameterSensitivities result = CurrencyParameterSensitivities.empty(); for (Entry<T, Curve> entry : baseCurves.entrySet()) { Curve curve = entry.getValue(); DoubleArray sensitivity = DoubleArray.of(curve.getParameterCount(), i -> { Curve dscBumped = curve.withParameter(i, curve.getParameter(i) + shift); Map<T, Curve> mapBumped = new HashMap<>(baseCurves); mapBumped.put(entry.getKey(), dscBumped); ImmutableRatesProvider providerDscBumped = storeBumpedFn.apply(provider, mapBumped); return (valueFn.apply(providerDscBumped).getAmount() - valueInit.getAmount()) / shift; }); result = result.combinedWith(curve.createParameterSensitivity(valueInit.getCurrency(), sensitivity)); } return result; }
public void test_of() { Curve test = ParallelShiftedCurve.of(CONSTANT_CURVE, ShiftType.RELATIVE, 0.1d); assertThat(test.yValue(0)).isEqualTo(3.3d, offset(1e-10)); assertThat(test.yValue(1)).isEqualTo(3.3d, offset(1e-10)); assertThat(test.getName()).isEqualTo(METADATA.getCurveName()); assertThat(test.getParameterCount()).isEqualTo(2); assertThat(test.getParameter(0)).isEqualTo(3d); assertThat(test.getParameter(1)).isEqualTo(0.1d); assertThat(test.getParameterMetadata(0)).isEqualTo(ParameterMetadata.empty()); assertThat(test.getParameterMetadata(1)).isEqualTo(LabelParameterMetadata.of("RelativeShift")); assertThat(test.getMetadata()).isEqualTo(METADATA); }
@Override public CombinedCurve withPerturbation(ParameterPerturbation perturbation) { Curve newBaseCurve = baseCurve.withPerturbation( (idx, value, meta) -> perturbation.perturbParameter( idx, baseCurve.getParameter(idx), baseCurve.getParameterMetadata(idx))); int offset = baseCurve.getParameterCount(); Curve newSpreadCurve = spreadCurve.withPerturbation( (idx, value, meta) -> perturbation.perturbParameter( idx + offset, spreadCurve.getParameter(idx), spreadCurve.getParameterMetadata(idx))); List<ParameterMetadata> newParamMeta = Stream.concat( IntStream.range(0, newBaseCurve.getParameterCount()) .mapToObj(i -> newBaseCurve.getParameterMetadata(i)), IntStream.range(0, newSpreadCurve.getParameterCount()) .mapToObj(i -> newSpreadCurve.getParameterMetadata(i))) .collect(toImmutableList()); return CombinedCurve.of( newBaseCurve, newSpreadCurve, metadata.withParameterMetadata(newParamMeta)); }
@Override public <T> Optional<T> findData(MarketDataName<T> name) { if (curve.getName().equals(name)) { return Optional.of(name.getMarketDataType().cast(curve)); } return Optional.empty(); }
/** * Creates a parameter sensitivity instance for this curve when the sensitivity values are known. * <p> * In most cases, {@link #yValueParameterSensitivity(double)} should be used and manipulated. * However, it can be useful to create a {@link UnitParameterSensitivity} from pre-computed sensitivity values. * * @param sensitivities the sensitivity values, which must match the parameter count of the curve * @return the sensitivity */ public default UnitParameterSensitivity createParameterSensitivity(DoubleArray sensitivities) { List<ParameterMetadata> paramMeta = IntStream.range(0, getParameterCount()) .mapToObj(i -> getParameterMetadata(i)) .collect(toImmutableList()); return UnitParameterSensitivity.of(getName(), paramMeta, sensitivities); }
private CrossGammaParameterSensitivity computeGammaForCurve( CurveName curveName, Curve curve, Currency sensitivityCurrency, Function<Curve, ImmutableLegalEntityDiscountingProvider> ratesProviderFn, Function<ImmutableLegalEntityDiscountingProvider, CurrencyParameterSensitivities> sensitivitiesFn) { Function<DoubleArray, DoubleArray> function = new Function<DoubleArray, DoubleArray>() { @Override public DoubleArray apply(DoubleArray t) { Curve newCurve = curve.withPerturbation((i, v, m) -> t.get(i)); ImmutableLegalEntityDiscountingProvider newRates = ratesProviderFn.apply(newCurve); CurrencyParameterSensitivities sensiMulti = sensitivitiesFn.apply(newRates); return sensiMulti.getSensitivity(curveName, sensitivityCurrency).getSensitivity(); } }; int nParams = curve.getParameterCount(); DoubleMatrix sensi = fd.differentiate(function).apply(DoubleArray.of(nParams, n -> curve.getParameter(n))); List<ParameterMetadata> metadata = IntStream.range(0, nParams) .mapToObj(i -> curve.getParameterMetadata(i)) .collect(toImmutableList()); return CrossGammaParameterSensitivity.of(curveName, metadata, sensitivityCurrency, sensi); }
private static List<String> curveSettings(Curve curve) { ArgChecker.isTrue(curve instanceof InterpolatedNodalCurve, "Curve must be an InterpolatedNodalCurve"); if (!VALUE_TYPE_MAP.inverse().containsKey(curve.getMetadata().getYValueType())) { throw new IllegalArgumentException( Messages.format("Unsupported ValueType in curve settings: {}", curve.getMetadata().getYValueType())); } InterpolatedNodalCurve interpolatedCurve = (InterpolatedNodalCurve) curve; List<String> line = new ArrayList<>(); line.add(curve.getName().getName()); line.add(VALUE_TYPE_MAP.inverse().get(curve.getMetadata().getYValueType())); line.add(curve.getMetadata().getInfo(CurveInfoType.DAY_COUNT).toString()); line.add(interpolatedCurve.getInterpolator().toString()); line.add(interpolatedCurve.getExtrapolatorLeft().toString()); line.add(interpolatedCurve.getExtrapolatorRight().toString()); return line; }
@Override public UnitParameterSensitivity createParameterSensitivity(DoubleArray sensitivities) { UnitParameterSensitivity baseSens = baseCurve.createParameterSensitivity( sensitivities.subArray(0, baseCurve.getParameterCount())); UnitParameterSensitivity spreadSens = spreadCurve.createParameterSensitivity( sensitivities.subArray(baseCurve.getParameterCount(), sensitivities.size())); return UnitParameterSensitivity.combine(getName(), baseSens, spreadSens); }
@Override public CurrencyParameterSensitivities createParameterSensitivity(Currency currency, DoubleArray sensitivities) { return CurrencyParameterSensitivities.of(curve.createParameterSensitivity(currency, sensitivities)); }
@Override public CombinedCurve withParameter(int parameterIndex, double newValue) { if (parameterIndex < baseCurve.getParameterCount()) { return new CombinedCurve( baseCurve.withParameter(parameterIndex, newValue), spreadCurve, metadata); } return new CombinedCurve( baseCurve, spreadCurve.withParameter(parameterIndex - baseCurve.getParameterCount(), newValue), metadata); }
@Override public double getParameter(int parameterIndex) { return curve.getParameter(parameterIndex); }
@Override public ParallelShiftedCurve withPerturbation(ParameterPerturbation perturbation) { Curve bumpedCurve = underlyingCurve.withPerturbation(perturbation); int shiftIndex = underlyingCurve.getParameterCount(); double bumpedShift = perturbation.perturbParameter(shiftIndex, shiftAmount, getParameterMetadata(shiftIndex)); return new ParallelShiftedCurve(bumpedCurve, shiftType, bumpedShift); }
@Override public default NodalCurve withPerturbation(ParameterPerturbation perturbation) { return (NodalCurve) Curve.super.withPerturbation(perturbation); }
public void test_withPerturbation() { Curve test = new TestingCurve(2d); assertEquals(test.withPerturbation((i, v, m) -> v + 1).getParameter(0), 3d); }
@Override public CurrencyParameterSensitivities parameterSensitivity(ZeroRateSensitivity pointSens) { double yearFraction = pointSens.getYearFraction(); double rp = curve.yValue(yearFraction); double rcBar = 1.0; double rpBar = 1.0 / (1 + rp / frequency) * rcBar; UnitParameterSensitivity unitSens = curve.yValueParameterSensitivity(yearFraction).multipliedBy(rpBar); CurrencyParameterSensitivity curSens = unitSens.multipliedBy(pointSens.getCurrency(), pointSens.getSensitivity()); return CurrencyParameterSensitivities.of(curSens); }