def test_pay():
libor_curve = build_curve(valuation_date)
swaptionType = SwapTypes.PAY
k = 0.02
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, k, swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuation_date, libor_curve, model1)
swap2 = swaption.value(valuation_date, libor_curve, model2)
swap3 = swaption.value(valuation_date, libor_curve, model3)
swap4 = swaption.value(valuation_date, libor_curve, model4)
swap5 = swaption.value(valuation_date, libor_curve, model5)
swap6 = swaption.value(valuation_date, libor_curve, model6)
assert round(swap1, 0) == 125087
assert round(swap2, 0) == 125087
assert round(swap3, 0) == 125087
assert round(swap4, 0) == 125087
assert round(swap5, 0) == 125684
assert round(swap6, 0) == 124501
k = 0.035
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, k, swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuation_date, libor_curve, model1)
swap2 = swaption.value(valuation_date, libor_curve, model2)
swap3 = swaption.value(valuation_date, libor_curve, model3)
swap4 = swaption.value(valuation_date, libor_curve, model4)
swap5 = swaption.value(valuation_date, libor_curve, model5)
swap6 = swaption.value(valuation_date, libor_curve, model6)
assert round(swap1, 1) == 62492.6
assert round(swap2, 1) == 62492.6
assert round(swap3, 1) == 62492.6
assert round(swap4, 1) == 62492.8
assert round(swap5, 1) == 63098.5
assert round(swap6, 1) == 62307.2
k = 0.065
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, k, swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuation_date, libor_curve, model1)
swap2 = swaption.value(valuation_date, libor_curve, model2)
swap3 = swaption.value(valuation_date, libor_curve, model3)
swap4 = swaption.value(valuation_date, libor_curve, model4)
swap5 = swaption.value(valuation_date, libor_curve, model5)
swap6 = swaption.value(valuation_date, libor_curve, model6)
assert round(swap1, 4) == 0.0
assert round(swap2, 4) == 0.0
assert round(swap3, 1) == 22.1
assert round(swap4, 1) == 60.3
assert round(swap5, 4) == 0.0
assert round(swap6, 4) == 0.0
def test_receive():
swaptionType = SwapTypes.RECEIVE
k = 0.02
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, k, swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuation_date, libor_curve, model1)
swap2 = swaption.value(valuation_date, libor_curve, model2)
swap3 = swaption.value(valuation_date, libor_curve, model3)
swap4 = swaption.value(valuation_date, libor_curve, model4)
swap5 = swaption.value(valuation_date, libor_curve, model5)
swap6 = swaption.value(valuation_date, libor_curve, model6)
assert round(swap1, 4) == 0.0
assert round(swap2, 4) == 0.0
assert round(swap3, 4) == 0.0
assert round(swap4, 4) == 0.0046
assert round(swap5, 4) == 0.0
assert round(swap6, 4) == 0.0
k = 0.05
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, k, swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuation_date, libor_curve, model1)
swap2 = swaption.value(valuation_date, libor_curve, model2)
swap3 = swaption.value(valuation_date, libor_curve, model3)
swap4 = swaption.value(valuation_date, libor_curve, model4)
swap5 = swaption.value(valuation_date, libor_curve, model5)
swap6 = swaption.value(valuation_date, libor_curve, model6)
assert round(swap1, 1) == 101.8
assert round(swap2, 1) == 101.8
assert round(swap3, 1) == 4945.4
assert round(swap4, 1) == 5392.6
assert round(swap5, 4) == 0.0
assert round(swap6, 1) == 762.5
k = 0.08
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, k, swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuation_date, libor_curve, model1)
swap2 = swaption.value(valuation_date, libor_curve, model2)
swap3 = swaption.value(valuation_date, libor_curve, model3)
swap4 = swaption.value(valuation_date, libor_curve, model4)
swap5 = swaption.value(valuation_date, libor_curve, model5)
swap6 = swaption.value(valuation_date, libor_curve, model6)
assert round(swap1, 1) == 125290.5
assert round(swap2, 1) == 125290.5
assert round(swap3, 1) == 125291.1
assert round(swap4, 1) == 125293.6
assert round(swap5, 1) == 124657.1
assert round(swap6, 1) == 124274.9
def testBlackModelCheck():
# Checking Andersen paper using Black's model
# Used to check swaption price below - we have Ts = 1 and Te = 4
# Expect a price around 122 cents which is what I find.
valuation_date = Date(1, 1, 2020)
libor_curve = DiscountCurveFlat(valuation_date, 0.06,
FrequencyTypes.SEMI_ANNUAL)
settlement_date = Date(1, 1, 2020)
exercise_date = Date(1, 1, 2021)
maturity_date = Date(1, 1, 2024)
fixed_coupon = 0.06
fixed_frequency_type = FrequencyTypes.SEMI_ANNUAL
fixed_day_count_type = DayCountTypes.THIRTY_E_360_ISDA
notional = 100.0
# Pricing a PAY
swaptionType = SwapTypes.PAY
swaption = IborSwaption(settlement_date, exercise_date, maturity_date,
swaptionType, fixed_coupon, fixed_frequency_type,
fixed_day_count_type, notional)
model = Black(0.20)
v = swaption.value(valuation_date, libor_curve, model)
testCases.header("LABEL", "VALUE")
testCases.print("BLACK'S MODEL PRICE:", v * 100)
def test_IborSwaptionQLExample():
valuation_date = Date(4, 3, 2014)
settlement_date = Date(4, 3, 2014)
depoDCCType = DayCountTypes.THIRTY_E_360_ISDA
depos = []
depo = IborDeposit(settlement_date, "1W", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "1M", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "3M", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "6M", 0.0023, depoDCCType)
depos.append(depo)
# No convexity correction provided so I omit interest rate futures
swaps = []
accType = DayCountTypes.ACT_365F
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
fixed_leg_type = SwapTypes.PAY
swap = IborSwap(settlement_date, "3Y", fixed_leg_type, 0.00790,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "4Y", fixed_leg_type, 0.01200,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "5Y", fixed_leg_type, 0.01570,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "6Y", fixed_leg_type, 0.01865,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "7Y", fixed_leg_type, 0.02160,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "8Y", fixed_leg_type, 0.02350,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "9Y", fixed_leg_type, 0.02540,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "10Y", fixed_leg_type, 0.0273,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "15Y", fixed_leg_type, 0.0297,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "20Y", fixed_leg_type, 0.0316,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "25Y", fixed_leg_type, 0.0335,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "30Y", fixed_leg_type, 0.0354,
fixedFreqType, accType)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, [], swaps,
InterpTypes.LINEAR_ZERO_RATES)
exercise_date = settlement_date.add_tenor("5Y")
swapMaturityDate = exercise_date.add_tenor("5Y")
swapFixedCoupon = 0.040852
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
swapFloatFrequencyType = FrequencyTypes.QUARTERLY
swapFloatDayCountType = DayCountTypes.ACT_360
swapNotional = 1000000
swaptionType = SwapTypes.PAY
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, swapFixedCoupon,
swapFixedFrequencyType, swapFixedDayCountType,
swapNotional, swapFloatFrequencyType,
swapFloatDayCountType)
testCases.header("MODEL", "VALUE")
model = Black(0.1533)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = BlackShifted(0.1533, -0.008)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = SABR(0.132, 0.5, 0.5, 0.5)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = SABRShifted(0.352, 0.5, 0.15, 0.15, -0.005)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = HWTree(0.010000000, 0.00000000001)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
def test_IborBermudanSwaptionBKModel():
""" Replicate examples in paper by Leif Andersen which can be found at
file:///C:/Users/Dominic/Downloads/SSRN-id155208.pdf """
valuation_date = Date(1, 1, 2011)
settlement_date = valuation_date
exercise_date = settlement_date.add_years(1)
swapMaturityDate = settlement_date.add_years(4)
swapFixedCoupon = 0.060
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.ACT_365F
libor_curve = DiscountCurveFlat(valuation_date, 0.0625,
FrequencyTypes.SEMI_ANNUAL,
DayCountTypes.ACT_365F)
fwdPAYSwap = IborSwap(exercise_date, swapMaturityDate, SwapTypes.PAY,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fwdSwapValue = fwdPAYSwap.value(settlement_date, libor_curve, libor_curve)
testCases.header("LABEL", "VALUE")
testCases.print("FWD SWAP VALUE", fwdSwapValue)
# fwdPAYSwap.print_fixed_leg_pv()
# Now we create the European swaptions
fixed_leg_type = SwapTypes.PAY
europeanSwaptionPay = IborSwaption(settlement_date, exercise_date,
swapMaturityDate, fixed_leg_type,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
europeanSwaptionRec = IborSwaption(settlement_date, exercise_date,
swapMaturityDate, fixed_leg_type,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
###########################################################################
###########################################################################
###########################################################################
# BLACK'S MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("======= ZERO VOLATILITY ========")
model = Black(0.0000001)
testCases.print("Black Model", model._volatility)
valuePay = europeanSwaptionPay.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK PAY VALUE ZERO VOL:", valuePay)
valueRec = europeanSwaptionRec.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK REC VALUE ZERO VOL:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner("======= 20%% BLACK VOLATILITY ========")
model = Black(0.20)
testCases.print("Black Model", model._volatility)
valuePay = europeanSwaptionPay.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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.000000001
a = 0.01
num_time_steps = 100
model = BKTree(sigma, a, num_time_steps)
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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 = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, 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 = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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 = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, 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 = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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 = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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
num_time_steps = 200
model = BDTTree(sigma, num_time_steps)
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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 = BDTTree(sigma, num_time_steps)
testCases.banner("BDT MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.000001
model = BDTTree(sigma, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 20% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.2
model = BDTTree(sigma, num_time_steps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, 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 = BDTTree(sigma, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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 = BDTTree(sigma, num_time_steps)
# print("BDT MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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
num_time_steps = 200
model = HWTree(sigma, a, num_time_steps)
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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 = HWTree(sigma, a, num_time_steps)
testCases.banner("HW MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========"
)
sigma = 0.000001
model = HWTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 100bp VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.01
model = HWTree(sigma, a, num_time_steps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, 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 = HWTree(sigma, a, num_time_steps)
testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY 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 = HWTree(sigma, a, num_time_steps)
testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)