def test_BDTExampleOne():
# HULL BOOK NOTES
# http://www-2.rotman.utoronto.ca/~hull/technicalnotes/TechnicalNote23.pdf
valuation_date = Date(1, 1, 2020)
years = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
zeroDates = valuation_date.addYears(years)
zeroRates = [0.00, 0.10, 0.11, 0.12, 0.125, 0.13]
testCases.header("DATES")
testCases.print(zeroDates)
testCases.header("RATES")
testCases.print(zeroRates)
curve = DiscountCurveZeros(valuation_date, zeroDates, zeroRates,
FrequencyTypes.ANNUAL)
yieldVol = 0.16
numTimeSteps = 5
tmat = years[-1]
dfs = curve.df(zeroDates)
testCases.print("DFS")
testCases.print(dfs)
years = np.array(years)
dfs = np.array(dfs)
model = FinModelRatesBDT(yieldVol, numTimeSteps)
model.buildTree(tmat, years, dfs)
def test_BondOptionAmericanConvergenceONE():
# Build discount curve
settlement_date = Date(1, 12, 2019)
discount_curve = DiscountCurveFlat(settlement_date, 0.05)
# Bond details
issue_date = Date(1, 9, 2010)
maturity_date = Date(1, 9, 2025)
coupon = 0.05
freq_type = FrequencyTypes.SEMI_ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
bond = Bond(issue_date, maturity_date, coupon, freq_type, accrual_type)
# Option Details
expiry_date = Date(1, 12, 2020)
strikePrice = 100.0
face = 100.0
testCases.header("TIME", "N", "PUT_AMER", "PUT_EUR",
"CALL_AME", "CALL_EUR")
timeSteps = range(30, 100, 1)
for numTimeSteps in timeSteps:
sigma = 0.20
start = time.time()
optionType = FinOptionTypes.AMERICAN_PUT
bondOption1 = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v1put = bondOption1.value(settlement_date, discount_curve, model)
optionType = FinOptionTypes.EUROPEAN_PUT
bondOption2 = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v2put = bondOption2.value(settlement_date, discount_curve, model)
optionType = FinOptionTypes.AMERICAN_CALL
bondOption1 = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v1call = bondOption1.value(settlement_date, discount_curve, model)
optionType = FinOptionTypes.EUROPEAN_CALL
bondOption2 = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v2call = bondOption2.value(settlement_date, discount_curve, model)
end = time.time()
period = end - start
testCases.print(period, numTimeSteps, v1put, v2put, v1call, v2call)
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_BDTExampleThree():
# Valuation of a swaption as in Leif Andersen's paper - see Table 1 on
# SSRN-id155208.pdf
testCases.banner("===================== ANDERSEN PAPER ==============")
# This is a sanity check
testBlackModelCheck()
settlement_date = Date(1, 1, 2020)
times = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
dates = settlement_date.addYears(times)
rate = 0.06
dfs = 1.0 / (1.0 + rate / 2.0)**(2.0 * times)
curve = DiscountCurve(settlement_date, dates, dfs)
coupon = 0.06
freq_type = FrequencyTypes.SEMI_ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
strikePrice = 100.0
face = 100.0
# Andersen paper
numTimeSteps = 200
testCases.header("ExerciseType", "Sigma", "NumSteps", "Texp", "Tmat",
"V_Fixed", "V_pay", "V_rec")
for exerciseType in [FinExerciseTypes.EUROPEAN, FinExerciseTypes.BERMUDAN]:
for maturityYears in [4.0, 5.0, 10.0, 20.0]:
maturity_date = settlement_date.addYears(maturityYears)
issue_date = Date(maturity_date._d, maturity_date._m, 2000)
if maturityYears == 4.0 or maturityYears == 5.0:
sigma = 0.2012
elif maturityYears == 10.0:
sigma = 0.1522
elif maturityYears == 20.0:
sigma = 0.1035
for expiryYears in range(
int(maturityYears / 2) - 1, int(maturityYears)):
expiry_date = settlement_date.addYears(expiryYears)
tmat = (maturity_date - settlement_date) / gDaysInYear
texp = (expiry_date - settlement_date) / gDaysInYear
bond = Bond(issue_date, maturity_date, coupon, freq_type,
accrual_type)
coupon_times = []
coupon_flows = []
cpn = bond._coupon / bond._frequency
for flowDate in bond._flow_dates:
if flowDate > expiry_date:
flow_time = (flowDate - settlement_date) / gDaysInYear
coupon_times.append(flow_time)
coupon_flows.append(cpn)
coupon_times = np.array(coupon_times)
coupon_flows = np.array(coupon_flows)
price = bond.clean_price_from_discount_curve(
settlement_date, curve)
model = FinModelRatesBDT(sigma, numTimeSteps)
model.buildTree(tmat, times, dfs)
v = model.bermudanSwaption(texp, tmat, strikePrice, face,
coupon_times, coupon_flows,
exerciseType)
testCases.print("%s" % exerciseType, "%9.5f" % sigma,
"%9.5f" % numTimeSteps, "%9.5f" % expiryYears,
"%9.5f" % maturityYears, "%9.5f" % price,
"%9.2f" % (v['pay'] * 100.0),
"%9.2f" % (v['rec'] * 100.0))
def test_BDTExampleTwo():
# Valuation of a European option on a coupon bearing bond
# This follows example in Fig 28.11 of John Hull's book (6th Edition)
# but does not have the exact same dt so there are some differences
testCases.banner("===================== FIG 28.11 HULL BOOK =============")
settlement_date = Date(1, 12, 2019)
issue_date = Date(1, 12, 2015)
expiry_date = settlement_date.addTenor("18m")
maturity_date = settlement_date.addTenor("10Y")
coupon = 0.05
freq_type = FrequencyTypes.SEMI_ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
bond = Bond(issue_date, maturity_date, coupon, freq_type, accrual_type)
coupon_times = []
coupon_flows = []
cpn = bond._coupon / bond._frequency
num_flows = len(bond._flow_dates)
for i in range(1, num_flows):
pcd = bond._flow_dates[i - 1]
ncd = bond._flow_dates[i]
if pcd < settlement_date and ncd > settlement_date:
flow_time = (pcd - settlement_date) / gDaysInYear
coupon_times.append(flow_time)
coupon_flows.append(cpn)
for flowDate in bond._flow_dates:
if flowDate > settlement_date:
flow_time = (flowDate - settlement_date) / gDaysInYear
coupon_times.append(flow_time)
coupon_flows.append(cpn)
coupon_times = np.array(coupon_times)
coupon_flows = np.array(coupon_flows)
strikePrice = 105.0
face = 100.0
tmat = (maturity_date - settlement_date) / gDaysInYear
texp = (expiry_date - settlement_date) / gDaysInYear
times = np.linspace(0, tmat, 11)
dates = settlement_date.addYears(times)
dfs = np.exp(-0.05 * times)
testCases.header("LABEL", "VALUES")
testCases.print("TIMES:", times)
curve = DiscountCurve(settlement_date, dates, dfs)
price = bond.clean_price_from_discount_curve(settlement_date, curve)
testCases.print("Fixed Income Price:", price)
sigma = 0.20
# Test convergence
num_stepsList = [5] #[100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
exerciseType = FinExerciseTypes.AMERICAN
testCases.header("Values")
treeVector = []
for numTimeSteps in num_stepsList:
model = FinModelRatesBDT(sigma, numTimeSteps)
model.buildTree(tmat, times, dfs)
v = model.bondOption(texp, strikePrice, face, coupon_times,
coupon_flows, exerciseType)
testCases.print(v)
treeVector.append(v['call'])
if PLOT_GRAPHS:
plt.plot(num_stepsList, treeVector)
# The value in Hull converges to 0.699 with 100 time steps while I get 0.70
if 1 == 0:
print("RT")
printTree(model._rt, 5)
print("Q")
printTree(model._Q, 5)
def test_BondOptionZEROVOLConvergence():
# Build discount curve
settlement_date = Date(1, 12, 2019) # CHANGED
rate = 0.05
discount_curve = DiscountCurveFlat(settlement_date, rate, FrequencyTypes.ANNUAL)
# Bond details
issue_date = Date(1, 9, 2015)
maturity_date = Date(1, 9, 2025)
coupon = 0.06
freq_type = FrequencyTypes.ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
bond = Bond(issue_date, maturity_date, coupon, freq_type, accrual_type)
# Option Details
expiry_date = settlement_date.addTenor("18m") # FinDate(1, 12, 2021)
# print("EXPIRY:", expiry_date)
face = 100.0
dfExpiry = discount_curve.df(expiry_date)
spotCleanValue = bond.clean_price_from_discount_curve(settlement_date, discount_curve)
fwdCleanValue = bond.clean_price_from_discount_curve(expiry_date, discount_curve)
# print("BOND SpotCleanBondPx", spotCleanValue)
# print("BOND FwdCleanBondPx", fwdCleanValue)
# print("BOND Accrued:", bond._accruedInterest)
spotCleanValue = bond.clean_price_from_discount_curve(settlement_date, discount_curve)
testCases.header("STRIKE", "STEPS",
"CALL_INT", "CALL_INT_PV", "CALL_EUR", "CALL_AMER",
"PUT_INT", "PUT_INT_PV", "PUT_EUR", "PUT_AMER")
numTimeSteps = range(100, 1000, 200)
strikePrices = [90, 100, 110, 120]
for strikePrice in strikePrices:
callIntrinsic = max(spotCleanValue - strikePrice, 0)
putIntrinsic = max(strikePrice - spotCleanValue, 0)
callIntrinsicPV = max(fwdCleanValue - strikePrice, 0) * dfExpiry
putIntrinsicPV = max(strikePrice - fwdCleanValue, 0) * dfExpiry
for num_steps in numTimeSteps:
sigma = 0.0000001
model = FinModelRatesBDT(sigma, num_steps)
optionType = FinOptionTypes.EUROPEAN_CALL
bondOption1 = BondOption(bond, expiry_date, strikePrice, face, optionType)
v1 = bondOption1.value(settlement_date, discount_curve, model)
optionType = FinOptionTypes.AMERICAN_CALL
bondOption2 = BondOption(bond, expiry_date, strikePrice, face, optionType)
v2 = bondOption2.value(settlement_date, discount_curve, model)
optionType = FinOptionTypes.EUROPEAN_PUT
bondOption3 = BondOption(bond, expiry_date, strikePrice, face, optionType)
v3 = bondOption3.value(settlement_date, discount_curve, model)
optionType = FinOptionTypes.AMERICAN_PUT
bondOption4 = BondOption(bond, expiry_date, strikePrice, face, optionType)
v4 = bondOption4.value(settlement_date, discount_curve, model)
testCases.print(strikePrice, num_steps,
callIntrinsic, callIntrinsicPV, v1, v2,
putIntrinsic, putIntrinsicPV, v3, v4)
def test_BondOption():
settlement_date = Date(1, 12, 2019)
issue_date = Date(1, 12, 2018)
maturity_date = settlement_date.addTenor("10Y")
coupon = 0.05
freq_type = FrequencyTypes.SEMI_ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
bond = Bond(issue_date, maturity_date, coupon, freq_type, accrual_type)
tmat = (maturity_date - settlement_date) / gDaysInYear
times = np.linspace(0, tmat, 20)
dates = settlement_date.addYears(times)
dfs = np.exp(-0.05*times)
discount_curve = DiscountCurve(settlement_date, dates, dfs)
expiry_date = settlement_date.addTenor("18m")
strikePrice = 105.0
face = 100.0
###########################################################################
strikes = [80, 90, 100, 110, 120]
optionType = FinOptionTypes.EUROPEAN_CALL
testCases.header("LABEL", "VALUE")
price = bond.full_price_from_discount_curve(settlement_date, discount_curve)
testCases.print("Fixed Income Price:", price)
numTimeSteps = 100
testCases.header("OPTION TYPE AND MODEL", "STRIKE", "VALUE")
for strikePrice in strikes:
sigma = 0.20
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("EUROPEAN CALL - BK", strikePrice, v)
for strikePrice in strikes:
sigma = 0.20
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("EUROPEAN CALL - BK", strikePrice, v)
###########################################################################
optionType = FinOptionTypes.AMERICAN_CALL
price = bond.full_price_from_discount_curve(settlement_date, discount_curve)
testCases.header("LABEL", "VALUE")
testCases.print("Fixed Income Price:", price)
testCases.header("OPTION TYPE AND MODEL", "STRIKE", "VALUE")
for strikePrice in strikes:
sigma = 0.20
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("AMERICAN CALL - BK", strikePrice, v)
for strikePrice in strikes:
sigma = 0.20
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("AMERICAN CALL - BK", strikePrice, v)
###########################################################################
optionType = FinOptionTypes.EUROPEAN_PUT
price = bond.full_price_from_discount_curve(settlement_date, discount_curve)
for strikePrice in strikes:
sigma = 0.01
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("EUROPEAN PUT - BK", strikePrice, v)
for strikePrice in strikes:
sigma = 0.20
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("EUROPEAN PUT - BK", strikePrice, v)
###########################################################################
optionType = FinOptionTypes.AMERICAN_PUT
price = bond.full_price_from_discount_curve(settlement_date, discount_curve)
for strikePrice in strikes:
sigma = 0.02
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("AMERICAN PUT - BK", strikePrice, v)
for strikePrice in strikes:
sigma = 0.20
bondOption = BondOption(bond, expiry_date, strikePrice, face, optionType)
model = FinModelRatesBDT(sigma, numTimeSteps)
v = bondOption.value(settlement_date, discount_curve, model)
testCases.print("AMERICAN PUT - BK", strikePrice, v)
def test_BondOptionAmericanConvergenceTWO():
# Build discount curve
settlement_date = Date(1, 12, 2019)
discount_curve = DiscountCurveFlat(settlement_date,
0.05,
FrequencyTypes.CONTINUOUS)
# Bond details
issue_date = Date(1, 9, 2014)
maturity_date = Date(1, 9, 2025)
coupon = 0.05
freq_type = FrequencyTypes.ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
bond = Bond(issue_date, maturity_date, coupon, freq_type, accrual_type)
expiry_date = settlement_date.addTenor("18m")
face = 100.0
spotValue = bond.full_price_from_discount_curve(settlement_date, discount_curve)
testCases.header("LABEL", "VALUE")
testCases.print("BOND PRICE", spotValue)
testCases.header("TIME", "N", "EUR_CALL", "AMER_CALL",
"EUR_PUT", "AMER_PUT")
sigma = 0.2
model = FinModelRatesBDT(sigma)
K = 101.0
vec_ec = []
vec_ac = []
vec_ep = []
vec_ap = []
if 1 == 1:
K = 100.0
bkModel = FinModelRatesBDT(sigma, 100)
europeanCallBondOption = BondOption(bond, expiry_date, K, face,
FinOptionTypes.EUROPEAN_CALL)
v_ec = europeanCallBondOption.value(settlement_date, discount_curve,
model)
testCases.header("LABEL", "VALUE")
testCases.print("OPTION", v_ec)
num_stepsVector = range(100, 100, 1) # should be 100-400
for num_steps in num_stepsVector:
bkModel = FinModelRatesBDT(sigma, num_steps)
start = time.time()
europeanCallBondOption = BondOption(bond, expiry_date, K, face,
FinOptionTypes.EUROPEAN_CALL)
v_ec = europeanCallBondOption.value(settlement_date, discount_curve,
bkModel)
americanCallBondOption = BondOption(bond, expiry_date, K, face,
FinOptionTypes.AMERICAN_CALL)
v_ac = americanCallBondOption.value(settlement_date, discount_curve,
bkModel)
europeanPutBondOption = BondOption(bond, expiry_date, K, face,
FinOptionTypes.EUROPEAN_PUT)
v_ep = europeanPutBondOption.value(settlement_date, discount_curve,
bkModel)
americanPutBondOption = BondOption(bond, expiry_date, K, face,
FinOptionTypes.AMERICAN_PUT)
v_ap = americanPutBondOption.value(settlement_date, discount_curve,
bkModel)
end = time.time()
period = end - start
testCases.print(period, num_steps, v_ec, v_ac, v_ep, v_ap)
vec_ec.append(v_ec)
vec_ac.append(v_ac)
vec_ep.append(v_ep)
vec_ap.append(v_ap)
if plotGraphs:
plt.figure()
plt.plot(num_stepsVector, vec_ec, label="European Call")
plt.legend()
plt.figure()
plt.plot(num_stepsVector, vec_ac, label="American Call")
plt.legend()
plt.figure()
plt.plot(num_stepsVector, vec_ep, label="European Put")
plt.legend()
plt.figure()
plt.plot(num_stepsVector, vec_ap, label="American Put")
plt.legend()
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)