/**
* Builder from the expiry date, the underlying swap and the long/short flqg.
*
* @param expiryDate The expiry date.
* @param underlyingSwap The underlying swap.
* @param isLong The long (true) / short (false) flag.
* @return The swaption.
*/
public static SwaptionCashFixedIborDefinition from(
final ZonedDateTime expiryDate,
final SwapFixedIborDefinition underlyingSwap,
final boolean isLong) {
Validate.notNull(expiryDate, "expiry date");
Validate.notNull(underlyingSwap, "underlying swap");
final double strike = underlyingSwap.getFixedLeg().getNthPayment(0).getRate();
// Implementation note: cash-settle swaptions underlying have the same rate on all coupons and
// standard conventions.
return new SwaptionCashFixedIborDefinition(
expiryDate, strike, underlyingSwap, underlyingSwap.getFixedLeg().isPayer(), isLong);
}
/**
* Tests present value in the region where there is extrapolation. Test a hard-coded value. Tests
* long/short parity. Test payer/receiver/swap parity.
*/
@Test
public void testPresentValueExtra() {
final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1();
final SABRInterestRateParameters sabrParameter = TestsDataSetsSABR.createSABR1();
final SABRInterestRateDataBundle sabrBundle =
new SABRInterestRateDataBundle(sabrParameter, curves);
final double highStrike = 0.10;
final SwapFixedIborDefinition swapDefinitionPayerHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, FIXED_IS_PAYER);
final SwapFixedIborDefinition swapDefinitionReceiverHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, !FIXED_IS_PAYER);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionShortPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, !IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongReceiverHighStrike =
SwaptionCashFixedIborDefinition.from(
EXPIRY_DATE, swapDefinitionReceiverHighStrike, IS_LONG);
final SwaptionCashFixedIbor swaptionLongPayerHighStrike =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionShortPayerHighStrike =
swaptionDefinitionShortPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionLongReceiverHighStrike =
swaptionDefinitionLongReceiverHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIborSABRExtrapolationRightMethod method =
new SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
final double priceLongPayer = method.presentValue(swaptionLongPayerHighStrike, sabrBundle);
final double priceShortPayer = method.presentValue(swaptionShortPayerHighStrike, sabrBundle);
final double priceLongReceiver =
method.presentValue(swaptionLongReceiverHighStrike, sabrBundle);
final double priceLongPayerExpected = 557829.033; // Value from previous run
final double priceLongReceiverExpected = 20759354.082; // Value from previous run
assertEquals(
"Swaption cash SABR extrapolation: fixed value",
priceLongPayerExpected,
priceLongPayer,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: fixed value",
priceLongReceiverExpected,
priceLongReceiver,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: long/short parity",
priceLongPayer,
-priceShortPayer,
1E-2);
}
/**
* Constructor from the expiry date, the underlying swap and the long/short flag.
*
* @param expiryDate The expiry date.
* @param strike The strike
* @param underlyingSwap The underlying swap.
* @param isCall Call.
* @param isLong The long (true) / short (false) flag.
*/
private SwaptionCashFixedIborDefinition(
final ZonedDateTime expiryDate,
final double strike,
final SwapFixedIborDefinition underlyingSwap,
final boolean isCall,
final boolean isLong) {
Validate.notNull(expiryDate, "expiry date");
Validate.notNull(underlyingSwap, "underlying swap");
Validate.isTrue(
isCall == underlyingSwap.getFixedLeg().isPayer(), "Call flag not in line with underlying");
// TODO do we need to check that the swaption expiry is consistent with the underlying swap?
_underlyingSwap = underlyingSwap;
_isLong = isLong;
_settlementDate = underlyingSwap.getFixedLeg().getNthPayment(0).getAccrualStartDate();
_expiry = new Expiry(expiryDate);
}
@Override
public String toString() {
String result = "European swaption cash delivery: \n";
result += "Expiry date: " + _expiry.toString() + ", Long: " + _isLong;
result += "\nUnderlying swap: \n" + _underlyingSwap.toString();
return result;
}
/**
* Cap/floor CMS builder from all the cap/floor details.
*
* @param paymentDate Coupon payment date.
* @param accrualStartDate Start date of the accrual period.
* @param accrualEndDate End date of the accrual period.
* @param accrualFactor Accrual factor of the accrual period.
* @param notional Coupon notional.
* @param fixingDate The coupon fixing date.
* @param underlyingSwap The underlying swap.
* @param cmsIndex The CMS index associated to the cap/floor.
* @param strike The strike
* @param isCap The cap (true) /floor (false) flag.
* @return The CMS cap/floor.
*/
public static CapFloorCMSDefinition from(
final ZonedDateTime paymentDate,
final ZonedDateTime accrualStartDate,
final ZonedDateTime accrualEndDate,
final double accrualFactor,
final double notional,
final ZonedDateTime fixingDate,
final SwapFixedIborDefinition underlyingSwap,
final CMSIndex cmsIndex,
final double strike,
final boolean isCap) {
Validate.notNull(underlyingSwap, "underlying swap");
return new CapFloorCMSDefinition(
underlyingSwap.getCurrency(),
paymentDate,
accrualStartDate,
accrualEndDate,
accrualFactor,
notional,
fixingDate,
underlyingSwap,
cmsIndex,
strike,
isCap);
}
/**
* Cap/floor CMS builder. The fixing date is computed from the start accrual date with the Ibor
* index spot lag. The underlying swap is computed from that date and the CMS index.
*
* @param paymentDate Coupon payment date.
* @param accrualStartDate Start date of the accrual period.
* @param accrualEndDate End date of the accrual period.
* @param accrualFactor Accrual factor of the accrual period.
* @param notional Coupon notional.
* @param cmsIndex The CMS index associated to the cap/floor.
* @param strike The strike
* @param isCap The cap (true) /floor (false) flag.
* @return The CMS cap/floor.
*/
public static CapFloorCMSDefinition from(
final ZonedDateTime paymentDate,
final ZonedDateTime accrualStartDate,
final ZonedDateTime accrualEndDate,
final double accrualFactor,
final double notional,
final CMSIndex cmsIndex,
final double strike,
final boolean isCap) {
ZonedDateTime fixingDate =
ScheduleCalculator.getAdjustedDate(
accrualStartDate,
cmsIndex.getIborIndex().getBusinessDayConvention(),
cmsIndex.getIborIndex().getCalendar(),
-cmsIndex.getIborIndex().getSettlementDays());
// Implementation comment: the underlying swap is used for forward. The notional, rate and payer
// flag are irrelevant.
final SwapFixedIborDefinition underlyingSwap =
SwapFixedIborDefinition.from(accrualStartDate, cmsIndex, 1.0, 1.0, true);
return from(
paymentDate,
accrualStartDate,
accrualEndDate,
accrualFactor,
notional,
fixingDate,
underlyingSwap,
cmsIndex,
strike,
isCap);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + _expiry.hashCode();
result = prime * result + (_isLong ? 1231 : 1237);
result = prime * result + _underlyingSwap.hashCode();
return result;
}
@Override
public SwaptionCashFixedIbor toDerivative(
final ZonedDateTime date, final String... yieldCurveNames) {
Validate.notNull(date, "date");
Validate.notNull(yieldCurveNames, "yield curve names");
final DayCount actAct = DayCountFactory.INSTANCE.getDayCount("Actual/Actual ISDA");
final double expiryTime = actAct.getDayCountFraction(date, _expiry.getExpiry());
final double settlementTime = actAct.getDayCountFraction(date, _settlementDate);
final FixedCouponSwap<? extends Payment> underlyingSwap =
_underlyingSwap.toDerivative(date, yieldCurveNames);
return SwaptionCashFixedIbor.from(expiryTime, underlyingSwap, settlementTime, _isLong);
}
/** Tests related to the pricing of physical delivery swaption in G2++ model. */
public class SwaptionPhysicalFixedIborG2ppMethodTest {
// Swaption 5Yx5Y
private static final Currency CUR = Currency.USD;
private static final Calendar CALENDAR = new MondayToFridayCalendar("A");
private static final BusinessDayConvention BUSINESS_DAY =
BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention("Modified Following");
private static final boolean IS_EOM = true;
private static final int SETTLEMENT_DAYS = 2;
private static final Period IBOR_TENOR = Period.ofMonths(3);
private static final DayCount IBOR_DAY_COUNT = DayCountFactory.INSTANCE.getDayCount("Actual/360");
private static final IborIndex IBOR_INDEX =
new IborIndex(
CUR, IBOR_TENOR, SETTLEMENT_DAYS, CALENDAR, IBOR_DAY_COUNT, BUSINESS_DAY, IS_EOM);
private static final int SWAP_TENOR_YEAR = 5;
private static final Period SWAP_TENOR = Period.ofYears(SWAP_TENOR_YEAR);
private static final Period FIXED_PAYMENT_PERIOD = Period.ofMonths(6);
private static final DayCount FIXED_DAY_COUNT = DayCountFactory.INSTANCE.getDayCount("30/360");
private static final CMSIndex CMS_INDEX =
new CMSIndex(FIXED_PAYMENT_PERIOD, FIXED_DAY_COUNT, IBOR_INDEX, SWAP_TENOR);
private static final ZonedDateTime EXPIRY_DATE = DateUtils.getUTCDate(2016, 7, 7);
private static final ZonedDateTime SETTLEMENT_DATE =
ScheduleCalculator.getAdjustedDate(EXPIRY_DATE, CALENDAR, SETTLEMENT_DAYS);
private static final double NOTIONAL = 100000000; // 100m
private static final double RATE = 0.0325;
private static final boolean FIXED_IS_PAYER = true;
private static final SwapFixedIborDefinition SWAP_PAYER_DEFINITION =
SwapFixedIborDefinition.from(SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, RATE, FIXED_IS_PAYER);
private static final SwapFixedIborDefinition SWAP_RECEIVER_DEFINITION =
SwapFixedIborDefinition.from(SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, RATE, !FIXED_IS_PAYER);
private static final boolean IS_LONG = true;
private static final SwaptionPhysicalFixedIborDefinition SWAPTION_PAYER_LONG_DEFINITION =
SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_PAYER_DEFINITION, IS_LONG);
private static final SwaptionPhysicalFixedIborDefinition SWAPTION_RECEIVER_LONG_DEFINITION =
SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_RECEIVER_DEFINITION, IS_LONG);
private static final SwaptionPhysicalFixedIborDefinition SWAPTION_PAYER_SHORT_DEFINITION =
SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_PAYER_DEFINITION, !IS_LONG);
private static final SwaptionPhysicalFixedIborDefinition SWAPTION_RECEIVER_SHORT_DEFINITION =
SwaptionPhysicalFixedIborDefinition.from(EXPIRY_DATE, SWAP_RECEIVER_DEFINITION, !IS_LONG);
// to derivatives
private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2011, 7, 7);
private static final String FUNDING_CURVE_NAME = "Funding";
private static final String FORWARD_CURVE_NAME = "Forward";
private static final String[] CURVES_NAME = {FUNDING_CURVE_NAME, FORWARD_CURVE_NAME};
private static final YieldCurveBundle CURVES = TestsDataSets.createCurves1();
private static final FixedCouponSwap<Coupon> SWAP_RECEIVER =
SWAP_RECEIVER_DEFINITION.toDerivative(REFERENCE_DATE, CURVES_NAME);
private static final SwaptionPhysicalFixedIbor SWAPTION_PAYER_LONG =
SWAPTION_PAYER_LONG_DEFINITION.toDerivative(REFERENCE_DATE, CURVES_NAME);
private static final SwaptionPhysicalFixedIbor SWAPTION_RECEIVER_LONG =
SWAPTION_RECEIVER_LONG_DEFINITION.toDerivative(REFERENCE_DATE, CURVES_NAME);
private static final SwaptionPhysicalFixedIbor SWAPTION_PAYER_SHORT =
SWAPTION_PAYER_SHORT_DEFINITION.toDerivative(REFERENCE_DATE, CURVES_NAME);
private static final SwaptionPhysicalFixedIbor SWAPTION_RECEIVER_SHORT =
SWAPTION_RECEIVER_SHORT_DEFINITION.toDerivative(REFERENCE_DATE, CURVES_NAME);
// Calculator
private static final SwaptionPhysicalFixedIborG2ppApproximationMethod METHOD_G2PP_APPROXIMATION =
new SwaptionPhysicalFixedIborG2ppApproximationMethod();
private static final SwaptionPhysicalFixedIborG2ppNumericalIntegrationMethod METHOD_G2PP_NI =
new SwaptionPhysicalFixedIborG2ppNumericalIntegrationMethod();
private static final G2ppPiecewiseConstantParameters PARAMETERS_G2PP =
G2ppTestsDataSet.createG2ppParameters();
private static final G2ppPiecewiseConstantDataBundle BUNDLE_G2PP =
new G2ppPiecewiseConstantDataBundle(PARAMETERS_G2PP, CURVES);
private static final PresentValueCalculator PVC = PresentValueCalculator.getInstance();
@Test(enabled = false)
/**
* Test the present value vs a external system. "enabled = false" for the standard testing: the
* external system is using a TimeCalculator with ACT/365.
*/
public void presentValueExternal() {
G2ppPiecewiseConstantParameters parametersCst = G2ppTestsDataSet.createG2ppCstParameters();
final YieldAndDiscountCurve curve5 = new YieldCurve(ConstantDoublesCurve.from(0.05));
final YieldCurveBundle curves = new YieldCurveBundle();
curves.setCurve(FUNDING_CURVE_NAME, curve5);
curves.setCurve(FORWARD_CURVE_NAME, curve5);
G2ppPiecewiseConstantDataBundle bundleCst =
new G2ppPiecewiseConstantDataBundle(parametersCst, curves);
CurrencyAmount pv = METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_PAYER_LONG, bundleCst);
double pvExternal = 6885626.28245924; // ! TimeCalculator with ACT/365
assertEquals(
"Swaption physical - G2++ - present value - external system",
pvExternal,
pv.getAmount(),
1E-2);
}
@Test(enabled = true)
/** Test the present value vs a hard-coded value. */
public void presentValue() {
CurrencyAmount pv = METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_PAYER_LONG, BUNDLE_G2PP);
double pvExpected = 4893110.87;
assertEquals(
"Swaption physical - G2++ - present value - hard coded value",
pvExpected,
pv.getAmount(),
1E-2);
}
@Test
/** Tests long/short parity. */
public void longShortParity() {
CurrencyAmount pvPayerLong =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_PAYER_LONG, BUNDLE_G2PP);
CurrencyAmount pvPayerShort =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_PAYER_SHORT, BUNDLE_G2PP);
assertEquals(
"Swaption physical - G2++ - present value - long/short parity",
pvPayerLong.getAmount(),
-pvPayerShort.getAmount(),
1E-2);
CurrencyAmount pvReceiverLong =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_RECEIVER_LONG, BUNDLE_G2PP);
CurrencyAmount pvReceiverShort =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_RECEIVER_SHORT, BUNDLE_G2PP);
assertEquals(
"Swaption physical - G2++ - present value - long/short parity",
pvReceiverLong.getAmount(),
-pvReceiverShort.getAmount(),
1E-2);
}
@Test
/** Tests payer/receiver/swap parity. */
public void payerReceiverParity() {
CurrencyAmount pvReceiverLong =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_RECEIVER_LONG, BUNDLE_G2PP);
CurrencyAmount pvPayerShort =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_PAYER_SHORT, BUNDLE_G2PP);
double pvSwap = PVC.visit(SWAP_RECEIVER, CURVES);
assertEquals(
"Swaption physical - G2++ - present value - payer/receiver/swap parity",
pvReceiverLong.getAmount() + pvPayerShort.getAmount(),
pvSwap,
1E-2);
}
@Test
/** Test the present value by approximation vs by numerical integration. */
public void approximationNumericalIntegration() {
CurrencyAmount pvApproximation =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_PAYER_LONG, BUNDLE_G2PP);
CurrencyAmount pvNI = METHOD_G2PP_NI.presentValue(SWAPTION_PAYER_LONG, BUNDLE_G2PP);
assertEquals(
"Swaption physical - G2++ - present value - approximation vs Numerical integration",
pvApproximation.getAmount(),
pvNI.getAmount(),
2.0E+3);
}
@Test(enabled = false)
/** Tests of performance. "enabled = false" for the standard testing. */
public void performance() {
long startTime, endTime;
final int nbTest = 100;
CurrencyAmount pvPayerLongApproximation = CurrencyAmount.of(CUR, 0.0);
CurrencyAmount pvPayerLongNI = CurrencyAmount.of(CUR, 0.0);
startTime = System.currentTimeMillis();
for (int looptest = 0; looptest < nbTest; looptest++) {
pvPayerLongApproximation =
METHOD_G2PP_APPROXIMATION.presentValue(SWAPTION_PAYER_LONG, BUNDLE_G2PP);
}
endTime = System.currentTimeMillis();
System.out.println(
nbTest + " pv swaption G2++ approximation method: " + (endTime - startTime) + " ms");
// Performance note: G2++ price: 24-Aug-11: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: 175 ms for
// 10000 swaptions.
startTime = System.currentTimeMillis();
for (int looptest = 0; looptest < nbTest; looptest++) {
pvPayerLongNI = METHOD_G2PP_NI.presentValue(SWAPTION_PAYER_LONG, BUNDLE_G2PP);
}
endTime = System.currentTimeMillis();
System.out.println(
nbTest
+ " pv swaption G2++ numerical integration method: "
+ (endTime - startTime)
+ " ms");
// Performance note: G2++ price: 24-Aug-11: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: 1075 ms for
// 100 swaptions.
System.out.println("G2++ approximation - present value: " + pvPayerLongApproximation);
System.out.println("G2++ numerical integration - present value: " + pvPayerLongNI);
}
}
/** Tests related to the construction of CapFloorCMSSpread. */
public class CapFloorCMSSpreadTest {
// Swaps
private static final Currency CUR = Currency.USD;
private static final Calendar CALENDAR = new MondayToFridayCalendar("A");
private static final BusinessDayConvention BUSINESS_DAY =
BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention("Modified Following");
private static final boolean IS_EOM = true;
private static final ZonedDateTime SETTLEMENT_DATE = DateUtils.getUTCDate(2011, 3, 17);
private static final Period FIXED_PAYMENT_PERIOD = Period.ofMonths(6);
private static final DayCount FIXED_DAY_COUNT = DayCountFactory.INSTANCE.getDayCount("30/360");
private static final boolean FIXED_IS_PAYER = true; // Irrelevant for the underlying
private static final double RATE = 0.0; // Irrelevant for the underlying
private static final Period INDEX_TENOR = Period.ofMonths(3);
private static final int SETTLEMENT_DAYS = 2;
private static final DayCount DAY_COUNT = DayCountFactory.INSTANCE.getDayCount("Actual/360");
private static final IborIndex IBOR_INDEX =
new IborIndex(CUR, INDEX_TENOR, SETTLEMENT_DAYS, CALENDAR, DAY_COUNT, BUSINESS_DAY, IS_EOM);
// Swap 10Y
private static final Period ANNUITY_TENOR_1 = Period.ofYears(10);
private static final IndexSwap CMS_INDEX_1 =
new IndexSwap(FIXED_PAYMENT_PERIOD, FIXED_DAY_COUNT, IBOR_INDEX, ANNUITY_TENOR_1);
private static final SwapFixedIborDefinition SWAP_DEFINITION_1 =
SwapFixedIborDefinition.from(SETTLEMENT_DATE, CMS_INDEX_1, 1.0, RATE, FIXED_IS_PAYER);
// Swap 2Y
private static final Period ANNUITY_TENOR_2 = Period.ofYears(2);
private static final IndexSwap CMS_INDEX_2 =
new IndexSwap(FIXED_PAYMENT_PERIOD, FIXED_DAY_COUNT, IBOR_INDEX, ANNUITY_TENOR_2);
private static final SwapFixedIborDefinition SWAP_DEFINITION_2 =
SwapFixedIborDefinition.from(SETTLEMENT_DATE, CMS_INDEX_2, 1.0, RATE, FIXED_IS_PAYER);
// CMS spread coupon
private static final double NOTIONAL = 10000000;
private static final ZonedDateTime PAYMENT_DATE = DateUtils.getUTCDate(2011, 4, 6);
private static final ZonedDateTime FIXING_DATE = DateUtils.getUTCDate(2010, 12, 30);
private static final ZonedDateTime ACCRUAL_START_DATE = DateUtils.getUTCDate(2011, 1, 5);
private static final ZonedDateTime ACCRUAL_END_DATE = DateUtils.getUTCDate(2011, 4, 5);
private static final DayCount PAYMENT_DAY_COUNT =
DayCountFactory.INSTANCE.getDayCount("Actual/360");
private static final double PAYMENT_ACCRUAL_FACTOR =
PAYMENT_DAY_COUNT.getDayCountFraction(ACCRUAL_START_DATE, ACCRUAL_END_DATE);
private static final double STRIKE = 0.0050; // 50 bps
private static final boolean IS_CAP = true;
// to derivatives
private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2010, 8, 18);
private static final String FUNDING_CURVE_NAME = "Funding";
private static final String FORWARD_CURVE_1_NAME = "Forward 1";
// private static final String FORWARD_CURVE_2_NAME = "Forward 2";
private static final String[] CURVES_2_NAME = {FUNDING_CURVE_NAME, FORWARD_CURVE_1_NAME};
// private static final String[] CURVES_3_NAME = {FUNDING_CURVE_NAME, FORWARD_CURVE_1_NAME,
// FORWARD_CURVE_2_NAME};
private static final FixedCouponSwap<? extends Payment> SWAP_1 =
SWAP_DEFINITION_1.toDerivative(REFERENCE_DATE, CURVES_2_NAME);
private static final FixedCouponSwap<? extends Payment> SWAP_2 =
SWAP_DEFINITION_2.toDerivative(REFERENCE_DATE, CURVES_2_NAME);
private static final DayCount ACT_ACT =
DayCountFactory.INSTANCE.getDayCount("Actual/Actual ISDA");
private static final ZonedDateTime REFERENCE_DATE_ZONED =
ZonedDateTime.of(LocalDateTime.ofMidnight(REFERENCE_DATE), TimeZone.UTC);
private static final double PAYMENT_TIME =
ACT_ACT.getDayCountFraction(REFERENCE_DATE_ZONED, PAYMENT_DATE);
private static final double FIXING_TIME =
ACT_ACT.getDayCountFraction(REFERENCE_DATE_ZONED, FIXING_DATE);
private static final double SETTLEMENT_TIME =
ACT_ACT.getDayCountFraction(
REFERENCE_DATE_ZONED,
SWAP_DEFINITION_1.getFixedLeg().getNthPayment(0).getAccrualStartDate());
private static final CapFloorCMSSpread CMS_SPREAD =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
@Test
public void testGetter() {
assertEquals(SWAP_1, CMS_SPREAD.getUnderlyingSwap1());
assertEquals(CMS_INDEX_1, CMS_SPREAD.getCmsIndex1());
assertEquals(SWAP_2, CMS_SPREAD.getUnderlyingSwap2());
assertEquals(CMS_INDEX_2, CMS_SPREAD.getCmsIndex2());
assertEquals(STRIKE, CMS_SPREAD.getStrike(), 1E-10);
assertEquals(IS_CAP, CMS_SPREAD.isCap());
}
@Test
public void testEqualHash() {
final CapFloorCMSSpread newCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(newCMSSpread.equals(CMS_SPREAD), true);
assertEquals(newCMSSpread.hashCode() == CMS_SPREAD.hashCode(), true);
final Currency newCur = Currency.EUR;
CapFloorCMSSpread modifiedCMSSpread;
modifiedCMSSpread =
new CapFloorCMSSpread(
newCur,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME + 1.0,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR + 1.0,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL + 1.0,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME + 1.0,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME + 1.0,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE + 1.0,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
!IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_2,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_2,
SWAP_2,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_1,
CMS_INDEX_2,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
modifiedCMSSpread =
new CapFloorCMSSpread(
CUR,
PAYMENT_TIME,
PAYMENT_ACCRUAL_FACTOR,
NOTIONAL,
FIXING_TIME,
SWAP_1,
CMS_INDEX_1,
SWAP_2,
CMS_INDEX_1,
SETTLEMENT_TIME,
STRIKE,
IS_CAP,
FUNDING_CURVE_NAME);
assertEquals(modifiedCMSSpread.equals(CMS_SPREAD), false);
}
}
/**
* Class to test the present value and present value rate sensitivity of the cash-settled European
* swaption in the SABR with extrapolation method. The SABR smile is extrapolated above a certain
* cut-off strike.
*/
public class SwaptionCashFixedIborSABRExtrapolationRightMethodTest {
// Swaption description
private static final ZonedDateTime EXPIRY_DATE = DateUtils.getUTCDate(2014, 3, 18);
private static final boolean IS_LONG = true;
private static final int SETTLEMENT_DAYS = 2;
// Swap 5Y description
private static final Currency CUR = Currency.USD;
private static final Calendar CALENDAR = new MondayToFridayCalendar("A");
private static final BusinessDayConvention BUSINESS_DAY =
BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention("Modified Following");
private static final boolean IS_EOM = true;
private static final int ANNUITY_TENOR_YEAR = 5;
private static final Period ANNUITY_TENOR = Period.ofYears(ANNUITY_TENOR_YEAR);
private static final ZonedDateTime SETTLEMENT_DATE =
ScheduleCalculator.getAdjustedDate(EXPIRY_DATE, SETTLEMENT_DAYS, CALENDAR);
private static final double NOTIONAL = 100000000; // 100m
// Fixed leg: Semi-annual bond
private static final Period FIXED_PAYMENT_PERIOD = Period.ofMonths(6);
private static final DayCount FIXED_DAY_COUNT = DayCountFactory.INSTANCE.getDayCount("30/360");
private static final double RATE = 0.04;
private static final boolean FIXED_IS_PAYER = true;
// Ibor leg: quarterly money
private static final Period INDEX_TENOR = Period.ofMonths(3);
private static final DayCount DAY_COUNT = DayCountFactory.INSTANCE.getDayCount("Actual/360");
private static final IborIndex IBOR_INDEX =
new IborIndex(CUR, INDEX_TENOR, SETTLEMENT_DAYS, CALENDAR, DAY_COUNT, BUSINESS_DAY, IS_EOM);
// Swaption construction
private static final IndexSwap CMS_INDEX =
new IndexSwap(FIXED_PAYMENT_PERIOD, FIXED_DAY_COUNT, IBOR_INDEX, ANNUITY_TENOR);
private static final SwapFixedIborDefinition SWAP_DEFINITION_PAYER =
SwapFixedIborDefinition.from(SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, RATE, FIXED_IS_PAYER);
private static final SwapFixedIborDefinition SWAP_DEFINITION_RECEIVER =
SwapFixedIborDefinition.from(SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, RATE, !FIXED_IS_PAYER);
private static final SwaptionCashFixedIborDefinition SWAPTION_DEFINITION_LONG_PAYER =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, SWAP_DEFINITION_PAYER, IS_LONG);
private static final SwaptionCashFixedIborDefinition SWAPTION_DEFINITION_LONG_RECEIVER =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, SWAP_DEFINITION_RECEIVER, IS_LONG);
private static final SwaptionCashFixedIborDefinition SWAPTION_DEFINITION_SHORT_PAYER =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, SWAP_DEFINITION_PAYER, !IS_LONG);
private static final SwaptionCashFixedIborDefinition SWAPTION_DEFINITION_SHORT_RECEIVER =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, SWAP_DEFINITION_RECEIVER, !IS_LONG);
// to derivatives
private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2008, 8, 18);
private static final String FUNDING_CURVE_NAME = "Funding";
private static final String FORWARD_CURVE_NAME = "Forward";
private static final String[] CURVES_NAME = {FUNDING_CURVE_NAME, FORWARD_CURVE_NAME};
private static final SwaptionCashFixedIbor SWAPTION_LONG_PAYER =
SWAPTION_DEFINITION_LONG_PAYER.toDerivative(REFERENCE_DATE, CURVES_NAME);
private static final SwaptionCashFixedIbor SWAPTION_LONG_RECEIVER =
SWAPTION_DEFINITION_LONG_RECEIVER.toDerivative(REFERENCE_DATE, CURVES_NAME);
private static final SwaptionCashFixedIbor SWAPTION_SHORT_PAYER =
SWAPTION_DEFINITION_SHORT_PAYER.toDerivative(REFERENCE_DATE, CURVES_NAME);
private static final SwaptionCashFixedIbor SWAPTION_SHORT_RECEIVER =
SWAPTION_DEFINITION_SHORT_RECEIVER.toDerivative(REFERENCE_DATE, CURVES_NAME);
// Extrapolation
private static final double CUT_OFF_STRIKE = 0.08;
private static final double MU = 10.0;
private static final SwaptionCashFixedIborSABRExtrapolationRightMethod METHOD_EXTRAPOLATION =
new SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
// Calculators
private static final PresentValueSABRExtrapolationCalculator PVC =
PresentValueSABRExtrapolationCalculator.getInstance();
/** Tests present value in the region where there is no extrapolation. Tests long/short parity. */
@Test
public void testPresentValueNoExtra() {
final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1();
final SABRInterestRateParameters sabrParameter =
TestsDataSetsSABR.createSABRExtrapolation1(CUT_OFF_STRIKE, MU);
final SABRInterestRateDataBundle sabrBundle =
new SABRInterestRateDataBundle(sabrParameter, curves);
final SwaptionCashFixedIborSABRExtrapolationRightMethod method =
new SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
final double priceLongPayer = method.presentValue(SWAPTION_LONG_PAYER, sabrBundle);
final double priceShortPayer = method.presentValue(SWAPTION_SHORT_PAYER, sabrBundle);
final double priceLongReceiver = method.presentValue(SWAPTION_LONG_RECEIVER, sabrBundle);
final double priceShortReceiver = method.presentValue(SWAPTION_SHORT_RECEIVER, sabrBundle);
final double priceLongPayerNoExtra = PVC.visit(SWAPTION_LONG_PAYER, sabrBundle);
final double priceShortPayerNoExtra = PVC.visit(SWAPTION_SHORT_PAYER, sabrBundle);
final double priceLongReceiverNoExtra = PVC.visit(SWAPTION_LONG_RECEIVER, sabrBundle);
final double priceShortReceiverNoExtra = PVC.visit(SWAPTION_SHORT_RECEIVER, sabrBundle);
assertEquals(
"Swaption cash SABR extrapolation: below cut-off strike",
priceLongPayerNoExtra,
priceLongPayer,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: below cut-off strike",
priceShortPayerNoExtra,
priceShortPayer,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: below cut-off strike",
priceLongReceiverNoExtra,
priceLongReceiver,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: below cut-off strike",
priceShortReceiverNoExtra,
priceShortReceiver,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: below cut-off strike long/short parity",
priceLongPayer,
-priceShortPayer,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: below cut-off strike long/short parity",
priceLongReceiver,
-priceShortReceiver,
1E-2);
}
/**
* Tests present value in the region where there is extrapolation. Test a hard-coded value. Tests
* long/short parity. Test payer/receiver/swap parity.
*/
@Test
public void testPresentValueExtra() {
final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1();
final SABRInterestRateParameters sabrParameter = TestsDataSetsSABR.createSABR1();
final SABRInterestRateDataBundle sabrBundle =
new SABRInterestRateDataBundle(sabrParameter, curves);
final double highStrike = 0.10;
final SwapFixedIborDefinition swapDefinitionPayerHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, FIXED_IS_PAYER);
final SwapFixedIborDefinition swapDefinitionReceiverHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, !FIXED_IS_PAYER);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionShortPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, !IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongReceiverHighStrike =
SwaptionCashFixedIborDefinition.from(
EXPIRY_DATE, swapDefinitionReceiverHighStrike, IS_LONG);
final SwaptionCashFixedIbor swaptionLongPayerHighStrike =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionShortPayerHighStrike =
swaptionDefinitionShortPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionLongReceiverHighStrike =
swaptionDefinitionLongReceiverHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIborSABRExtrapolationRightMethod method =
new SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
final double priceLongPayer = method.presentValue(swaptionLongPayerHighStrike, sabrBundle);
final double priceShortPayer = method.presentValue(swaptionShortPayerHighStrike, sabrBundle);
final double priceLongReceiver =
method.presentValue(swaptionLongReceiverHighStrike, sabrBundle);
final double priceLongPayerExpected = 557829.033; // Value from previous run
final double priceLongReceiverExpected = 20759354.082; // Value from previous run
assertEquals(
"Swaption cash SABR extrapolation: fixed value",
priceLongPayerExpected,
priceLongPayer,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: fixed value",
priceLongReceiverExpected,
priceLongReceiver,
1E-2);
assertEquals(
"Swaption cash SABR extrapolation: long/short parity",
priceLongPayer,
-priceShortPayer,
1E-2);
}
@Test
/**
* Test the present value sensitivity to rate for a swaption with strike above the cut-off strike.
*/
public void testPresentValueSensitivityExtra() {
final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1();
final SABRInterestRateParameters sabrParameter = TestsDataSetsSABR.createSABR1();
final SABRInterestRateDataBundle sabrBundle =
new SABRInterestRateDataBundle(sabrParameter, curves);
final double highStrike = 0.10;
final SwapFixedIborDefinition swapDefinitionPayerHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, FIXED_IS_PAYER);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionShortPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, !IS_LONG);
final SwaptionCashFixedIbor swaptionLongPayerHighStrike =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionShortPayerHighStrike =
swaptionDefinitionShortPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIborSABRExtrapolationRightMethod methodExtra =
new SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
// Swaption sensitivity
InterestRateCurveSensitivity pvsLongPayerExtra =
methodExtra.presentValueSensitivity(swaptionLongPayerHighStrike, sabrBundle);
final InterestRateCurveSensitivity pvsShortPayerExtra =
methodExtra.presentValueSensitivity(swaptionShortPayerHighStrike, sabrBundle);
// Long/short parity
final InterestRateCurveSensitivity pvsShortPayer_1 = pvsShortPayerExtra.multiply(-1);
assertEquals(pvsLongPayerExtra.getSensitivities(), pvsShortPayer_1.getSensitivities());
// Present value sensitivity comparison with finite difference.
final double deltaTolerance = 5.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-5;
pvsLongPayerExtra = pvsLongPayerExtra.clean();
final double pv = methodExtra.presentValue(swaptionLongPayerHighStrike, sabrBundle);
// 1. Forward curve sensitivity
final String bumpedCurveName = "Bumped Curve";
final String[] bumpedCurvesForwardName = {FUNDING_CURVE_NAME, bumpedCurveName};
final SwaptionCashFixedIbor swaptionBumpedForward =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, bumpedCurvesForwardName);
final YieldAndDiscountCurve curveForward = curves.getCurve(FORWARD_CURVE_NAME);
final Set<Double> timeForwardSet = new TreeSet<Double>();
for (final Payment pay :
swaptionLongPayerHighStrike.getUnderlyingSwap().getSecondLeg().getPayments()) {
final CouponIbor coupon = (CouponIbor) pay;
timeForwardSet.add(coupon.getFixingPeriodStartTime());
timeForwardSet.add(coupon.getFixingPeriodEndTime());
}
final int nbForwardDate = timeForwardSet.size();
final List<Double> timeForwardList = new ArrayList<Double>(timeForwardSet);
Double[] timeForwardArray = new Double[nbForwardDate];
timeForwardArray = timeForwardList.toArray(timeForwardArray);
final double[] yieldsForward = new double[nbForwardDate + 1];
final double[] nodeTimesForward = new double[nbForwardDate + 1];
yieldsForward[0] = curveForward.getInterestRate(0.0);
for (int i = 0; i < nbForwardDate; i++) {
nodeTimesForward[i + 1] = timeForwardArray[i];
yieldsForward[i + 1] = curveForward.getInterestRate(nodeTimesForward[i + 1]);
}
final YieldAndDiscountCurve tempCurveForward =
new YieldCurve(
InterpolatedDoublesCurve.fromSorted(
nodeTimesForward, yieldsForward, new LinearInterpolator1D()));
final List<DoublesPair> tempForward =
pvsLongPayerExtra.getSensitivities().get(FORWARD_CURVE_NAME);
final double[] resFwd = new double[nbForwardDate];
for (int i = 0; i < nbForwardDate; i++) {
final YieldAndDiscountCurve bumpedCurveForward =
tempCurveForward.withSingleShift(nodeTimesForward[i + 1], deltaShift);
final YieldCurveBundle curvesBumpedForward = new YieldCurveBundle();
curvesBumpedForward.addAll(curves);
curvesBumpedForward.setCurve("Bumped Curve", bumpedCurveForward);
final SABRInterestRateDataBundle sabrBundleBumped =
new SABRInterestRateDataBundle(sabrParameter, curvesBumpedForward);
final double bumpedpv = methodExtra.presentValue(swaptionBumpedForward, sabrBundleBumped);
resFwd[i] = (bumpedpv - pv) / deltaShift;
final DoublesPair pair = tempForward.get(i);
assertEquals(
"Sensitivity to forward curve: Node " + i,
nodeTimesForward[i + 1],
pair.getFirst(),
1E-8);
assertEquals(
"Sensitivity to forward curve: Node " + i, resFwd[i], pair.getSecond(), deltaTolerance);
}
// 2. Funding curve sensitivity
final String[] bumpedCurvesFundingName = {bumpedCurveName, FORWARD_CURVE_NAME};
final SwaptionCashFixedIbor swaptionBumpedFunding =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, bumpedCurvesFundingName);
final int nbPayDate =
swaptionDefinitionLongPayerHighStrike.getUnderlyingSwap().getIborLeg().getPayments().length;
final YieldAndDiscountCurve curveFunding = curves.getCurve(FUNDING_CURVE_NAME);
final double[] yieldsFunding = new double[nbPayDate + 2];
final double[] nodeTimesFunding = new double[nbPayDate + 2];
yieldsFunding[0] = curveFunding.getInterestRate(0.0);
nodeTimesFunding[1] = swaptionLongPayerHighStrike.getSettlementTime();
yieldsFunding[1] = curveFunding.getInterestRate(nodeTimesFunding[1]);
for (int i = 0; i < nbPayDate; i++) {
nodeTimesFunding[i + 2] =
swaptionLongPayerHighStrike
.getUnderlyingSwap()
.getSecondLeg()
.getNthPayment(i)
.getPaymentTime();
yieldsFunding[i + 2] = curveFunding.getInterestRate(nodeTimesFunding[i + 2]);
}
final YieldAndDiscountCurve tempCurveFunding =
new YieldCurve(
InterpolatedDoublesCurve.fromSorted(
nodeTimesFunding, yieldsFunding, new LinearInterpolator1D()));
final List<DoublesPair> tempFunding =
pvsLongPayerExtra.getSensitivities().get(FUNDING_CURVE_NAME);
final double[] resDsc = new double[nbPayDate];
for (int i = 0; i < nbPayDate; i++) {
final YieldAndDiscountCurve bumpedCurve =
tempCurveFunding.withSingleShift(nodeTimesFunding[i + 1], deltaShift);
final YieldCurveBundle curvesBumped = new YieldCurveBundle();
curvesBumped.addAll(curves);
curvesBumped.setCurve("Bumped Curve", bumpedCurve);
final SABRInterestRateDataBundle sabrBundleBumped =
new SABRInterestRateDataBundle(sabrParameter, curvesBumped);
final double bumpedpv = methodExtra.presentValue(swaptionBumpedFunding, sabrBundleBumped);
resDsc[i] = (bumpedpv - pv) / deltaShift;
final DoublesPair pair = tempFunding.get(i);
assertEquals(
"Sensitivity to discounting curve: Node " + i,
nodeTimesFunding[i + 1],
pair.getFirst(),
1E-8);
assertEquals(
"Sensitivity to discounting curve: Node " + i,
resDsc[i],
pair.getSecond(),
deltaTolerance);
}
}
@Test
/**
* Test the present value sensitivity to SABR parameters for a swaption with strike above the
* cut-off strike.
*/
public void testPresentValueSABRSensitivity() {
final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1();
final SABRInterestRateParameters sabrParameter = TestsDataSetsSABR.createSABR1();
final SABRInterestRateDataBundle sabrBundle =
new SABRInterestRateDataBundle(sabrParameter, curves);
final double highStrike = 0.10;
final SwapFixedIborDefinition swapDefinitionPayerHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, FIXED_IS_PAYER);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionShortPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, !IS_LONG);
final SwaptionCashFixedIbor swaptionLongPayerHighStrike =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionShortPayerHighStrike =
swaptionDefinitionShortPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
// SwaptionCashFixedIborSABRExtrapolationRightMethod methodExtra = new
// SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
// Swaption sensitivity
final PresentValueSABRSensitivityDataBundle pvsLongPayer =
METHOD_EXTRAPOLATION.presentValueSABRSensitivity(swaptionLongPayerHighStrike, sabrBundle);
PresentValueSABRSensitivityDataBundle pvsShortPayer =
METHOD_EXTRAPOLATION.presentValueSABRSensitivity(swaptionShortPayerHighStrike, sabrBundle);
// Long/short parity
pvsShortPayer = PresentValueSABRSensitivityDataBundle.multiplyBy(pvsShortPayer, -1.0);
assertEquals(pvsLongPayer.getAlpha(), pvsShortPayer.getAlpha());
// SABR sensitivity vs finite difference
final double pvLongPayer =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundle);
final DoublesPair expectedExpiryTenor =
new DoublesPair(swaptionLongPayerHighStrike.getTimeToExpiry(), ANNUITY_TENOR_YEAR);
final double shift = 0.000005;
// Alpha sensitivity vs finite difference computation
final SABRInterestRateParameters sabrParameterAlphaBumped =
TestsDataSetsSABR.createSABR1AlphaBumped(shift);
final SABRInterestRateDataBundle sabrBundleAlphaBumped =
new SABRInterestRateDataBundle(sabrParameterAlphaBumped, curves);
final double pvLongPayerAlphaBumped =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundleAlphaBumped);
final double expectedAlphaSensi = (pvLongPayerAlphaBumped - pvLongPayer) / shift;
assertEquals(
"Number of alpha sensitivity", pvsLongPayer.getAlpha().getMap().keySet().size(), 1);
assertEquals(
"Alpha sensitivity expiry/tenor",
pvsLongPayer.getAlpha().getMap().keySet().contains(expectedExpiryTenor),
true);
assertEquals(
"Alpha sensitivity value",
expectedAlphaSensi,
pvsLongPayer.getAlpha().getMap().get(expectedExpiryTenor),
2.0E+3);
// Rho sensitivity vs finite difference computation
final SABRInterestRateParameters sabrParameterRhoBumped =
TestsDataSetsSABR.createSABR1RhoBumped(shift);
final SABRInterestRateDataBundle sabrBundleRhoBumped =
new SABRInterestRateDataBundle(sabrParameterRhoBumped, curves);
final double pvLongPayerRhoBumped =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundleRhoBumped);
final double expectedRhoSensi = (pvLongPayerRhoBumped - pvLongPayer) / shift;
assertEquals("Number of rho sensitivity", pvsLongPayer.getRho().getMap().keySet().size(), 1);
assertEquals(
"Rho sensitivity expiry/tenor",
pvsLongPayer.getRho().getMap().keySet().contains(expectedExpiryTenor),
true);
assertEquals(
"Rho sensitivity value",
expectedRhoSensi,
pvsLongPayer.getRho().getMap().get(expectedExpiryTenor),
1.0E+0);
// Alpha sensitivity vs finite difference computation
final SABRInterestRateParameters sabrParameterNuBumped =
TestsDataSetsSABR.createSABR1NuBumped(shift);
final SABRInterestRateDataBundle sabrBundleNuBumped =
new SABRInterestRateDataBundle(sabrParameterNuBumped, curves);
final double pvLongPayerNuBumped =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundleNuBumped);
final double expectedNuSensi = (pvLongPayerNuBumped - pvLongPayer) / shift;
assertEquals("Number of nu sensitivity", pvsLongPayer.getNu().getMap().keySet().size(), 1);
assertEquals(
"Nu sensitivity expiry/tenor",
pvsLongPayer.getNu().getMap().keySet().contains(expectedExpiryTenor),
true);
assertEquals(
"Nu sensitivity value",
expectedNuSensi,
pvsLongPayer.getNu().getMap().get(expectedExpiryTenor),
5.0E+1);
}
}
@Test
/**
* Test the present value sensitivity to SABR parameters for a swaption with strike above the
* cut-off strike.
*/
public void testPresentValueSABRSensitivity() {
final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1();
final SABRInterestRateParameters sabrParameter = TestsDataSetsSABR.createSABR1();
final SABRInterestRateDataBundle sabrBundle =
new SABRInterestRateDataBundle(sabrParameter, curves);
final double highStrike = 0.10;
final SwapFixedIborDefinition swapDefinitionPayerHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, FIXED_IS_PAYER);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionShortPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, !IS_LONG);
final SwaptionCashFixedIbor swaptionLongPayerHighStrike =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionShortPayerHighStrike =
swaptionDefinitionShortPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
// SwaptionCashFixedIborSABRExtrapolationRightMethod methodExtra = new
// SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
// Swaption sensitivity
final PresentValueSABRSensitivityDataBundle pvsLongPayer =
METHOD_EXTRAPOLATION.presentValueSABRSensitivity(swaptionLongPayerHighStrike, sabrBundle);
PresentValueSABRSensitivityDataBundle pvsShortPayer =
METHOD_EXTRAPOLATION.presentValueSABRSensitivity(swaptionShortPayerHighStrike, sabrBundle);
// Long/short parity
pvsShortPayer = PresentValueSABRSensitivityDataBundle.multiplyBy(pvsShortPayer, -1.0);
assertEquals(pvsLongPayer.getAlpha(), pvsShortPayer.getAlpha());
// SABR sensitivity vs finite difference
final double pvLongPayer =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundle);
final DoublesPair expectedExpiryTenor =
new DoublesPair(swaptionLongPayerHighStrike.getTimeToExpiry(), ANNUITY_TENOR_YEAR);
final double shift = 0.000005;
// Alpha sensitivity vs finite difference computation
final SABRInterestRateParameters sabrParameterAlphaBumped =
TestsDataSetsSABR.createSABR1AlphaBumped(shift);
final SABRInterestRateDataBundle sabrBundleAlphaBumped =
new SABRInterestRateDataBundle(sabrParameterAlphaBumped, curves);
final double pvLongPayerAlphaBumped =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundleAlphaBumped);
final double expectedAlphaSensi = (pvLongPayerAlphaBumped - pvLongPayer) / shift;
assertEquals(
"Number of alpha sensitivity", pvsLongPayer.getAlpha().getMap().keySet().size(), 1);
assertEquals(
"Alpha sensitivity expiry/tenor",
pvsLongPayer.getAlpha().getMap().keySet().contains(expectedExpiryTenor),
true);
assertEquals(
"Alpha sensitivity value",
expectedAlphaSensi,
pvsLongPayer.getAlpha().getMap().get(expectedExpiryTenor),
2.0E+3);
// Rho sensitivity vs finite difference computation
final SABRInterestRateParameters sabrParameterRhoBumped =
TestsDataSetsSABR.createSABR1RhoBumped(shift);
final SABRInterestRateDataBundle sabrBundleRhoBumped =
new SABRInterestRateDataBundle(sabrParameterRhoBumped, curves);
final double pvLongPayerRhoBumped =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundleRhoBumped);
final double expectedRhoSensi = (pvLongPayerRhoBumped - pvLongPayer) / shift;
assertEquals("Number of rho sensitivity", pvsLongPayer.getRho().getMap().keySet().size(), 1);
assertEquals(
"Rho sensitivity expiry/tenor",
pvsLongPayer.getRho().getMap().keySet().contains(expectedExpiryTenor),
true);
assertEquals(
"Rho sensitivity value",
expectedRhoSensi,
pvsLongPayer.getRho().getMap().get(expectedExpiryTenor),
1.0E+0);
// Alpha sensitivity vs finite difference computation
final SABRInterestRateParameters sabrParameterNuBumped =
TestsDataSetsSABR.createSABR1NuBumped(shift);
final SABRInterestRateDataBundle sabrBundleNuBumped =
new SABRInterestRateDataBundle(sabrParameterNuBumped, curves);
final double pvLongPayerNuBumped =
METHOD_EXTRAPOLATION.presentValue(swaptionLongPayerHighStrike, sabrBundleNuBumped);
final double expectedNuSensi = (pvLongPayerNuBumped - pvLongPayer) / shift;
assertEquals("Number of nu sensitivity", pvsLongPayer.getNu().getMap().keySet().size(), 1);
assertEquals(
"Nu sensitivity expiry/tenor",
pvsLongPayer.getNu().getMap().keySet().contains(expectedExpiryTenor),
true);
assertEquals(
"Nu sensitivity value",
expectedNuSensi,
pvsLongPayer.getNu().getMap().get(expectedExpiryTenor),
5.0E+1);
}
@Test
/**
* Test the present value sensitivity to rate for a swaption with strike above the cut-off strike.
*/
public void testPresentValueSensitivityExtra() {
final YieldCurveBundle curves = TestsDataSetsSABR.createCurves1();
final SABRInterestRateParameters sabrParameter = TestsDataSetsSABR.createSABR1();
final SABRInterestRateDataBundle sabrBundle =
new SABRInterestRateDataBundle(sabrParameter, curves);
final double highStrike = 0.10;
final SwapFixedIborDefinition swapDefinitionPayerHighStrike =
SwapFixedIborDefinition.from(
SETTLEMENT_DATE, CMS_INDEX, NOTIONAL, highStrike, FIXED_IS_PAYER);
final SwaptionCashFixedIborDefinition swaptionDefinitionLongPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, IS_LONG);
final SwaptionCashFixedIborDefinition swaptionDefinitionShortPayerHighStrike =
SwaptionCashFixedIborDefinition.from(EXPIRY_DATE, swapDefinitionPayerHighStrike, !IS_LONG);
final SwaptionCashFixedIbor swaptionLongPayerHighStrike =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIbor swaptionShortPayerHighStrike =
swaptionDefinitionShortPayerHighStrike.toDerivative(REFERENCE_DATE, CURVES_NAME);
final SwaptionCashFixedIborSABRExtrapolationRightMethod methodExtra =
new SwaptionCashFixedIborSABRExtrapolationRightMethod(CUT_OFF_STRIKE, MU);
// Swaption sensitivity
InterestRateCurveSensitivity pvsLongPayerExtra =
methodExtra.presentValueSensitivity(swaptionLongPayerHighStrike, sabrBundle);
final InterestRateCurveSensitivity pvsShortPayerExtra =
methodExtra.presentValueSensitivity(swaptionShortPayerHighStrike, sabrBundle);
// Long/short parity
final InterestRateCurveSensitivity pvsShortPayer_1 = pvsShortPayerExtra.multiply(-1);
assertEquals(pvsLongPayerExtra.getSensitivities(), pvsShortPayer_1.getSensitivities());
// Present value sensitivity comparison with finite difference.
final double deltaTolerance = 5.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-5;
pvsLongPayerExtra = pvsLongPayerExtra.clean();
final double pv = methodExtra.presentValue(swaptionLongPayerHighStrike, sabrBundle);
// 1. Forward curve sensitivity
final String bumpedCurveName = "Bumped Curve";
final String[] bumpedCurvesForwardName = {FUNDING_CURVE_NAME, bumpedCurveName};
final SwaptionCashFixedIbor swaptionBumpedForward =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, bumpedCurvesForwardName);
final YieldAndDiscountCurve curveForward = curves.getCurve(FORWARD_CURVE_NAME);
final Set<Double> timeForwardSet = new TreeSet<Double>();
for (final Payment pay :
swaptionLongPayerHighStrike.getUnderlyingSwap().getSecondLeg().getPayments()) {
final CouponIbor coupon = (CouponIbor) pay;
timeForwardSet.add(coupon.getFixingPeriodStartTime());
timeForwardSet.add(coupon.getFixingPeriodEndTime());
}
final int nbForwardDate = timeForwardSet.size();
final List<Double> timeForwardList = new ArrayList<Double>(timeForwardSet);
Double[] timeForwardArray = new Double[nbForwardDate];
timeForwardArray = timeForwardList.toArray(timeForwardArray);
final double[] yieldsForward = new double[nbForwardDate + 1];
final double[] nodeTimesForward = new double[nbForwardDate + 1];
yieldsForward[0] = curveForward.getInterestRate(0.0);
for (int i = 0; i < nbForwardDate; i++) {
nodeTimesForward[i + 1] = timeForwardArray[i];
yieldsForward[i + 1] = curveForward.getInterestRate(nodeTimesForward[i + 1]);
}
final YieldAndDiscountCurve tempCurveForward =
new YieldCurve(
InterpolatedDoublesCurve.fromSorted(
nodeTimesForward, yieldsForward, new LinearInterpolator1D()));
final List<DoublesPair> tempForward =
pvsLongPayerExtra.getSensitivities().get(FORWARD_CURVE_NAME);
final double[] resFwd = new double[nbForwardDate];
for (int i = 0; i < nbForwardDate; i++) {
final YieldAndDiscountCurve bumpedCurveForward =
tempCurveForward.withSingleShift(nodeTimesForward[i + 1], deltaShift);
final YieldCurveBundle curvesBumpedForward = new YieldCurveBundle();
curvesBumpedForward.addAll(curves);
curvesBumpedForward.setCurve("Bumped Curve", bumpedCurveForward);
final SABRInterestRateDataBundle sabrBundleBumped =
new SABRInterestRateDataBundle(sabrParameter, curvesBumpedForward);
final double bumpedpv = methodExtra.presentValue(swaptionBumpedForward, sabrBundleBumped);
resFwd[i] = (bumpedpv - pv) / deltaShift;
final DoublesPair pair = tempForward.get(i);
assertEquals(
"Sensitivity to forward curve: Node " + i,
nodeTimesForward[i + 1],
pair.getFirst(),
1E-8);
assertEquals(
"Sensitivity to forward curve: Node " + i, resFwd[i], pair.getSecond(), deltaTolerance);
}
// 2. Funding curve sensitivity
final String[] bumpedCurvesFundingName = {bumpedCurveName, FORWARD_CURVE_NAME};
final SwaptionCashFixedIbor swaptionBumpedFunding =
swaptionDefinitionLongPayerHighStrike.toDerivative(REFERENCE_DATE, bumpedCurvesFundingName);
final int nbPayDate =
swaptionDefinitionLongPayerHighStrike.getUnderlyingSwap().getIborLeg().getPayments().length;
final YieldAndDiscountCurve curveFunding = curves.getCurve(FUNDING_CURVE_NAME);
final double[] yieldsFunding = new double[nbPayDate + 2];
final double[] nodeTimesFunding = new double[nbPayDate + 2];
yieldsFunding[0] = curveFunding.getInterestRate(0.0);
nodeTimesFunding[1] = swaptionLongPayerHighStrike.getSettlementTime();
yieldsFunding[1] = curveFunding.getInterestRate(nodeTimesFunding[1]);
for (int i = 0; i < nbPayDate; i++) {
nodeTimesFunding[i + 2] =
swaptionLongPayerHighStrike
.getUnderlyingSwap()
.getSecondLeg()
.getNthPayment(i)
.getPaymentTime();
yieldsFunding[i + 2] = curveFunding.getInterestRate(nodeTimesFunding[i + 2]);
}
final YieldAndDiscountCurve tempCurveFunding =
new YieldCurve(
InterpolatedDoublesCurve.fromSorted(
nodeTimesFunding, yieldsFunding, new LinearInterpolator1D()));
final List<DoublesPair> tempFunding =
pvsLongPayerExtra.getSensitivities().get(FUNDING_CURVE_NAME);
final double[] resDsc = new double[nbPayDate];
for (int i = 0; i < nbPayDate; i++) {
final YieldAndDiscountCurve bumpedCurve =
tempCurveFunding.withSingleShift(nodeTimesFunding[i + 1], deltaShift);
final YieldCurveBundle curvesBumped = new YieldCurveBundle();
curvesBumped.addAll(curves);
curvesBumped.setCurve("Bumped Curve", bumpedCurve);
final SABRInterestRateDataBundle sabrBundleBumped =
new SABRInterestRateDataBundle(sabrParameter, curvesBumped);
final double bumpedpv = methodExtra.presentValue(swaptionBumpedFunding, sabrBundleBumped);
resDsc[i] = (bumpedpv - pv) / deltaShift;
final DoublesPair pair = tempFunding.get(i);
assertEquals(
"Sensitivity to discounting curve: Node " + i,
nodeTimesFunding[i + 1],
pair.getFirst(),
1E-8);
assertEquals(
"Sensitivity to discounting curve: Node " + i,
resDsc[i],
pair.getSecond(),
deltaTolerance);
}
}