/** * Builder of Ibor-like coupon from the fixing date and the index. The payment and accrual dates * are the one of the fixing period. * * @param notional Coupon notional. * @param fixingDate The coupon fixing date. * @param index The coupon Ibor index. * @param calendar The holiday calendar for the ibor index. * @return The Ibor coupon. */ public static CouponIborDefinition from( final double notional, final ZonedDateTime fixingDate, final IborIndex index, final Calendar calendar) { ArgumentChecker.notNull(fixingDate, "fixing date"); ArgumentChecker.notNull(index, "index"); final ZonedDateTime fixingPeriodStartDate = ScheduleCalculator.getAdjustedDate(fixingDate, index.getSpotLag(), calendar); final ZonedDateTime fixingPeriodEndDate = ScheduleCalculator.getAdjustedDate( fixingPeriodStartDate, index.getTenor(), index.getBusinessDayConvention(), calendar, index.isEndOfMonth()); final double fixingPeriodAccrualFactor = index .getDayCount() .getDayCountFraction(fixingPeriodStartDate, fixingPeriodEndDate, calendar); return new CouponIborDefinition( index.getCurrency(), fixingPeriodEndDate, fixingPeriodStartDate, fixingPeriodEndDate, fixingPeriodAccrualFactor, notional, fixingDate, index, calendar); }
@Test(enabled = false) /** Analyzes the shape of the forward curve. */ public void forwardAnalysis() { final MulticurveProviderInterface marketDsc = CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK.get(0).getFirst(); final int jump = 1; final int startIndex = 0; final int nbDate = 2750; ZonedDateTime startDate = ScheduleCalculator.getAdjustedDate(NOW, AUDBB3M.getSpotLag() + startIndex * jump, SYD); final double[] rateDsc = new double[nbDate]; final double[] startTime = new double[nbDate]; try { final FileWriter writer = new FileWriter("fwd-dsc.csv"); for (int loopdate = 0; loopdate < nbDate; loopdate++) { startTime[loopdate] = TimeCalculator.getTimeBetween(NOW, startDate); final ZonedDateTime endDate = ScheduleCalculator.getAdjustedDate(startDate, AUDBB3M, SYD); final double endTime = TimeCalculator.getTimeBetween(NOW, endDate); final double accrualFactor = AUDBB3M.getDayCount().getDayCountFraction(startDate, endDate); rateDsc[loopdate] = marketDsc.getForwardRate(AUDBB3M, startTime[loopdate], endTime, accrualFactor); startDate = ScheduleCalculator.getAdjustedDate(startDate, jump, SYD); writer.append(0.0 + "," + startTime[loopdate] + "," + rateDsc[loopdate] + "\n"); } writer.flush(); writer.close(); } catch (final IOException e) { e.printStackTrace(); } }
@Override protected void buildMessage( final FudgeSerializer serializer, final MutableFudgeMsg message, final IborIndex object) { message.add(SPOT_LAG_FIELD, object.getSpotLag()); message.add(DAY_COUNT_FIELD, object.getDayCount().getConventionName()); message.add( BUSINESS_DAY_CONVENTION_FIELD, object.getBusinessDayConvention().getConventionName()); message.add(EOM_FIELD, object.isEndOfMonth()); message.add(TENOR_FIELD, object.getTenor().toString()); message.add(NAME_FIELD, object.getName()); message.add(CURRENCY_FIELD, object.getCurrency().getCode()); }
/** * Builder of a coupon from the accrual dates and the index. The fixing dates are calculated using * the index. The payment date is the end accrual date. * * @param accrualStartDate Start date of the accrual period. * @param accrualEndDate End date of the accrual period. * @param accrualFactor The accrual factor of the accrual period. * @param notional The coupon notional. * @param index The coupon Ibor index. Should of the same currency as the payment. * @param calendar The holiday calendar for the ibor index. * @return The coupon. */ public static CouponIborDefinition from( final ZonedDateTime accrualStartDate, final ZonedDateTime accrualEndDate, final double accrualFactor, final double notional, final IborIndex index, final Calendar calendar) { final ZonedDateTime fixingDate = ScheduleCalculator.getAdjustedDate(accrualStartDate, -index.getSpotLag(), calendar); return new CouponIborDefinition( index.getCurrency(), accrualEndDate, accrualStartDate, accrualEndDate, accrualFactor, notional, fixingDate, index, calendar); }
@Test /** Tests the present value for curves with seasonal adjustment. */ public void presentValueSeasonality() { MarketBundle marketSeason = MarketDataSets.createMarket2(PRICING_DATE); int tenorYear = 5; double notional = 100000000; ZonedDateTime settleDate = ScheduleCalculator.getAdjustedDate(PRICING_DATE, USDLIBOR3M.getSpotLag(), CALENDAR_USD); ZonedDateTime paymentDate = ScheduleCalculator.getAdjustedDate( settleDate, Period.ofYears(tenorYear), BUSINESS_DAY, CALENDAR_USD, USDLIBOR3M.isEndOfMonth()); double weightSettle = 1.0 - (settleDate.getDayOfMonth() - 1.0) / settleDate.getMonthOfYear().getLastDayOfMonth(settleDate.isLeapYear()); double indexStart = weightSettle * 225.964 + (1 - weightSettle) * 225.722; CouponInflationZeroCouponInterpolationDefinition zeroCouponUsdDefinition = CouponInflationZeroCouponInterpolationDefinition.from( settleDate, paymentDate, notional, PRICE_INDEX_US, indexStart, MONTH_LAG, false); CouponInflationZeroCouponInterpolation zeroCouponUsd = zeroCouponUsdDefinition.toDerivative(PRICING_DATE, "not used"); CurrencyAmount pvInflation = METHOD.presentValue(zeroCouponUsd, marketSeason); double df = MARKET .getCurve(zeroCouponUsd.getCurrency()) .getDiscountFactor(zeroCouponUsd.getPaymentTime()); double indexMonth0 = marketSeason.getCurve(PRICE_INDEX_US).getPriceIndex(zeroCouponUsd.getReferenceEndTime()[0]); double indexMonth1 = marketSeason.getCurve(PRICE_INDEX_US).getPriceIndex(zeroCouponUsd.getReferenceEndTime()[1]); double finalIndex = zeroCouponUsdDefinition.getWeight() * indexMonth0 + (1 - zeroCouponUsdDefinition.getWeight()) * indexMonth1; double pvExpected = (finalIndex / indexStart - 1) * df * notional; assertEquals( "PV in market with seasonal adjustment", pvExpected, pvInflation.getAmount(), 1E-2); }
/** * Constructor of a Ibor-like floating coupon from the coupon details and the Ibor index. The * payment currency is the index currency. The fixing dates and accrual factors are inferred from * the index. * * @param currency The coupon currency. * @param paymentDate The coupon payment date. * @param accrualStartDate The start date of the accrual period. * @param accrualEndDate The end date of the accrual period. * @param paymentAccrualFactor The accrual factor of the accrual period. * @param notional The coupon notional. * @param fixingDate The coupon fixing date. * @param index The coupon Ibor index. Should of the same currency as the payment. * @param calendar The holiday calendar for the ibor index. */ public CouponIborDefinition( final Currency currency, final ZonedDateTime paymentDate, final ZonedDateTime accrualStartDate, final ZonedDateTime accrualEndDate, final double paymentAccrualFactor, final double notional, final ZonedDateTime fixingDate, final IborIndex index, final Calendar calendar) { super( currency, paymentDate, accrualStartDate, accrualEndDate, paymentAccrualFactor, notional, fixingDate); ArgumentChecker.notNull(index, "index"); ArgumentChecker.notNull(calendar, "calendar"); ArgumentChecker.isTrue( currency.equals(index.getCurrency()), "index currency different from payment currency"); _index = index; _fixingPeriodStartDate = ScheduleCalculator.getAdjustedDate(fixingDate, _index.getSpotLag(), calendar); _fixingPeriodEndDate = ScheduleCalculator.getAdjustedDate( _fixingPeriodStartDate, index.getTenor(), index.getBusinessDayConvention(), calendar, index.isEndOfMonth()); _fixingPeriodAccrualFactor = index .getDayCount() .getDayCountFraction(_fixingPeriodStartDate, _fixingPeriodEndDate, calendar); _calendar = calendar; }
/** * Tests for the methods related to interest rate securities pricing with Hull-White model convexity * adjustment. */ @Test(groups = TestGroup.UNIT) public class InterestRateFutureSecurityHullWhiteMethodTest { private static final MulticurveProviderDiscount MULTICURVES = MulticurveProviderDiscountDataSets.createMulticurveEurUsd(); private static final IborIndex[] INDEX_LIST = MulticurveProviderDiscountDataSets.getIndexesIborMulticurveEurUsd(); private static final IborIndex EURIBOR3M = INDEX_LIST[0]; private static final Currency EUR = EURIBOR3M.getCurrency(); private static final Calendar CALENDAR = MulticurveProviderDiscountDataSets.getEURCalendar(); // Future private static final ZonedDateTime SPOT_LAST_TRADING_DATE = DateUtils.getUTCDate(2012, 9, 19); private static final ZonedDateTime LAST_TRADING_DATE = ScheduleCalculator.getAdjustedDate(SPOT_LAST_TRADING_DATE, -EURIBOR3M.getSpotLag(), CALENDAR); private static final double NOTIONAL = 1000000.0; // 1m private static final double FUTURE_FACTOR = 0.25; private static final String NAME = "ERU2"; private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2011, 5, 12); private static final InterestRateFutureSecurityDefinition ERU2_DEFINITION = new InterestRateFutureSecurityDefinition( LAST_TRADING_DATE, EURIBOR3M, NOTIONAL, FUTURE_FACTOR, NAME, CALENDAR); private static final InterestRateFutureSecurity ERU2 = ERU2_DEFINITION.toDerivative(REFERENCE_DATE); private static final double MEAN_REVERSION = 0.01; private static final double[] VOLATILITY = new double[] {0.01, 0.011, 0.012, 0.013, 0.014}; private static final double[] VOLATILITY_TIME = new double[] {0.5, 1.0, 2.0, 5.0}; private static final HullWhiteOneFactorPiecewiseConstantParameters MODEL_PARAMETERS = new HullWhiteOneFactorPiecewiseConstantParameters( MEAN_REVERSION, VOLATILITY, VOLATILITY_TIME); private static final HullWhiteOneFactorProviderDiscount HW_MULTICURVES = new HullWhiteOneFactorProviderDiscount(MULTICURVES, MODEL_PARAMETERS, EUR); private static final HullWhiteOneFactorPiecewiseConstantInterestRateModel MODEL = new HullWhiteOneFactorPiecewiseConstantInterestRateModel(); private static final InterestRateFutureSecurityHullWhiteMethod METHOD_IRFUT_HW = InterestRateFutureSecurityHullWhiteMethod.getInstance(); private static final MarketQuoteHullWhiteCalculator MQHWC = MarketQuoteHullWhiteCalculator.getInstance(); private static final MarketQuoteCurveSensitivityHullWhiteCalculator MQCSHWC = MarketQuoteCurveSensitivityHullWhiteCalculator.getInstance(); private static final ConvexityAdjustmentHullWhiteCalculator CAHWC = ConvexityAdjustmentHullWhiteCalculator.getInstance(); private static final ParRateHullWhiteCalculator PRHWC = ParRateHullWhiteCalculator.getInstance(); private static final double SHIFT_FD = 1.0E-6; private static final SimpleParameterSensitivityParameterCalculator< HullWhiteOneFactorProviderInterface> SPSHWC = new SimpleParameterSensitivityParameterCalculator<>(MQCSHWC); private static final SimpleParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator SPSHWC_FD = new SimpleParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator(MQHWC, SHIFT_FD); private static final double TOLERANCE_PRICE = 1.0E-10; private static final double TOLERANCE_PRICE_DELTA = 1.0E-8; @Test /** Test the price computed from the curves and HW parameters. */ public void price() { final double price = METHOD_IRFUT_HW.price(ERU2, HW_MULTICURVES); final double forward = MULTICURVES.getSimplyCompoundForwardRate( EURIBOR3M, ERU2.getFixingPeriodStartTime(), ERU2.getFixingPeriodEndTime(), ERU2.getFixingPeriodAccrualFactor()); final double factor = MODEL.futuresConvexityFactor( MODEL_PARAMETERS, ERU2.getTradingLastTime(), ERU2.getFixingPeriodStartTime(), ERU2.getFixingPeriodEndTime()); final double expectedPrice = 1.0 - factor * forward + (1 - factor) / ERU2.getFixingPeriodAccrualFactor(); assertEquals( "InterestRateFutureSecurityHullWhiteProviderMethod: price", expectedPrice, price, TOLERANCE_PRICE); } @Test /** Test the par rate computed from the curves and HW parameters. Par rate = 1-price. */ public void parRate() { final double price = METHOD_IRFUT_HW.price(ERU2, HW_MULTICURVES); final double parRateExpected = 1.0d - price; final double parRateComputed = METHOD_IRFUT_HW.parRate(ERU2, HW_MULTICURVES); assertEquals( "InterestRateFutureSecurityHullWhiteProviderMethod: parRate", parRateExpected, parRateComputed, TOLERANCE_PRICE); } @Test /** Test the par rate computed from the method and the calculator. */ public void parRateMethodVsCalculator() { final double parRateMethod = METHOD_IRFUT_HW.parRate(ERU2, HW_MULTICURVES); final double parRateCalculator = ERU2.accept(PRHWC, HW_MULTICURVES); assertEquals( "InterestRateFutureSecurityHullWhiteProviderMethod: parRate", parRateMethod, parRateCalculator, TOLERANCE_PRICE); } @Test /** Test the price as "MarketQuote" */ public void marketQuote() { final double priceMethod = METHOD_IRFUT_HW.price(ERU2, HW_MULTICURVES); final double marketQuote = ERU2.accept(MQHWC, HW_MULTICURVES); assertEquals( "InterestRateFutureSecurityHullWhiteProviderMethod: price", priceMethod, marketQuote, TOLERANCE_PRICE); } @Test /** Test the convexity adjustment */ public void convexityAdjustment() { final double price = METHOD_IRFUT_HW.price(ERU2, HW_MULTICURVES); final double forward = MULTICURVES.getSimplyCompoundForwardRate( EURIBOR3M, ERU2.getFixingPeriodStartTime(), ERU2.getFixingPeriodEndTime(), ERU2.getFixingPeriodAccrualFactor()); final double convexityAdjustment = METHOD_IRFUT_HW.convexityAdjustment(ERU2, HW_MULTICURVES); assertEquals( "InterestRateFutureSecurityHullWhiteProviderMethod: convexity adjustment", price - (1.0d - forward), convexityAdjustment, TOLERANCE_PRICE); final double caCalculator = ERU2.accept(CAHWC, HW_MULTICURVES); assertEquals( "DeliverableSwapFuturesSecurityDefinition: convexity adjustment", caCalculator, convexityAdjustment, TOLERANCE_PRICE); } @Test /** Test the price curve sensitivity versus a finite difference computation. */ public void priceCurveSensitivity() { final SimpleParameterSensitivity pcsExact = SPSHWC.calculateSensitivity(ERU2, HW_MULTICURVES, MULTICURVES.getAllNames()); final SimpleParameterSensitivity pcsFD = SPSHWC_FD.calculateSensitivity(ERU2, HW_MULTICURVES); AssertSensitivityObjects.assertEquals( "DeliverableSwapFuturesSecurityHullWhiteMethod: priceCurveSensitivity", pcsExact, pcsFD, TOLERANCE_PRICE_DELTA); } }
/** Tests the interest rate future option with margin transaction description. */ @Test public class InterestRateFutureOptionPremiumTransactionDefinitionTest { private static final HolidayCalendar CALENDAR = HolidayCalendars.SAT_SUN; private static final IborIndex IBOR_INDEX = IndexIborMaster.getInstance().getIndex("EURIBOR3M"); // Future option mid-curve 1Y private static final ZonedDateTime SPOT_LAST_TRADING_DATE = DateUtils.getUTCDate(2012, 9, 19); private static final ZonedDateTime LAST_TRADING_DATE = ScheduleCalculator.getAdjustedDate( SPOT_LAST_TRADING_DATE, -IBOR_INDEX.getSpotLag(), CALENDAR); private static final double NOTIONAL = 1000000.0; // 1m private static final double FUTURE_FACTOR = 0.25; private static final String NAME = "ERU2"; private static final double STRIKE = 0.9895; private static final InterestRateFutureSecurityDefinition ERU2 = new InterestRateFutureSecurityDefinition( LAST_TRADING_DATE, IBOR_INDEX, NOTIONAL, FUTURE_FACTOR, NAME, CALENDAR); private static final ZonedDateTime EXPIRATION_DATE = DateUtils.getUTCDate(2011, 9, 16); private static final boolean IS_CALL = true; private static final InterestRateFutureOptionPremiumSecurityDefinition OPTION_EDU2 = new InterestRateFutureOptionPremiumSecurityDefinition(ERU2, EXPIRATION_DATE, STRIKE, IS_CALL); // Transaction private static final int QUANTITY = -123; private static final ZonedDateTime PREMIUM_DATE = DateUtils.getUTCDate(2011, 5, 12); private static final double TRADE_PRICE = 0.0050; private static final InterestRateFutureOptionPremiumTransactionDefinition OPTION_TRANSACTION = new InterestRateFutureOptionPremiumTransactionDefinition( OPTION_EDU2, QUANTITY, PREMIUM_DATE, TRADE_PRICE); // Derivative private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2010, 8, 18); private static final String DISCOUNTING_CURVE_NAME = "Funding"; private static final String FORWARD_CURVE_NAME = "Forward"; private static final String[] CURVES = {DISCOUNTING_CURVE_NAME, FORWARD_CURVE_NAME}; @Test(expectedExceptions = IllegalArgumentException.class) public void testNullUnderlying() { new InterestRateFutureOptionPremiumTransactionDefinition( null, QUANTITY, PREMIUM_DATE, TRADE_PRICE); } @Test(expectedExceptions = IllegalArgumentException.class) public void testNullTradeDate() { new InterestRateFutureOptionPremiumTransactionDefinition( OPTION_EDU2, QUANTITY, null, TRADE_PRICE); } @Test /** Tests the class getters. */ public void getter() { assertEquals(OPTION_EDU2, OPTION_TRANSACTION.getUnderlyingOption()); assertEquals(QUANTITY, OPTION_TRANSACTION.getQuantity()); assertEquals(PREMIUM_DATE, OPTION_TRANSACTION.getPremium().getPaymentDate()); assertEquals(TRADE_PRICE, OPTION_TRANSACTION.getTradePrice()); } @Test /** Tests the equal and hashCode methods. */ public void equalHash() { final InterestRateFutureOptionPremiumTransactionDefinition other = new InterestRateFutureOptionPremiumTransactionDefinition( OPTION_EDU2, QUANTITY, PREMIUM_DATE, TRADE_PRICE); assertTrue(OPTION_TRANSACTION.equals(other)); assertTrue(OPTION_TRANSACTION.hashCode() == other.hashCode()); InterestRateFutureOptionPremiumTransactionDefinition modifidOption; modifidOption = new InterestRateFutureOptionPremiumTransactionDefinition( OPTION_EDU2, QUANTITY + 1, PREMIUM_DATE, TRADE_PRICE); assertFalse(OPTION_TRANSACTION.equals(modifidOption)); modifidOption = new InterestRateFutureOptionPremiumTransactionDefinition( OPTION_EDU2, QUANTITY, LAST_TRADING_DATE, TRADE_PRICE); assertFalse(OPTION_TRANSACTION.equals(modifidOption)); modifidOption = new InterestRateFutureOptionPremiumTransactionDefinition( OPTION_EDU2, QUANTITY, PREMIUM_DATE, TRADE_PRICE - 0.00001); assertFalse(OPTION_TRANSACTION.equals(modifidOption)); } @Test /** Tests the toDerivative method when the reference date is before the premium settlement. */ public void toDerivativeBeforeSettlement() { final InterestRateFutureOptionPremiumTransaction transactionConverted = OPTION_TRANSACTION.toDerivative(REFERENCE_DATE); final InterestRateFutureOptionPremiumSecurity security = OPTION_EDU2.toDerivative(REFERENCE_DATE); final double premiumTime = TimeCalculator.getTimeBetween(REFERENCE_DATE, PREMIUM_DATE); final InterestRateFutureOptionPremiumTransaction transaction = new InterestRateFutureOptionPremiumTransaction( security, QUANTITY, premiumTime, TRADE_PRICE); assertEquals("Option on future: to derivative", transaction, transactionConverted); } @Test /** Tests the toDerivative method when the reference date is on the premium settlement. */ public void toDerivativeOnSettlement() { final ZonedDateTime referenceDate = PREMIUM_DATE; final InterestRateFutureOptionPremiumTransaction transactionConverted = OPTION_TRANSACTION.toDerivative(referenceDate); final InterestRateFutureOptionPremiumSecurity security = OPTION_EDU2.toDerivative(referenceDate); final double premiumTime = 0.0; final InterestRateFutureOptionPremiumTransaction transaction = new InterestRateFutureOptionPremiumTransaction( security, QUANTITY, premiumTime, TRADE_PRICE); assertEquals("Option on future: to derivative", transaction, transactionConverted); } @Test /** Tests the toDerivative method when the reference date is after the premium settlement. */ public void toDerivativeAfterSettlement() { final ZonedDateTime referenceDate = PREMIUM_DATE.plusDays(1); final InterestRateFutureOptionPremiumTransaction transactionConverted = OPTION_TRANSACTION.toDerivative(referenceDate); final InterestRateFutureOptionPremiumSecurity security = OPTION_EDU2.toDerivative(referenceDate); final double premiumTime = 0.0; final double price = 0.0; // The payment is in the past and is represented by a 0 payment today. final InterestRateFutureOptionPremiumTransaction transaction = new InterestRateFutureOptionPremiumTransaction(security, QUANTITY, premiumTime, price); assertEquals("Option on future: to derivative", transaction, transactionConverted); } }
/** Tests related to the pricing of physical delivery swaption in Hull-White one factor model. */ public class SwaptionPhysicalFixedIborHullWhiteMethodTest { private static final MulticurveProviderDiscount MULTICURVES = MulticurveProviderDiscountDataSets.createMulticurveEurUsd(); private static final IborIndex EURIBOR6M = MulticurveProviderDiscountDataSets.getIndexesIborMulticurveEurUsd()[1]; private static final Currency EUR = EURIBOR6M.getCurrency(); private static final Calendar CALENDAR = MulticurveProviderDiscountDataSets.getEURCalendar(); private static final HullWhiteOneFactorPiecewiseConstantParameters HW_PARAMETERS = HullWhiteDataSets.createHullWhiteParameters(); private static final HullWhiteOneFactorProviderDiscount HW_MULTICURVES = new HullWhiteOneFactorProviderDiscount(MULTICURVES, HW_PARAMETERS, EUR); private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2011, 7, 7); // Swaption 5Yx5Y private static final int SPOT_LAG = EURIBOR6M.getSpotLag(); private static final int SWAP_TENOR_YEAR = 5; private static final Period SWAP_TENOR = Period.ofYears(SWAP_TENOR_YEAR); private static final GeneratorSwapFixedIbor EUR1YEURIBOR6M = GeneratorSwapFixedIborMaster.getInstance().getGenerator("EUR1YEURIBOR6M", CALENDAR); private static final ZonedDateTime EXPIRY_DATE = DateUtils.getUTCDate(2016, 7, 7); private static final boolean IS_LONG = true; private static final ZonedDateTime SETTLEMENT_DATE = ScheduleCalculator.getAdjustedDate(EXPIRY_DATE, SPOT_LAG, CALENDAR); private static final double NOTIONAL = 100000000; // 100m private static final double RATE = 0.0175; private static final boolean FIXED_IS_PAYER = true; private static final SwapFixedIborDefinition SWAP_PAYER_DEFINITION = SwapFixedIborDefinition.from( SETTLEMENT_DATE, SWAP_TENOR, EUR1YEURIBOR6M, NOTIONAL, RATE, FIXED_IS_PAYER); private static final SwapFixedIborDefinition SWAP_RECEIVER_DEFINITION = SwapFixedIborDefinition.from( SETTLEMENT_DATE, SWAP_TENOR, EUR1YEURIBOR6M, NOTIONAL, RATE, !FIXED_IS_PAYER); private static final SwaptionPhysicalFixedIborDefinition SWAPTION_LONG_PAYER_DEFINITION = SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_PAYER_DEFINITION, IS_LONG); private static final SwaptionPhysicalFixedIborDefinition SWAPTION_LONG_RECEIVER_DEFINITION = SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_RECEIVER_DEFINITION, IS_LONG); private static final SwaptionPhysicalFixedIborDefinition SWAPTION_SHORT_PAYER_DEFINITION = SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_PAYER_DEFINITION, !IS_LONG); private static final SwaptionPhysicalFixedIborDefinition SWAPTION_SHORT_RECEIVER_DEFINITION = SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_RECEIVER_DEFINITION, !IS_LONG); private static final SwapFixedCoupon<Coupon> SWAP_RECEIVER = SWAP_RECEIVER_DEFINITION.toDerivative(REFERENCE_DATE); private static final SwaptionPhysicalFixedIbor SWAPTION_LONG_PAYER = SWAPTION_LONG_PAYER_DEFINITION.toDerivative(REFERENCE_DATE); private static final SwaptionPhysicalFixedIbor SWAPTION_LONG_RECEIVER = SWAPTION_LONG_RECEIVER_DEFINITION.toDerivative(REFERENCE_DATE); private static final SwaptionPhysicalFixedIbor SWAPTION_SHORT_PAYER = SWAPTION_SHORT_PAYER_DEFINITION.toDerivative(REFERENCE_DATE); private static final SwaptionPhysicalFixedIbor SWAPTION_SHORT_RECEIVER = SWAPTION_SHORT_RECEIVER_DEFINITION.toDerivative(REFERENCE_DATE); // Calculator private static final SwaptionPhysicalFixedIborHullWhiteMethod METHOD_HW = SwaptionPhysicalFixedIborHullWhiteMethod.getInstance(); private static final SwapFixedCouponDiscountingMethod METHOD_SWAP = SwapFixedCouponDiscountingMethod.getInstance(); private static final CashFlowEquivalentCalculator CFEC = CashFlowEquivalentCalculator.getInstance(); private static final ParRateDiscountingCalculator PRDC = ParRateDiscountingCalculator.getInstance(); private static final PresentValueDiscountingCalculator PVDC = PresentValueDiscountingCalculator.getInstance(); private static final PresentValueCurveSensitivityDiscountingCalculator PVCSDC = PresentValueCurveSensitivityDiscountingCalculator.getInstance(); private static final PresentValueHullWhiteCalculator PVHWC = PresentValueHullWhiteCalculator.getInstance(); private static final PresentValueCurveSensitivityHullWhiteCalculator PVCSHWC = PresentValueCurveSensitivityHullWhiteCalculator.getInstance(); private static final double SHIFT = 1.0E-6; private static final ParameterSensitivityParameterCalculator<HullWhiteOneFactorProviderInterface> PS_HW_C = new ParameterSensitivityParameterCalculator<>(PVCSHWC); private static final ParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator PS_HW_FDC = new ParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator(PVHWC, SHIFT); private static final SwaptionPhysicalFixedIborHullWhiteNumericalIntegrationMethod METHOD_HW_INTEGRATION = SwaptionPhysicalFixedIborHullWhiteNumericalIntegrationMethod.getInstance(); private static final SwaptionPhysicalFixedIborHullWhiteApproximationMethod METHOD_HW_APPROXIMATION = SwaptionPhysicalFixedIborHullWhiteApproximationMethod.getInstance(); private static final int NB_PATH = 12500; private static final HullWhiteMonteCarloMethod METHOD_HW_MONTECARLO = new HullWhiteMonteCarloMethod(new NormalRandomNumberGenerator(0.0, 1.0), NB_PATH); private static final HullWhiteOneFactorPiecewiseConstantInterestRateModel MODEL = new HullWhiteOneFactorPiecewiseConstantInterestRateModel(); private static final ProbabilityDistribution<Double> NORMAL = new NormalDistribution(0, 1); private static final double TOLERANCE_PV = 1.0E-2; private static final double TOLERANCE_PV_DELTA = 1.0E+0; // Testing note: Sensitivity is for a movement of 1. 1E+2 = 1 cent for a 1 bp move. @Test /** Test the present value. */ public void presentValueExplicit() { final MultipleCurrencyAmount pv = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final double timeToExpiry = SWAPTION_LONG_PAYER.getTimeToExpiry(); final AnnuityPaymentFixed cfe = CFEC.visitSwap(SWAPTION_LONG_PAYER.getUnderlyingSwap(), MULTICURVES); final int numberOfPayments = cfe.getNumberOfPayments(); final double alpha[] = new double[numberOfPayments]; final double disccf[] = new double[numberOfPayments]; for (int loopcf = 0; loopcf < numberOfPayments; loopcf++) { alpha[loopcf] = MODEL.alpha( HW_PARAMETERS, 0.0, timeToExpiry, timeToExpiry, cfe.getNthPayment(loopcf).getPaymentTime()); disccf[loopcf] = MULTICURVES.getDiscountFactor(EUR, cfe.getNthPayment(loopcf).getPaymentTime()) * cfe.getNthPayment(loopcf).getAmount(); } final double kappa = MODEL.kappa(disccf, alpha); double pvExpected = 0.0; for (int loopcf = 0; loopcf < numberOfPayments; loopcf++) { pvExpected += disccf[loopcf] * NORMAL.getCDF(-kappa - alpha[loopcf]); } assertEquals( "Swaption physical - Hull-White - present value", pvExpected, pv.getAmount(EUR), 1E-2); final MultipleCurrencyAmount pv2 = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, cfe, HW_MULTICURVES); assertEquals("Swaption physical - Hull-White - present value", pv, pv2); } @Test /** Tests long/short parity. */ public void longShortParityExplicit() { final MultipleCurrencyAmount pvLong = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvShort = METHOD_HW.presentValue(SWAPTION_SHORT_PAYER, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - present value - long/short parity", pvLong.getAmount(EUR), -pvShort.getAmount(EUR), TOLERANCE_PV); } @Test /** Tests payer/receiver/swap parity. */ public void payerReceiverParityExplicit() { final MultipleCurrencyAmount pvReceiverLong = METHOD_HW.presentValue(SWAPTION_LONG_RECEIVER, HW_MULTICURVES); final MultipleCurrencyAmount pvPayerShort = METHOD_HW.presentValue(SWAPTION_SHORT_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvSwap = SWAP_RECEIVER.accept(PVDC, MULTICURVES); assertEquals( "Swaption physical - Hull-White - present value - payer/receiver/swap parity", pvReceiverLong.getAmount(EUR) + pvPayerShort.getAmount(EUR), pvSwap.getAmount(EUR), TOLERANCE_PV); } @Test /** Tests the method against the present value calculator. */ public void presentValueMethodVsCalculator() { final MultipleCurrencyAmount pvMethod = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvCalculator = SWAPTION_LONG_PAYER.accept(PVHWC, HW_MULTICURVES); assertEquals( "SwaptionPhysicalFixedIborSABRMethod: present value : method and calculator", pvMethod, pvCalculator); } @Test /** Compare explicit formula with numerical integration. */ public void presentValueNumericalIntegration() { final MultipleCurrencyAmount pvPayerLongExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvPayerLongIntegration = METHOD_HW_INTEGRATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - present value - explicit/numerical integration", pvPayerLongExplicit.getAmount(EUR), pvPayerLongIntegration.getAmount(EUR), TOLERANCE_PV); final MultipleCurrencyAmount pvPayerShortExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvPayerShortIntegration = METHOD_HW_INTEGRATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - present value - explicit/numerical integration", pvPayerShortExplicit.getAmount(EUR), pvPayerShortIntegration.getAmount(EUR), TOLERANCE_PV); final MultipleCurrencyAmount pvReceiverLongExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvReceiverLongIntegration = METHOD_HW_INTEGRATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - present value - explicit/numerical integration", pvReceiverLongExplicit.getAmount(EUR), pvReceiverLongIntegration.getAmount(EUR), TOLERANCE_PV); final MultipleCurrencyAmount pvReceiverShortExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvReceiverShortIntegration = METHOD_HW_INTEGRATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - present value - explicit/numerical integration", pvReceiverShortExplicit.getAmount(EUR), pvReceiverShortIntegration.getAmount(EUR), TOLERANCE_PV); } @Test /** Compare explicit formula with approximated formula. */ public void presentValueApproximation() { final BlackImpliedVolatilityFormula implied = new BlackImpliedVolatilityFormula(); final double forward = SWAPTION_LONG_PAYER .getUnderlyingSwap() .accept(ParRateDiscountingCalculator.getInstance(), MULTICURVES); final double pvbp = METHOD_SWAP.presentValueBasisPoint(SWAPTION_LONG_PAYER.getUnderlyingSwap(), MULTICURVES); final MultipleCurrencyAmount pvPayerLongExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvPayerLongApproximation = METHOD_HW_APPROXIMATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final BlackFunctionData data = new BlackFunctionData(forward, pvbp, 0.20); final double volExplicit = implied.getImpliedVolatility(data, SWAPTION_LONG_PAYER, pvPayerLongExplicit.getAmount(EUR)); final double volApprox = implied.getImpliedVolatility( data, SWAPTION_LONG_PAYER, pvPayerLongApproximation.getAmount(EUR)); assertEquals( "Swaption physical - Hull-White - present value - explicit/approximation", pvPayerLongExplicit.getAmount(EUR), pvPayerLongApproximation.getAmount(EUR), 5.0E+2); assertEquals( "Swaption physical - Hull-White - present value - explicit/approximation", volExplicit, volApprox, 2.5E-4); // 0.025% final MultipleCurrencyAmount pvReceiverLongExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvReceiverLongApproximation = METHOD_HW_APPROXIMATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - present value - explicit/numerical integration", pvReceiverLongExplicit.getAmount(EUR), pvReceiverLongApproximation.getAmount(EUR), 5.0E+2); } @Test /** Approximation analysis. */ public void presentValueApproximationAnalysis() { final NormalImpliedVolatilityFormula implied = new NormalImpliedVolatilityFormula(); final int nbStrike = 20; final double[] pvExplicit = new double[nbStrike + 1]; final double[] pvApproximation = new double[nbStrike + 1]; final double[] strike = new double[nbStrike + 1]; final double[] volExplicit = new double[nbStrike + 1]; final double[] volApprox = new double[nbStrike + 1]; final double strikeRange = 0.010; final SwapFixedCoupon<Coupon> swap = SWAP_PAYER_DEFINITION.toDerivative(REFERENCE_DATE); final double forward = swap.accept(PRDC, MULTICURVES); final double pvbp = METHOD_SWAP.presentValueBasisPoint(swap, MULTICURVES); for (int loopstrike = 0; loopstrike <= nbStrike; loopstrike++) { strike[loopstrike] = forward - strikeRange + 3 * strikeRange * loopstrike / nbStrike; // From forward-strikeRange to forward+2*strikeRange final SwapFixedIborDefinition swapDefinition = SwapFixedIborDefinition.from( SETTLEMENT_DATE, SWAP_TENOR, EUR1YEURIBOR6M, NOTIONAL, strike[loopstrike], FIXED_IS_PAYER); final SwaptionPhysicalFixedIborDefinition swaptionDefinition = SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, swapDefinition, IS_LONG); final SwaptionPhysicalFixedIbor swaption = swaptionDefinition.toDerivative(REFERENCE_DATE); pvExplicit[loopstrike] = METHOD_HW.presentValue(swaption, HW_MULTICURVES).getAmount(EUR); pvApproximation[loopstrike] = METHOD_HW_APPROXIMATION.presentValue(swaption, HW_MULTICURVES).getAmount(EUR); final NormalFunctionData data = new NormalFunctionData(forward, pvbp, 0.01); volExplicit[loopstrike] = implied.getImpliedVolatility(data, swaption, pvExplicit[loopstrike]); volApprox[loopstrike] = implied.getImpliedVolatility(data, swaption, pvApproximation[loopstrike]); assertEquals( "Swaption physical - Hull-White - implied volatility - explicit/approximation", volExplicit[loopstrike], volApprox[loopstrike], 1.0E-3); // 0.10% } } @Test(enabled = true) /** Compare explicit formula with Monte-Carlo and long/short and payer/receiver parities. */ public void presentValueMonteCarlo() { HullWhiteMonteCarloMethod methodMC; methodMC = new HullWhiteMonteCarloMethod( new NormalRandomNumberGenerator(0.0, 1.0, new MersenneTwister()), NB_PATH); // Seed fixed to the DEFAULT_SEED for testing purposes. final MultipleCurrencyAmount pvPayerLongExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyAmount pvPayerLongMC = methodMC.presentValue(SWAPTION_LONG_PAYER, EUR, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - Monte Carlo", pvPayerLongExplicit.getAmount(EUR), pvPayerLongMC.getAmount(EUR), 1.0E+4); final double pvMCPreviousRun = 4221400.891; assertEquals( "Swaption physical - Hull-White - Monte Carlo", pvMCPreviousRun, pvPayerLongMC.getAmount(EUR), TOLERANCE_PV); methodMC = new HullWhiteMonteCarloMethod( new NormalRandomNumberGenerator(0.0, 1.0, new MersenneTwister()), NB_PATH); final MultipleCurrencyAmount pvPayerShortMC = methodMC.presentValue(SWAPTION_SHORT_PAYER, EUR, HW_MULTICURVES); assertEquals( "Swaption physical - Hull-White - Monte Carlo", -pvPayerLongMC.getAmount(EUR), pvPayerShortMC.getAmount(EUR), TOLERANCE_PV); final MultipleCurrencyAmount pvReceiverLongMC = methodMC.presentValue(SWAPTION_LONG_RECEIVER, EUR, HW_MULTICURVES); final MultipleCurrencyAmount pvSwap = SWAP_RECEIVER.accept(PVDC, MULTICURVES); assertEquals( "Swaption physical - Hull-White - Monte Carlo - payer/receiver/swap parity", pvReceiverLongMC.getAmount(EUR) + pvPayerShortMC.getAmount(EUR), pvSwap.getAmount(EUR), 1.0E+5); } @Test /** Tests the Hull-White parameters sensitivity for the explicit formula. */ public void presentValueHullWhiteSensitivityExplicit() { final double[] hwSensitivity = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); final int nbVolatility = HW_PARAMETERS.getVolatility().length; final double shiftVol = 1.0E-6; final double[] volatilityBumped = new double[nbVolatility]; System.arraycopy(HW_PARAMETERS.getVolatility(), 0, volatilityBumped, 0, nbVolatility); final double[] volatilityTime = new double[nbVolatility - 1]; System.arraycopy(HW_PARAMETERS.getVolatilityTime(), 1, volatilityTime, 0, nbVolatility - 1); final double[] pvBumpedPlus = new double[nbVolatility]; final double[] pvBumpedMinus = new double[nbVolatility]; final HullWhiteOneFactorPiecewiseConstantParameters parametersBumped = new HullWhiteOneFactorPiecewiseConstantParameters( HW_PARAMETERS.getMeanReversion(), volatilityBumped, volatilityTime); final HullWhiteOneFactorProviderDiscount bundleBumped = new HullWhiteOneFactorProviderDiscount(MULTICURVES, parametersBumped, EUR); for (int loopvol = 0; loopvol < nbVolatility; loopvol++) { volatilityBumped[loopvol] += shiftVol; parametersBumped.setVolatility(volatilityBumped); pvBumpedPlus[loopvol] = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, bundleBumped).getAmount(EUR); volatilityBumped[loopvol] -= 2 * shiftVol; parametersBumped.setVolatility(volatilityBumped); pvBumpedMinus[loopvol] = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, bundleBumped).getAmount(EUR); assertEquals( "Swaption - Hull-White sensitivity adjoint: derivative " + loopvol + " - difference:" + ((pvBumpedPlus[loopvol] - pvBumpedMinus[loopvol]) / (2 * shiftVol) - hwSensitivity[loopvol]), (pvBumpedPlus[loopvol] - pvBumpedMinus[loopvol]) / (2 * shiftVol), hwSensitivity[loopvol], TOLERANCE_PV_DELTA); volatilityBumped[loopvol] = HW_PARAMETERS.getVolatility()[loopvol]; } } @Test /** Tests long/short parity. */ public void presentValueHullWhiteSensitivitylongShortParityExplicit() { final double[] pvhwsLong = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); final double[] pvhwsShort = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_SHORT_PAYER, HW_MULTICURVES); for (int loophw = 0; loophw < pvhwsLong.length; loophw++) { assertEquals( "Swaption physical - Hull-White - presentValueHullWhiteSensitivity - long/short parity", pvhwsLong[loophw], -pvhwsShort[loophw], TOLERANCE_PV_DELTA); } } @Test /** Tests payer/receiver/swap parity. */ public void presentValueHullWhiteSensitivitypayerReceiverParityExplicit() { final double[] pvhwsReceiverLong = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_LONG_RECEIVER, HW_MULTICURVES); final double[] pvhwsPayerShort = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_SHORT_PAYER, HW_MULTICURVES); for (int loophw = 0; loophw < pvhwsReceiverLong.length; loophw++) { assertEquals( "Swaption physical - Hull-White - present value - payer/receiver/swap parity", 0, pvhwsReceiverLong[loophw] + pvhwsPayerShort[loophw], TOLERANCE_PV_DELTA); } } @Test /** Tests present value curve sensitivity when the valuation date is on trade date. */ public void presentValueCurveSensitivity() { final MultipleCurrencyParameterSensitivity pvpsExact = PS_HW_C.calculateSensitivity( SWAPTION_SHORT_RECEIVER, HW_MULTICURVES, HW_MULTICURVES.getMulticurveProvider().getAllNames()); final MultipleCurrencyParameterSensitivity pvpsFD = PS_HW_FDC.calculateSensitivity(SWAPTION_SHORT_RECEIVER, HW_MULTICURVES); AssertSensivityObjects.assertEquals( "SwaptionPhysicalFixedIborSABRMethod: presentValueCurveSensitivity ", pvpsExact, pvpsFD, TOLERANCE_PV_DELTA); } @Test(enabled = false) /** Tests present value curve sensitivity when the valuation date is on trade date. */ public void presentValueCurveSensitivityStability() { // 5Yx5Y final MultipleCurrencyParameterSensitivity pvpsExact = PS_HW_C.calculateSensitivity( SWAPTION_SHORT_RECEIVER, HW_MULTICURVES, HW_MULTICURVES.getMulticurveProvider().getAllNames()); final double derivativeExact = pvpsExact.totalSensitivity(MULTICURVES.getFxRates(), EUR); final double startingShift = 1.0E-4; final double ratio = Math.sqrt(2.0); final int nbShift = 55; final double[] eps = new double[nbShift + 1]; final double[] derivative_FD = new double[nbShift]; final double[] diff = new double[nbShift]; eps[0] = startingShift; for (int loopshift = 0; loopshift < nbShift; loopshift++) { final ParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator fdShift = new ParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator(PVHWC, eps[loopshift]); final MultipleCurrencyParameterSensitivity pvpsFD = fdShift.calculateSensitivity(SWAPTION_SHORT_RECEIVER, HW_MULTICURVES); derivative_FD[loopshift] = pvpsFD.totalSensitivity(MULTICURVES.getFxRates(), EUR); diff[loopshift] = derivative_FD[loopshift] - derivativeExact; eps[loopshift + 1] = eps[loopshift] / ratio; } // 1Mx5Y final Period expirationPeriod = Period.ofDays( 1); // Period.ofDays(1); Period.ofDays(7); Period.ofMonths(1); Period.ofYears(1); // Period.ofYears(10); final ZonedDateTime expiryDateExp = ScheduleCalculator.getAdjustedDate(REFERENCE_DATE, expirationPeriod, EURIBOR6M, CALENDAR); final ZonedDateTime settlementDateExp = ScheduleCalculator.getAdjustedDate(expiryDateExp, SPOT_LAG, CALENDAR); final double ATM = 0.0151; // 1W: 1.52% - 1M: 1.52% - 1Y: 1.51% - 10Y: 1.51% final SwapFixedIborDefinition swapExpx5YDefinition = SwapFixedIborDefinition.from( settlementDateExp, SWAP_TENOR, EUR1YEURIBOR6M, NOTIONAL, ATM, !FIXED_IS_PAYER); final SwaptionPhysicalFixedIborDefinition swaptionExpx5YDefinition = SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, swapExpx5YDefinition, !IS_LONG); final SwaptionPhysicalFixedIbor swaptionExpx5Y = swaptionExpx5YDefinition.toDerivative(REFERENCE_DATE); // final double forward = swaptionExpx5Y.getUnderlyingSwap().accept(PRDC, MULTICURVES); final MultipleCurrencyParameterSensitivity pvpsExactExp = PS_HW_C.calculateSensitivity( swaptionExpx5Y, HW_MULTICURVES, HW_MULTICURVES.getMulticurveProvider().getAllNames()); final double derivativeExactExp = pvpsExactExp.totalSensitivity(MULTICURVES.getFxRates(), EUR); final double[] derivative_FDExp = new double[nbShift]; final double[] diffExp = new double[nbShift]; for (int loopshift = 0; loopshift < nbShift; loopshift++) { final ParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator fdShift = new ParameterSensitivityHullWhiteDiscountInterpolatedFDCalculator(PVHWC, eps[loopshift]); final MultipleCurrencyParameterSensitivity pvpsFD = fdShift.calculateSensitivity(swaptionExpx5Y, HW_MULTICURVES); derivative_FDExp[loopshift] = pvpsFD.totalSensitivity(MULTICURVES.getFxRates(), EUR); diffExp[loopshift] = derivative_FDExp[loopshift] - derivativeExactExp; } // int t = 0; // t++; } @Test /** Tests long/short parity. */ public void presentValueCurveSensitivityLongShortParityExplicit() { final MultipleCurrencyMulticurveSensitivity pvhwsLong = METHOD_HW.presentValueCurveSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); final MultipleCurrencyMulticurveSensitivity pvhwsShort = METHOD_HW.presentValueCurveSensitivity(SWAPTION_SHORT_PAYER, HW_MULTICURVES); AssertSensivityObjects.assertEquals( "Swaption physical - Hull-White - presentValueCurveSensitivity - long/short parity", pvhwsLong, pvhwsShort.multipliedBy(-1.0), TOLERANCE_PV_DELTA); } @Test /** Tests payer/receiver/swap parity. */ public void presentValueCurveSensitivityPayerReceiverParityExplicit() { final MultipleCurrencyMulticurveSensitivity pvhwsReceiverLong = METHOD_HW.presentValueCurveSensitivity(SWAPTION_LONG_RECEIVER, HW_MULTICURVES); final MultipleCurrencyMulticurveSensitivity pvhwsPayerShort = METHOD_HW.presentValueCurveSensitivity(SWAPTION_SHORT_PAYER, HW_MULTICURVES); final MultipleCurrencyMulticurveSensitivity pvSwap = SWAP_RECEIVER.accept(PVCSDC, MULTICURVES); AssertSensivityObjects.assertEquals( "Swaption physical - Hull-White - presentValueCurveSensitivity - payer/receiver/swap parity", pvSwap.cleaned(TOLERANCE_PV_DELTA), pvhwsReceiverLong.plus(pvhwsPayerShort).cleaned(TOLERANCE_PV_DELTA), TOLERANCE_PV_DELTA); } @Test /** Tests the curve sensitivity in Monte Carlo approach. */ public void presentValueCurveSensitivityMonteCarlo() { final double toleranceDelta = 1.0E+6; // 100 USD by bp final MultipleCurrencyMulticurveSensitivity pvcsExplicit = METHOD_HW .presentValueCurveSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES) .cleaned(TOLERANCE_PV_DELTA); final HullWhiteMonteCarloMethod methodMC = new HullWhiteMonteCarloMethod( new NormalRandomNumberGenerator(0.0, 1.0, new MersenneTwister()), NB_PATH); final MultipleCurrencyMulticurveSensitivity pvcsMC = methodMC .presentValueCurveSensitivity(SWAPTION_LONG_PAYER, EUR, HW_MULTICURVES) .cleaned(TOLERANCE_PV_DELTA); AssertSensivityObjects.assertEquals( "Swaption physical - Hull-White - presentValueCurveSensitivity - payer/receiver/swap parity", pvcsExplicit, pvcsMC, toleranceDelta); } @Test(enabled = false) /** Tests of performance. "enabled = false" for the standard testing. */ public void performance() { long startTime, endTime; final int nbTest = 1000; MultipleCurrencyAmount pvPayerLongExplicit = MultipleCurrencyAmount.of(EUR, 0.0); MultipleCurrencyAmount pvPayerLongIntegration = MultipleCurrencyAmount.of(EUR, 0.0); MultipleCurrencyAmount pvPayerLongApproximation = MultipleCurrencyAmount.of(EUR, 0.0); @SuppressWarnings("unused") MultipleCurrencyAmount pvPayerLongMC = MultipleCurrencyAmount.of(EUR, 0.0); double[] pvhws = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); MultipleCurrencyMulticurveSensitivity pvcs = METHOD_HW.presentValueCurveSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvPayerLongExplicit = METHOD_HW.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " pv swaption Hull-White explicit method: " + (endTime - startTime) + " ms"); // Performance note: HW price: 19-Nov-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: 380 ms for // 10000 swaptions. startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvhws = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " HW sensitivity swaption Hull-White explicit method: " + (endTime - startTime) + " ms"); // Performance note: HW sensitivity (3): 19-Nov-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: // 430 ms for 10000 swaptions. startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvcs = METHOD_HW.presentValueCurveSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " curve sensitivity swaption Hull-White explicit method: " + (endTime - startTime) + " ms"); // Performance note: curve sensitivity (40): 19-Nov-2012: On Mac Pro 3.2 GHz Quad-Core Intel // Xeon: 855 ms for 10000 swaptions. startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvhws = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); pvcs = METHOD_HW.presentValueCurveSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); pvhws = METHOD_HW.presentValueHullWhiteSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " price/delta/vega swaption Hull-White explicit method: " + (endTime - startTime) + " ms"); // Performance note: present value/delta/vega: 19-Nov-2012: On Mac Pro 3.2 GHz Quad-Core Intel // Xeon: 1730 ms for 10000 swaptions. startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvPayerLongIntegration = METHOD_HW_INTEGRATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " swaption Hull-White numerical integration method: " + (endTime - startTime) + " ms"); // Performance note: HW numerical integration: 19-Nov-2012: On Mac Pro 3.2 GHz Quad-Core Intel // Xeon: 1700 ms for 10000 swaptions. startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvPayerLongApproximation = METHOD_HW_APPROXIMATION.presentValue(SWAPTION_LONG_PAYER, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " swaption Hull-White approximation method: " + (endTime - startTime) + " ms"); // Performance note: HW approximation: 19-Nov-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: 250 // ms for 10000 swaptions. startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvPayerLongMC = METHOD_HW_MONTECARLO.presentValue(SWAPTION_LONG_PAYER, EUR, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " swaption Hull-White Monte Carlo method (" + NB_PATH + " paths): " + (endTime - startTime) + " ms"); // Performance note: HW approximation: 18-Aug-11: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: 9200 // ms for 1000 swaptions (12500 paths). final double difference = pvPayerLongExplicit.getAmount(EUR) - pvPayerLongIntegration.getAmount(EUR); final double difference2 = pvPayerLongExplicit.getAmount(EUR) - pvPayerLongApproximation.getAmount(EUR); // double difference3 = pvPayerLongExplicit.getAmount(CUR) - pvPayerLongMC.getAmount(CUR); System.out.println("Difference explicit-integration: " + difference); System.out.println("Difference explicit-approximation: " + difference2); // System.out.println("Difference explicit-Monte Carlo: " + difference3); System.out.println("Curve sensitivity: " + pvcs.toString()); System.out.println("HW sensitivity: " + Arrays.toString(pvhws)); } @Test(enabled = false) /** Tests of performance. "enabled = false" for the standard testing. */ public void performanceCurveSensitivity() { long startTime, endTime; final int nbTest = 25; MultipleCurrencyAmount pvMC = MultipleCurrencyAmount.of(EUR, 0.0); final MultipleCurrencyMulticurveSensitivity pvcsExplicit = METHOD_HW.presentValueCurveSensitivity(SWAPTION_LONG_PAYER, HW_MULTICURVES); MultipleCurrencyMulticurveSensitivity pvcsMC = pvcsExplicit; final HullWhiteMonteCarloMethod methodMC = new HullWhiteMonteCarloMethod( new NormalRandomNumberGenerator(0.0, 1.0, new MersenneTwister()), NB_PATH); startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvMC = METHOD_HW_MONTECARLO.presentValue(SWAPTION_LONG_PAYER, EUR, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " swaption Hull-White Monte Carlo method (" + NB_PATH + " paths): " + (endTime - startTime) + " ms / price:" + pvMC.toString()); // Performance note: HW approximation: 03-Dec-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: 250 // ms for 25 swaptions (12500 paths). startTime = System.currentTimeMillis(); for (int looptest = 0; looptest < nbTest; looptest++) { pvcsMC = methodMC.presentValueCurveSensitivity(SWAPTION_LONG_PAYER, EUR, HW_MULTICURVES); } endTime = System.currentTimeMillis(); System.out.println( nbTest + " curve sensitivity swaption Hull-White MC method: (" + NB_PATH + " paths) " + (endTime - startTime) + " ms / risk:" + pvcsMC.toString()); // Performance note: curve sensitivity (40): 03-Dec-2012: On Mac Pro 3.2 GHz Quad-Core Intel // Xeon: 600 ms for 25 swaptions (12500 paths). } }
/** * Test class for the replication method for CMS caplet/floorlet using a SABR smile with * extrapolation. */ @Test public class CapFloorCMSSABRExtrapolationRightReplicationMethodTest { private static final MulticurveProviderDiscount MULTICURVES = MulticurveProviderDiscountDataSets.createMulticurveEurUsd(); private static final IborIndex EURIBOR6M = MulticurveProviderDiscountDataSets.getIndexesIborMulticurveEurUsd()[1]; private static final Currency EUR = EURIBOR6M.getCurrency(); private static final HolidayCalendar CALENDAR = MulticurveProviderDiscountDataSets.getEURCalendar(); private static final SABRInterestRateParameters SABR_PARAMETER = SABRDataSets.createSABR1(); private static final GeneratorSwapFixedIbor EUR1YEURIBOR6M = GeneratorSwapFixedIborMaster.getInstance().getGenerator("EUR1YEURIBOR6M", CALENDAR); private static final SABRSwaptionProviderDiscount SABR_MULTICURVES = new SABRSwaptionProviderDiscount(MULTICURVES, SABR_PARAMETER, EUR1YEURIBOR6M); // Swap 5Y private static final BusinessDayConvention BUSINESS_DAY = BusinessDayConventions.MODIFIED_FOLLOWING; private static final boolean IS_EOM = true; private static final Period ANNUITY_TENOR = Period.ofYears(5); private static final ZonedDateTime SETTLEMENT_DATE = DateUtils.getUTCDate(2020, 4, 28); // Fixed leg: Semi-annual bond private static final Period FIXED_PAYMENT_PERIOD = Period.ofMonths(6); private static final DayCount FIXED_DAY_COUNT = DayCounts.THIRTY_U_360; private static final double RATE = 0.0325; private static final boolean FIXED_IS_PAYER = true; private static final AnnuityCouponFixedDefinition FIXED_ANNUITY = AnnuityCouponFixedDefinition.from( EUR, SETTLEMENT_DATE, ANNUITY_TENOR, FIXED_PAYMENT_PERIOD, CALENDAR, FIXED_DAY_COUNT, BUSINESS_DAY, IS_EOM, 1.0, RATE, FIXED_IS_PAYER); // Ibor leg: quarterly money private static final AnnuityCouponIborDefinition IBOR_ANNUITY = AnnuityCouponIborDefinition.from( SETTLEMENT_DATE, ANNUITY_TENOR, 1.0, EURIBOR6M, !FIXED_IS_PAYER, CALENDAR); // CMS coupon construction private static final IndexSwap CMS_INDEX = new IndexSwap(FIXED_PAYMENT_PERIOD, FIXED_DAY_COUNT, EURIBOR6M, ANNUITY_TENOR, CALENDAR); private static final SwapFixedIborDefinition SWAP_DEFINITION = new SwapFixedIborDefinition(FIXED_ANNUITY, IBOR_ANNUITY); private static final ZonedDateTime FIXING_DATE = ScheduleCalculator.getAdjustedDate(SETTLEMENT_DATE, -EURIBOR6M.getSpotLag(), CALENDAR); private static final ZonedDateTime ACCRUAL_START_DATE = SETTLEMENT_DATE; // pre-fixed private static final ZonedDateTime ACCRUAL_END_DATE = ScheduleCalculator.getAdjustedDate( ACCRUAL_START_DATE, FIXED_PAYMENT_PERIOD, BUSINESS_DAY, CALENDAR); private static final ZonedDateTime PAYMENT_DATE = ACCRUAL_END_DATE; private static final DayCount PAYMENT_DAY_COUNT = DayCounts.ACT_360; private static final double ACCRUAL_FACTOR = DayCountUtils.yearFraction(PAYMENT_DAY_COUNT, ACCRUAL_START_DATE, ACCRUAL_END_DATE); private static final double NOTIONAL = 10000000; // 10m private static final CouponCMSDefinition CMS_COUPON_RECEIVER_DEFINITION = CouponCMSDefinition.from( PAYMENT_DATE, ACCRUAL_START_DATE, ACCRUAL_END_DATE, ACCRUAL_FACTOR, NOTIONAL, FIXING_DATE, SWAP_DEFINITION, CMS_INDEX); private static final CouponCMSDefinition CMS_COUPON_PAYER_DEFINITION = CouponCMSDefinition.from( PAYMENT_DATE, ACCRUAL_START_DATE, ACCRUAL_END_DATE, ACCRUAL_FACTOR, -NOTIONAL, FIXING_DATE, SWAP_DEFINITION, CMS_INDEX); // Cap/Floor construction private static final double STRIKE = 0.04; private static final boolean IS_CAP = true; private static final CapFloorCMSDefinition CMS_CAP_LONG_DEFINITION = CapFloorCMSDefinition.from(CMS_COUPON_RECEIVER_DEFINITION, STRIKE, IS_CAP); private static final CapFloorCMSDefinition CMS_CAP_SHORT_DEFINITION = CapFloorCMSDefinition.from(CMS_COUPON_PAYER_DEFINITION, STRIKE, IS_CAP); private static final CapFloorCMSDefinition CMS_CAP_0_DEFINITION = CapFloorCMSDefinition.from(CMS_COUPON_RECEIVER_DEFINITION, 0.0, IS_CAP); // to derivatives private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2010, 8, 18); private static final CouponCMS CMS_COUPON = (CouponCMS) CMS_COUPON_RECEIVER_DEFINITION.toDerivative(REFERENCE_DATE); private static final CapFloorCMS CMS_CAP_0 = (CapFloorCMS) CMS_CAP_0_DEFINITION.toDerivative(REFERENCE_DATE); private static final CapFloorCMS CMS_CAP_LONG = (CapFloorCMS) CMS_CAP_LONG_DEFINITION.toDerivative(REFERENCE_DATE); private static final CapFloorCMS CMS_CAP_SHORT = (CapFloorCMS) CMS_CAP_SHORT_DEFINITION.toDerivative(REFERENCE_DATE); // Calculators & methods private static final CapFloorCMSSABRReplicationMethod METHOD_STANDARD_CAP = CapFloorCMSSABRReplicationMethod.getDefaultInstance(); private static final CouponCMSSABRReplicationMethod METHOD_STANDARD_CPN = CouponCMSSABRReplicationMethod.getInstance(); private static final CouponCMSDiscountingMethod METHOD_DSC_CPN = CouponCMSDiscountingMethod.getInstance(); private static final double CUT_OFF_STRIKE = 0.10; private static final double MU = 2.50; private static final CapFloorCMSSABRExtrapolationRightReplicationMethod METHOD_EXTRAPOLATION_CAP = new CapFloorCMSSABRExtrapolationRightReplicationMethod(CUT_OFF_STRIKE, MU); private static final CouponCMSSABRExtrapolationRightReplicationMethod METHOD_EXTRAPOLATION_CPN = new CouponCMSSABRExtrapolationRightReplicationMethod(CUT_OFF_STRIKE, MU); // Calculators private static final PresentValueSABRSwaptionRightExtrapolationCalculator PVSSXC = new PresentValueSABRSwaptionRightExtrapolationCalculator(CUT_OFF_STRIKE, MU); private static final PresentValueCurveSensitivitySABRSwaptionRightExtrapolationCalculator PVCSSSXC = new PresentValueCurveSensitivitySABRSwaptionRightExtrapolationCalculator( CUT_OFF_STRIKE, MU); private static final PresentValueSABRSensitivitySABRSwaptionRightExtrapolationCalculator PVSSSSXC = new PresentValueSABRSensitivitySABRSwaptionRightExtrapolationCalculator( CUT_OFF_STRIKE, MU); private static final double SHIFT = 1.0E-6; private static final ParameterSensitivityParameterCalculator<SABRSwaptionProviderInterface> PS_SS_C = new ParameterSensitivityParameterCalculator<>(PVCSSSXC); private static final ParameterSensitivitySABRSwaptionDiscountInterpolatedFDCalculator PS_SS_FDC = new ParameterSensitivitySABRSwaptionDiscountInterpolatedFDCalculator(PVSSXC, SHIFT); private static final double TOLERANCE_PV = 1.0E-2; private static final double TOLERANCE_PV_DELTA = 5.0E+3; // 0.01 currency unit for 1 bp. /** * Test the present value for a CMS coupon with pricing by replication in the SABR with * extrapolation framework. The present value is tested against hard-coded value and cap of strike * 0. */ public void presentValue() { // CMS cap/floor with strike 0 has the same price as a CMS coupon. final double priceCouponStd = METHOD_STANDARD_CPN.presentValue(CMS_COUPON, SABR_MULTICURVES).getAmount(EUR).getAmount(); final double rateCouponStd = priceCouponStd / (CMS_COUPON.getPaymentYearFraction() * CMS_COUPON.getNotional() * MULTICURVES.getDiscountFactor(EUR, CMS_COUPON.getPaymentTime())); final double priceCouponExtra = METHOD_EXTRAPOLATION_CPN .presentValue(CMS_COUPON, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); final double rateCouponExtra = priceCouponExtra / (CMS_COUPON.getPaymentYearFraction() * CMS_COUPON.getNotional() * MULTICURVES.getDiscountFactor(EUR, CMS_COUPON.getPaymentTime())); final double priceCouponNoAdj = METHOD_DSC_CPN.presentValue(CMS_COUPON, MULTICURVES).getAmount(EUR).getAmount(); final double rateCouponNoAdj = priceCouponNoAdj / (CMS_COUPON.getPaymentYearFraction() * CMS_COUPON.getNotional() * MULTICURVES.getDiscountFactor(EUR, CMS_COUPON.getPaymentTime())); assertEquals( "Extrapolation: comparison with standard method", rateCouponStd > rateCouponExtra, true); assertEquals( "Extrapolation: comparison with no convexity adjustment", rateCouponExtra > rateCouponNoAdj, true); final double rateCouponExtraExpected = 0.0189864; // From previous run. assertEquals("Extrapolation: hard-coded value", rateCouponExtraExpected, rateCouponExtra, 1E-6); final double priceCap0Extra = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_0, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); assertEquals( "Extrapolation: CMS coupon vs Cap 0", priceCouponExtra, priceCap0Extra, TOLERANCE_PV); } /** * Tests the price of CMS coupon and cap/floor using replication in the SABR framework. Method v * Calculator. */ public void presentValueMethodVsCalculator() { final double pvMethod = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_LONG, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); final double pvCalculator = CMS_CAP_LONG.accept(PVSSXC, SABR_MULTICURVES).getAmount(EUR).getAmount(); assertEquals( "CMS cap/floor SABR: Present value : method vs calculator", pvMethod, pvCalculator, TOLERANCE_PV); } /** * Test the present value for a CMS cap with pricing by replication in the SABR with extrapolation * framework. The present value is tested against hard-coded value and a long/short parity is * tested. */ public void presentValueReplicationCap() { // CMS cap/floor with strike 0 has the same price as a CMS coupon. final double priceCapLongStd = METHOD_STANDARD_CAP.presentValue(CMS_CAP_LONG, SABR_MULTICURVES).getAmount(EUR).getAmount(); final double priceCapLongExtra = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_LONG, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); final double priceCapShortExtra = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_SHORT, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); assertEquals( "CMS cap by replication - Extrapolation: comparison with standard method", priceCapLongStd > priceCapLongExtra, true); final double priceCapExtraExpected = 30696.572; // From previous run. assertEquals( "CMS cap by replication - Extrapolation: hard-coded value", priceCapExtraExpected, priceCapLongExtra, TOLERANCE_PV); assertEquals( "CMS cap by replication - Extrapolation: long/short parity", -priceCapShortExtra, priceCapLongExtra, TOLERANCE_PV); } /** * Test the present value rate sensitivity for a CMS cap with pricing by replication in the SABR * with extrapolation framework. */ public void presentValueCurveSensitivity() { final MultipleCurrencyParameterSensitivity pvpsCapLongExact = PS_SS_C.calculateSensitivity( CMS_CAP_LONG, SABR_MULTICURVES, SABR_MULTICURVES.getMulticurveProvider().getAllNames()); final MultipleCurrencyParameterSensitivity pvpsCapLongFD = PS_SS_FDC.calculateSensitivity(CMS_CAP_LONG, SABR_MULTICURVES); AssertSensitivityObjects.assertEquals( "SwaptionPhysicalFixedIborSABRMethod: presentValueCurveSensitivity ", pvpsCapLongExact, pvpsCapLongFD, TOLERANCE_PV_DELTA); final MultipleCurrencyParameterSensitivity pvpsCapShortExact = PS_SS_C.calculateSensitivity( CMS_CAP_SHORT, SABR_MULTICURVES, SABR_MULTICURVES.getMulticurveProvider().getAllNames()); final MultipleCurrencyParameterSensitivity pvpsCapShortFD = PS_SS_FDC.calculateSensitivity(CMS_CAP_SHORT, SABR_MULTICURVES); AssertSensitivityObjects.assertEquals( "SwaptionPhysicalFixedIborSABRMethod: presentValueCurveSensitivity ", pvpsCapShortExact, pvpsCapShortFD, TOLERANCE_PV_DELTA); } /** * Test the present value rate sensitivity for a CMS cap with pricing by replication in the SABR * with extrapolation framework. Method v Calculator. */ public void presentValueCurveSensitivityMethodVsCalculator() { final MultipleCurrencyMulticurveSensitivity pvcsMethod = METHOD_EXTRAPOLATION_CAP.presentValueCurveSensitivity(CMS_CAP_LONG, SABR_MULTICURVES); final MultipleCurrencyMulticurveSensitivity pvcsCalculator = CMS_CAP_LONG.accept(PVCSSSXC, SABR_MULTICURVES); AssertSensitivityObjects.assertEquals( "CMS cap/floor SABR: Present value : method vs calculator", pvcsMethod, pvcsCalculator, TOLERANCE_PV_DELTA); } /** Tests the cap present value SABR parameters sensitivity vs finite difference. */ public void presentValueSABRSensitivity() { final double pv = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_LONG, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); final PresentValueSABRSensitivityDataBundle pvsCapLong = METHOD_EXTRAPOLATION_CAP.presentValueSABRSensitivity(CMS_CAP_LONG, SABR_MULTICURVES); // SABR sensitivity vs finite difference final double shift = 0.0001; final double shiftAlpha = 0.00001; final double maturity = CMS_CAP_LONG .getUnderlyingSwap() .getFixedLeg() .getNthPayment( CMS_CAP_LONG.getUnderlyingSwap().getFixedLeg().getNumberOfPayments() - 1) .getPaymentTime() - CMS_CAP_LONG.getSettlementTime(); final DoublesPair expectedExpiryTenor = DoublesPair.of(CMS_CAP_LONG.getFixingTime(), maturity); // Alpha sensitivity vs finite difference computation final SABRInterestRateParameters sabrParameterAlphaBumped = SABRDataSets.createSABR1AlphaBumped(shiftAlpha); final SABRSwaptionProviderDiscount sabrBundleAlphaBumped = new SABRSwaptionProviderDiscount(MULTICURVES, sabrParameterAlphaBumped, EUR1YEURIBOR6M); final double pvLongPayerAlphaBumped = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_LONG, sabrBundleAlphaBumped) .getAmount(EUR) .getAmount(); final double expectedAlphaSensi = (pvLongPayerAlphaBumped - pv) / shiftAlpha; assertEquals("Number of alpha sensitivity", pvsCapLong.getAlpha().getMap().keySet().size(), 1); assertEquals( "Alpha sensitivity expiry/tenor", pvsCapLong.getAlpha().getMap().keySet().contains(expectedExpiryTenor), true); assertEquals( "Alpha sensitivity value", expectedAlphaSensi, pvsCapLong.getAlpha().getMap().get(expectedExpiryTenor), TOLERANCE_PV_DELTA); // Rho sensitivity vs finite difference computation final SABRInterestRateParameters sabrParameterRhoBumped = SABRDataSets.createSABR1RhoBumped(); final SABRSwaptionProviderDiscount sabrBundleRhoBumped = new SABRSwaptionProviderDiscount(MULTICURVES, sabrParameterRhoBumped, EUR1YEURIBOR6M); final double pvLongPayerRhoBumped = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_LONG, sabrBundleRhoBumped) .getAmount(EUR) .getAmount(); final double expectedRhoSensi = (pvLongPayerRhoBumped - pv) / shift; assertEquals("Number of rho sensitivity", pvsCapLong.getRho().getMap().keySet().size(), 1); assertEquals( "Rho sensitivity expiry/tenor", pvsCapLong.getRho().getMap().keySet().contains(expectedExpiryTenor), true); assertEquals( "Rho sensitivity value", expectedRhoSensi, pvsCapLong.getRho().getMap().get(expectedExpiryTenor), TOLERANCE_PV_DELTA); // Alpha sensitivity vs finite difference computation final SABRInterestRateParameters sabrParameterNuBumped = SABRDataSets.createSABR1NuBumped(); final SABRSwaptionProviderDiscount sabrBundleNuBumped = new SABRSwaptionProviderDiscount(MULTICURVES, sabrParameterNuBumped, EUR1YEURIBOR6M); final double pvLongPayerNuBumped = METHOD_EXTRAPOLATION_CAP .presentValue(CMS_CAP_LONG, sabrBundleNuBumped) .getAmount(EUR) .getAmount(); final double expectedNuSensi = (pvLongPayerNuBumped - pv) / shift; assertEquals("Number of nu sensitivity", pvsCapLong.getNu().getMap().keySet().size(), 1); assertTrue( "Nu sensitivity expiry/tenor", pvsCapLong.getNu().getMap().keySet().contains(expectedExpiryTenor)); assertEquals( "Nu sensitivity value", expectedNuSensi, pvsCapLong.getNu().getMap().get(expectedExpiryTenor), TOLERANCE_PV_DELTA); } /** Tests the coupon present value SABR parameters sensitivity vs finite difference. */ public void presentValueSABRSensitivityCoupon() { final double pv = METHOD_EXTRAPOLATION_CPN .presentValue(CMS_COUPON, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); final PresentValueSABRSensitivityDataBundle pvsCpn = METHOD_EXTRAPOLATION_CPN.presentValueSABRSensitivity(CMS_COUPON, SABR_MULTICURVES); // SABR sensitivity vs finite difference final double shift = 0.0001; final double shiftAlpha = 0.00001; final double maturity = CMS_COUPON .getUnderlyingSwap() .getFixedLeg() .getNthPayment( CMS_COUPON.getUnderlyingSwap().getFixedLeg().getNumberOfPayments() - 1) .getPaymentTime() - CMS_COUPON.getSettlementTime(); final DoublesPair expectedExpiryTenor = DoublesPair.of(CMS_COUPON.getFixingTime(), maturity); // Alpha sensitivity vs finite difference computation final SABRInterestRateParameters sabrParameterAlphaBumped = SABRDataSets.createSABR1AlphaBumped(shiftAlpha); final SABRSwaptionProviderDiscount sabrBundleAlphaBumped = new SABRSwaptionProviderDiscount(MULTICURVES, sabrParameterAlphaBumped, EUR1YEURIBOR6M); final double pvLongPayerAlphaBumped = METHOD_EXTRAPOLATION_CPN .presentValue(CMS_COUPON, sabrBundleAlphaBumped) .getAmount(EUR) .getAmount(); final double expectedAlphaSensi = (pvLongPayerAlphaBumped - pv) / shiftAlpha; assertEquals("Number of alpha sensitivity", pvsCpn.getAlpha().getMap().keySet().size(), 1); assertEquals( "Alpha sensitivity expiry/tenor", pvsCpn.getAlpha().getMap().keySet().contains(expectedExpiryTenor), true); assertEquals( "Alpha sensitivity value", expectedAlphaSensi, pvsCpn.getAlpha().getMap().get(expectedExpiryTenor), TOLERANCE_PV_DELTA); // Rho sensitivity vs finite difference computation final SABRInterestRateParameters sabrParameterRhoBumped = SABRDataSets.createSABR1RhoBumped(); final SABRSwaptionProviderDiscount sabrBundleRhoBumped = new SABRSwaptionProviderDiscount(MULTICURVES, sabrParameterRhoBumped, EUR1YEURIBOR6M); final double pvLongPayerRhoBumped = METHOD_EXTRAPOLATION_CPN .presentValue(CMS_COUPON, sabrBundleRhoBumped) .getAmount(EUR) .getAmount(); final double expectedRhoSensi = (pvLongPayerRhoBumped - pv) / shift; assertEquals("Number of rho sensitivity", pvsCpn.getRho().getMap().keySet().size(), 1); assertEquals( "Rho sensitivity expiry/tenor", pvsCpn.getRho().getMap().keySet().contains(expectedExpiryTenor), true); assertEquals( "Rho sensitivity value", expectedRhoSensi, pvsCpn.getRho().getMap().get(expectedExpiryTenor), TOLERANCE_PV_DELTA); // Nu sensitivity vs finite difference computation final SABRInterestRateParameters sabrParameterNuBumped = SABRDataSets.createSABR1NuBumped(); final SABRSwaptionProviderDiscount sabrBundleNuBumped = new SABRSwaptionProviderDiscount(MULTICURVES, sabrParameterNuBumped, EUR1YEURIBOR6M); final double pvLongPayerNuBumped = METHOD_EXTRAPOLATION_CPN .presentValue(CMS_COUPON, sabrBundleNuBumped) .getAmount(EUR) .getAmount(); final double expectedNuSensi = (pvLongPayerNuBumped - pv) / shift; assertEquals("Number of nu sensitivity", pvsCpn.getNu().getMap().keySet().size(), 1); assertTrue( "Nu sensitivity expiry/tenor", pvsCpn.getNu().getMap().keySet().contains(expectedExpiryTenor)); assertEquals( "Nu sensitivity value", expectedNuSensi, pvsCpn.getNu().getMap().get(expectedExpiryTenor), TOLERANCE_PV_DELTA); } /** Tests the present value SABR parameters sensitivity: Method vs Calculator. */ public void presentValueSABRSensitivityMethodVsCalculator() { final PresentValueSABRSensitivityDataBundle pvssMethod = METHOD_EXTRAPOLATION_CAP.presentValueSABRSensitivity(CMS_CAP_LONG, SABR_MULTICURVES); final PresentValueSABRSensitivityDataBundle pvssCalculator = CMS_CAP_LONG.accept(PVSSSSXC, SABR_MULTICURVES); assertEquals( "CMS cap/floor SABR: Present value SABR sensitivity: method vs calculator", pvssMethod, pvssCalculator); } /** Tests the present value strike sensitivity: Cap. */ public void presentValueStrikeSensitivityCap() { final double[] strikes = new double[] {0.0001, 0.0010, 0.0050, 0.0100, 0.0200, 0.0400, 0.0500}; final int nbStrikes = strikes.length; final double shift = 1.0E-5; final double[] errorRelative = new double[nbStrikes]; for (int loopstrike = 0; loopstrike < nbStrikes; loopstrike++) { final CapFloorCMSDefinition cmsCapDefinition = CapFloorCMSDefinition.from(CMS_COUPON_RECEIVER_DEFINITION, strikes[loopstrike], IS_CAP); final CapFloorCMSDefinition cmsCapShiftUpDefinition = CapFloorCMSDefinition.from( CMS_COUPON_RECEIVER_DEFINITION, strikes[loopstrike] + shift, IS_CAP); final CapFloorCMSDefinition cmsCapShiftDoDefinition = CapFloorCMSDefinition.from( CMS_COUPON_RECEIVER_DEFINITION, strikes[loopstrike] - shift, IS_CAP); final CapFloorCMS cmsCap = (CapFloorCMS) cmsCapDefinition.toDerivative(REFERENCE_DATE); final CapFloorCMS cmsCapShiftUp = (CapFloorCMS) cmsCapShiftUpDefinition.toDerivative(REFERENCE_DATE); final CapFloorCMS cmsCapShiftDo = (CapFloorCMS) cmsCapShiftDoDefinition.toDerivative(REFERENCE_DATE); final double pvShiftUp = METHOD_EXTRAPOLATION_CAP .presentValue(cmsCapShiftUp, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); final double pvShiftDo = METHOD_EXTRAPOLATION_CAP .presentValue(cmsCapShiftDo, SABR_MULTICURVES) .getAmount(EUR) .getAmount(); final double sensiExpected = (pvShiftUp - pvShiftDo) / (2 * shift); final double sensiComputed = METHOD_EXTRAPOLATION_CAP.presentValueStrikeSensitivity(cmsCap, SABR_MULTICURVES); errorRelative[loopstrike] = (sensiExpected - sensiComputed) / sensiExpected; assertEquals( "CMS cap/floor SABR: Present value strike sensitivity " + loopstrike, 0, errorRelative[loopstrike], 5.0E-3); } } /** * Tests to estimate the impact of mu on the CMS coupon pricing. "enabled = false" for the * standard testing. */ public void testPriceMultiMu() { final double[] mu = new double[] {1.10, 1.30, 1.55, 2.25, 3.50, 6.00, 15.0}; final int nbMu = mu.length; final double priceCouponStd = METHOD_STANDARD_CPN.presentValue(CMS_COUPON, SABR_MULTICURVES).getAmount(EUR).getAmount(); @SuppressWarnings("unused") final double rateCouponStd = priceCouponStd / (CMS_COUPON.getPaymentYearFraction() * CMS_COUPON.getNotional() * MULTICURVES.getDiscountFactor(EUR, CMS_COUPON.getPaymentTime())); final double[] priceCouponExtra = new double[nbMu]; final double[] rateCouponExtra = new double[nbMu]; for (int loopmu = 0; loopmu < nbMu; loopmu++) { final CouponCMSSABRExtrapolationRightReplicationMethod methodExtrapolation = new CouponCMSSABRExtrapolationRightReplicationMethod(CUT_OFF_STRIKE, mu[loopmu]); priceCouponExtra[loopmu] = methodExtrapolation.presentValue(CMS_COUPON, SABR_MULTICURVES).getAmount(EUR).getAmount(); rateCouponExtra[loopmu] = priceCouponExtra[loopmu] / (CMS_COUPON.getPaymentYearFraction() * CMS_COUPON.getNotional() * MULTICURVES.getDiscountFactor(EUR, CMS_COUPON.getPaymentTime())); } final double priceCouponNoAdj = METHOD_DSC_CPN.presentValue(CMS_COUPON, MULTICURVES).getAmount(EUR).getAmount(); final double rateCouponNoAdj = priceCouponNoAdj / (CMS_COUPON.getPaymentYearFraction() * CMS_COUPON.getNotional() * MULTICURVES.getDiscountFactor(EUR, CMS_COUPON.getPaymentTime())); for (int loopmu = 1; loopmu < nbMu; loopmu++) { assertTrue( "Extrapolation: comparison with standard method", rateCouponExtra[loopmu - 1] > rateCouponExtra[loopmu]); } assertTrue( "Extrapolation: comparison with standard method", rateCouponExtra[nbMu - 1] > rateCouponNoAdj); } }
public class CouponFixedCompoundingDefinitionTest { private static final Calendar NYC = new MondayToFridayCalendar("NYC"); private static final IndexIborMaster MASTER_IBOR = IndexIborMaster.getInstance(); private static final IborIndex USDLIBOR1M = MASTER_IBOR.getIndex("USDLIBOR1M"); private static final Currency CURRENCY = USDLIBOR1M.getCurrency(); private static final Period TENOR_3M = Period.ofMonths(3); private static final ZonedDateTime START_DATE = DateUtils.getUTCDate(2012, 8, 24); private static final double NOTIONAL = 123454321; private static final double FIXED_RATE = .02; private static final ZonedDateTime[] ACCRUAL_END_DATES = ScheduleCalculator.getAdjustedDateSchedule( START_DATE, TENOR_3M, true, false, USDLIBOR1M, NYC); private static final int NB_SUB_PERIOD = ACCRUAL_END_DATES.length; private static final ZonedDateTime[] ACCRUAL_START_DATES = new ZonedDateTime[NB_SUB_PERIOD]; private static final double[] PAYMENT_ACCRUAL_FACTORS = new double[NB_SUB_PERIOD]; private static final double PAYMENT_ACCRUAL_FACTOR; static { ACCRUAL_START_DATES[0] = START_DATE; for (int loopsub = 1; loopsub < NB_SUB_PERIOD; loopsub++) { ACCRUAL_START_DATES[loopsub] = ACCRUAL_END_DATES[loopsub - 1]; } double af = 0.0; for (int loopsub = 0; loopsub < NB_SUB_PERIOD; loopsub++) { PAYMENT_ACCRUAL_FACTORS[loopsub] = USDLIBOR1M .getDayCount() .getDayCountFraction(ACCRUAL_START_DATES[loopsub], ACCRUAL_END_DATES[loopsub]); af += PAYMENT_ACCRUAL_FACTORS[loopsub]; } PAYMENT_ACCRUAL_FACTOR = af; } private static final ZonedDateTime[] FIXING_DATES = ScheduleCalculator.getAdjustedDate(ACCRUAL_START_DATES, -USDLIBOR1M.getSpotLag(), NYC); private static final ZonedDateTime[] FIXING_PERIOD_END_DATES = ScheduleCalculator.getAdjustedDate(ACCRUAL_START_DATES, USDLIBOR1M, NYC); private static final double[] FIXING_ACCRUAL_FACTORS = new double[NB_SUB_PERIOD]; static { for (int loopsub = 0; loopsub < NB_SUB_PERIOD; loopsub++) { FIXING_ACCRUAL_FACTORS[loopsub] = USDLIBOR1M .getDayCount() .getDayCountFraction(ACCRUAL_START_DATES[loopsub], FIXING_PERIOD_END_DATES[loopsub]); } } private static final ZonedDateTime PAYMENT_DATE = ACCRUAL_END_DATES[NB_SUB_PERIOD - 1]; private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2012, 8, 17); private static final double[] FIXING_TIMES = TimeCalculator.getTimeBetween(REFERENCE_DATE, FIXING_DATES); private static final double[] FIXING_PERIOD_END_TIMES = TimeCalculator.getTimeBetween(REFERENCE_DATE, FIXING_PERIOD_END_DATES); private static final double[] ACCRUAL_START_TIMES = TimeCalculator.getTimeBetween(REFERENCE_DATE, ACCRUAL_START_DATES); private static final double[] ACCRUAL_END_TIMES = TimeCalculator.getTimeBetween(REFERENCE_DATE, ACCRUAL_END_DATES); private static final double PAYMENT_TIME = ACCRUAL_END_TIMES[NB_SUB_PERIOD - 1]; private static final String DSC_NAME = "Dsc_USD"; private static final String FWD_NAME = "Forward1M_USD"; private static final CouponFixedCompoundingDefinition COUPON = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); @Test /** Tests the getters. */ public void testGetters() { assertEquals(COUPON.getPaymentDate(), PAYMENT_DATE); assertEquals(COUPON.getAccrualStartDate(), ACCRUAL_START_DATES[0]); assertEquals(COUPON.getAccrualEndDate(), ACCRUAL_END_DATES[NB_SUB_PERIOD - 1]); assertEquals(COUPON.getPaymentYearFraction(), PAYMENT_ACCRUAL_FACTOR, 1E-10); assertEquals(COUPON.getNotional(), NOTIONAL, 1E-2); assertEquals(COUPON.getRate(), FIXED_RATE, 1E-10); assertArrayEquals(COUPON.getAccrualStartDates(), ACCRUAL_START_DATES); assertArrayEquals(COUPON.getAccrualEndDates(), ACCRUAL_END_DATES); assertArrayEquals(COUPON.getPaymentAccrualFactors(), PAYMENT_ACCRUAL_FACTORS, 0); } @Test(expectedExceptions = IllegalArgumentException.class) public void nullCurrency() { CouponFixedCompoundingDefinition.from( null, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); } @Test(expectedExceptions = IllegalArgumentException.class) public void testNullPaymentDate() { CouponFixedCompoundingDefinition.from( CURRENCY, null, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); } @Test(expectedExceptions = IllegalArgumentException.class) public void testNegativePaymentAccrualFactor() { CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], -PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); } @Test /** Tests the equal and hash code. */ public void testEqualHash() { assertEquals("CouponIbor: equal-hash", COUPON, COUPON); final CouponFixedCompoundingDefinition other = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); assertEquals("CouponFixedCompoundingDefinition: equal-hash", other, COUPON); assertEquals( "CouponFixedCompoundingDefinition: equal-hash", other.hashCode(), COUPON.hashCode()); CouponFixedCompoundingDefinition modified; modified = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE.plusDays(1), ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); assertFalse("CouponIbor: equal-hash", COUPON.equals(modified)); modified = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0].plusDays(1), ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); assertFalse("CouponIbor: equal-hash", COUPON.equals(modified)); modified = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1].plusDays(1), PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); assertFalse("CouponIbor: equal-hash", COUPON.equals(modified)); modified = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR + 1, NOTIONAL, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); assertFalse("CouponIbor: equal-hash", COUPON.equals(modified)); modified = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL + 1, FIXED_RATE, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); assertFalse("CouponIbor: equal-hash", COUPON.equals(modified)); modified = CouponFixedCompoundingDefinition.from( CURRENCY, PAYMENT_DATE, ACCRUAL_START_DATES[0], ACCRUAL_END_DATES[NB_SUB_PERIOD - 1], PAYMENT_ACCRUAL_FACTOR, NOTIONAL, FIXED_RATE + 1, ACCRUAL_START_DATES, ACCRUAL_END_DATES, PAYMENT_ACCRUAL_FACTORS); assertFalse("CouponIbor: equal-hash", COUPON.equals(modified)); } }
/** Tests related to the construction of Ibor coupon. */ public class CouponIborTest { private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2010, 12, 27); private static final Calendar TARGET = new MondayToFridayCalendar("TARGET"); private static final IndexIborMaster INDEX_IBOR_MASTER = IndexIborMaster.getInstance(); private static final IborIndex INDEX_EURIBOR3M = INDEX_IBOR_MASTER.getIndex("EURIBOR3M"); private static final Currency EUR = INDEX_EURIBOR3M.getCurrency(); // Coupon private static final DayCount DAY_COUNT_COUPON = DayCountFactory.INSTANCE.getDayCount("Actual/365"); private static final ZonedDateTime ACCRUAL_START_DATE = DateUtils.getUTCDate(2011, 5, 23); private static final ZonedDateTime ACCRUAL_END_DATE = DateUtils.getUTCDate(2011, 8, 22); private static final ZonedDateTime PAYMENT_DATE = DateUtils.getUTCDate(2011, 8, 24); private static final double ACCRUAL_FACTOR = DAY_COUNT_COUPON.getDayCountFraction(ACCRUAL_START_DATE, ACCRUAL_END_DATE); private static final double NOTIONAL = 1000000; // 1m private static final ZonedDateTime FIXING_DATE = ScheduleCalculator.getAdjustedDate( ACCRUAL_END_DATE, -INDEX_EURIBOR3M.getSpotLag(), TARGET); // In arrears private static final ZonedDateTime FIXING_START_DATE = ACCRUAL_END_DATE; private static final ZonedDateTime FIXING_END_DATE = ScheduleCalculator.getAdjustedDate(FIXING_START_DATE, INDEX_EURIBOR3M, TARGET); private static final double PAYMENT_TIME = TimeCalculator.getTimeBetween(REFERENCE_DATE, PAYMENT_DATE); private static final double FIXING_TIME = TimeCalculator.getTimeBetween(REFERENCE_DATE, FIXING_DATE); private static final double FIXING_START_TIME = TimeCalculator.getTimeBetween(REFERENCE_DATE, FIXING_START_DATE); private static final double FIXING_END_TIME = TimeCalculator.getTimeBetween(REFERENCE_DATE, FIXING_END_DATE); private static final double FIXING_ACCRUAL_FACTOR = INDEX_EURIBOR3M.getDayCount().getDayCountFraction(FIXING_START_DATE, FIXING_END_DATE); private static final CouponIbor CPN_IBOR = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); @Test(expectedExceptions = IllegalArgumentException.class) public void nullCurrency() { new CouponIbor( null, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); } @Test(expectedExceptions = IllegalArgumentException.class) public void nullIndex() { new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, null, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); } @Test(expectedExceptions = IllegalArgumentException.class) public void incompatibleCurrency() { new CouponIbor( Currency.USD, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); } @Test /** Tests the getters. */ public void getter() { assertEquals("CouponIbor: getter", EUR, CPN_IBOR.getCurrency()); assertEquals("CouponIbor: getter", INDEX_EURIBOR3M, CPN_IBOR.getIndex()); assertEquals("CouponIbor: getter", FIXING_START_TIME, CPN_IBOR.getFixingPeriodStartTime()); assertEquals("CouponIbor: getter", FIXING_END_TIME, CPN_IBOR.getFixingPeriodEndTime()); assertEquals("CouponIbor: getter", FIXING_ACCRUAL_FACTOR, CPN_IBOR.getFixingAccrualFactor()); } @Test public void testWithNotional() { final double notional = NOTIONAL + 1000; final CouponIbor expected = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, notional, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertEquals(expected, CPN_IBOR.withNotional(notional)); } @Test /** Tests the equal and hash code. */ public void testEqualHash() { assertEquals("CouponIbor: equal-hash", CPN_IBOR, CPN_IBOR); final CouponIbor other = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertEquals("CouponIbor: equal-hash", other, CPN_IBOR); assertEquals("CouponIbor: equal-hash", other.hashCode(), CPN_IBOR.hashCode()); CouponIbor modified; modified = new CouponIbor( EUR, PAYMENT_TIME + 0.1, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); modified = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR + 0.1, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); modified = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL + 1.0, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); modified = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME - 0.1, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); modified = new CouponIbor( Currency.USD, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_IBOR_MASTER.getIndex("USDLIBOR3M"), FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); modified = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME + 0.1, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); modified = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME + 0.1, FIXING_ACCRUAL_FACTOR); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); modified = new CouponIbor( EUR, PAYMENT_TIME, ACCRUAL_FACTOR, NOTIONAL, FIXING_TIME, INDEX_EURIBOR3M, FIXING_START_TIME, FIXING_END_TIME, FIXING_ACCRUAL_FACTOR + 0.1); assertFalse("CouponIbor: equal-hash", CPN_IBOR.equals(modified)); } }