def test_LiborSwap():
# I have tried to reproduce the example from the blog by Ioannis Rigopoulos
# https://blog.deriscope.com/index.php/en/excel-interest-rate-swap-price-dual-bootstrapping-curve
startDate = FinDate(2017, 12, 27)
endDate = FinDate(2067, 12, 27)
fixedCoupon = 0.015
fixedFreqType = FinFrequencyTypes.ANNUAL
fixedDayCountType = FinDayCountTypes.THIRTY_E_360
floatSpread = 0.0
floatFreqType = FinFrequencyTypes.SEMI_ANNUAL
floatDayCountType = FinDayCountTypes.ACT_360
firstFixing = -0.00268
swapCalendarType = FinCalendarTypes.WEEKEND
busDayAdjustType = FinBusDayAdjustTypes.FOLLOWING
dateGenRuleType = FinDateGenRuleTypes.BACKWARD
swapType = FinLiborSwapTypes.RECEIVER
notional = 10.0 * ONE_MILLION
swap = FinLiborSwap(startDate,
endDate,
swapType,
fixedCoupon,
fixedFreqType,
fixedDayCountType,
notional,
floatSpread,
floatFreqType,
floatDayCountType,
swapCalendarType,
busDayAdjustType,
dateGenRuleType)
''' Now perform a valuation after the swap has seasoned but with the
same curve being used for discounting and working out the implied
future Libor rates. '''
valuationDate = FinDate(30, 11, 2018)
settlementDate = valuationDate.addDays(2)
liborCurve = buildLiborCurve(valuationDate)
v = swap.value(settlementDate, liborCurve, liborCurve, firstFixing)
v_bbg = 388147.0
testCases.header("LABEL", "VALUE")
testCases.print("SWAP_VALUE USING ONE_CURVE", v)
testCases.print("BLOOMBERG VALUE", v_bbg)
testCases.print("DIFFERENCE VALUE", v_bbg - v)
def test_dp_example():
# http://www.derivativepricing.com/blogpage.asp?id=8
startDate = FinDate(14, 11, 2011)
endDate = FinDate(14, 11, 2016)
fixedFreqType = FinFrequencyTypes.SEMI_ANNUAL
swapCalendarType = FinCalendarTypes.TARGET
busDayAdjustType = FinBusDayAdjustTypes.MODIFIED_FOLLOWING
dateGenRuleType = FinDateGenRuleTypes.BACKWARD
fixedDayCountType = FinDayCountTypes.THIRTY_E_360_ISDA
swapType = FinLiborSwapTypes.PAYER
fixedCoupon = 0.0124
notional = ONE_MILLION
swap = FinLiborSwap(startDate,
endDate,
swapType,
fixedCoupon=fixedCoupon,
fixedFreqType=fixedFreqType,
fixedDayCountType=fixedDayCountType,
floatFreqType=FinFrequencyTypes.SEMI_ANNUAL,
floatDayCountType=FinDayCountTypes.ACT_360,
notional=notional,
calendarType=swapCalendarType,
busDayAdjustType=busDayAdjustType,
dateGenRuleType=dateGenRuleType)
# swap.printFixedLegFlows()
dts = [FinDate(14, 11, 2011), FinDate(14, 5, 2012), FinDate(14, 11, 2012),
FinDate(14, 5, 2013), FinDate(14, 11, 2013), FinDate(14, 5, 2014),
FinDate(14, 11, 2014), FinDate(14, 5, 2015), FinDate(16, 11, 2015),
FinDate(16, 5, 2016), FinDate(14, 11, 2016)]
dfs = [0.9999843, 0.9966889, 0.9942107, 0.9911884, 0.9880738, 0.9836490,
0.9786276, 0.9710461, 0.9621778, 0.9514315, 0.9394919]
valuationDate = startDate
curve = FinDiscountCurve(valuationDate, dts, np.array(dfs),
FinInterpTypes.FLAT_FORWARDS)
v = swap.value(valuationDate, curve, curve)
# swap.printFixedLegPV()
# swap.printFloatLegPV()
# This is essentially zero
testCases.header("LABEL", "VALUE")
testCases.print("Swap Value on a Notional of $1M:", v)
def test_FinLiborBermudanSwaptionBKModel():
''' Replicate examples in paper by Leif Andersen which can be found at
file:///C:/Users/Dominic/Downloads/SSRN-id155208.pdf '''
valuationDate = FinDate(1, 1, 2011)
settlementDate = valuationDate
exerciseDate = settlementDate.addYears(1)
swapMaturityDate = settlementDate.addYears(4)
swapFixedCoupon = 0.060
swapFixedFrequencyType = FinFrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = FinDayCountTypes.ACT_365F
liborCurve = FinDiscountCurveFlat(valuationDate,
0.0625,
FinFrequencyTypes.SEMI_ANNUAL)
fwdPayerSwap = FinLiborSwap(exerciseDate,
swapMaturityDate,
FinLiborSwapTypes.PAYER,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
fwdSwapValue = fwdPayerSwap.value(settlementDate, liborCurve, liborCurve)
testCases.header("LABEL", "VALUE")
testCases.print("FWD SWAP VALUE", fwdSwapValue)
# fwdPayerSwap.printFixedLegPV()
# Now we create the European swaptions
swapType = FinLiborSwapTypes.PAYER
europeanSwaptionPay = FinLiborSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
swapType = FinLiborSwapTypes.RECEIVER
europeanSwaptionRec = FinLiborSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
###########################################################################
###########################################################################
###########################################################################
# BLACK'S MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("======= ZERO VOLATILITY ========")
model = FinModelBlack(0.0000001)
testCases.print("Black Model", model._volatility)
valuePay = europeanSwaptionPay.value(settlementDate, liborCurve, model)
testCases.print("EUROPEAN BLACK PAY VALUE ZERO VOL:", valuePay)
valueRec = europeanSwaptionRec.value(settlementDate, liborCurve, model)
testCases.print("EUROPEAN BLACK REC VALUE ZERO VOL:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 20%% BLACK VOLATILITY ========")
model = FinModelBlack(0.20)
testCases.print("Black Model", model._volatility)
valuePay = europeanSwaptionPay.value(settlementDate, liborCurve, model)
testCases.print("EUROPEAN BLACK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(settlementDate, liborCurve, model)
testCases.print("EUROPEAN BLACK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
###########################################################################
###########################################################################
# BK MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("==================== BK MODEL =========================")
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("======= 0% VOLATILITY EUROPEAN SWAPTION BK MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.00001
a = 0.01
numTimeSteps = 200
model = FinModelRatesBK(sigma, a, numTimeSteps)
valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 20% VOLATILITY EUROPEAN SWAPTION BK MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = FinModelRatesBK(sigma, a, numTimeSteps)
testCases.banner("BK MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
swapType = FinLiborSwapTypes.PAYER
exerciseType = FinOptionExerciseTypes.EUROPEAN
bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
swapType = FinLiborSwapTypes.RECEIVER
exerciseType = FinOptionExerciseTypes.EUROPEAN
bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner("======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BK MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = FinModelRatesBK(sigma, a, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BK MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.2
a = 0.01
model = FinModelRatesBK(sigma, a, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
swapType = FinLiborSwapTypes.PAYER
exerciseType = FinOptionExerciseTypes.BERMUDAN
bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
swapType = FinLiborSwapTypes.RECEIVER
exerciseType = FinOptionExerciseTypes.BERMUDAN
bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner("======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BK MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = FinModelRatesBK(sigma, a, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BK MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = FinModelRatesBK(sigma, a, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
###########################################################################
###########################################################################
# BDT MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("======================= BDT MODEL =====================")
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("====== 0% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.00001
numTimeSteps = 200
model = FinModelRatesBDT(sigma, numTimeSteps)
valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BDT PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("===== 20% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = FinModelRatesBDT(sigma, numTimeSteps)
testCases.banner("BDT MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BDT PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
swapType = FinLiborSwapTypes.PAYER
exerciseType = FinOptionExerciseTypes.EUROPEAN
bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
swapType = FinLiborSwapTypes.RECEIVER
bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner("======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.000001
model = FinModelRatesBDT(sigma, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.2
model = FinModelRatesBDT(sigma, numTimeSteps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
swapType = FinLiborSwapTypes.PAYER
exerciseType = FinOptionExerciseTypes.BERMUDAN
bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
swapType = FinLiborSwapTypes.RECEIVER
bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner("======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BDT MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = FinModelRatesBDT(sigma, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BDT MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = FinModelRatesBDT(sigma, numTimeSteps)
print("BDT MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
###########################################################################
###########################################################################
# BDT MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("======================= HW MODEL ======================")
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("====== 0% VOLATILITY EUROPEAN SWAPTION HW MODEL ======")
sigma = 0.0000001
a = 0.1
numTimeSteps = 200
model = FinModelRatesHW(sigma, a, numTimeSteps)
valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN HW PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("===== 20% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.01
a = 0.01
model = FinModelRatesHW(sigma, a, numTimeSteps)
testCases.banner("HW MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN HW PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("EUROPEAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
swapType = FinLiborSwapTypes.PAYER
exerciseType = FinOptionExerciseTypes.EUROPEAN
bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
swapType = FinLiborSwapTypes.RECEIVER
bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner("======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========")
sigma = 0.000001
model = FinModelRatesHW(sigma, a, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 100bp VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.01
model = FinModelRatesHW(sigma, a, numTimeSteps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
swapType = FinLiborSwapTypes.PAYER
exerciseType = FinOptionExerciseTypes.BERMUDAN
bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
swapType = FinLiborSwapTypes.RECEIVER
bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate,
exerciseDate,
swapMaturityDate,
swapType,
exerciseType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner("======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE HW MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = FinModelRatesHW(sigma, a, numTimeSteps)
testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)
testCases.banner("======= 100bps VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE HW MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.01
a = 0.01
model = FinModelRatesHW(sigma, a, numTimeSteps)
testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model)
testCases.print("BERMUDAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAYER MINUS RECEIVER :", payRec)