def test_FinFXVanillaOptionBloombergExample():
# Example Bloomberg Pricing at
# https://stackoverflow.com/questions/48778712/fx-vanilla-call-price-in-quantlib-doesnt-match-bloomberg
valueDate = FinDate(13, 2, 2018)
expiryDate = FinDate(15, 2, 2019)
# In BS the FX rate is the price in domestic of one unit of foreign
# In case of EURUSD = 1.3 the domestic currency is USD and foreign is EUR
# DOM = USD , FOR = EUR
forName = "EUR"
domName = "USD"
forDepoRate = 0.05 # EUR
domDepoRate = 0.02 # USD
currencyPair = forName + domName # Always FORDOM
spotFXRate = 1.30
strikeFXRate = 1.3650
volatility = 0.20
spotDays = 0
settlementDate = valueDate.addWorkDays(spotDays)
maturityDate = settlementDate.addMonths(12)
notional = 1000000.0
notionalCurrency = "EUR"
calendarType = FinCalendarTypes.TARGET
depos = []
fras = []
swaps = []
depo = FinLiborDeposit(settlementDate, maturityDate, domDepoRate,
FinDayCountTypes.ACT_360, notional, calendarType)
depos.append(depo)
domDiscountCurve = FinLiborCurve(forName, settlementDate, depos, fras,
swaps)
depos = []
fras = []
swaps = []
depo = FinLiborDeposit(settlementDate, maturityDate, forDepoRate,
FinDayCountTypes.ACT_360, notional, calendarType)
depos.append(depo)
forDiscountCurve = FinLiborCurve(domName, settlementDate, depos, fras,
swaps)
model = FinFXModelBlackScholes(volatility)
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, currencyPair,
FinOptionTypes.EUROPEAN_CALL, notional,
notionalCurrency, 2)
value = callOption.value(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve, model)
delta = callOption.delta(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve, model)
testCases.header("value", "delta")
testCases.print(value, delta)
def test_FinFXVanillaOptionWystupExample1():
# Example from Book extract by Uwe Wystup with results in Table 1.2
# https://mathfinance.com/wp-content/uploads/2017/06/FXOptionsStructuredProducts2e-Extract.pdf
# Not exactly T=1.0 but close so don't exact exact agreement
# (in fact I do not get exact agreement even if I do set T=1.0)
valueDate = FinDate(13, 2, 2018)
expiryDate = FinDate(13, 2, 2019)
# In BS the FX rate is the price in domestic of one unit of foreign
# In case of EURUSD = 1.3 the domestic currency is USD and foreign is EUR
# DOM = USD , FOR = EUR
ccy1 = "EUR"
ccy2 = "USD"
ccy1CCRate = 0.030 # EUR
ccy2CCRate = 0.025 # USD
currencyPair = ccy1 + ccy2 # Always ccy1ccy2
spotFXRate = 1.20
strikeFXRate = 1.250
volatility = 0.10
spotDays = 0
settlementDate = valueDate.addWorkDays(spotDays)
maturityDate = settlementDate.addMonths(12)
notional = 1000000.0
notionalCurrency = "EUR"
calendarType = FinCalendarTypes.TARGET
domDiscountCurve = FinFlatCurve(valueDate, ccy2CCRate)
forDiscountCurve = FinFlatCurve(valueDate, ccy1CCRate)
model = FinFXModelBlackScholes(volatility)
# Two examples to show that changing the notional currency and notional
# keeps the value unchanged
notional = 1000000.0
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, currencyPair,
FinOptionTypes.EUROPEAN_CALL, notional,
"EUR", 2)
value = callOption.value(1.0, spotFXRate, domDiscountCurve,
forDiscountCurve, model)
notional = 1250000.0
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, currencyPair,
FinOptionTypes.EUROPEAN_CALL, notional,
"USD", 2)
value = callOption.value(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve, model)
delta = callOption.delta(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve, model)
testCases.header("value", "delta")
testCases.print(value, delta)
def test_FinFXForward():
# https://stackoverflow.com/questions/48778712
# /fx-vanilla-call-price-in-quantlib-doesnt-match-bloomberg
valueDate = FinDate(13, 2, 2018)
expiryDate = valueDate.addMonths(12)
# Forward is on EURUSD which is expressed as number of USD per EUR
# ccy1 = EUR and ccy2 = USD
forName = "EUR"
domName = "USD"
currencyPair = forName + domName # Always ccy1ccy2
spotFXRate = 1.300 # USD per EUR
strikeFXRate = 1.365 # USD per EUR
ccy1InterestRate = 0.02 # USD Rates
ccy2InterestRate = 0.05 # EUR rates
###########################################################################
spotDays = 0
settlementDate = valueDate.addWorkDays(spotDays)
maturityDate = settlementDate.addMonths(12)
notional = 100.0
calendarType = FinCalendarTypes.TARGET
depos = []
fras = []
swaps = []
depositRate = ccy1InterestRate
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
FinDayCountTypes.ACT_360, notional, calendarType)
depos.append(depo)
forDiscountCurve = FinLiborCurve(settlementDate, depos, fras, swaps)
depos = []
fras = []
swaps = []
depositRate = ccy2InterestRate
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
FinDayCountTypes.ACT_360, notional, calendarType)
depos.append(depo)
domDiscountCurve = FinLiborCurve(settlementDate, depos, fras, swaps)
notional = 100.0
notionalCurrency = forName
fxForward = FinFXForward(expiryDate, strikeFXRate, currencyPair, notional,
notionalCurrency)
testCases.header("SPOT FX", "FX FWD", "VALUE_BS")
fwdValue = fxForward.value(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve)
fwdFXRate = fxForward.forward(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve)
testCases.print(spotFXRate, fwdFXRate, fwdValue)
def test_FinLiborDepositsOnly():
# I have used the following useful blog post by Ioannis Rigopoulos for this
# https://blog.deriscope.com/index.php/en/yield-curve-excel-quantlib-deposit
valuationDate = FinDate(2018, 2, 23)
spotDays = 0
settlementDate = valuationDate.addWorkDays(spotDays)
depoDCCType = FinDayCountTypes.ACT_360
notional = 100.0
calendarType = FinCalendarTypes.TARGET
depos = []
# 1 month
depositRate = 0.04
maturityDate = settlementDate.addMonths(1)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType, notional, calendarType)
depos.append(depo)
# 2 months
depositRate = 0.04
maturityDate = settlementDate.addMonths(2)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType, notional, calendarType)
depos.append(depo)
# 6 months
depositRate = 0.04
maturityDate = settlementDate.addMonths(6)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType, notional, calendarType)
depos.append(depo)
# 1 year
depositRate = 0.04
maturityDate = settlementDate.addMonths(12)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType, notional, calendarType)
depos.append(depo)
fras = []
swaps = []
liborCurve = FinLiborCurve(settlementDate, depos, fras, swaps)
testCases.header("LABEL", "DATE", "VALUE")
''' Check calibration '''
for depo in depos:
v = depo.value(settlementDate, liborCurve)
testCases.print("DEPO", depo._maturityDate, v)
def test_FinFXVanillaOptionWystupExample2():
# Example Bloomberg Pricing at
# https://stackoverflow.com/questions/48778712/fx-vanilla-call-price-in-quantlib-doesnt-match-bloomberg
valueDate = FinDate(13, 2, 2018)
expiryDate = FinDate(13, 2, 2019)
# In BS the FX rate is the price in domestic of one unit of foreign
# In case of EURUSD = 1.3 the domestic currency is USD and foreign is EUR
# DOM = USD , FOR = EUR
ccy1 = "EUR"
ccy2 = "USD"
ccy1CCRate = 0.0396 # EUR
ccy2CCRate = 0.0357 # USD
currencyPair = ccy1 + ccy2 # Always ccy1ccy2
spotFXRate = 0.9090
strikeFXRate = 0.9090
volatility = 0.12
spotDays = 0
settlementDate = valueDate.addWorkDays(spotDays)
maturityDate = settlementDate.addMonths(12)
notional = 1000000.0
notionalCurrency = "EUR"
calendarType = FinCalendarTypes.TARGET
domDiscountCurve = FinFlatCurve(valueDate, ccy2CCRate)
forDiscountCurve = FinFlatCurve(valueDate, ccy1CCRate)
model = FinFXModelBlackScholes(volatility)
# Two examples to show that changing the notional currency and notional
# keeps the value unchanged
notional = 1000000.0
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, currencyPair,
FinOptionTypes.EUROPEAN_PUT, notional,
"EUR", 2)
value = callOption.value(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve, model)
delta = callOption.delta(valueDate, spotFXRate, domDiscountCurve,
forDiscountCurve, model)
testCases.header("value", "delta")
testCases.print(value, delta)
def test_FinLiborFRAsOnly():
# TO DO FIX THIS
valuationDate = FinDate(2018, 2, 23)
spotDays = 0
settlementDate = valuationDate.addWorkDays(spotDays)
depoDCCType = FinDayCountTypes.ACT_360
notional = 100.0
payFixed = True
calendarType = FinCalendarTypes.TARGET
fras = []
# 1 x 4 FRA
fraRate = 0.04
fraSettlementDate = settlementDate.addMonths(1)
fraMaturityDate = settlementDate.addMonths(4)
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType,
notional, payFixed, calendarType)
fras.append(fra)
# 4 x 7 FRA
fraRate = 0.08
fraSettlementDate = settlementDate.addMonths(4)
fraMaturityDate = settlementDate.addMonths(7)
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType,
notional, payFixed, calendarType)
fras.append(fra)
depos = []
swaps = []
liborCurve = FinLiborCurve(settlementDate, depos, fras, swaps)
testCases.header("DATE", "MATDATE", "VALUE")
''' Check calibration '''
for fra in fras:
v = fra.value(settlementDate, liborCurve)
testCases.print("FRA:", fra._maturityDate, v)
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!
valueDate = FinDate(16, 8, 2016)
settlementDate = valueDate.addWorkDays(3)
###########################################################################
discountCurve = FinDiscountCurveFlat(valueDate, 0.035,
FinFrequencyTypes.SEMI_ANNUAL)
###########################################################################
issueDate = FinDate(15, 9, 2010)
maturityDate = FinDate(15, 9, 2022)
coupon = 0.025
frequencyType = FinFrequencyTypes.QUARTERLY
accrualType = FinDayCountTypes.ACT_ACT_ICMA
bond = FinBond(issueDate, maturityDate, coupon, frequencyType, accrualType)
###########################################################################
# Set up the call and put times and prices
###########################################################################
nextCallDate = FinDate(15, 9, 2016)
callDates = [nextCallDate]
callPrices = [100.0]
for _ 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 / 0.035 # basis point volatility
a = 0.03
puttableBond = FinBondEmbeddedOption(issueDate, maturityDate, coupon,
frequencyType, accrualType, callDates,
callPrices, putDates, putPrices)
testCases.header("BOND PRICE", "PRICE")
v = bond.cleanPriceFromDiscountCurve(settlementDate, discountCurve)
testCases.print("Bond Pure Price:", v)
testCases.header("PERIOD", "NumTimeSteps", "BondWithOption", "BondPure")
timeSteps = range(100, 200, 10) # 1000, 10)
values = []
for numTimeSteps in timeSteps:
model = FinModelRatesBK(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_FinLiborCapFloor():
todayDate = FinDate(20, 6, 2019)
valuationDate = todayDate
startDate = todayDate.addWorkDays(2)
maturityDate = startDate.addTenor("1Y")
liborCurve = test_FinLiborDepositsAndSwaps(todayDate)
# The capfloor has begun
# lastFixing = 0.028
##########################################################################
# COMPARISON OF MODELS
##########################################################################
strikes = np.linspace(0.02, 0.08, 10)
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 = FinLiborCapFloorTypes.CAP
capfloor = FinLiborCapFloor(startDate, maturityDate, capFloorType, k)
cvalue1 = capfloor.value(valuationDate, liborCurve, model1)
cvalue2 = capfloor.value(valuationDate, liborCurve, model2)
cvalue3 = capfloor.value(valuationDate, liborCurve, model3)
cvalue4 = capfloor.value(valuationDate, liborCurve, model4)
cvalue5 = capfloor.value(valuationDate, liborCurve, model5)
cvalue6 = capfloor.value(valuationDate, liborCurve, 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 = FinLiborCapFloorTypes.FLOOR
capfloor = FinLiborCapFloor(startDate, maturityDate, capFloorType, k)
fvalue1 = capfloor.value(valuationDate, liborCurve, model1)
fvalue2 = capfloor.value(valuationDate, liborCurve, model2)
fvalue3 = capfloor.value(valuationDate, liborCurve, model3)
fvalue4 = capfloor.value(valuationDate, liborCurve, model4)
fvalue5 = capfloor.value(valuationDate, liborCurve, model5)
fvalue6 = capfloor.value(valuationDate, liborCurve, 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 = FinLiborCapFloorTypes.CAP
capfloor = FinLiborCapFloor(startDate, maturityDate, capFloorType, k)
cvalue1 = capfloor.value(valuationDate, liborCurve, model1)
cvalue2 = capfloor.value(valuationDate, liborCurve, model2)
cvalue3 = capfloor.value(valuationDate, liborCurve, model3)
cvalue4 = capfloor.value(valuationDate, liborCurve, model4)
cvalue5 = capfloor.value(valuationDate, liborCurve, model5)
cvalue6 = capfloor.value(valuationDate, liborCurve, model6)
capFloorType = FinLiborCapFloorTypes.FLOOR
capfloor = FinLiborCapFloor(startDate, maturityDate, capFloorType, k)
fvalue1 = capfloor.value(valuationDate, liborCurve, model1)
fvalue2 = capfloor.value(valuationDate, liborCurve, model2)
fvalue3 = capfloor.value(valuationDate, liborCurve, model3)
fvalue4 = capfloor.value(valuationDate, liborCurve, model4)
fvalue5 = capfloor.value(valuationDate, liborCurve, model5)
fvalue6 = capfloor.value(valuationDate, liborCurve, 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)
print("PRINT DATES")
print(dt1)
# To add two days we can do
print("ADD CALENDAR DAYS")
dt2 = dt1.addDays(2)
print(dt2)
# dt has not changed, we just created a new date
# To add business days we do the following - note this does not know
# about regional or religious holidays - just weekends
print("ADD WORKDAYS")
print(dt1, dt1.addWorkDays(2))
# The weekend has now been skipped
# To add a month do
print("ADD MONTHS")
print(dt1, dt1.addMonths(2))
# An invalid date will throw an error
# dt5 = FinDate(2019, 1, 31)
# print(dt5)
# You can use tenors - a number and a 'd', 'm' or 'y' in upper or lower case
print("TENORS")
print(dt1.addTenor("1d"))
print(dt1.addTenor("2D"))
def test_bloombergPricingExample():
''' This is an example of a replication of a BBG example from
https://github.com/vilen22/curve-building/blob/master/Bloomberg%20Curve%20Building%20Replication.xlsx
'''
valuationDate = FinDate(6, 6, 2018)
# We do the O/N rate which settles on trade date
spotDays = 0
settlementDate = valuationDate.addWorkDays(spotDays)
depoDCCType = FinDayCountTypes.ACT_360
depos = []
depositRate = 0.0231381
maturityDate = settlementDate.addMonths(3)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType)
depos.append(depo)
futs = []
fut = FinLiborFuture(valuationDate, 1)
futs.append(fut)
fut = FinLiborFuture(valuationDate, 2)
futs.append(fut)
fut = FinLiborFuture(valuationDate, 3)
futs.append(fut)
fut = FinLiborFuture(valuationDate, 4)
futs.append(fut)
fut = FinLiborFuture(valuationDate, 5)
futs.append(fut)
fut = FinLiborFuture(valuationDate, 6)
futs.append(fut)
fras = [None] * 6
fras[0] = futs[0].toFRA(97.6675, -0.00005)
fras[1] = futs[1].toFRA(97.5200, -0.00060)
fras[2] = futs[2].toFRA(97.3550, -0.00146)
fras[3] = futs[3].toFRA(97.2450, -0.00263)
fras[4] = futs[4].toFRA(97.1450, -0.00411)
fras[5] = futs[5].toFRA(97.0750, -0.00589)
accrual = FinDayCountTypes.THIRTY_E_360
freq = FinFrequencyTypes.SEMI_ANNUAL
spotDays = 2
settlementDate = valuationDate.addWorkDays(spotDays)
notional = ONE_MILLION
swapType = FinLiborSwapTypes.PAYER
swaps = []
swap = FinLiborSwap(settlementDate, "2Y", swapType,
(2.77417 + 2.77844) / 200, freq, accrual, notional)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "3Y", swapType,
(2.86098 + 2.86582) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "4Y", swapType,
(2.90240 + 2.90620) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "5Y", swapType,
(2.92944 + 2.92906) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "6Y", swapType,
(2.94001 + 2.94499) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "7Y", swapType,
(2.95352 + 2.95998) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "8Y", swapType,
(2.96830 + 2.97400) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "9Y", swapType,
(2.98403 + 2.98817) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "10Y", swapType,
(2.99716 + 3.00394) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "11Y", swapType,
(3.01344 + 3.01596) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "12Y", swapType,
(3.02276 + 3.02684) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "15Y", swapType,
(3.04092 + 3.04508) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "20Y", swapType,
(3.04417 + 3.05183) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "25Y", swapType,
(3.03219 + 3.03621) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "30Y", swapType,
(3.01030 + 3.01370) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "40Y", swapType,
(2.96946 + 2.97354) / 200, freq, accrual)
swaps.append(swap)
swap = FinLiborSwap(settlementDate, "50Y", swapType,
(2.91552 + 2.93748) / 200, freq, accrual)
swaps.append(swap)
liborCurve = FinLiborCurve(valuationDate, depos, fras, swaps)
# The valuation of 53714.55 is very close to the spreadsheet value 53713.96
principal = 0.0
testCases.header("VALUATION TO TODAY DATE", " PV")
testCases.print(
"VALUE:", swaps[0].value(valuationDate, liborCurve, liborCurve, None,
principal))
testCases.print(
"FIXED:", swaps[0].fixedLegValue(valuationDate, liborCurve, principal))
testCases.print(
"FLOAT:", swaps[0].floatLegValue(valuationDate, liborCurve, liborCurve,
None, principal))
testCases.header("VALUATION TO SWAP SETTLEMENT DATE", " PV")
testCases.print(
"VALUE:", swaps[0].value(settlementDate, liborCurve, liborCurve, None,
principal))
testCases.print(
"FIXED:", swaps[0].fixedLegValue(settlementDate, liborCurve,
principal))
testCases.print(
"FLOAT:", swaps[0].floatLegValue(settlementDate, liborCurve,
liborCurve, None, principal))
def test_derivativePricingExample():
valuationDate = FinDate(10, 11, 2011)
dccType = FinDayCountTypes.ACT_360
depos = []
# We do the O/N rate which settles on trade date
spotDays = 0
settlementDate = valuationDate.addWorkDays(spotDays)
depositRate = 0.001410
depo = FinLiborDeposit(settlementDate, "ON", depositRate, dccType)
depos.append(depo)
spotDays = 1
settlementDate = valuationDate.addWorkDays(spotDays)
depositRate = 0.001410
depo = FinLiborDeposit(settlementDate, "TN", depositRate, dccType)
depos.append(depo)
spotDays = 2
settlementDate = valuationDate.addWorkDays(spotDays)
depositRate = 0.001910
depo = FinLiborDeposit(settlementDate, "1W", depositRate, dccType)
depos.append(depo)
depositRate = 0.002090
depo = FinLiborDeposit(settlementDate, "2W", depositRate, dccType)
depos.append(depo)
depositRate = 0.002490
depo = FinLiborDeposit(settlementDate, "1M", depositRate, dccType)
depos.append(depo)
depositRate = 0.003450
depo = FinLiborDeposit(settlementDate, "2M", depositRate, dccType)
depos.append(depo)
depositRate = 0.004570
depo = FinLiborDeposit(settlementDate, "3M", depositRate, dccType)
depos.append(depo)
depositRate = 0.005230
depo = FinLiborDeposit(settlementDate, "4M", depositRate, dccType)
depos.append(depo)
depositRate = 0.005860
depo = FinLiborDeposit(settlementDate, "5M", depositRate, dccType)
depos.append(depo)
depositRate = 0.006540
depo = FinLiborDeposit(settlementDate, "6M", depositRate, dccType)
depos.append(depo)
depositRate = 0.007080
depo = FinLiborDeposit(settlementDate, "7M", depositRate, dccType)
depos.append(depo)
depositRate = 0.007540
depo = FinLiborDeposit(settlementDate, "8M", depositRate, dccType)
depos.append(depo)
depositRate = 0.008080
depo = FinLiborDeposit(settlementDate, "9M", depositRate, dccType)
depos.append(depo)
depositRate = 0.008570
depo = FinLiborDeposit(settlementDate, "10M", depositRate, dccType)
depos.append(depo)
depositRate = 0.009130
depo = FinLiborDeposit(settlementDate, "11M", depositRate, dccType)
depos.append(depo)
fras = []
swaps = []
dayCountType = FinDayCountTypes.THIRTY_E_360_ISDA
# dayCountType = FinDayCountTypes.ACT_360
freqType = FinFrequencyTypes.SEMI_ANNUAL
swapType = FinLiborSwapTypes.PAYER
swapRate = 0.0058
swap = FinLiborSwap(settlementDate, "1Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
swapRate = 0.0060
swap = FinLiborSwap(settlementDate, "2Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
swapRate = 0.0072
swap = FinLiborSwap(settlementDate, "3Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
swapRate = 0.0096
swap = FinLiborSwap(settlementDate, "4Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
swapRate = 0.0124
swap = FinLiborSwap(settlementDate, "5Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
swapRate = 0.0173
swap = FinLiborSwap(settlementDate, "7Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
swapRate = 0.0219
swap = FinLiborSwap(settlementDate, "10Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
swapRate = 0.0283
swap = FinLiborSwap(settlementDate, "30Y", swapType, swapRate, freqType,
dayCountType)
swaps.append(swap)
numRepeats = 10
start = time.time()
for _ in range(0, numRepeats):
_ = FinLiborCurve(valuationDate, depos, fras, swaps,
FinInterpTypes.FLAT_FORWARDS)
end = time.time()
elapsed1 = end - start
start = time.time()
for _ in range(0, numRepeats):
_ = FinLiborCurve(valuationDate, depos, fras, swaps,
FinInterpTypes.LINEAR_SWAP_RATES)
end = time.time()
elapsed2 = end - start
testCases.header("METHOD", "TIME")
testCases.print("NON-LINEAR SOLVER BOOTSTRAP", elapsed1 / numRepeats)
testCases.print("LINEAR SWAP BOOTSTRAP", elapsed2 / numRepeats)
def test_FinLiborDepositsFuturesSwaps():
spotDate = FinDate(6, 6, 2018)
spotDays = 0
settlementDate = spotDate.addWorkDays(spotDays)
depoDCCType = FinDayCountTypes.ACT_360
depos = []
depositRate = 0.0231381
depo = FinLiborDeposit(settlementDate, "3M", depositRate, depoDCCType)
depos.append(depo)
depositRate = 0.027
depo = FinLiborDeposit(settlementDate, "3M", depositRate, depoDCCType)
depos.append(depo)
depos = []
depo = FinLiborDeposit(settlementDate, "1M", 0.0230, depoDCCType)
depos.append(depo)
depo = FinLiborDeposit(settlementDate, "2M", 0.0235, depoDCCType)
depos.append(depo)
depo = FinLiborDeposit(settlementDate, "3M", 0.0240, depoDCCType)
depos.append(depo)
fras = []
fraRate = futureToFRARate(97.6675, -0.00005)
fraSettlementDate = spotDate.nextIMMDate()
fraMaturityDate = fraSettlementDate.nextIMMDate()
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.5200, -0.00060)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.nextIMMDate()
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.3550, -0.00146)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.nextIMMDate()
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.2450, -0.00263)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.nextIMMDate()
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.1450, -0.00411)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.nextIMMDate()
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.0750, -0.00589)
fraSettlementDate = fraSettlementDate.nextIMMDate()
fraMaturityDate = fraSettlementDate.nextIMMDate()
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
###########################################################################
spotDays = 2
startDate = spotDate.addWorkDays(spotDays)
swaps = []
swapType = FinLiborSwapTypes.PAYER
fixedDCCType = FinDayCountTypes.THIRTY_E_360
fixedFreqType = FinFrequencyTypes.SEMI_ANNUAL
floatFreqType = FinFrequencyTypes.QUARTERLY
notional = 1000000
floatSpread = 0.0
floatDCCType = FinDayCountTypes.ACT_360
calendarType = FinCalendarTypes.US
busDayAdjustRule = FinBusDayAdjustTypes.PRECEDING
swapRate = 0.02776305
swap = FinLiborSwap(startDate, "2Y", swapType, swapRate, fixedFreqType,
fixedDCCType, notional, floatSpread, floatFreqType,
floatDCCType, calendarType, busDayAdjustRule)
swaps.append(swap)
liborCurve = FinLiborCurve(spotDate, depos, fras, swaps)
times = np.linspace(0.0, 2.0, 25)
dates = spotDate.addYears(times)
zeroRates = liborCurve.zeroRate(dates)
fwdRates = liborCurve.fwd(dates)
if PLOT_GRAPHS:
plt.figure(figsize=(8, 6))
plt.plot(times, zeroRates * 100, label="zero rates")
plt.plot(times, fwdRates * 100, label="fwd rates")
plt.xlabel("Times")
plt.ylabel("CC forward rates")
plt.legend()
print("==============================================================")
for fra in fras:
print(fra)
print("==============================================================")
endDate = spotDate
df = liborCurve.df(endDate)
print(endDate, df)
endDate = settlementDate
df = liborCurve.df(endDate)
print(endDate, df)
endDate = FinDate(20, 6, 2018)
df = liborCurve.df(endDate)
print(endDate, df)
for depo in depos:
endDate = depo._maturityDate
df = liborCurve.df(endDate)
print(endDate, df)
for fra in fras:
endDate = fra._maturityDate
df = liborCurve.df(endDate)
print(endDate, df)
for swap in swaps:
endDate = swap._maturityDate
df = liborCurve.df(endDate)
print(endDate, df)
swap.printFixedLegPV(spotDate)
swap.printFloatLegPV(spotDate)
def test_FinLiborDepositsFRAsSwaps():
valuationDate = FinDate(2019, 9, 18)
dccType = FinDayCountTypes.THIRTY_E_360_ISDA
depos = []
spotDays = 0
settlementDate = valuationDate.addWorkDays(spotDays)
depositRate = 0.050
maturityDate = settlementDate.addMonths(1)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate, dccType)
depos.append(depo)
maturityDate = settlementDate.addMonths(2)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate, dccType)
depos.append(depo)
maturityDate = settlementDate.addMonths(3)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate, dccType)
depos.append(depo)
maturityDate = settlementDate.addMonths(6)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate, dccType)
depos.append(depo)
maturityDate = settlementDate.addMonths(9)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate, dccType)
depos.append(depo)
maturityDate = settlementDate.addMonths(12)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate, dccType)
depos.append(depo)
fras = []
# 1 x 4 FRA
fraRate = 0.04
fraSettlementDate = settlementDate.addMonths(9)
fraMaturityDate = settlementDate.addMonths(13)
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, dccType)
fras.append(fra)
# 4 x 7 FRA
fraRate = 0.03
fraSettlementDate = settlementDate.addMonths(13)
fraMaturityDate = settlementDate.addMonths(17)
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, dccType)
fras.append(fra)
# 4 x 7 FRA
fraRate = 0.07
fraSettlementDate = settlementDate.addMonths(17)
fraMaturityDate = settlementDate.addMonths(21)
fra = FinLiborFRA(fraSettlementDate, fraMaturityDate, fraRate, dccType)
fras.append(fra)
swaps = []
fixedDCCType = FinDayCountTypes.ACT_365F
fixedFreqType = FinFrequencyTypes.SEMI_ANNUAL
swapRate = 0.05
# maturityDate = settlementDate.addMonths(24)
# swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
# fixedDCCType)
# swaps.append(swap)
swapType = FinLiborSwapTypes.PAYER
maturityDate = settlementDate.addMonths(36)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(48)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(60)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(72)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(84)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(96)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(108)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(120)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(132)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(144)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(180)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(240)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(300)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(360)
swap = FinLiborSwap(settlementDate, maturityDate, swapType, swapRate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
liborCurve = FinLiborCurve(valuationDate, depos, fras, swaps)
df = liborCurve.df(settlementDate)
testCases.header("SETTLEMENT DATE", "DF")
testCases.print(str(settlementDate), df)
testCases.header("DATE", "DF")
for deposit in depos:
df = liborCurve.df(deposit._maturityDate)
testCases.print(str(deposit._maturityDate), df)
for swap in swaps:
df = liborCurve.df(swap._maturityDate)
testCases.print(str(swap._maturityDate), df)
def test_FinLiborSwaption():
import time
valuationDate = FinDate(2011, 1, 1)
exerciseDate = FinDate(2012, 1, 1)
swapMaturityDate = FinDate(2017, 1, 1)
swapFixedCoupon = 0.030
swapFixedFrequencyType = FinFrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = FinDayCountTypes.ACT_365_ISDA
liborCurve = test_FinLiborDepositsAndSwaps(valuationDate)
start = time.time()
swaptionType = FinLiborSwaptionType.PAYER
swaption = FinLiborSwaption(exerciseDate, swapMaturityDate, swaptionType,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
model = FinLiborModelBlack(0.25)
settlementDate = valuationDate.addWorkDays(2)
value = swaption.value(settlementDate, liborCurve, model)
# swaption.print()
testCases.header("LABEL", "VALUE")
testCases.print("PAYER Swaption Value", value)
swaptionType = FinLiborSwaptionType.RECEIVER
swaption = FinLiborSwaption(exerciseDate, swapMaturityDate, swaptionType,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
model = FinLiborModelBlack(0.25)
settlementDate = valuationDate.addWorkDays(2)
value = swaption.value(settlementDate, liborCurve, model)
# swaption.print()
testCases.print("RECEIVER Swaption Value", value)
end = time.time()
testCases.header("TIME")
testCases.print(end - start)
##########################################################################
##########################################################################
start = time.time()
swaptionType = FinLiborSwaptionType.PAYER
testCases.banner(
"===================================================================")
swaption = FinLiborSwaption(exerciseDate, swapMaturityDate, swaptionType,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
model = FinLiborModelSABR(0.28, 1.0, -0.09, 0.21)
value = swaption.value(settlementDate, liborCurve, model)
# swaption.print()
testCases.header("LABEL", "VALUE")
testCases.print("PAYER Swaption Value", value)
swaptionType = FinLiborSwaptionType.RECEIVER
swaption = FinLiborSwaption(exerciseDate, swapMaturityDate, swaptionType,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
model = FinLiborModelSABR(0.28, 1.0, -0.09, 0.21)
value = swaption.value(settlementDate, liborCurve, model)
# swaption.print()
testCases.print("RECEIVER Swaption Value", value)
end = time.time()
testCases.header("TIME")
testCases.print(end - start)
def testFinLiborSwaptionModels():
##########################################################################
# COMPARISON OF MODELS
##########################################################################
valuationDate = FinDate(2011, 1, 1)
liborCurve = test_FinLiborDepositsAndSwaps(valuationDate)
exerciseDate = FinDate(2012, 1, 1)
swapMaturityDate = FinDate(2017, 1, 1)
swapFixedFrequencyType = FinFrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = FinDayCountTypes.ACT_365F
strikes = np.linspace(0.02, 0.08, 10)
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)
settlementDate = valuationDate.addWorkDays(2)
for k in strikes:
swaptionType = FinLiborSwapTypes.PAYER
swaption = FinLiborSwaption(settlementDate, exerciseDate,
swapMaturityDate, swaptionType, k,
swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuationDate, liborCurve, model1)
swap2 = swaption.value(valuationDate, liborCurve, model2)
swap3 = swaption.value(valuationDate, liborCurve, model3)
swap4 = swaption.value(valuationDate, liborCurve, model4)
swap5 = swaption.value(valuationDate, liborCurve, model5)
swap6 = swaption.value(valuationDate, liborCurve, 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 = FinLiborSwapTypes.RECEIVER
swaption = FinLiborSwaption(settlementDate, exerciseDate,
swapMaturityDate, swaptionType, k,
swapFixedFrequencyType,
swapFixedDayCountType)
swap1 = swaption.value(valuationDate, liborCurve, model1)
swap2 = swaption.value(valuationDate, liborCurve, model2)
swap3 = swaption.value(valuationDate, liborCurve, model3)
swap4 = swaption.value(valuationDate, liborCurve, model4)
swap5 = swaption.value(valuationDate, liborCurve, model5)
swap6 = swaption.value(valuationDate, liborCurve, model6)
testCases.print("REC", k, swap1, swap2, swap3, swap4, swap5, swap6)
def test_FinFXAmericanOption():
# There is no FXAmericanOption class. It is embedded in the FXVanillaOption
# class. This test just compares it to the European
valueDate = FinDate(13, 2, 2018)
expiryDate = FinDate(13, 2, 2019)
# In BS the FX rate is the price in domestic of one unit of foreign
# In case of EURUSD = 1.3 the domestic currency is USD and foreign is EUR
# DOM = USD , FOR = EUR
ccy1 = "EUR"
ccy2 = "USD"
ccy1CCRate = 0.030 # EUR
ccy2CCRate = 0.025 # USD
currencyPair = ccy1 + ccy2 # Always ccy1ccy2
spotFXRate = 1.20
strikeFXRate = 1.250
volatility = 0.10
spotDays = 0
settlementDate = valueDate.addWorkDays(spotDays)
maturityDate = settlementDate.addMonths(12)
notional = 1000000.0
notionalCurrency = "EUR"
calendarType = FinCalendarTypes.TARGET
domDiscountCurve = FinFlatCurve(valueDate, ccy2CCRate)
forDiscountCurve = FinFlatCurve(valueDate, ccy1CCRate)
model = FinFXModelBlackScholes(volatility)
# Two examples to show that changing the notional currency and notional
# keeps the value unchanged
notional = 1000000.0
testCases.header("SPOT FX RATE", "VALUE_BS", "VOL_IN", "IMPLD_VOL")
spotFXRates = np.arange(50, 200, 10) / 100.0
for spotFXRate in spotFXRates:
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, "EURUSD",
FinOptionTypes.EUROPEAN_CALL, 1000000,
"USD")
valueEuropean = callOption.value(valueDate, spotFXRate,
domDiscountCurve, forDiscountCurve,
model)['v']
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, "EURUSD",
FinOptionTypes.AMERICAN_CALL, 1000000,
"USD")
valueAmerican = callOption.value(valueDate, spotFXRate,
domDiscountCurve, forDiscountCurve,
model)['v']
diff = (valueAmerican - valueEuropean)
print("CALL %9.6f %9.6f %9.7f %10.8f" %
(spotFXRate, valueEuropean, valueAmerican, diff))
for spotFXRate in spotFXRates:
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, "EURUSD",
FinOptionTypes.EUROPEAN_PUT, 1000000,
"USD")
valueEuropean = callOption.value(valueDate, spotFXRate,
domDiscountCurve, forDiscountCurve,
model)['v']
callOption = FinFXVanillaOption(expiryDate, strikeFXRate, "EURUSD",
FinOptionTypes.AMERICAN_PUT, 1000000,
"USD")
valueAmerican = callOption.value(valueDate, spotFXRate,
domDiscountCurve, forDiscountCurve,
model)['v']
diff = (valueAmerican - valueEuropean)
print("PUT %9.6f %9.6f %9.7f %10.8f" %
(spotFXRate, valueEuropean, valueAmerican, diff))
def test_FinLiborDepositsAndSwaps():
valuationDate = FinDate(2019, 9, 18)
depoDCCType = FinDayCountTypes.THIRTY_E_360_ISDA
depos = []
spotDays = 2
settlementDate = valuationDate.addWorkDays(spotDays)
depositRate = 0.050
maturityDate = settlementDate.addMonths(1)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType)
depos.append(depo)
maturityDate = settlementDate.addMonths(2)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType)
depos.append(depo)
maturityDate = settlementDate.addMonths(3)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType)
depos.append(depo)
maturityDate = settlementDate.addMonths(6)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType)
depos.append(depo)
maturityDate = settlementDate.addMonths(9)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType)
depos.append(depo)
maturityDate = settlementDate.addMonths(12)
depo = FinLiborDeposit(settlementDate, maturityDate, depositRate,
depoDCCType)
depos.append(depo)
fras = []
swaps = []
fixedDCCType = FinDayCountTypes.ACT_365_ISDA
fixedFreqType = FinFrequencyTypes.SEMI_ANNUAL
swapRate = 0.05
maturityDate = settlementDate.addMonths(24)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(36)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(48)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(60)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(72)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(84)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(96)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(108)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(120)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(132)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(144)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(180)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(240)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(300)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
maturityDate = settlementDate.addMonths(360)
swap = FinLiborSwap(settlementDate, maturityDate, swapRate, fixedFreqType,
fixedDCCType)
swaps.append(swap)
liborCurve = FinLiborCurve("USD_LIBOR", settlementDate, depos, fras, swaps)
df = liborCurve.df(settlementDate)
testCases.header("SETTLEMENT DATE", "DF")
testCases.print(str(settlementDate), df)
testCases.header("DATE", "DF")
for deposit in depos:
df = liborCurve.df(deposit._maturityDate)
testCases.print(str(deposit._maturityDate), df)
for swap in swaps:
df = liborCurve.df(deposit._maturityDate)
testCases.print(str(deposit._maturityDate), df)
