public void test_combine() { UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1); UnitParameterSensitivity base2 = UnitParameterSensitivity.of(NAME2, METADATA2, VECTOR2); UnitParameterSensitivity test = UnitParameterSensitivity.combine(NAME_COMBINED, base1, base2); assertEquals(test.getMarketDataName(), NAME_COMBINED); assertEquals(test.getParameterCount(), VECTOR_COMBINED.size()); assertEquals(test.getParameterMetadata(), METADATA_COMBINED); assertEquals(test.getParameterMetadata(0), METADATA_COMBINED.get(0)); assertEquals(test.getSensitivity(), VECTOR_COMBINED); assertEquals(test.getParameterSplit(), Optional.of(PARAM_SPLIT)); }
/** * Converts this sensitivity to a monetary value, multiplying by the specified factor. * <p> * The result will consist of the entries based on the entries of this instance. * Each entry in the result will be in the specified currency and multiplied by the specified amount. * * @param currency the currency of the amount * @param amount the amount to multiply by * @return the resulting sensitivity object */ public CurrencyParameterSensitivities multipliedBy(Currency currency, double amount) { return sensitivities.stream() .map(s -> s.multipliedBy(currency, amount)) .collect( Collectors.collectingAndThen( Guavate.toImmutableList(), CurrencyParameterSensitivities::of)); }
public void test_plus_sensitivity() { UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1); UnitParameterSensitivity test = base1.plus(base1); assertEquals(test, base1.multipliedBy(2)); }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 842855857: // marketDataName return ((UnitParameterSensitivity) bean).getMarketDataName(); case -1169106440: // parameterMetadata return ((UnitParameterSensitivity) bean).getParameterMetadata(); case 564403871: // sensitivity return ((UnitParameterSensitivity) bean).getSensitivity(); case 1122130161: // parameterSplit return ((UnitParameterSensitivity) bean).parameterSplit; } return super.propertyGet(bean, propertyName, quiet); }
private static void insert(List<UnitParameterSensitivity> mutable, UnitParameterSensitivity addition) { int index = Collections.binarySearch( mutable, addition, UnitParameterSensitivity::compareKey); if (index >= 0) { UnitParameterSensitivity base = mutable.get(index); DoubleArray combined = base.getSensitivity().plus(addition.getSensitivity()); mutable.set(index, base.withSensitivity(combined)); } else { int insertionPoint = -(index + 1); mutable.add(insertionPoint, addition); } }
/** * Returns an instance with the specified sensitivity array added to the array in this instance. * <p> * The specified instance must have the same name, metadata and parameter split as this instance. * * @param otherSensitivty the other parameter sensitivity * @return an instance based on this one, with the other instance added * @throws IllegalArgumentException if the market data name, metadata or parameter split differs */ public UnitParameterSensitivity plus(UnitParameterSensitivity otherSensitivty) { if (!marketDataName.equals(otherSensitivty.marketDataName) || !parameterMetadata.equals(otherSensitivty.parameterMetadata) || (parameterSplit != null && !parameterSplit.equals(otherSensitivty.parameterSplit))) { throw new IllegalArgumentException("Two sensitivity instances can only be added if name, metadata and split are equal"); } return plus(otherSensitivty.getSensitivity()); }
throw new IllegalArgumentException("At least two sensitivity instances must be specified"); int size = Stream.of(sensitivities).mapToInt(s -> s.getParameterCount()).sum(); double[] combinedSensitivities = new double[size]; ImmutableList.Builder<ParameterMetadata> combinedMeta = ImmutableList.builder(); for (int i = 0; i < sensitivities.length; i++) { UnitParameterSensitivity sens = sensitivities[i]; System.arraycopy(sens.getSensitivity().toArrayUnsafe(), 0, combinedSensitivities, count, sens.getParameterCount()); combinedMeta.addAll(sens.getParameterMetadata()); split.add(ParameterSize.of(sens.getMarketDataName(), sens.getParameterCount())); count += sens.getParameterCount(); return new UnitParameterSensitivity( marketDataName, combinedMeta.build(), DoubleArray.ofUnsafe(combinedSensitivities), split.build());
if (!sens1.getSensitivity().equalWithTolerance(sens2.getSensitivity(), tolerance)) { return false; } else { if (!sens1.getSensitivity().equalZeroWithTolerance(tolerance)) { return false; if (!sens2.getSensitivity().equalZeroWithTolerance(tolerance)) { return false;
@Override public UnitParameterSensitivity yValueParameterSensitivity(double x) { int i = seasonalityIndex(x); double adjustment = seasonality.get(i); double derivativeFactor = 0d; if (adjustmentType.equals(ShiftType.ABSOLUTE)) { derivativeFactor = 1d; } else if (adjustmentType.equals(ShiftType.SCALED)) { derivativeFactor = adjustment; } else { throw new IllegalArgumentException("ShiftType " + adjustmentType + " is not supported for sensitivities"); } // remove the first point from the underlying sensitivity UnitParameterSensitivity u = underlying.yValueParameterSensitivity(x); UnitParameterSensitivity u2 = UnitParameterSensitivity.of( u.getMarketDataName(), u.getParameterMetadata().subList(1, u.getParameterMetadata().size()), u.getSensitivity().subArray(1)); return u2.multipliedBy(derivativeFactor); }
private DoubleArray sensitivitySwap(BasicFixedLeg swap, NodalCurve curve, double swapRate) { int nPayments = swap.getNumPayments(); double annuity = 0d; UnitParameterSensitivities sensi = UnitParameterSensitivities.empty(); for (int i = 0; i < nPayments - 1; i++) { double t = swap.getPaymentTime(i); double df = Math.exp(-curve.yValue(t) * t); annuity += swap.getYearFraction(i) * df; sensi = sensi.combinedWith(curve.yValueParameterSensitivity(t).multipliedBy(-df * t * swap.getYearFraction(i) * swapRate)); } int lastIndex = nPayments - 1; double t = swap.getPaymentTime(lastIndex); double df = Math.exp(-curve.yValue(t) * t); annuity += swap.getYearFraction(lastIndex) * df; sensi = sensi.combinedWith( curve.yValueParameterSensitivity(t).multipliedBy(-df * t * (1d + swap.getYearFraction(lastIndex) * swapRate))); sensi = sensi.multipliedBy(-1d / annuity); ArgChecker.isTrue(sensi.size() == 1); return sensi.getSensitivities().get(0).getSensitivity(); }
/** * Converts this instance to the equivalent unit sensitivity. * <p> * The result has the same sensitivity values, but no longer records the currency. * * @return an instance based on this one, with the currency removed */ public UnitParameterSensitivity toUnitParameterSensitivity() { return UnitParameterSensitivity.of(marketDataName, parameterMetadata, sensitivity); }
public void test_values() { ConstantNodalCurve test = ConstantNodalCurve.of(METADATA, XVALUE, YVALUE); assertThat(test.yValue(10.2421)).isEqualTo(YVALUE); assertThat(test.yValueParameterSensitivity(10.2421).getMarketDataName()).isEqualTo(CURVE_NAME); assertThat(test.yValueParameterSensitivity(10.2421).getSensitivity()).isEqualTo(DoubleArray.of(1d)); assertThat(test.firstDerivative(10.2421)).isEqualTo(0d); }
public void test_multipliedBy() { UnitParameterSensitivity base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1); UnitParameterSensitivity test = base.multipliedBy(FACTOR1); assertEquals(test, UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1_FACTOR)); }
public void test_split2() { UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1); UnitParameterSensitivity base2 = UnitParameterSensitivity.of(NAME2, METADATA2, VECTOR2); UnitParameterSensitivity combined = UnitParameterSensitivity.combine(NAME_COMBINED, base1, base2); ImmutableList<UnitParameterSensitivity> test = combined.split(); assertEquals(test.size(), 2); assertEquals(test.get(0), base1); assertEquals(test.get(1), base2); }
public void yParameterSensitivity() { for (int i = 0; i < X_SAMPLE.length; i++) { UnitParameterSensitivity dComputed = ADD_FIXED_CURVE.yValueParameterSensitivity(X_SAMPLE[i]); UnitParameterSensitivity dExpected = SPREAD_CURVE.yValueParameterSensitivity(X_SAMPLE[i]); assertTrue(dComputed.compareKey(dExpected) == 0); assertTrue(dComputed.getSensitivity().equalWithTolerance(dExpected.getSensitivity(), TOLERANCE_Y)); } }
public void test_combine_duplicateNames() { UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1); UnitParameterSensitivity base2 = UnitParameterSensitivity.of(NAME1, METADATA2, VECTOR2); assertThrowsIllegalArg(() -> UnitParameterSensitivity.combine(NAME_COMBINED, base1, base2)); }
/** * Splits this sensitivity instance. * <p> * This examines each individual sensitivity to see if it can be {@link CurrencyParameterSensitivity#split() split}. * If any can be split, the result will contain the combination of the split sensitivities. * * @return this sensitivity, with any combined sensitivities split */ public UnitParameterSensitivities split() { if (!sensitivities.stream().anyMatch(s -> s.getParameterSplit().isPresent())) { return this; } return of(sensitivities.stream() .flatMap(s -> s.split().stream()) .collect(toImmutableList())); }
public void test_withSensitivity() { UnitParameterSensitivity base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1); UnitParameterSensitivity test = base.withSensitivity(VECTOR1_FACTOR); assertEquals(test, UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1_FACTOR)); assertThrowsIllegalArg(() -> base.withSensitivity(DoubleArray.of(1d))); }