def test_FinBondEmbeddedOptionMATLAB():
# https://fr.mathworks.com/help/fininst/optembndbyhw.html
# I FIND THAT THE PRICE CONVERGES TO 102.88 WHICH IS CLOSE TO 102.9127
# FOUND BY MATLAB ALTHOUGH THEY DO NOT EXAMINE THE ASYMPTOTIC PRICE
# WHICH MIGHT BE A BETTER MATCH
settlementDate = FinDate(1, 1, 2007)
valuationDate = settlementDate
###########################################################################
dcType = FinDayCountTypes.THIRTY_E_360
fixedFreq = FinFrequencyTypes.ANNUAL
fixedLegType = FinSwapTypes.PAY
swap1 = FinIborSwap(settlementDate, "1Y", fixedLegType, 0.0350, fixedFreq,
dcType)
swap2 = FinIborSwap(settlementDate, "2Y", fixedLegType, 0.0400, fixedFreq,
dcType)
swap3 = FinIborSwap(settlementDate, "3Y", fixedLegType, 0.0450, fixedFreq,
dcType)
swaps = [swap1, swap2, swap3]
discountCurve = FinIborSingleCurve(valuationDate, [], [], swaps)
###########################################################################
issueDate = FinDate(1, 1, 2004)
maturityDate = FinDate(1, 1, 2010)
coupon = 0.0525
freqType = FinFrequencyTypes.ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType)
callDates = []
callPrices = []
putDates = []
putPrices = []
putDate = FinDate(1, 1, 2008)
for i in range(0, 24):
putDates.append(putDate)
putPrices.append(100)
putDate = putDate.addMonths(1)
testCases.header("BOND PRICE", "PRICE")
v = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
testCases.print("Bond Pure Price:", v)
sigma = 0.01 # basis point volatility
a = 0.1
puttableBond = FinBondEmbeddedOption(issueDate, maturityDate, coupon,
freqType, accrualType, callDates,
callPrices, putDates, putPrices)
testCases.header("TIME", "NumTimeSteps", "BondWithOption", "BondPure")
timeSteps = range(50, 1000, 10)
values = []
for numTimeSteps in timeSteps:
model = FinModelRatesHW(sigma, a, numTimeSteps)
start = time.time()
v = puttableBond.value(settlementDate, discountCurve, model)
end = time.time()
period = end - start
testCases.print(period, numTimeSteps, v['bondwithoption'],
v['bondpure'])
values.append(v['bondwithoption'])
if plotGraphs:
plt.figure()
plt.plot(timeSteps, values)
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()
settlementDate = FinDate(1, 1, 2020)
times = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
dates = settlementDate.addYears(times)
rate = 0.06
dfs = 1.0 / (1.0 + rate / 2.0)**(2.0 * times)
curve = FinDiscountCurve(settlementDate, dates, dfs)
coupon = 0.06
freqType = FinFrequencyTypes.SEMI_ANNUAL
accrualType = FinDayCountTypes.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]:
maturityDate = settlementDate.addYears(maturityYears)
issueDate = FinDate(maturityDate._d, maturityDate._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)):
expiryDate = settlementDate.addYears(expiryYears)
tmat = (maturityDate - settlementDate) / gDaysInYear
texp = (expiryDate - settlementDate) / gDaysInYear
bond = FinBond(issueDate, maturityDate, coupon, freqType,
accrualType)
couponTimes = []
couponFlows = []
cpn = bond._coupon / bond._frequency
for flowDate in bond._flowDates:
if flowDate > expiryDate:
flowTime = (flowDate - settlementDate) / gDaysInYear
couponTimes.append(flowTime)
couponFlows.append(cpn)
couponTimes = np.array(couponTimes)
couponFlows = np.array(couponFlows)
price = bond.cleanPriceFromDiscountCurve(settlementDate, curve)
model = FinModelRatesBDT(sigma, numTimeSteps)
model.buildTree(tmat, times, dfs)
v = model.bermudanSwaption(texp, tmat, strikePrice, face,
couponTimes, couponFlows,
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_FinBondEmbeddedOptionQUANTLIB():
# Based on example at the nice blog on Quantlib at
# http://gouthamanbalaraman.com/blog/callable-bond-quantlib-python.html
# I get a price of 68.97 for 1000 time steps which is higher than the
# 68.38 found in blog article. But this is for 40 grid points.
# Note also that a basis point vol of 0.120 is 12% which is VERY HIGH!
valuationDate = FinDate(16, 8, 2016)
settlementDate = valuationDate.addWeekDays(3)
###########################################################################
discountCurve = FinDiscountCurveFlat(valuationDate, 0.035,
FinFrequencyTypes.SEMI_ANNUAL)
###########################################################################
issueDate = FinDate(15, 9, 2010)
maturityDate = FinDate(15, 9, 2022)
coupon = 0.025
freqType = FinFrequencyTypes.QUARTERLY
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType)
###########################################################################
# Set up the call and put times and prices
###########################################################################
nextCallDate = FinDate(15, 9, 2016)
callDates = [nextCallDate]
callPrices = [100.0]
for i in range(1, 24):
nextCallDate = nextCallDate.addMonths(3)
callDates.append(nextCallDate)
callPrices.append(100.0)
putDates = []
putPrices = []
# the value used in blog of 12% bp vol is unrealistic
sigma = 0.12 # basis point volatility
a = 0.03
puttableBond = FinBondEmbeddedOption(issueDate, maturityDate, coupon,
freqType, accrualType, callDates,
callPrices, putDates, putPrices)
testCases.header("BOND PRICE", "PRICE")
v = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
testCases.print("Bond Pure Price:", v)
testCases.header("TIME", "NumTimeSteps", "BondWithOption", "BondPure")
timeSteps = range(100, 1000, 100)
values = []
for numTimeSteps in timeSteps:
model = FinModelRatesHW(sigma, a, numTimeSteps)
start = time.time()
v = puttableBond.value(settlementDate, discountCurve, model)
end = time.time()
period = end - start
testCases.print(period, numTimeSteps, v['bondwithoption'],
v['bondpure'])
values.append(v['bondwithoption'])
if plotGraphs:
plt.figure()
plt.title("Puttable Bond Price Convergence")
plt.plot(timeSteps, values)
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 =============")
settlementDate = FinDate(1, 12, 2019)
issueDate = FinDate(1, 12, 2015)
expiryDate = settlementDate.addTenor("18m")
maturityDate = settlementDate.addTenor("10Y")
coupon = 0.05
freqType = FinFrequencyTypes.SEMI_ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType)
couponTimes = []
couponFlows = []
cpn = bond._coupon / bond._frequency
numFlows = len(bond._flowDates)
for i in range(1, numFlows):
pcd = bond._flowDates[i - 1]
ncd = bond._flowDates[i]
if pcd < settlementDate and ncd > settlementDate:
flowTime = (pcd - settlementDate) / gDaysInYear
couponTimes.append(flowTime)
couponFlows.append(cpn)
for flowDate in bond._flowDates:
if flowDate > settlementDate:
flowTime = (flowDate - settlementDate) / gDaysInYear
couponTimes.append(flowTime)
couponFlows.append(cpn)
couponTimes = np.array(couponTimes)
couponFlows = np.array(couponFlows)
strikePrice = 105.0
face = 100.0
tmat = (maturityDate - settlementDate) / gDaysInYear
texp = (expiryDate - settlementDate) / gDaysInYear
times = np.linspace(0, tmat, 11)
dates = settlementDate.addYears(times)
dfs = np.exp(-0.05 * times)
testCases.header("LABEL", "VALUES")
testCases.print("TIMES:", times)
curve = FinDiscountCurve(settlementDate, dates, dfs)
price = bond.cleanPriceFromDiscountCurve(settlementDate, curve)
testCases.print("Fixed Income Price:", price)
sigma = 0.20
# Test convergence
numStepsList = [5] #[100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
exerciseType = FinExerciseTypes.AMERICAN
testCases.header("Values")
treeVector = []
for numTimeSteps in numStepsList:
model = FinModelRatesBDT(sigma, numTimeSteps)
model.buildTree(tmat, times, dfs)
v = model.bondOption(texp, strikePrice, face, couponTimes, couponFlows,
exerciseType)
testCases.print(v)
treeVector.append(v['call'])
if PLOT_GRAPHS:
plt.plot(numStepsList, 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_FinBondOptionZEROVOLConvergence():
# Build discount curve
settlementDate = FinDate(1, 12, 2019) # CHANGED
rate = 0.05
discountCurve = FinDiscountCurveFlat(settlementDate, rate,
FinFrequencyTypes.ANNUAL)
# Bond details
issueDate = FinDate(1, 9, 2015)
maturityDate = FinDate(1, 9, 2025)
coupon = 0.06
freqType = FinFrequencyTypes.ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType)
# Option Details
expiryDate = settlementDate.addTenor("18m") # FinDate(1, 12, 2021)
# print("EXPIRY:", expiryDate)
face = 100.0
dfExpiry = discountCurve.df(expiryDate)
spotCleanValue = bond.cleanPriceFromDiscountCurve(settlementDate,
discountCurve)
fwdCleanValue = bond.cleanPriceFromDiscountCurve(expiryDate, discountCurve)
# print("BOND SpotCleanBondPx", spotCleanValue)
# print("BOND FwdCleanBondPx", fwdCleanValue)
# print("BOND Accrued:", bond._accruedInterest)
spotCleanValue = bond.cleanPriceFromDiscountCurve(settlementDate,
discountCurve)
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 numSteps in numTimeSteps:
sigma = 0.0000001
model = FinModelRatesBDT(sigma, numSteps)
optionType = FinOptionTypes.EUROPEAN_CALL
bondOption1 = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
v1 = bondOption1.value(settlementDate, discountCurve, model)
optionType = FinOptionTypes.AMERICAN_CALL
bondOption2 = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
v2 = bondOption2.value(settlementDate, discountCurve, model)
optionType = FinOptionTypes.EUROPEAN_PUT
bondOption3 = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
v3 = bondOption3.value(settlementDate, discountCurve, model)
optionType = FinOptionTypes.AMERICAN_PUT
bondOption4 = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
v4 = bondOption4.value(settlementDate, discountCurve, model)
testCases.print(strikePrice, numSteps, callIntrinsic,
callIntrinsicPV, v1, v2, putIntrinsic,
putIntrinsicPV, v3, v4)
def test_FinBondOption():
settlementDate = FinDate(1, 12, 2019)
issueDate = FinDate(1, 12, 2018)
maturityDate = settlementDate.addTenor("10Y")
coupon = 0.05
freqType = FinFrequencyTypes.SEMI_ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType)
times = np.linspace(0, 10.0, 21)
dfs = np.exp(-0.05 * times)
dates = settlementDate.addYears(times)
discountCurve = FinDiscountCurve(settlementDate, dates, dfs)
expiryDate = settlementDate.addTenor("18m")
strikePrice = 105.0
face = 100.0
###########################################################################
strikes = [80, 85, 90, 95, 100, 105, 110, 115, 120]
optionType = FinOptionTypes.EUROPEAN_CALL
testCases.header("LABEL", "VALUE")
price = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
testCases.print("Fixed Income Price:", price)
numTimeSteps = 100
testCases.banner("HW EUROPEAN CALL")
testCases.header("STRIKE", "VALUE")
for strikePrice in strikes:
sigma = 0.01
a = 0.1
bondOption = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
model = FinModelRatesHW(sigma, a, numTimeSteps)
v = bondOption.value(settlementDate, discountCurve, model)
testCases.print(strikePrice, v)
###########################################################################
optionType = FinOptionTypes.AMERICAN_CALL
price = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
testCases.header("LABEL", "VALUE")
testCases.print("Fixed Income Price:", price)
testCases.banner("HW AMERICAN CALL")
testCases.header("STRIKE", "VALUE")
for strikePrice in strikes:
sigma = 0.01
a = 0.1
bondOption = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
model = FinModelRatesHW(sigma, a)
v = bondOption.value(settlementDate, discountCurve, model)
testCases.print(strikePrice, v)
###########################################################################
optionType = FinOptionTypes.EUROPEAN_PUT
testCases.banner("HW EUROPEAN PUT")
testCases.header("STRIKE", "VALUE")
price = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
for strikePrice in strikes:
sigma = 0.01
a = 0.1
bondOption = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
model = FinModelRatesHW(sigma, a)
v = bondOption.value(settlementDate, discountCurve, model)
testCases.print(strikePrice, v)
###########################################################################
optionType = FinOptionTypes.AMERICAN_PUT
testCases.banner("HW AMERICAN PUT")
testCases.header("STRIKE", "VALUE")
price = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
for strikePrice in strikes:
sigma = 0.02
a = 0.1
bondOption = FinBondOption(bond, expiryDate, strikePrice, face,
optionType)
model = FinModelRatesHW(sigma, a)
v = bondOption.value(settlementDate, discountCurve, model)
testCases.print(strikePrice, v)
def test_FinBondOptionAmericanConvergenceTWO():
# Build discount curve
settlementDate = FinDate(1, 12, 2019)
discountCurve = FinDiscountCurveFlat(settlementDate, 0.05)
# Bond details
issueDate = FinDate(1, 12, 2015)
maturityDate = settlementDate.addTenor("10Y")
coupon = 0.05
freqType = FinFrequencyTypes.SEMI_ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType)
expiryDate = settlementDate.addTenor("18m")
face = 100.0
spotValue = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
testCases.header("LABEL", "VALUE")
testCases.print("BOND PRICE", spotValue)
testCases.header("TIME", "N", "EUR_CALL", "AMER_CALL", "EUR_PUT",
"AMER_PUT")
sigma = 0.01
a = 0.1
hwModel = FinModelRatesHW(sigma, a)
K = 102.0
vec_ec = []
vec_ac = []
vec_ep = []
vec_ap = []
numStepsVector = range(100, 500, 100)
for numSteps in numStepsVector:
hwModel = FinModelRatesHW(sigma, a, numSteps)
start = time.time()
europeanCallBondOption = FinBondOption(bond, expiryDate, K, face,
FinOptionTypes.EUROPEAN_CALL)
v_ec = europeanCallBondOption.value(settlementDate, discountCurve,
hwModel)
americanCallBondOption = FinBondOption(bond, expiryDate, K, face,
FinOptionTypes.AMERICAN_CALL)
v_ac = americanCallBondOption.value(settlementDate, discountCurve,
hwModel)
europeanPutBondOption = FinBondOption(bond, expiryDate, K, face,
FinOptionTypes.EUROPEAN_PUT)
v_ep = europeanPutBondOption.value(settlementDate, discountCurve,
hwModel)
americanPutBondOption = FinBondOption(bond, expiryDate, K, face,
FinOptionTypes.AMERICAN_PUT)
v_ap = americanPutBondOption.value(settlementDate, discountCurve,
hwModel)
end = time.time()
period = end - start
testCases.print(period, numSteps, 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(numStepsVector, vec_ac, label="American Call")
plt.legend()
plt.figure()
plt.plot(numStepsVector, vec_ap, label="American Put")
plt.legend()
def test_HullWhiteCallableBond():
# Valuation of a European option on a coupon bearing bond
settlementDate = FinDate(1, 12, 2019)
issueDate = FinDate(1, 12, 2018)
maturityDate = settlementDate.addTenor("10Y")
coupon = 0.05
frequencyType = FinFrequencyTypes.SEMI_ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, frequencyType, accrualType)
couponTimes = []
couponFlows = []
cpn = bond._coupon / bond._frequency
for flowDate in bond._flowDates[1:]:
if flowDate > settlementDate:
flowTime = (flowDate - settlementDate) / gDaysInYear
couponTimes.append(flowTime)
couponFlows.append(cpn)
couponTimes = np.array(couponTimes)
couponFlows = np.array(couponFlows)
###########################################################################
# Set up the call and put times and prices
###########################################################################
callDates = []
callPrices = []
callPx = 120.0
callDates.append(settlementDate.addTenor("2Y"))
callPrices.append(callPx)
callDates.append(settlementDate.addTenor("3Y"))
callPrices.append(callPx)
callDates.append(settlementDate.addTenor("4Y"))
callPrices.append(callPx)
callDates.append(settlementDate.addTenor("5Y"))
callPrices.append(callPx)
callDates.append(settlementDate.addTenor("6Y"))
callPrices.append(callPx)
callDates.append(settlementDate.addTenor("7Y"))
callPrices.append(callPx)
callDates.append(settlementDate.addTenor("8Y"))
callPrices.append(callPx)
callTimes = []
for dt in callDates:
t = (dt - settlementDate) / gDaysInYear
callTimes.append(t)
putDates = []
putPrices = []
putPx = 98.0
putDates.append(settlementDate.addTenor("2Y"))
putPrices.append(putPx)
putDates.append(settlementDate.addTenor("3Y"))
putPrices.append(putPx)
putDates.append(settlementDate.addTenor("4Y"))
putPrices.append(putPx)
putDates.append(settlementDate.addTenor("5Y"))
putPrices.append(putPx)
putDates.append(settlementDate.addTenor("6Y"))
putPrices.append(putPx)
putDates.append(settlementDate.addTenor("7Y"))
putPrices.append(putPx)
putDates.append(settlementDate.addTenor("8Y"))
putPrices.append(putPx)
putTimes = []
for dt in putDates:
t = (dt - settlementDate) / gDaysInYear
putTimes.append(t)
###########################################################################
tmat = (maturityDate - settlementDate) / gDaysInYear
curve = FinDiscountCurveFlat(settlementDate, 0.05,
FinFrequencyTypes.CONTINUOUS)
dfs = []
times = []
for dt in bond._flowDates:
if dt > settlementDate:
t = (dt - settlementDate) / gDaysInYear
df = curve.df(dt)
times.append(t)
dfs.append(df)
dfs = np.array(dfs)
times = np.array(times)
###########################################################################
v1 = bond.cleanPriceFromDiscountCurve(settlementDate, curve)
sigma = 0.02 # basis point volatility
a = 0.01
# Test convergence
numStepsList = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
tmat = (maturityDate - settlementDate) / gDaysInYear
testCases.header("NUMSTEPS", "BOND_ONLY", "CALLABLE_BOND", "TIME")
for numTimeSteps in numStepsList:
start = time.time()
model = FinModelRatesHW(sigma, a, numTimeSteps)
model.buildTree(tmat, times, dfs)
v2 = model.callablePuttableBond_Tree(couponTimes, couponFlows,
callTimes, callPrices, putTimes,
putPrices, 100.0)
end = time.time()
period = end - start
testCases.print(numTimeSteps, v1, v2, period)
