public void test_presentValue_after_expiry() { CurrencyAmount pvRec = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG_PAST, RATE_PROVIDER, VOLS); CurrencyAmount pvPay = PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT_PAST, RATE_PROVIDER, VOLS); assertEquals(pvRec.getAmount(), 0d, NOTIONAL * TOL); assertEquals(pvPay.getAmount(), 0d, NOTIONAL * TOL); }
public void test_presentValueSensitivityNormalVolatility_after_expiry() { SwaptionSensitivity sensiRec = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG_PAST, RATE_PROVIDER, VOLS); SwaptionSensitivity sensiPay = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT_PAST, RATE_PROVIDER, VOLS); assertEquals(sensiRec.getSensitivity(), 0.0d, NOTIONAL * TOL); assertEquals(sensiPay.getSensitivity(), 0.0d, NOTIONAL * TOL); }
public void test_presentValueSensitivityRatesStickyStrike() { PointSensitivities pointRec = PRICER_SWAPTION .presentValueSensitivityRatesStickyStrike(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS_FLAT).build(); CurrencyParameterSensitivities computedRec = RATE_PROVIDER.parameterSensitivity(pointRec); CurrencyParameterSensitivities expectedRec = FINITE_DIFFERENCE_CALCULATOR.sensitivity( RATE_PROVIDER, (p) -> PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, p, VOLS_FLAT)); assertTrue(computedRec.equalWithTolerance(expectedRec, NOTIONAL * FD_EPS * 200d)); PointSensitivities pointPay = PRICER_SWAPTION .presentValueSensitivityRatesStickyStrike(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS_FLAT).build(); CurrencyParameterSensitivities computedPay = RATE_PROVIDER.parameterSensitivity(pointPay); CurrencyParameterSensitivities expectedPay = FINITE_DIFFERENCE_CALCULATOR.sensitivity( RATE_PROVIDER, (p) -> PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT, p, VOLS_FLAT)); assertTrue(computedPay.equalWithTolerance(expectedPay, NOTIONAL * FD_EPS * 200d)); }
public void implied_volatility_round_trip() { // Compute pv and then implied vol from PV and compare with direct implied vol CurrencyAmount pvLongRec = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); double impliedLongRecComputed = PRICER_SWAPTION.impliedVolatilityFromPresentValue( SWAPTION_REC_LONG, RATE_PROVIDER, ACT_365F, pvLongRec.getAmount()); double impliedLongRecInterpolated = PRICER_SWAPTION.impliedVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); assertEquals(impliedLongRecComputed, impliedLongRecInterpolated, TOL); CurrencyAmount pvLongPay = PRICER_SWAPTION.presentValue(SWAPTION_PAY_LONG, RATE_PROVIDER, VOLS); double impliedLongPayComputed = PRICER_SWAPTION.impliedVolatilityFromPresentValue( SWAPTION_PAY_LONG, RATE_PROVIDER, ACT_365F, pvLongPay.getAmount()); double impliedLongPayInterpolated = PRICER_SWAPTION.impliedVolatility(SWAPTION_PAY_LONG, RATE_PROVIDER, VOLS); assertEquals(impliedLongPayComputed, impliedLongPayInterpolated, TOL); CurrencyAmount pvShortRec = PRICER_SWAPTION.presentValue(SWAPTION_REC_SHORT, RATE_PROVIDER, VOLS); double impliedShortRecComputed = PRICER_SWAPTION.impliedVolatilityFromPresentValue( SWAPTION_REC_SHORT, RATE_PROVIDER, ACT_365F, pvShortRec.getAmount()); double impliedShortRecInterpolated = PRICER_SWAPTION.impliedVolatility(SWAPTION_REC_SHORT, RATE_PROVIDER, VOLS); assertEquals(impliedShortRecComputed, impliedShortRecInterpolated, TOL); }
public void implied_volatility_wrong_sign() { CurrencyAmount pvLongRec = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); assertThrowsIllegalArg(() -> PRICER_SWAPTION.impliedVolatilityFromPresentValue( SWAPTION_REC_LONG, RATE_PROVIDER, ACT_365F, -pvLongRec.getAmount())); }
validateSwaption(swaption); LocalDate valuationDate = ratesProvider.getValuationDate(); LocalDate expiryDate = swaption.getExpiryDate(); double expiry = dayCount.yearFraction(valuationDate, expiryDate); ResolvedSwap underlying = swaption.getUnderlying(); ResolvedSwapLeg fixedLeg = fixedLeg(underlying); double forward = getSwapPricer().parRate(underlying, ratesProvider); double numeraire = calculateNumeraire(swaption, fixedLeg, forward, ratesProvider); double strike = calculateStrike(fixedLeg); PutCall putCall = PutCall.ofPut(fixedLeg.getPayReceive().isReceive()); return NormalFormulaRepository.impliedVolatility(
public void test_currencyExposure() { MultiCurrencyAmount computedRec = PRICER_SWAPTION.currencyExposure(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); MultiCurrencyAmount computedPay = PRICER_SWAPTION.currencyExposure(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS); PointSensitivityBuilder pointRec = PRICER_SWAPTION.presentValueSensitivityRatesStickyStrike(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); MultiCurrencyAmount expectedRec = RATE_PROVIDER.currencyExposure(pointRec.build()) .plus(PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS)); assertEquals(computedRec.size(), 1); assertEquals(computedRec.getAmount(USD).getAmount(), expectedRec.getAmount(USD).getAmount(), NOTIONAL * TOL); PointSensitivityBuilder pointPay = PRICER_SWAPTION.presentValueSensitivityRatesStickyStrike(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS); MultiCurrencyAmount expectedPay = RATE_PROVIDER.currencyExposure(pointPay.build()) .plus(PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS)); assertEquals(computedPay.size(), 1); assertEquals(computedPay.getAmount(USD).getAmount(), expectedPay.getAmount(USD).getAmount(), NOTIONAL * TOL); }
public void test_presentValueSensitivityRatesStickyStrike_after_expiry() { PointSensitivityBuilder pointRec = PRICER_SWAPTION .presentValueSensitivityRatesStickyStrike(SWAPTION_REC_LONG_PAST, RATE_PROVIDER, VOLS); PointSensitivityBuilder pointPay = PRICER_SWAPTION .presentValueSensitivityRatesStickyStrike(SWAPTION_PAY_SHORT_PAST, RATE_PROVIDER, VOLS); assertEquals(pointRec, PointSensitivityBuilder.none()); assertEquals(pointPay, PointSensitivityBuilder.none()); }
public void test_presentValueSensitivityNormalVolatility() { SwaptionSensitivity computedRec = PRICER_SWAPTION .presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); CurrencyAmount pvRecUp = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(FD_EPS)); CurrencyAmount pvRecDw = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(-FD_EPS)); double expectedRec = 0.5 * (pvRecUp.getAmount() - pvRecDw.getAmount()) / FD_EPS; assertEquals(computedRec.getCurrency(), USD); assertEquals(computedRec.getSensitivity(), expectedRec, FD_EPS * NOTIONAL); assertEquals(computedRec.getVolatilitiesName(), VOLS.getName()); assertEquals(computedRec.getExpiry(), VOLS.relativeTime(SWAPTION_REC_LONG.getExpiry())); assertEquals(computedRec.getTenor(), SWAP_TENOR_YEAR, TOL); assertEquals(computedRec.getStrike(), STRIKE, TOL); assertEquals(computedRec.getForward(), PRICER_SWAP.parRate(RSWAP_REC, RATE_PROVIDER), TOL); SwaptionSensitivity computedPay = PRICER_SWAPTION .presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS); CurrencyAmount pvUpPay = PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(FD_EPS)); CurrencyAmount pvDwPay = PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT, RATE_PROVIDER, SwaptionNormalVolatilityDataSets.normalVolSwaptionProviderUsdStsShifted(-FD_EPS)); double expectedPay = 0.5 * (pvUpPay.getAmount() - pvDwPay.getAmount()) / FD_EPS; assertEquals(computedPay.getCurrency(), USD); assertEquals(computedPay.getSensitivity(), expectedPay, FD_EPS * NOTIONAL); assertEquals(computedPay.getVolatilitiesName(), VOLS.getName()); assertEquals(computedPay.getExpiry(), VOLS.relativeTime(SWAPTION_PAY_SHORT.getExpiry())); assertEquals(computedPay.getTenor(), SWAP_TENOR_YEAR, TOL); assertEquals(computedPay.getStrike(), STRIKE, TOL); assertEquals(computedPay.getForward(), PRICER_SWAP.parRate(RSWAP_PAY, RATE_PROVIDER), TOL); }
public void test_impliedVolatility_after_expiry() { assertThrowsIllegalArg(() -> PRICER_SWAPTION.impliedVolatility(SWAPTION_REC_LONG_PAST, RATE_PROVIDER, VOLS)); assertThrowsIllegalArg(() -> PRICER_SWAPTION.impliedVolatility(SWAPTION_PAY_SHORT_PAST, RATE_PROVIDER, VOLS)); }
public void test_currencyExposure_after_expiry() { MultiCurrencyAmount computedRec = PRICER_SWAPTION.currencyExposure(SWAPTION_REC_LONG_PAST, RATE_PROVIDER, VOLS); MultiCurrencyAmount computedPay = PRICER_SWAPTION.currencyExposure(SWAPTION_PAY_SHORT_PAST, RATE_PROVIDER, VOLS); assertEquals(computedRec.size(), 1); assertEquals(computedRec.getAmount(USD).getAmount(), 0d, NOTIONAL * TOL); assertEquals(computedPay.size(), 1); assertEquals(computedPay.getAmount(USD).getAmount(), 0d, NOTIONAL * TOL); }
public void test_currencyExposure_at_expiry() { MultiCurrencyAmount computedRec = PRICER_SWAPTION.currencyExposure(SWAPTION_REC_LONG_AT_EXPIRY, RATE_PROVIDER, VOLS); MultiCurrencyAmount computedPay = PRICER_SWAPTION.currencyExposure(SWAPTION_PAY_SHORT_AT_EXPIRY, RATE_PROVIDER, VOLS); PointSensitivityBuilder pointRec = PRICER_SWAPTION.presentValueSensitivityRatesStickyStrike(SWAPTION_REC_LONG_AT_EXPIRY, RATE_PROVIDER, VOLS); MultiCurrencyAmount expectedRec = RATE_PROVIDER.currencyExposure(pointRec.build()) .plus(PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG_AT_EXPIRY, RATE_PROVIDER, VOLS)); assertEquals(computedRec.size(), 1); assertEquals(computedRec.getAmount(USD).getAmount(), expectedRec.getAmount(USD).getAmount(), NOTIONAL * TOL); PointSensitivityBuilder pointPay = PRICER_SWAPTION.presentValueSensitivityRatesStickyStrike(SWAPTION_PAY_SHORT_AT_EXPIRY, RATE_PROVIDER, VOLS); MultiCurrencyAmount expectedPay = RATE_PROVIDER.currencyExposure(pointPay.build()) .plus(PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT_AT_EXPIRY, RATE_PROVIDER, VOLS)); assertEquals(computedPay.size(), 1); assertEquals(computedPay.getAmount(USD).getAmount(), expectedPay.getAmount(USD).getAmount(), NOTIONAL * TOL); }
public void present_value_sensitivity_premium_valuedate() { PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PRETOD_LONG_REC, RATE_PROVIDER, VOLS); PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS); CurrencyParameterSensitivities pvpsTrade = RATE_PROVIDER.parameterSensitivity(pvcsTrade); CurrencyParameterSensitivities pvpsProduct = RATE_PROVIDER.parameterSensitivity(pvcsProduct.build()); assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, NOTIONAL * TOL)); }
public void test_impliedVolatility_at_expiry() { double forward = PRICER_SWAP.parRate(RSWAP_REC, RATE_PROVIDER); double expected = VOLS.volatility( VAL_DATE.atTime(SWAPTION_EXPIRY_TIME).atZone(SWAPTION_EXPIRY_ZONE), SWAP_TENOR_YEAR, STRIKE, forward); double computedRec = PRICER_SWAPTION.impliedVolatility(SWAPTION_REC_LONG_AT_EXPIRY, RATE_PROVIDER, VOLS); double computedPay = PRICER_SWAPTION.impliedVolatility(SWAPTION_PAY_SHORT_AT_EXPIRY, RATE_PROVIDER, VOLS); assertEquals(computedRec, expected, TOL); assertEquals(computedPay, expected, TOL); }
public void present_value_premium_past() { CurrencyAmount pvTrade = PRICER_TRADE.presentValue(SWAPTION_PREPAST_LONG_REC, RATE_PROVIDER, VOLS); CurrencyAmount pvProduct = PRICER_PRODUCT.presentValue(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS); assertEquals(pvTrade.getAmount(), pvProduct.getAmount(), NOTIONAL * TOL); }
public void test_presentValueSensitivityRatesStickyStrike_at_expiry() { PointSensitivities pointRec = PRICER_SWAPTION.presentValueSensitivityRatesStickyStrike( SWAPTION_REC_LONG_AT_EXPIRY, RATE_PROVIDER, VOLS).build(); for (PointSensitivity sensi : pointRec.getSensitivities()) { assertEquals(Math.abs(sensi.getSensitivity()), 0d); } PointSensitivities pointPay = PRICER_SWAPTION.presentValueSensitivityRatesStickyStrike( SWAPTION_PAY_SHORT_AT_EXPIRY, RATE_PROVIDER, VOLS).build(); CurrencyParameterSensitivities computedPay = RATE_PROVIDER.parameterSensitivity(pointPay); CurrencyParameterSensitivities expectedPay = FINITE_DIFFERENCE_CALCULATOR.sensitivity( RATE_PROVIDER, (p) -> PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT_AT_EXPIRY, p, VOLS_FLAT)); assertTrue(computedPay.equalWithTolerance(expectedPay, NOTIONAL * FD_EPS * 100d)); }
public void present_value_sensitivity_premium_past() { PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREPAST_LONG_REC, RATE_PROVIDER, VOLS); PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS); CurrencyParameterSensitivities pvpsTrade = RATE_PROVIDER.parameterSensitivity(pvcsTrade); CurrencyParameterSensitivities pvpsProduct = RATE_PROVIDER.parameterSensitivity(pvcsProduct.build()); assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, NOTIONAL * TOL)); }
public void test_presentValueSensitivityNormalVolatility_at_expiry() { SwaptionSensitivity sensiRec = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_REC_LONG_AT_EXPIRY, RATE_PROVIDER, VOLS); assertEquals(sensiRec.getSensitivity(), 0d, NOTIONAL * TOL); SwaptionSensitivity sensiPay = PRICER_SWAPTION.presentValueSensitivityModelParamsVolatility(SWAPTION_PAY_SHORT_AT_EXPIRY, RATE_PROVIDER, VOLS); assertEquals(sensiPay.getSensitivity(), 0d, NOTIONAL * TOL); }
public void test_impliedVolatility() { double forward = PRICER_SWAP.parRate(RSWAP_REC, RATE_PROVIDER); double expected = VOLS.volatility(SWAPTION_REC_LONG.getExpiry(), SWAP_TENOR_YEAR, STRIKE, forward); double computedRec = PRICER_SWAPTION.impliedVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS); double computedPay = PRICER_SWAPTION.impliedVolatility(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS); assertEquals(computedRec, expected, TOL); assertEquals(computedPay, expected, TOL); }
public void test_presentValue_at_expiry() { CurrencyAmount pvRec = PRICER_SWAPTION.presentValue(SWAPTION_REC_LONG_AT_EXPIRY, RATE_PROVIDER, VOLS); CurrencyAmount pvPay = PRICER_SWAPTION.presentValue(SWAPTION_PAY_SHORT_AT_EXPIRY, RATE_PROVIDER, VOLS); double forward = PRICER_SWAP.parRate(RSWAP_REC, RATE_PROVIDER); double annuityCash = PRICER_SWAP.getLegPricer().annuityCash(RSWAP_REC.getLegs(SwapLegType.FIXED).get(0), forward); double discount = RATE_PROVIDER.discountFactor(USD, SETTLE_DATE); assertEquals(pvRec.getAmount(), 0d, NOTIONAL * TOL); assertEquals(pvPay.getAmount(), discount * annuityCash * (STRIKE - forward), NOTIONAL * TOL); }