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)
exerciseDate = Date(1, 1, 2021)
maturity_date = Date(1, 1, 2024)
fixedCoupon = 0.06
fixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
fixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
notional = 100.0
# Pricing a PAY
swaptionType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional)
model = FinModelBlack(0.20)
v = swaption.value(valuation_date, libor_curve, model)
testCases.header("LABEL", "VALUE")
testCases.print("BLACK'S MODEL PRICE:", v * 100)
def test_FinIborCapFloorQLExample():
valuation_date = Date(14, 6, 2016)
dates = [Date(14, 6, 2016), Date(14, 9, 2016),
Date(14, 12, 2016), Date(14, 6, 2017),
Date(14, 6, 2019), Date(14, 6, 2021),
Date(15, 6, 2026), Date(16, 6, 2031),
Date(16, 6, 2036), Date(14, 6, 2046)]
rates = [0.000000, 0.006616, 0.007049, 0.007795,
0.009599, 0.011203, 0.015068, 0.017583,
0.018998, 0.020080]
freq_type = FrequencyTypes.ANNUAL
day_count_type = DayCountTypes.ACT_ACT_ISDA
discount_curve = DiscountCurveZeros(valuation_date,
dates,
rates,
freq_type,
day_count_type,
FinInterpTypes.LINEAR_ZERO_RATES)
start_date = Date(14, 6, 2016)
end_date = Date(14, 6, 2026)
calendar_type = CalendarTypes.UNITED_STATES
bus_day_adjust_type = BusDayAdjustTypes.MODIFIED_FOLLOWING
freq_type = FrequencyTypes.QUARTERLY
date_gen_rule_type = DateGenRuleTypes.FORWARD
lastFixing = 0.0065560
notional = 1000000
day_count_type = DayCountTypes.ACT_360
optionType = FinCapFloorTypes.CAP
strikeRate = 0.02
cap = FinIborCapFloor(start_date, end_date, optionType, strikeRate,
lastFixing, freq_type, day_count_type, notional,
calendar_type, bus_day_adjust_type, date_gen_rule_type)
blackVol = 0.547295
model = FinModelBlack(blackVol)
start = time.time()
numRepeats = 10
for i in range(0, numRepeats):
v = cap.value(valuation_date, discount_curve, model)
end = time.time()
period = end - start
def test_FinIborCapletHull():
# Hull Page 703, example 29.3
todayDate = Date(20, 6, 2019)
valuation_date = todayDate
maturity_date = valuation_date.addTenor("2Y")
libor_curve = DiscountCurveFlat(valuation_date,
0.070,
FrequencyTypes.QUARTERLY,
DayCountTypes.THIRTY_E_360)
k = 0.08
capFloorType = FinCapFloorTypes.CAP
capFloor = FinIborCapFloor(valuation_date,
maturity_date,
capFloorType,
k,
None,
FrequencyTypes.QUARTERLY,
DayCountTypes.THIRTY_E_360)
# Value cap using a single flat cap volatility
model = FinModelBlack(0.20)
capFloor.value(valuation_date, libor_curve, model)
# Value cap by breaking it down into caplets using caplet vols
capletStartDate = valuation_date.addTenor("1Y")
capletEndDate = capletStartDate.addTenor("3M")
vCaplet = capFloor.valueCapletFloorLet(valuation_date,
capletStartDate,
capletEndDate,
libor_curve,
model)
# Cannot match Hull due to dates being adjusted
testCases.header("CORRECT PRICE", "MODEL_PRICE")
testCases.print(517.29, vCaplet)
def test_FinIborBermudanSwaptionBKModel():
""" 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
exerciseDate = settlement_date.addYears(1)
swapMaturityDate = settlement_date.addYears(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 = FinIborSwap(exerciseDate, swapMaturityDate, FinSwapTypes.PAY,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fwdSwapValue = fwdPAYSwap.value(settlement_date, libor_curve, libor_curve)
testCases.header("LABEL", "VALUE")
testCases.print("FWD SWAP VALUE", fwdSwapValue)
# fwdPAYSwap.printFixedLegPV()
# Now we create the European swaptions
fixed_legType = FinSwapTypes.PAY
europeanSwaptionPay = FinIborSwaption(settlement_date, exerciseDate,
swapMaturityDate, fixed_legType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
fixed_legType = FinSwapTypes.RECEIVE
europeanSwaptionRec = FinIborSwaption(settlement_date, exerciseDate,
swapMaturityDate, fixed_legType,
swapFixedCoupon,
swapFixedFrequencyType,
swapFixedDayCountType)
###########################################################################
###########################################################################
###########################################################################
# BLACK'S MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("======= ZERO VOLATILITY ========")
model = FinModelBlack(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 = FinModelBlack(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
numTimeSteps = 100
model = FinModelRatesBK(sigma, a, numTimeSteps)
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 = FinModelRatesBK(sigma, a, numTimeSteps)
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_legType = FinSwapTypes.PAY
exerciseType = FinExerciseTypes.EUROPEAN
bermudanSwaptionPay = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
exerciseType, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_legType = FinSwapTypes.RECEIVE
exerciseType = FinExerciseTypes.EUROPEAN
bermudanSwaptionRec = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
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(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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 = FinModelRatesBK(sigma, a, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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_legType = FinSwapTypes.PAY
exerciseType = FinExerciseTypes.BERMUDAN
bermudanSwaptionPay = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
exerciseType, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_legType = FinSwapTypes.RECEIVE
exerciseType = FinExerciseTypes.BERMUDAN
bermudanSwaptionRec = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
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(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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 = FinModelRatesBK(sigma, a, numTimeSteps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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
numTimeSteps = 200
model = FinModelRatesBDT(sigma, numTimeSteps)
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 = FinModelRatesBDT(sigma, numTimeSteps)
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_legType = FinSwapTypes.PAY
exerciseType = FinExerciseTypes.EUROPEAN
bermudanSwaptionPay = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
exerciseType, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_legType = FinSwapTypes.RECEIVE
bermudanSwaptionRec = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
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(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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 = FinModelRatesBDT(sigma, numTimeSteps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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_legType = FinSwapTypes.PAY
exerciseType = FinExerciseTypes.BERMUDAN
bermudanSwaptionPay = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
exerciseType, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_legType = FinSwapTypes.RECEIVE
bermudanSwaptionRec = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
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(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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 = FinModelRatesBDT(sigma, numTimeSteps)
# print("BDT MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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
numTimeSteps = 200
model = FinModelRatesHW(sigma, a, numTimeSteps)
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 = FinModelRatesHW(sigma, a, numTimeSteps)
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_legType = FinSwapTypes.PAY
exerciseType = FinExerciseTypes.EUROPEAN
bermudanSwaptionPay = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
exerciseType, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_legType = FinSwapTypes.RECEIVE
bermudanSwaptionRec = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
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(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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 = FinModelRatesHW(sigma, a, numTimeSteps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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_legType = FinSwapTypes.PAY
exerciseType = FinExerciseTypes.BERMUDAN
bermudanSwaptionPay = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
exerciseType, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_legType = FinSwapTypes.RECEIVE
bermudanSwaptionRec = FinIborBermudanSwaption(
settlement_date, exerciseDate, swapMaturityDate, fixed_legType,
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(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.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 = FinModelRatesHW(sigma, a, numTimeSteps)
testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
def test_FinIborCapFloor():
todayDate = Date(20, 6, 2019)
valuation_date = todayDate
start_date = todayDate.addWeekDays(2)
maturity_date = start_date.addTenor("1Y")
libor_curve = test_FinIborDepositsAndSwaps(todayDate)
# The capfloor has begun
# lastFixing = 0.028
##########################################################################
# COMPARISON OF MODELS
##########################################################################
strikes = np.linspace(0.02, 0.08, 5)
testCases.header("LABEL", "STRIKE", "BLK", "BLK_SHFTD", "SABR",
"SABR_SHFTD", "HW", "BACH")
model1 = FinModelBlack(0.20)
model2 = FinModelBlackShifted(0.25, 0.0)
model3 = FinModelSABR(0.013, 0.5, 0.5, 0.5)
model4 = FinModelSABRShifted(0.013, 0.5, 0.5, 0.5, -0.008)
model5 = FinModelRatesHW(0.30, 0.01)
model6 = FinModelBachelier(0.01)
for k in strikes:
capFloorType = FinCapFloorTypes.CAP
capfloor = FinIborCapFloor(start_date, maturity_date, capFloorType, k)
cvalue1 = capfloor.value(valuation_date, libor_curve, model1)
cvalue2 = capfloor.value(valuation_date, libor_curve, model2)
cvalue3 = capfloor.value(valuation_date, libor_curve, model3)
cvalue4 = capfloor.value(valuation_date, libor_curve, model4)
cvalue5 = capfloor.value(valuation_date, libor_curve, model5)
cvalue6 = capfloor.value(valuation_date, libor_curve, model6)
testCases.print("CAP", k, cvalue1, cvalue2, cvalue3, cvalue4, cvalue5, cvalue6)
testCases.header("LABEL", "STRIKE", "BLK", "BLK_SHFTD", "SABR",
"SABR_SHFTD", "HW", "BACH")
for k in strikes:
capFloorType = FinCapFloorTypes.FLOOR
capfloor = FinIborCapFloor(start_date, maturity_date, capFloorType, k)
fvalue1 = capfloor.value(valuation_date, libor_curve, model1)
fvalue2 = capfloor.value(valuation_date, libor_curve, model2)
fvalue3 = capfloor.value(valuation_date, libor_curve, model3)
fvalue4 = capfloor.value(valuation_date, libor_curve, model4)
fvalue5 = capfloor.value(valuation_date, libor_curve, model5)
fvalue6 = capfloor.value(valuation_date, libor_curve, model6)
testCases.print("FLR", k, fvalue1, fvalue2, fvalue3, fvalue4, fvalue5, fvalue6)
###############################################################################
# PUT CALL CHECK
###############################################################################
testCases.header("LABEL", "STRIKE", "BLK", "BLK_SHFTD", "SABR",
"SABR SHFTD", "HW", "BACH")
for k in strikes:
capFloorType = FinCapFloorTypes.CAP
capfloor = FinIborCapFloor(start_date, maturity_date, capFloorType, k)
cvalue1 = capfloor.value(valuation_date, libor_curve, model1)
cvalue2 = capfloor.value(valuation_date, libor_curve, model2)
cvalue3 = capfloor.value(valuation_date, libor_curve, model3)
cvalue4 = capfloor.value(valuation_date, libor_curve, model4)
cvalue5 = capfloor.value(valuation_date, libor_curve, model5)
cvalue6 = capfloor.value(valuation_date, libor_curve, model6)
capFloorType = FinCapFloorTypes.FLOOR
capfloor = FinIborCapFloor(start_date, maturity_date, capFloorType, k)
fvalue1 = capfloor.value(valuation_date, libor_curve, model1)
fvalue2 = capfloor.value(valuation_date, libor_curve, model2)
fvalue3 = capfloor.value(valuation_date, libor_curve, model3)
fvalue4 = capfloor.value(valuation_date, libor_curve, model4)
fvalue5 = capfloor.value(valuation_date, libor_curve, model5)
fvalue6 = capfloor.value(valuation_date, libor_curve, model6)
pcvalue1 = cvalue1 - fvalue1
pcvalue2 = cvalue2 - fvalue2
pcvalue3 = cvalue3 - fvalue3
pcvalue4 = cvalue4 - fvalue4
pcvalue5 = cvalue5 - fvalue5
pcvalue6 = cvalue6 - fvalue6
testCases.print("PUT_CALL", k, pcvalue1, pcvalue2, pcvalue3,
pcvalue4, pcvalue5, pcvalue6)
def test_FinIborCapFloorVolCurve():
""" Aim here is to price cap and caplets using cap and caplet vols and to
demonstrate they are the same - NOT SURE THAT HULLS BOOKS FORMULA WORKS FOR
OPTIONS. """
todayDate = Date(20, 6, 2019)
valuation_date = todayDate
maturity_date = valuation_date.addTenor("3Y")
day_count_type = DayCountTypes.THIRTY_E_360
frequency = FrequencyTypes.ANNUAL
k = 0.04
capFloorType = FinCapFloorTypes.CAP
capFloor = FinIborCapFloor(valuation_date,
maturity_date,
capFloorType,
k,
None,
frequency,
day_count_type)
capVolDates = Schedule(valuation_date,
valuation_date.addTenor("10Y"),
frequency)._generate()
flatRate = 0.04
libor_curve = DiscountCurveFlat(valuation_date,
flatRate,
frequency,
day_count_type)
flat = False
if flat is True:
capVolatilities = [20.0] * 11
capVolatilities[0] = 0.0
else:
capVolatilities = [0.00, 15.50, 18.25, 17.91, 17.74, 17.27,
16.79, 16.30, 16.01, 15.76, 15.54]
capVolatilities = np.array(capVolatilities)/100.0
capVolatilities[0] = 0.0
volCurve = FinIborCapVolCurve(valuation_date,
capVolDates,
capVolatilities,
day_count_type)
# print(volCurve._capletGammas)
# Value cap using a single flat cap volatility
tcap = (maturity_date - valuation_date) / gDaysInYear
vol = volCurve.capVol(maturity_date)
model = FinModelBlack(vol)
valueCap = capFloor.value(valuation_date, libor_curve, model)
# print("CAP T", tcap, "VOL:", vol, "VALUE OF CAP:", valueCap)
# Value cap by breaking it down into caplets using caplet vols
vCaplets = 0.0
capletStartDate = capFloor._capFloorLetDates[1]
testCases.header("START", "END", "VOL", "VALUE")
for capletEndDate in capFloor._capFloorLetDates[2:]:
vol = volCurve.capletVol(capletEndDate)
modelCaplet = FinModelBlack(vol)
vCaplet = capFloor.valueCapletFloorLet(valuation_date,
capletStartDate,
capletEndDate,
libor_curve,
modelCaplet)
vCaplets += vCaplet
testCases.print("%12s" % capletStartDate,
"%s" % capletEndDate,
"%9.5f" % (vol*100.0),
"%9.5f" % vCaplet)
capletStartDate = capletEndDate
testCases.header("LABEL", "VALUE")
testCases.print("CAPLETS->CAP: ", vCaplets)
def testFinIborSwaptionModels():
##########################################################################
# COMPARISON OF MODELS
##########################################################################
valuation_date = Date(1, 1, 2011)
libor_curve = test_FinIborDepositsAndSwaps(valuation_date)
exerciseDate = Date(1, 1, 2012)
swapMaturityDate = Date(1, 1, 2017)
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.ACT_365F
strikes = np.linspace(0.02, 0.08, 5)
testCases.header("LAB", "STRIKE", "BLK", "BLK_SHFT", "SABR", "SABR_SHFT",
"HW", "BK")
model1 = FinModelBlack(0.00001)
model2 = FinModelBlackShifted(0.00001, 0.0)
model3 = FinModelSABR(0.013, 0.5, 0.5, 0.5)
model4 = FinModelSABRShifted(0.013, 0.5, 0.5, 0.5, -0.008)
model5 = FinModelRatesHW(0.00001, 0.00001)
model6 = FinModelRatesBK(0.01, 0.01)
settlement_date = valuation_date.addWeekDays(2)
for k in strikes:
swaptionType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate,
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)
testCases.print("PAY", k, swap1, swap2, swap3, swap4, swap5, swap6)
testCases.header("LABEL", "STRIKE", "BLK", "BLK_SHFTD", "SABR",
"SABR_SHFTD", "HW", "BK")
for k in strikes:
swaptionType = FinSwapTypes.RECEIVE
swaption = FinIborSwaption(settlement_date, exerciseDate,
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)
testCases.print("REC", k, swap1, swap2, swap3, swap4, swap5, swap6)
def testFinIborSwaptionMatlabExamples():
# We value a European swaption using Black's model and try to replicate a
# ML example at https://fr.mathworks.com/help/fininst/swaptionbyblk.html
testCases.header("=======================================")
testCases.header("MATLAB EXAMPLE WITH FLAT TERM STRUCTURE")
testCases.header("=======================================")
valuation_date = Date(1, 1, 2010)
libor_curve = DiscountCurveFlat(valuation_date, 0.06,
FrequencyTypes.CONTINUOUS,
DayCountTypes.THIRTY_E_360)
settlement_date = Date(1, 1, 2011)
exerciseDate = Date(1, 1, 2016)
maturity_date = Date(1, 1, 2019)
fixedCoupon = 0.062
fixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
fixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
notional = 100.0
# Pricing a PAY
swaptionType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional)
model = FinModelBlack(0.20)
v_finpy = swaption.value(valuation_date, libor_curve, model)
v_matlab = 2.071
testCases.header("LABEL", "VALUE")
testCases.print("FP Price:", v_finpy)
testCases.print("MATLAB Prix:", v_matlab)
testCases.print("DIFF:", v_finpy - v_matlab)
###############################################################################
testCases.header("===================================")
testCases.header("MATLAB EXAMPLE WITH TERM STRUCTURE")
testCases.header("===================================")
valuation_date = Date(1, 1, 2010)
dates = [
Date(1, 1, 2011),
Date(1, 1, 2012),
Date(1, 1, 2013),
Date(1, 1, 2014),
Date(1, 1, 2015)
]
zeroRates = [0.03, 0.034, 0.037, 0.039, 0.040]
contFreq = FrequencyTypes.CONTINUOUS
interp_type = FinInterpTypes.LINEAR_ZERO_RATES
day_count_type = DayCountTypes.THIRTY_E_360
libor_curve = DiscountCurveZeros(valuation_date, dates, zeroRates,
contFreq, day_count_type, interp_type)
settlement_date = Date(1, 1, 2011)
exerciseDate = Date(1, 1, 2012)
maturity_date = Date(1, 1, 2017)
fixedCoupon = 0.03
fixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
fixedDayCountType = DayCountTypes.THIRTY_E_360
floatFrequencyType = FrequencyTypes.SEMI_ANNUAL
floatDayCountType = DayCountTypes.THIRTY_E_360
notional = 1000.0
# Pricing a put
swaptionType = FinSwapTypes.RECEIVE
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional, floatFrequencyType,
floatDayCountType)
model = FinModelBlack(0.21)
v_finpy = swaption.value(valuation_date, libor_curve, model)
v_matlab = 0.5771
testCases.header("LABEL", "VALUE")
testCases.print("FP Price:", v_finpy)
testCases.print("MATLAB Prix:", v_matlab)
testCases.print("DIFF:", v_finpy - v_matlab)
###############################################################################
testCases.header("===================================")
testCases.header("MATLAB EXAMPLE WITH SHIFTED BLACK")
testCases.header("===================================")
valuation_date = Date(1, 1, 2016)
dates = [
Date(1, 1, 2017),
Date(1, 1, 2018),
Date(1, 1, 2019),
Date(1, 1, 2020),
Date(1, 1, 2021)
]
zeroRates = np.array([-0.02, 0.024, 0.047, 0.090, 0.12]) / 100.0
contFreq = FrequencyTypes.ANNUAL
interp_type = FinInterpTypes.LINEAR_ZERO_RATES
day_count_type = DayCountTypes.THIRTY_E_360
libor_curve = DiscountCurveZeros(valuation_date, dates, zeroRates,
contFreq, day_count_type, interp_type)
settlement_date = Date(1, 1, 2016)
exerciseDate = Date(1, 1, 2017)
maturity_date = Date(1, 1, 2020)
fixedCoupon = -0.003
fixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
fixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
floatFrequencyType = FrequencyTypes.SEMI_ANNUAL
floatDayCountType = DayCountTypes.THIRTY_E_360_ISDA
notional = 1000.0
# Pricing a PAY
swaptionType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional, floatFrequencyType,
floatDayCountType)
model = FinModelBlackShifted(0.31, 0.008)
v_finpy = swaption.value(valuation_date, libor_curve, model)
v_matlab = 12.8301
testCases.header("LABEL", "VALUE")
testCases.print("FP Price:", v_finpy)
testCases.print("MATLAB Prix:", v_matlab)
testCases.print("DIFF:", v_finpy - v_matlab)
###############################################################################
testCases.header("===================================")
testCases.header("MATLAB EXAMPLE WITH HULL WHITE")
testCases.header("===================================")
# https://fr.mathworks.com/help/fininst/swaptionbyhw.html
valuation_date = Date(1, 1, 2007)
dates = [
Date(1, 1, 2007),
Date(1, 7, 2007),
Date(1, 1, 2008),
Date(1, 7, 2008),
Date(1, 1, 2009),
Date(1, 7, 2009),
Date(1, 1, 2010),
Date(1, 7, 2010),
Date(1, 1, 2011),
Date(1, 7, 2011),
Date(1, 1, 2012)
]
zeroRates = np.array([0.075] * 11)
interp_type = FinInterpTypes.FLAT_FWD_RATES
day_count_type = DayCountTypes.THIRTY_E_360_ISDA
contFreq = FrequencyTypes.SEMI_ANNUAL
libor_curve = DiscountCurveZeros(valuation_date, dates, zeroRates,
contFreq, day_count_type, interp_type)
settlement_date = valuation_date
exerciseDate = Date(1, 1, 2010)
maturity_date = Date(1, 1, 2012)
fixedCoupon = 0.04
fixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
fixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
notional = 100.0
swaptionType = FinSwapTypes.RECEIVE
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional)
model = FinModelRatesHW(0.05, 0.01)
v_finpy = swaption.value(valuation_date, libor_curve, model)
v_matlab = 2.9201
testCases.header("LABEL", "VALUE")
testCases.print("FP Price:", v_finpy)
testCases.print("MATLAB Prix:", v_matlab)
testCases.print("DIFF:", v_finpy - v_matlab)
###############################################################################
testCases.header("====================================")
testCases.header("MATLAB EXAMPLE WITH BLACK KARASINSKI")
testCases.header("====================================")
# https://fr.mathworks.com/help/fininst/swaptionbybk.html
valuation_date = Date(1, 1, 2007)
dates = [
Date(1, 1, 2007),
Date(1, 7, 2007),
Date(1, 1, 2008),
Date(1, 7, 2008),
Date(1, 1, 2009),
Date(1, 7, 2009),
Date(1, 1, 2010),
Date(1, 7, 2010),
Date(1, 1, 2011),
Date(1, 7, 2011),
Date(1, 1, 2012)
]
zeroRates = np.array([0.07] * 11)
interp_type = FinInterpTypes.FLAT_FWD_RATES
day_count_type = DayCountTypes.THIRTY_E_360_ISDA
contFreq = FrequencyTypes.SEMI_ANNUAL
libor_curve = DiscountCurveZeros(valuation_date, dates, zeroRates,
contFreq, day_count_type, interp_type)
settlement_date = valuation_date
exerciseDate = Date(1, 1, 2011)
maturity_date = Date(1, 1, 2012)
fixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
fixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
notional = 100.0
model = FinModelRatesBK(0.1, 0.05, 200)
fixedCoupon = 0.07
swaptionType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional)
v_finpy = swaption.value(valuation_date, libor_curve, model)
v_matlab = 0.3634
testCases.header("LABEL", "VALUE")
testCases.print("FP Price:", v_finpy)
testCases.print("MATLAB Prix:", v_matlab)
testCases.print("DIFF:", v_finpy - v_matlab)
fixedCoupon = 0.0725
swaptionType = FinSwapTypes.RECEIVE
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional)
v_finpy = swaption.value(valuation_date, libor_curve, model)
v_matlab = 0.4798
testCases.header("LABEL", "VALUE")
testCases.print("FP Price:", v_finpy)
testCases.print("MATLAB Prix:", v_matlab)
testCases.print("DIFF:", v_finpy - v_matlab)
###############################################################################
testCases.header("====================================")
testCases.header("MATLAB EXAMPLE WITH BLACK-DERMAN-TOY")
testCases.header("====================================")
# https://fr.mathworks.com/help/fininst/swaptionbybdt.html
valuation_date = Date(1, 1, 2007)
dates = [
Date(1, 1, 2007),
Date(1, 7, 2007),
Date(1, 1, 2008),
Date(1, 7, 2008),
Date(1, 1, 2009),
Date(1, 7, 2009),
Date(1, 1, 2010),
Date(1, 7, 2010),
Date(1, 1, 2011),
Date(1, 7, 2011),
Date(1, 1, 2012)
]
zeroRates = np.array([0.06] * 11)
interp_type = FinInterpTypes.FLAT_FWD_RATES
day_count_type = DayCountTypes.THIRTY_E_360_ISDA
contFreq = FrequencyTypes.ANNUAL
libor_curve = DiscountCurveZeros(valuation_date, dates, zeroRates,
contFreq, day_count_type, interp_type)
settlement_date = valuation_date
exerciseDate = Date(1, 1, 2012)
maturity_date = Date(1, 1, 2015)
fixedFrequencyType = FrequencyTypes.ANNUAL
fixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
notional = 100.0
fixedCoupon = 0.062
swaptionType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate, maturity_date,
swaptionType, fixedCoupon, fixedFrequencyType,
fixedDayCountType, notional)
model = FinModelRatesBDT(0.20, 200)
v_finpy = swaption.value(valuation_date, libor_curve, model)
v_matlab = 2.0592
testCases.header("LABEL", "VALUE")
testCases.print("FP Price:", v_finpy)
testCases.print("MATLAB Prix:", v_matlab)
testCases.print("DIFF:", v_finpy - v_matlab)
def testFinIborCashSettledSwaption():
testCases.header("LABEL", "VALUE")
valuation_date = Date(1, 1, 2020)
settlement_date = Date(1, 1, 2020)
depoDCCType = DayCountTypes.THIRTY_E_360_ISDA
depos = []
depo = FinIborDeposit(settlement_date, "1W", 0.0023, depoDCCType)
depos.append(depo)
depo = FinIborDeposit(settlement_date, "1M", 0.0023, depoDCCType)
depos.append(depo)
depo = FinIborDeposit(settlement_date, "3M", 0.0023, depoDCCType)
depos.append(depo)
depo = FinIborDeposit(settlement_date, "6M", 0.0023, depoDCCType)
depos.append(depo)
# No convexity correction provided so I omit interest rate futures
settlement_date = Date(2, 1, 2020)
swaps = []
accType = DayCountTypes.ACT_365F
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
fixed_legType = FinSwapTypes.PAY
swap = FinIborSwap(settlement_date, "3Y", fixed_legType, 0.00790,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "4Y", fixed_legType, 0.01200,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "5Y", fixed_legType, 0.01570,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "6Y", fixed_legType, 0.01865,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "7Y", fixed_legType, 0.02160,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "8Y", fixed_legType, 0.02350,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "9Y", fixed_legType, 0.02540,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "10Y", fixed_legType, 0.0273,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "15Y", fixed_legType, 0.0297,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "20Y", fixed_legType, 0.0316,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "25Y", fixed_legType, 0.0335,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "30Y", fixed_legType, 0.0354,
fixedFreqType, accType)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, [], swaps,
FinInterpTypes.LINEAR_ZERO_RATES)
exerciseDate = settlement_date.addTenor("5Y")
swapMaturityDate = exerciseDate.addTenor("5Y")
swapFixedCoupon = 0.040852
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
swapFloatFrequencyType = FrequencyTypes.QUARTERLY
swapFloatDayCountType = DayCountTypes.ACT_360
swapNotional = 1000000
fixed_legType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate, swapMaturityDate,
fixed_legType, swapFixedCoupon,
swapFixedFrequencyType, swapFixedDayCountType,
swapNotional, swapFloatFrequencyType,
swapFloatDayCountType)
model = FinModelBlack(0.1533)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print("Swaption No-Arb Value:", v)
fwdSwapRate1 = libor_curve.swap_rate(exerciseDate, swapMaturityDate,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.print("Curve Fwd Swap Rate:", fwdSwapRate1)
fwdSwap = FinIborSwap(exerciseDate, swapMaturityDate, fixed_legType,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fwdSwapRate2 = fwdSwap.swap_rate(settlement_date, libor_curve)
testCases.print("Fwd Swap Swap Rate:", fwdSwapRate2)
model = FinModelBlack(0.1533)
v = swaption.cashSettledValue(valuation_date, libor_curve, fwdSwapRate2,
model)
testCases.print("Swaption Cash Settled Value:", v)
def test_FinIborSwaptionQLExample():
valuation_date = Date(4, 3, 2014)
settlement_date = Date(4, 3, 2014)
depoDCCType = DayCountTypes.THIRTY_E_360_ISDA
depos = []
depo = FinIborDeposit(settlement_date, "1W", 0.0023, depoDCCType)
depos.append(depo)
depo = FinIborDeposit(settlement_date, "1M", 0.0023, depoDCCType)
depos.append(depo)
depo = FinIborDeposit(settlement_date, "3M", 0.0023, depoDCCType)
depos.append(depo)
depo = FinIborDeposit(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_legType = FinSwapTypes.PAY
swap = FinIborSwap(settlement_date, "3Y", fixed_legType, 0.00790,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "4Y", fixed_legType, 0.01200,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "5Y", fixed_legType, 0.01570,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "6Y", fixed_legType, 0.01865,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "7Y", fixed_legType, 0.02160,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "8Y", fixed_legType, 0.02350,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "9Y", fixed_legType, 0.02540,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "10Y", fixed_legType, 0.0273,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "15Y", fixed_legType, 0.0297,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "20Y", fixed_legType, 0.0316,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "25Y", fixed_legType, 0.0335,
fixedFreqType, accType)
swaps.append(swap)
swap = FinIborSwap(settlement_date, "30Y", fixed_legType, 0.0354,
fixedFreqType, accType)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, [], swaps,
FinInterpTypes.LINEAR_ZERO_RATES)
exerciseDate = settlement_date.addTenor("5Y")
swapMaturityDate = exerciseDate.addTenor("5Y")
swapFixedCoupon = 0.040852
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
swapFloatFrequencyType = FrequencyTypes.QUARTERLY
swapFloatDayCountType = DayCountTypes.ACT_360
swapNotional = 1000000
swaptionType = FinSwapTypes.PAY
swaption = FinIborSwaption(settlement_date, exerciseDate, swapMaturityDate,
swaptionType, swapFixedCoupon,
swapFixedFrequencyType, swapFixedDayCountType,
swapNotional, swapFloatFrequencyType,
swapFloatDayCountType)
testCases.header("MODEL", "VALUE")
model = FinModelBlack(0.1533)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = FinModelBlackShifted(0.1533, -0.008)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = FinModelSABR(0.132, 0.5, 0.5, 0.5)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = FinModelSABRShifted(0.352, 0.5, 0.15, 0.15, -0.005)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = FinModelRatesHW(0.010000000, 0.00000000001)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
def test_Black():
forward = 0.034
strike = 0.050
riskFreeIR = 0.00
timeToExpiry = 2.0
volatility = 0.20
testCases.header("ITEM", "CALL", "PUT")
callOptionType = FinOptionTypes.EUROPEAN_CALL
putOptionType = FinOptionTypes.EUROPEAN_PUT
df = np.exp(-riskFreeIR * timeToExpiry)
model = FinModelBlack(volatility)
dp = 12 # Precision
try:
#######################################################################
valueCall = model.value(forward, strike, timeToExpiry, df,
callOptionType)
valuePut = model.value(forward, strike, timeToExpiry, df,
putOptionType)
assert round((valueCall - valuePut), dp) == round(df*(forward - strike), dp), \
"The method called 'value()' doesn't comply with Call-Put parity"
testCases.print("VALUE", valueCall, valuePut)
#######################################################################
deltaCall = model.delta(forward, strike, timeToExpiry, df,
callOptionType)
deltaPut = model.delta(forward, strike, timeToExpiry, df,
putOptionType)
assert round((1/df) * (deltaCall - deltaPut), dp) == 1.0, \
"The method called 'delta()' doesn't comply with Call-put parity"
testCases.print("DELTA", deltaCall, deltaPut)
#######################################################################
gammaCall = model.gamma(forward, strike, timeToExpiry, df,
callOptionType)
gammaPut = model.gamma(forward, strike, timeToExpiry, df,
putOptionType)
assert round(gammaCall - gammaPut, dp) == 0.0, \
"The method called 'gamma()' doesn't comply with Call-Put parity"
testCases.print("GAMMA", gammaCall, gammaPut)
#######################################################################
thetaCall = model.theta(forward, strike, timeToExpiry, df,
callOptionType)
thetaPut = model.theta(forward, strike, timeToExpiry, df,
putOptionType)
assert round((thetaCall - thetaPut), dp) == round((riskFreeIR * timeToExpiry) * (forward - strike) * df, dp), \
"The method called 'theta()' doesn't comply with Call-Put parity"
testCases.print("THETA", thetaCall, thetaPut)
#######################################################################
vegaCall = model.vega(forward, strike, timeToExpiry, df,
callOptionType)
vegaPut = model.vega(forward, strike, timeToExpiry, df, putOptionType)
assert round(vegaCall - vegaPut, dp) == 0.0, \
"The method called 'vega()' doesn't comply with Call-Put parity"
testCases.print("VEGA", vegaCall, vegaPut)
#######################################################################
except AssertionError as err:
raise err