@Test /** Tests the curve sensitivity. */ public void presentValueCurveSensitivity() { InterestRateCurveSensitivity pvsSwaption = METHOD_HW_APPROXIMATION.presentValueCurveSensitivity(SWAPTION_PAYER_LONG, BUNDLE_HW); pvsSwaption = pvsSwaption.cleaned(); final double deltaTolerancePrice = 1.0E+4; // Testing note: Sensitivity is for a movement of 1. 1E+2 = 1 cent for a 1 bp move. Tolerance // increased to cope with numerical imprecision of finite difference. final double deltaShift = 1.0E-6; // 1. Forward curve sensitivity final String bumpedCurveName = "Bumped Curve"; final SwaptionCashFixedIbor swptBumpedForward = SWAPTION_PAYER_LONG_DEFINITION.toDerivative( REFERENCE_DATE, new String[] {CURVES_NAME[0], bumpedCurveName}); DoubleAVLTreeSet forwardTime = new DoubleAVLTreeSet(); for (int loopcpn = 0; loopcpn < SWAPTION_PAYER_LONG.getUnderlyingSwap().getSecondLeg().getNumberOfPayments(); loopcpn++) { CouponIbor cpn = (CouponIbor) SWAPTION_PAYER_LONG.getUnderlyingSwap().getSecondLeg().getNthPayment(loopcpn); forwardTime.add(cpn.getFixingPeriodStartTime()); forwardTime.add(cpn.getFixingPeriodEndTime()); } double[] nodeTimesForward = forwardTime.toDoubleArray(); final double[] sensiForwardMethod = SensitivityFiniteDifference.curveSensitivity( swptBumpedForward, BUNDLE_HW, CURVES_NAME[1], bumpedCurveName, nodeTimesForward, deltaShift, METHOD_HW_APPROXIMATION); final List<DoublesPair> sensiPvForward = pvsSwaption.getSensitivities().get(CURVES_NAME[1]); for (int loopnode = 0; loopnode < sensiForwardMethod.length; loopnode++) { final DoublesPair pairPv = sensiPvForward.get(loopnode); assertEquals( "Sensitivity swaption pv to forward curve: Node " + loopnode, nodeTimesForward[loopnode], pairPv.getFirst(), 1E-8); assertEquals( "Sensitivity finite difference method: node sensitivity " + loopnode, sensiForwardMethod[loopnode], pairPv.second, deltaTolerancePrice); } // 2. Discounting curve sensitivity final SwaptionCashFixedIbor swptBumpedDisc = SWAPTION_PAYER_LONG_DEFINITION.toDerivative( REFERENCE_DATE, new String[] {bumpedCurveName, CURVES_NAME[1]}); DoubleAVLTreeSet discTime = new DoubleAVLTreeSet(); discTime.add(SWAPTION_PAYER_LONG.getSettlementTime()); for (int loopcpn = 0; loopcpn < SWAPTION_PAYER_LONG.getUnderlyingSwap().getSecondLeg().getNumberOfPayments(); loopcpn++) { CouponIbor cpn = (CouponIbor) SWAPTION_PAYER_LONG.getUnderlyingSwap().getSecondLeg().getNthPayment(loopcpn); discTime.add(cpn.getPaymentTime()); } double[] nodeTimesDisc = discTime.toDoubleArray(); final double[] sensiDiscMethod = SensitivityFiniteDifference.curveSensitivity( swptBumpedDisc, BUNDLE_HW, CURVES_NAME[0], bumpedCurveName, nodeTimesDisc, deltaShift, METHOD_HW_APPROXIMATION); assertEquals( "Sensitivity finite difference method: number of node", 11, sensiDiscMethod.length); final List<DoublesPair> sensiPvDisc = pvsSwaption.getSensitivities().get(CURVES_NAME[0]); for (int loopnode = 0; loopnode < sensiDiscMethod.length; loopnode++) { final DoublesPair pairPv = sensiPvDisc.get(loopnode); assertEquals( "Sensitivity swaption pv to forward curve: Node " + loopnode, nodeTimesDisc[loopnode], pairPv.getFirst(), 1E-8); assertEquals( "Sensitivity finite difference method: node sensitivity", sensiDiscMethod[loopnode], pairPv.second, deltaTolerancePrice); } }
/** * The method calibrates a LMM on a set of vanilla swaption priced with SABR. The set of vanilla * swaptions is given by the CalibrationType. The curve sensitivities of the original swaption are * calculated with LMM re-calibration. * * @param swaption The swaption. * @param curves The curves and SABR data. * @return The present value curve sensitivities. */ public InterestRateCurveSensitivity presentValueCurveSensitivity( final SwaptionPhysicalFixedIbor swaption, final SABRInterestRateDataBundle curves) { ArgumentChecker.notNull(swaption, "swaption"); ArgumentChecker.notNull(curves, "curves"); // TODO: Create a way to chose the LMM base parameters (displacement, mean reversion, // volatility). final LiborMarketModelDisplacedDiffusionParameters lmmParameters = LiborMarketModelDisplacedDiffusionParameters.from( swaption, DEFAULT_DISPLACEMENT, DEFAULT_MEAN_REVERSION, new VolatilityLMMAngle(DEFAULT_ANGLE, DEFAULT_DISPLACEMENT)); final SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationObjective objective = new SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationObjective(lmmParameters); final SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationEngine calibrationEngine = new SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationEngine(objective); final SwaptionPhysicalFixedIbor[] swaptionCalibration = METHOD_BASKET.calibrationBasketFixedLegPeriod(swaption); calibrationEngine.addInstrument(swaptionCalibration, METHOD_SWAPTION_SABR); calibrationEngine.calibrate(curves); final LiborMarketModelDisplacedDiffusionDataBundle lmmBundle = new LiborMarketModelDisplacedDiffusionDataBundle(lmmParameters, curves); // Risks final int nbCal = swaptionCalibration.length; final int nbFact = lmmParameters.getNbFactor(); final List<Integer> instrumentIndex = calibrationEngine.getInstrumentIndex(); final double[] dPvAmdLambda = new double[nbCal]; final double[][][] dPvCaldGamma = new double[nbCal][][]; final double[][] dPvCaldLambda = new double[nbCal][nbCal]; InterestRateCurveSensitivity pvcsCal = METHOD_SWAPTION_LMM.presentValueCurveSensitivity(swaption, lmmBundle); pvcsCal = pvcsCal.cleaned(); final double[][] dPvAmdGamma = METHOD_SWAPTION_LMM.presentValueLMMSensitivity(swaption, lmmBundle); for (int loopcal = 0; loopcal < nbCal; loopcal++) { dPvCaldGamma[loopcal] = METHOD_SWAPTION_LMM.presentValueLMMSensitivity(swaptionCalibration[loopcal], lmmBundle); } // Multiplicative-factor sensitivity for (int loopcal = 0; loopcal < nbCal; loopcal++) { for (int loopperiod = instrumentIndex.get(loopcal); loopperiod < instrumentIndex.get(loopcal + 1); loopperiod++) { for (int loopfact = 0; loopfact < nbFact; loopfact++) { dPvAmdLambda[loopcal] += dPvAmdGamma[loopperiod][loopfact] * lmmParameters.getVolatility()[loopperiod][loopfact]; } } } for (int loopcal1 = 0; loopcal1 < nbCal; loopcal1++) { for (int loopcal2 = 0; loopcal2 < nbCal; loopcal2++) { for (int loopperiod = instrumentIndex.get(loopcal2); loopperiod < instrumentIndex.get(loopcal2 + 1); loopperiod++) { for (int loopfact = 0; loopfact < nbFact; loopfact++) { dPvCaldLambda[loopcal1][loopcal2] += dPvCaldGamma[loopcal1][loopperiod][loopfact] * lmmParameters.getVolatility()[loopperiod][loopfact]; } } } } final InterestRateCurveSensitivity[] pvcsCalBase = new InterestRateCurveSensitivity[nbCal]; final InterestRateCurveSensitivity[] pvcsCalCal = new InterestRateCurveSensitivity[nbCal]; final InterestRateCurveSensitivity[] pvcsCalDiff = new InterestRateCurveSensitivity[nbCal]; for (int loopcal = 0; loopcal < nbCal; loopcal++) { pvcsCalBase[loopcal] = METHOD_SWAPTION_SABR.presentValueCurveSensitivity(swaptionCalibration[loopcal], curves); pvcsCalBase[loopcal] = pvcsCalBase[loopcal].cleaned(); pvcsCalCal[loopcal] = METHOD_SWAPTION_LMM.presentValueCurveSensitivity(swaptionCalibration[loopcal], lmmBundle); pvcsCalCal[loopcal] = pvcsCalCal[loopcal].cleaned(); pvcsCalDiff[loopcal] = pvcsCalBase[loopcal].plus(pvcsCalCal[loopcal].multipliedBy(-1)); pvcsCalDiff[loopcal] = pvcsCalDiff[loopcal].cleaned(); } final CommonsMatrixAlgebra matrix = new CommonsMatrixAlgebra(); final DoubleMatrix2D dPvCaldLambdaMatrix = new DoubleMatrix2D(dPvCaldLambda); final DoubleMatrix2D dPvCaldLambdaMatrixInverse = matrix.getInverse(dPvCaldLambdaMatrix); // Curve sensitivity final InterestRateCurveSensitivity[] dLambdadC = new InterestRateCurveSensitivity[nbCal]; for (int loopcal1 = 0; loopcal1 < nbCal; loopcal1++) { dLambdadC[loopcal1] = new InterestRateCurveSensitivity(); for (int loopcal2 = 0; loopcal2 <= loopcal1; loopcal2++) { dLambdadC[loopcal1] = dLambdadC[loopcal1].plus( pvcsCalDiff[loopcal2].multipliedBy( dPvCaldLambdaMatrixInverse.getEntry(loopcal1, loopcal2))); } } InterestRateCurveSensitivity pvcsAdjust = new InterestRateCurveSensitivity(); for (int loopcal = 0; loopcal < nbCal; loopcal++) { pvcsAdjust = pvcsAdjust.plus(dLambdadC[loopcal].multipliedBy(dPvAmdLambda[loopcal])); } pvcsAdjust = pvcsAdjust.cleaned(); InterestRateCurveSensitivity pvcsTot = pvcsCal.plus(pvcsAdjust); pvcsTot = pvcsTot.cleaned(); return pvcsTot; }
/** * The method calibrates a LMM on a set of vanilla swaption priced with SABR. The set of vanilla * swaptions is given by the CalibrationType. The curve and SABR sensitivities of the original * swaption are calculated with LMM re-calibration. Used mainly for performance test purposes as * the output is hybrid list. * * @param swaption The swaption. * @param curves The curves and SABR data. * @return The results (returned as a list of objects) [0] the present value, [1] the present * curve sensitivity, [2] the present value SABR sensitivity. */ public List<Object> presentValueCurveSABRSensitivity( final SwaptionPhysicalFixedIbor swaption, final SABRInterestRateDataBundle curves) { ArgumentChecker.notNull(swaption, "swaption"); ArgumentChecker.notNull(curves, "curves"); // TODO: Create a way to chose the LMM base parameters (displacement, mean reversion, // volatility). final LiborMarketModelDisplacedDiffusionParameters lmmParameters = LiborMarketModelDisplacedDiffusionParameters.from( swaption, DEFAULT_DISPLACEMENT, DEFAULT_MEAN_REVERSION, new VolatilityLMMAngle(DEFAULT_ANGLE, DEFAULT_DISPLACEMENT)); final SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationObjective objective = new SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationObjective(lmmParameters); final SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationEngine calibrationEngine = new SwaptionPhysicalLMMDDSuccessiveRootFinderCalibrationEngine(objective); final SwaptionPhysicalFixedIbor[] swaptionCalibration = METHOD_BASKET.calibrationBasketFixedLegPeriod(swaption); calibrationEngine.addInstrument(swaptionCalibration, METHOD_SWAPTION_SABR); calibrationEngine.calibrate(curves); final LiborMarketModelDisplacedDiffusionDataBundle lmmBundle = new LiborMarketModelDisplacedDiffusionDataBundle(lmmParameters, curves); // Risks final int nbCal = swaptionCalibration.length; final int nbFact = lmmParameters.getNbFactor(); final List<Integer> instrumentIndex = calibrationEngine.getInstrumentIndex(); final double[] dPvAmdLambda = new double[nbCal]; final double[][][] dPvCaldGamma = new double[nbCal][][]; final double[][] dPvCaldLambda = new double[nbCal][nbCal]; final PresentValueSABRSensitivityDataBundle[] dPvCaldSABR = new PresentValueSABRSensitivityDataBundle[nbCal]; InterestRateCurveSensitivity pvcsCal = METHOD_SWAPTION_LMM.presentValueCurveSensitivity(swaption, lmmBundle); pvcsCal = pvcsCal.cleaned(); final double[][] dPvAmdGamma = METHOD_SWAPTION_LMM.presentValueLMMSensitivity(swaption, lmmBundle); for (int loopcal = 0; loopcal < nbCal; loopcal++) { dPvCaldGamma[loopcal] = METHOD_SWAPTION_LMM.presentValueLMMSensitivity(swaptionCalibration[loopcal], lmmBundle); } // Multiplicative-factor sensitivity for (int loopcal = 0; loopcal < nbCal; loopcal++) { for (int loopperiod = instrumentIndex.get(loopcal); loopperiod < instrumentIndex.get(loopcal + 1); loopperiod++) { for (int loopfact = 0; loopfact < nbFact; loopfact++) { dPvAmdLambda[loopcal] += dPvAmdGamma[loopperiod][loopfact] * lmmParameters.getVolatility()[loopperiod][loopfact]; } } } for (int loopcal1 = 0; loopcal1 < nbCal; loopcal1++) { for (int loopcal2 = 0; loopcal2 < nbCal; loopcal2++) { for (int loopperiod = instrumentIndex.get(loopcal2); loopperiod < instrumentIndex.get(loopcal2 + 1); loopperiod++) { for (int loopfact = 0; loopfact < nbFact; loopfact++) { dPvCaldLambda[loopcal1][loopcal2] += dPvCaldGamma[loopcal1][loopperiod][loopfact] * lmmParameters.getVolatility()[loopperiod][loopfact]; } } } } final InterestRateCurveSensitivity[] pvcsCalBase = new InterestRateCurveSensitivity[nbCal]; final InterestRateCurveSensitivity[] pvcsCalCal = new InterestRateCurveSensitivity[nbCal]; final InterestRateCurveSensitivity[] pvcsCalDiff = new InterestRateCurveSensitivity[nbCal]; for (int loopcal = 0; loopcal < nbCal; loopcal++) { pvcsCalBase[loopcal] = METHOD_SWAPTION_SABR.presentValueCurveSensitivity(swaptionCalibration[loopcal], curves); pvcsCalBase[loopcal] = pvcsCalBase[loopcal].cleaned(); pvcsCalCal[loopcal] = METHOD_SWAPTION_LMM.presentValueCurveSensitivity(swaptionCalibration[loopcal], lmmBundle); pvcsCalCal[loopcal] = pvcsCalCal[loopcal].cleaned(); pvcsCalDiff[loopcal] = pvcsCalBase[loopcal].plus(pvcsCalCal[loopcal].multipliedBy(-1)); pvcsCalDiff[loopcal] = pvcsCalDiff[loopcal].cleaned(); } final CommonsMatrixAlgebra matrix = new CommonsMatrixAlgebra(); final DoubleMatrix2D dPvCaldLambdaMatrix = new DoubleMatrix2D(dPvCaldLambda); final DoubleMatrix2D dPvCaldLambdaMatrixInverse = matrix.getInverse(dPvCaldLambdaMatrix); // SABR sensitivity final double[][] dPvCaldAlpha = new double[nbCal][nbCal]; final double[][] dPvCaldRho = new double[nbCal][nbCal]; final double[][] dPvCaldNu = new double[nbCal][nbCal]; for (int loopcal = 0; loopcal < nbCal; loopcal++) { dPvCaldSABR[loopcal] = METHOD_SWAPTION_SABR.presentValueSABRSensitivity(swaptionCalibration[loopcal], curves); final Set<DoublesPair> keySet = dPvCaldSABR[loopcal].getAlpha().getMap().keySet(); final DoublesPair[] keys = keySet.toArray(new DoublesPair[keySet.size()]); dPvCaldAlpha[loopcal][loopcal] = dPvCaldSABR[loopcal].getAlpha().getMap().get(keys[0]); dPvCaldRho[loopcal][loopcal] = dPvCaldSABR[loopcal].getRho().getMap().get(keys[0]); dPvCaldNu[loopcal][loopcal] = dPvCaldSABR[loopcal].getNu().getMap().get(keys[0]); } final DoubleMatrix1D dPvAmdLambdaMatrix = new DoubleMatrix1D(dPvAmdLambda); final DoubleMatrix2D dPvCaldAlphaMatrix = new DoubleMatrix2D(dPvCaldAlpha); final DoubleMatrix2D dLambdadAlphaMatrix = (DoubleMatrix2D) matrix.multiply(dPvCaldLambdaMatrixInverse, dPvCaldAlphaMatrix); final DoubleMatrix2D dPvAmdAlphaMatrix = (DoubleMatrix2D) matrix.multiply(matrix.getTranspose(dLambdadAlphaMatrix), dPvAmdLambdaMatrix); final DoubleMatrix2D dPvCaldRhoMatrix = new DoubleMatrix2D(dPvCaldRho); final DoubleMatrix2D dLambdadRhoMatrix = (DoubleMatrix2D) matrix.multiply(dPvCaldLambdaMatrixInverse, dPvCaldRhoMatrix); final DoubleMatrix2D dPvAmdRhoMatrix = (DoubleMatrix2D) matrix.multiply(matrix.getTranspose(dLambdadRhoMatrix), dPvAmdLambdaMatrix); final DoubleMatrix2D dPvCaldNuMatrix = new DoubleMatrix2D(dPvCaldNu); final DoubleMatrix2D dLambdadNuMatrix = (DoubleMatrix2D) matrix.multiply(dPvCaldLambdaMatrixInverse, dPvCaldNuMatrix); final DoubleMatrix2D dPvAmdNuMatrix = (DoubleMatrix2D) matrix.multiply(matrix.getTranspose(dLambdadNuMatrix), dPvAmdLambdaMatrix); final double[] dPvAmdAlpha = matrix.getTranspose(dPvAmdAlphaMatrix).getData()[0]; final double[] dPvAmdRho = matrix.getTranspose(dPvAmdRhoMatrix).getData()[0]; final double[] dPvAmdNu = matrix.getTranspose(dPvAmdNuMatrix).getData()[0]; // Storage in PresentValueSABRSensitivityDataBundle final PresentValueSABRSensitivityDataBundle pvss = new PresentValueSABRSensitivityDataBundle(); for (int loopcal = 0; loopcal < nbCal; loopcal++) { final DoublesPair expiryMaturity = DoublesPair.of( swaptionCalibration[loopcal].getTimeToExpiry(), swaptionCalibration[loopcal].getMaturityTime()); pvss.addAlpha(expiryMaturity, dPvAmdAlpha[loopcal]); pvss.addRho(expiryMaturity, dPvAmdRho[loopcal]); pvss.addNu(expiryMaturity, dPvAmdNu[loopcal]); } // Curve sensitivity final InterestRateCurveSensitivity[] dLambdadC = new InterestRateCurveSensitivity[nbCal]; for (int loopcal1 = 0; loopcal1 < nbCal; loopcal1++) { dLambdadC[loopcal1] = new InterestRateCurveSensitivity(); for (int loopcal2 = 0; loopcal2 <= loopcal1; loopcal2++) { dLambdadC[loopcal1] = dLambdadC[loopcal1].plus( pvcsCalDiff[loopcal2].multipliedBy( dPvCaldLambdaMatrixInverse.getEntry(loopcal1, loopcal2))); } } InterestRateCurveSensitivity pvcs = new InterestRateCurveSensitivity(); for (int loopcal = 0; loopcal < nbCal; loopcal++) { pvcs = pvcs.plus(dLambdadC[loopcal].multipliedBy(dPvAmdLambda[loopcal])); } pvcs = pvcs.plus(pvcsCal); pvcs = pvcs.cleaned(); final List<Object> results = new ArrayList<>(); results.add( CurrencyAmount.of( swaption.getCurrency(), METHOD_SWAPTION_LMM.presentValue(swaption, lmmBundle).getAmount())); results.add(pvcs); results.add(pvss); return results; }
@Test /** * Test the present value rate sensitivity against a finite difference computation; strike above * the cut-off strike. Test sensitivity long/short parity. */ public void testPresentValueSensitivityAboveCutOff() { final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1(); final SABRInterestRateParameters sabrParameter = TestsDataSetsSABR.createSABR1(); final SABRInterestRateDataBundle sabrBundle = new SABRInterestRateDataBundle(sabrParameter, curves); InterestRateCurveSensitivity pvsCapLong = METHOD.presentValueSensitivity(CAP_HIGH_LONG, sabrBundle); final InterestRateCurveSensitivity pvsCapShort = METHOD.presentValueSensitivity(CAP_HIGH_SHORT, sabrBundle); // Long/short parity final InterestRateCurveSensitivity pvsCapShort_1 = pvsCapShort.multipliedBy(-1); assertEquals(pvsCapLong.getSensitivities(), pvsCapShort_1.getSensitivities()); // Present value sensitivity comparison with finite difference. final double deltaTolerancePrice = 1.0E-1; // Testing note: Sensitivity is for a movement of 1. 1E+2 = 1 cent for a 1 bp move. final double deltaShift = 1.0E-7; pvsCapLong = pvsCapLong.cleaned(); final String bumpedCurveName = "Bumped Curve"; // 1. Forward curve sensitivity final String[] CurveNameBumpedForward = {FUNDING_CURVE_NAME, bumpedCurveName}; final CapFloorIbor capBumpedForward = (CapFloorIbor) CAP_HIGH_LONG_DEFINITION.toDerivative(REFERENCE_DATE, CurveNameBumpedForward); final double[] nodeTimesForward = new double[] { capBumpedForward.getFixingPeriodStartTime(), capBumpedForward.getFixingPeriodEndTime() }; final double[] sensiForwardMethod = SensitivityFiniteDifference.curveSensitivity( capBumpedForward, SABR_BUNDLE, FORWARD_CURVE_NAME, bumpedCurveName, nodeTimesForward, deltaShift, METHOD); assertEquals( "Sensitivity finite difference method: number of node", 2, sensiForwardMethod.length); final List<DoublesPair> sensiPvForward = pvsCapLong.getSensitivities().get(FORWARD_CURVE_NAME); for (int loopnode = 0; loopnode < sensiForwardMethod.length; loopnode++) { final DoublesPair pairPv = sensiPvForward.get(loopnode); assertEquals( "Sensitivity cap/floor pv to forward curve: Node " + loopnode, nodeTimesForward[loopnode], pairPv.getFirst(), 1E-8); // assertEquals("Sensitivity finite difference method: node sensitivity: Node " + // loopnode, pairPv.second, sensiForwardMethod[loopnode], deltaTolerancePrice); } // 2. Discounting curve sensitivity final String[] CurveNameBumpedDisc = {bumpedCurveName, FORWARD_CURVE_NAME}; final CapFloorIbor capBumpedDisc = (CapFloorIbor) CAP_HIGH_LONG_DEFINITION.toDerivative(REFERENCE_DATE, CurveNameBumpedDisc); final double[] nodeTimesDisc = new double[] {capBumpedDisc.getPaymentTime()}; final double[] sensiDiscMethod = SensitivityFiniteDifference.curveSensitivity( capBumpedDisc, SABR_BUNDLE, FUNDING_CURVE_NAME, bumpedCurveName, nodeTimesDisc, deltaShift, METHOD); assertEquals("Sensitivity finite difference method: number of node", 1, sensiDiscMethod.length); final List<DoublesPair> sensiPvDisc = pvsCapLong.getSensitivities().get(FUNDING_CURVE_NAME); for (int loopnode = 0; loopnode < sensiDiscMethod.length; loopnode++) { final DoublesPair pairPv = sensiPvDisc.get(loopnode); assertEquals( "Sensitivity cap/floor pv to forward curve: Node " + loopnode, nodeTimesDisc[loopnode], pairPv.getFirst(), 1E-8); assertEquals( "Sensitivity finite difference method: node sensitivity", pairPv.second, sensiDiscMethod[loopnode], deltaTolerancePrice); } }