public void test_normalized_sorts() { PointSensitivities test = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1)); assertEquals(test.normalized().getSensitivities(), ImmutableList.of(CS1, CS2, CS3)); }
public void test_combinedWith() { PointSensitivities test = PointSensitivities.of(Lists.newArrayList(CS2, CS1)); PointSensitivities test2 = PointSensitivities.of(Lists.newArrayList(CS3)); assertEquals(test.combinedWith(test2).getSensitivities(), ImmutableList.of(CS2, CS1, CS3)); }
public void test_convertedTo_singleCurrency() { double rate = 1.5d; FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate); PointSensitivities base = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1)); PointSensitivities test1 = base.convertedTo(USD, matrix); PointSensitivity c1Conv = CS1.convertedTo(USD, matrix); PointSensitivity c2Conv = CS2.convertedTo(USD, matrix); PointSensitivity c3Conv = CS3.convertedTo(USD, matrix); PointSensitivities expected = PointSensitivities.of(Lists.newArrayList(c3Conv, c2Conv, c1Conv)); assertEquals(test1.normalized(), expected.normalized()); PointSensitivities test2 = base.convertedTo(GBP, matrix); assertEquals(test2.normalized(), base.normalized()); }
public void test_equalWithTolerance_date() { PointSensitivities test1 = PointSensitivities.of(Lists.newArrayList(CS3, CS1)).normalized(); PointSensitivities test2 = PointSensitivities.of(Lists.newArrayList(CS3, CS2)).normalized(); assertFalse(test1.equalWithTolerance(test2, 1.0E+1)); }
public void test_normalized_empty() { assertEquals(PointSensitivities.empty().normalized(), PointSensitivities.empty()); }
public void presentValueSensitivity_beforeFixing_coupon() { PointSensitivities pv = PRICER_CMS.presentValueSensitivity(COUPON, RATES_PROVIDER).build(); double df = RATES_PROVIDER.discountFactor(EUR, PAYMENT); ZeroRateSensitivity dfdr = RATES_PROVIDER.discountFactors(EUR).zeroRatePointSensitivity(PAYMENT); double forward = PRICER_SWAP.parRate(COUPON.getUnderlyingSwap(), RATES_PROVIDER); PointSensitivities forwarddr = PRICER_SWAP.parRateSensitivity(COUPON.getUnderlyingSwap(), RATES_PROVIDER).build(); PointSensitivities expected = forwarddr.multipliedBy(df).combinedWith(dfdr.multipliedBy(forward).build()) .multipliedBy(NOTIONAL * ACC_FACTOR); assertTrue(pv.equalWithTolerance(expected, TOLERANCE_DELTA)); }
public void test_marginIndexSensitivity() { double notional = FUTURE.getNotional(); double accrualFactor = FUTURE.getAccrualFactor(); PointSensitivities priceSensitivity = PRICER.priceSensitivity(FUTURE, RATES_PROVIDER); PointSensitivities sensiComputed = PRICER.marginIndexSensitivity(FUTURE, priceSensitivity); assertTrue(sensiComputed.equalWithTolerance(priceSensitivity.multipliedBy(accrualFactor * notional), TOL * notional)); }
public void test_build() { CreditCurveZeroRateSensitivity base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d); PointSensitivities test = base.build(); assertEquals(test.getSensitivities(), ImmutableList.of(base)); }
public void test_of_array() { PointSensitivities test = PointSensitivities.of(CS1, CS2); assertEquals(test.getSensitivities(), ImmutableList.of(CS1, CS2)); assertEquals(test.size(), 2); }
public void test_multipliedBy() { PointSensitivities test = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1)); assertEquals( test.multipliedBy(2d).getSensitivities(), ImmutableList.of(CS3.withSensitivity(64d), CS2.withSensitivity(44d), CS1.withSensitivity(24d))); }
public void test_mapSensitivities() { PointSensitivities test = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1)); assertEquals( test.mapSensitivities(s -> s / 2).getSensitivities(), ImmutableList.of(CS3.withSensitivity(16d), CS2.withSensitivity(11d), CS1.withSensitivity(6d))); }
public void test_presentValueSensitivity_afterExpiry() { PointSensitivities point = PRICER.presentValueSensitivityRatesStickyStrike(CALL_ITM, RATES_PROVIDER_AFTER, VOLS_AFTER); assertEquals(point, PointSensitivities.empty()); }
/** * Calculates the present value sensitivity of a bill trade. * <p> * If the settlement details are provided, the sensitivity is the sum of the underlying product's sensitivity * multiplied by the quantity and the sensitivity of the settlement payment if still due at the valuation date. * If not it is the underlying product's sensitivity multiplied by the quantity. * * @param trade the trade * @param provider the discounting provider * @return the present value sensitivity */ public PointSensitivities presentValueSensitivity(ResolvedBillTrade trade, LegalEntityDiscountingProvider provider) { if (provider.getValuationDate().isAfter(trade.getProduct().getNotional().getDate())) { return PointSensitivities.empty(); } PointSensitivities sensiProduct = productPricer.presentValueSensitivity(trade.getProduct(), provider) .multipliedBy(trade.getQuantity()); if (!trade.getSettlement().isPresent()) { return sensiProduct; } Payment settlement = trade.getSettlement().get(); RepoCurveDiscountFactors repoDf = DiscountingBillProductPricer.repoCurveDf(trade.getProduct(), provider); PointSensitivities sensiSettle = presentValueSensitivitySettlement(settlement, repoDf); return sensiProduct.combinedWith(sensiSettle); }
/** * Calculates the par spread sensitivity to the curves. * <p> * The sensitivity is reported in the counter currency of the product, but is actually dimensionless. * * @param swap the product * @param provider the rates provider * @return the spread curve sensitivity */ public PointSensitivities parSpreadSensitivity(ResolvedFxSwap swap, RatesProvider provider) { Payment counterPaymentNear = swap.getNearLeg().getCounterCurrencyPayment(); MultiCurrencyAmount pv = presentValue(swap, provider); double pvCounterCcy = pv.convertedTo(counterPaymentNear.getCurrency(), provider).getAmount(); double dfEnd = provider.discountFactor(counterPaymentNear.getCurrency(), swap.getFarLeg().getPaymentDate()); double notionalBaseCcy = swap.getNearLeg().getBaseCurrencyPayment().getAmount(); double ps = -pvCounterCcy / (notionalBaseCcy * dfEnd); // backward sweep double psBar = 1d; double pvCounterCcyBar = -1d / (notionalBaseCcy * dfEnd) * psBar; double dfEndBar = -ps / dfEnd * psBar; ZeroRateSensitivity ddfEnddr = provider.discountFactors(counterPaymentNear.getCurrency()) .zeroRatePointSensitivity(swap.getFarLeg().getPaymentDate()); PointSensitivities result = ddfEnddr.multipliedBy(dfEndBar).build(); PointSensitivities dpvdr = presentValueSensitivity(swap, provider); PointSensitivities dpvdrConverted = dpvdr.convertedTo(counterPaymentNear.getCurrency(), provider); return result.combinedWith(dpvdrConverted.multipliedBy(pvCounterCcyBar)); }
public void test_currencyExposure_fx() { ResolvedSwapLeg expSwapLeg = FIXED_FX_RESET_SWAP_LEG_PAY_GBP; PointSensitivities point = PRICER_LEG.presentValueSensitivity(expSwapLeg, RATES_GBP_USD).build(); MultiCurrencyAmount expected = RATES_GBP_USD.currencyExposure(point.convertedTo(USD, RATES_GBP_USD)) .plus(PRICER_LEG.presentValue(expSwapLeg, RATES_GBP_USD)); MultiCurrencyAmount computed = PRICER_LEG.currencyExposure(expSwapLeg, RATES_GBP_USD); assertEquals(computed.getAmount(USD).getAmount(), expected.getAmount(USD).getAmount(), EPS * NOTIONAL); assertFalse(computed.contains(GBP)); // 0 GBP }
public void presentValueSensitivity_zspread_aftermaturity() { PointSensitivities sensiComputed = PRICER.presentValueSensitivityWithZSpread(BILL_PAST, PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0); PointSensitivities sensiExpected = PointSensitivities.empty(); assertTrue(sensiComputed.equalWithTolerance(sensiExpected, TOLERANCE_PV)); }
public void test_priceSensitivity() { IborIndexRates mockIbor = mock(IborIndexRates.class); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.setIborRates(mockIbor); PointSensitivities sensiExpected = PointSensitivities.of(IborRateSensitivity.of(FUTURE.getIborRate().getObservation(), -1d)); PointSensitivities sensiComputed = PRICER.priceSensitivity(FUTURE, prov); assertTrue(sensiComputed.equalWithTolerance(sensiExpected, TOLERANCE_PRICE_DELTA)); }
public void test_convertedTo_empty() { assertEquals(PointSensitivities.empty().convertedTo(GBP, FxMatrix.empty()), PointSensitivities.empty()); }
/** * Returns an immutable version of this object. * <p> * The result is an instance of the immutable {@link PointSensitivities}. * It will contain the same individual point sensitivities. * * @return the immutable sensitivity instance, not null */ public PointSensitivities toImmutable() { return PointSensitivities.of(sensitivities); }
/** * Calculates the present value sensitivity of the FX swap product. * <p> * The present value sensitivity of the product is the sensitivity of the present value to * the underlying curves. * * @param swap the product * @param provider the rates provider * @return the present value sensitivity */ public PointSensitivities presentValueSensitivity(ResolvedFxSwap swap, RatesProvider provider) { PointSensitivities nearSens = fxPricer.presentValueSensitivity(swap.getNearLeg(), provider); PointSensitivities farSens = fxPricer.presentValueSensitivity(swap.getFarLeg(), provider); return nearSens.combinedWith(farSens); }